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/StmtVisitor.h" 19 #include "clang/AST/DeclCXX.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/ExprCXX.h" 22 23 namespace clang { 24 25 class ASTContext; 26 27 /// \begin Given a potentially-evaluated expression, this visitor visits all 28 /// of its potentially-evaluated subexpressions, recursively. 29 template<typename ImplClass> 30 class EvaluatedExprVisitor : public StmtVisitor<ImplClass> { 31 ASTContext &Context; 32 33 public: EvaluatedExprVisitor(ASTContext & Context)34 explicit EvaluatedExprVisitor(ASTContext &Context) : Context(Context) { } 35 36 // Expressions that have no potentially-evaluated subexpressions (but may have 37 // other sub-expressions). VisitDeclRefExpr(DeclRefExpr * E)38 void VisitDeclRefExpr(DeclRefExpr *E) { } VisitOffsetOfExpr(OffsetOfExpr * E)39 void VisitOffsetOfExpr(OffsetOfExpr *E) { } VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)40 void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { } VisitExpressionTraitExpr(ExpressionTraitExpr * E)41 void VisitExpressionTraitExpr(ExpressionTraitExpr *E) { } VisitBlockExpr(BlockExpr * E)42 void VisitBlockExpr(BlockExpr *E) { } VisitCXXUuidofExpr(CXXUuidofExpr * E)43 void VisitCXXUuidofExpr(CXXUuidofExpr *E) { } VisitCXXNoexceptExpr(CXXNoexceptExpr * E)44 void VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { } 45 VisitMemberExpr(MemberExpr * E)46 void VisitMemberExpr(MemberExpr *E) { 47 // Only the base matters. 48 return this->Visit(E->getBase()); 49 } 50 VisitChooseExpr(ChooseExpr * E)51 void VisitChooseExpr(ChooseExpr *E) { 52 // Only the selected subexpression matters; the other one is not evaluated. 53 return this->Visit(E->getChosenSubExpr(Context)); 54 } 55 VisitDesignatedInitExpr(DesignatedInitExpr * E)56 void VisitDesignatedInitExpr(DesignatedInitExpr *E) { 57 // Only the actual initializer matters; the designators are all constant 58 // expressions. 59 return this->Visit(E->getInit()); 60 } 61 VisitCXXTypeidExpr(CXXTypeidExpr * E)62 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { 63 // typeid(expression) is potentially evaluated when the argument is 64 // a glvalue of polymorphic type. (C++ 5.2.8p2-3) 65 if (!E->isTypeOperand() && E->Classify(Context).isGLValue()) 66 if (const RecordType *Record 67 = E->getExprOperand()->getType()->template getAs<RecordType>()) 68 if (cast<CXXRecordDecl>(Record->getDecl())->isPolymorphic()) 69 return this->Visit(E->getExprOperand()); 70 } 71 72 /// \brief The basis case walks all of the children of the statement or 73 /// expression, assuming they are all potentially evaluated. VisitStmt(Stmt * S)74 void VisitStmt(Stmt *S) { 75 for (Stmt::child_range C = S->children(); C; ++C) 76 if (*C) 77 this->Visit(*C); 78 } 79 }; 80 81 } 82 83 #endif // LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H 84