1 //===--- EvaluatedExprVisitor.h - Evaluated expression visitor --*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the EvaluatedExprVisitor class template, which visits 11 // the potentially-evaluated subexpressions of a potentially-evaluated 12 // expression. 13 // 14 //===----------------------------------------------------------------------===// 15 #ifndef LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H 16 #define LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H 17 18 #include "clang/AST/DeclCXX.h" 19 #include "clang/AST/Expr.h" 20 #include "clang/AST/ExprCXX.h" 21 #include "clang/AST/StmtVisitor.h" 22 #include "llvm/ADT/STLExtras.h" 23 24 namespace clang { 25 26 class ASTContext; 27 28 /// Given a potentially-evaluated expression, this visitor visits all 29 /// of its potentially-evaluated subexpressions, recursively. 30 template<template <typename> class Ptr, typename ImplClass> 31 class EvaluatedExprVisitorBase : public StmtVisitorBase<Ptr, ImplClass, void> { 32 protected: 33 const ASTContext &Context; 34 35 public: 36 #define PTR(CLASS) typename Ptr<CLASS>::type 37 EvaluatedExprVisitorBase(const ASTContext & Context)38 explicit EvaluatedExprVisitorBase(const ASTContext &Context) : Context(Context) { } 39 40 // Expressions that have no potentially-evaluated subexpressions (but may have 41 // other sub-expressions). VisitDeclRefExpr(PTR (DeclRefExpr)E)42 void VisitDeclRefExpr(PTR(DeclRefExpr) E) { } VisitOffsetOfExpr(PTR (OffsetOfExpr)E)43 void VisitOffsetOfExpr(PTR(OffsetOfExpr) E) { } VisitUnaryExprOrTypeTraitExpr(PTR (UnaryExprOrTypeTraitExpr)E)44 void VisitUnaryExprOrTypeTraitExpr(PTR(UnaryExprOrTypeTraitExpr) E) { } VisitExpressionTraitExpr(PTR (ExpressionTraitExpr)E)45 void VisitExpressionTraitExpr(PTR(ExpressionTraitExpr) E) { } VisitBlockExpr(PTR (BlockExpr)E)46 void VisitBlockExpr(PTR(BlockExpr) E) { } VisitCXXUuidofExpr(PTR (CXXUuidofExpr)E)47 void VisitCXXUuidofExpr(PTR(CXXUuidofExpr) E) { } VisitCXXNoexceptExpr(PTR (CXXNoexceptExpr)E)48 void VisitCXXNoexceptExpr(PTR(CXXNoexceptExpr) E) { } 49 VisitMemberExpr(PTR (MemberExpr)E)50 void VisitMemberExpr(PTR(MemberExpr) E) { 51 // Only the base matters. 52 return this->Visit(E->getBase()); 53 } 54 VisitChooseExpr(PTR (ChooseExpr)E)55 void VisitChooseExpr(PTR(ChooseExpr) E) { 56 // Don't visit either child expression if the condition is dependent. 57 if (E->getCond()->isValueDependent()) 58 return; 59 // Only the selected subexpression matters; the other one is not evaluated. 60 return this->Visit(E->getChosenSubExpr()); 61 } 62 VisitGenericSelectionExpr(PTR (GenericSelectionExpr)E)63 void VisitGenericSelectionExpr(PTR(GenericSelectionExpr) E) { 64 // The controlling expression of a generic selection is not evaluated. 65 66 // Don't visit either child expression if the condition is type-dependent. 67 if (E->isResultDependent()) 68 return; 69 // Only the selected subexpression matters; the other subexpressions and the 70 // controlling expression are not evaluated. 71 return this->Visit(E->getResultExpr()); 72 } 73 VisitDesignatedInitExpr(PTR (DesignatedInitExpr)E)74 void VisitDesignatedInitExpr(PTR(DesignatedInitExpr) E) { 75 // Only the actual initializer matters; the designators are all constant 76 // expressions. 77 return this->Visit(E->getInit()); 78 } 79 VisitCXXTypeidExpr(PTR (CXXTypeidExpr)E)80 void VisitCXXTypeidExpr(PTR(CXXTypeidExpr) E) { 81 if (E->isPotentiallyEvaluated()) 82 return this->Visit(E->getExprOperand()); 83 } 84 VisitCallExpr(PTR (CallExpr)CE)85 void VisitCallExpr(PTR(CallExpr) CE) { 86 if (!CE->isUnevaluatedBuiltinCall(Context)) 87 return static_cast<ImplClass*>(this)->VisitExpr(CE); 88 } 89 VisitLambdaExpr(PTR (LambdaExpr)LE)90 void VisitLambdaExpr(PTR(LambdaExpr) LE) { 91 // Only visit the capture initializers, and not the body. 92 for (LambdaExpr::const_capture_init_iterator I = LE->capture_init_begin(), 93 E = LE->capture_init_end(); 94 I != E; ++I) 95 if (*I) 96 this->Visit(*I); 97 } 98 99 /// The basis case walks all of the children of the statement or 100 /// expression, assuming they are all potentially evaluated. VisitStmt(PTR (Stmt)S)101 void VisitStmt(PTR(Stmt) S) { 102 for (auto *SubStmt : S->children()) 103 if (SubStmt) 104 this->Visit(SubStmt); 105 } 106 107 #undef PTR 108 }; 109 110 /// EvaluatedExprVisitor - This class visits 'Expr *'s 111 template <typename ImplClass> 112 class EvaluatedExprVisitor 113 : public EvaluatedExprVisitorBase<std::add_pointer, ImplClass> { 114 public: EvaluatedExprVisitor(const ASTContext & Context)115 explicit EvaluatedExprVisitor(const ASTContext &Context) 116 : EvaluatedExprVisitorBase<std::add_pointer, ImplClass>(Context) {} 117 }; 118 119 /// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s. 120 template <typename ImplClass> 121 class ConstEvaluatedExprVisitor 122 : public EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass> { 123 public: ConstEvaluatedExprVisitor(const ASTContext & Context)124 explicit ConstEvaluatedExprVisitor(const ASTContext &Context) 125 : EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass>(Context) {} 126 }; 127 } 128 129 #endif // LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H 130