Home | History | Annotate | Download | only in AST 
      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:
     34   explicit EvaluatedExprVisitor(ASTContext &Context) : Context(Context) { }
     35 
     36   // Expressions that have no potentially-evaluated subexpressions (but may have
     37   // other sub-expressions).
     38   void VisitDeclRefExpr(DeclRefExpr *E) { }
     39   void VisitOffsetOfExpr(OffsetOfExpr *E) { }
     40   void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) { }
     41   void VisitExpressionTraitExpr(ExpressionTraitExpr *E) { }
     42   void VisitBlockExpr(BlockExpr *E) { }
     43   void VisitCXXUuidofExpr(CXXUuidofExpr *E) { }
     44   void VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { }
     45 
     46   void VisitMemberExpr(MemberExpr *E) {
     47     // Only the base matters.
     48     return this->Visit(E->getBase());
     49   }
     50 
     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 
     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 
     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.
     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