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/DeclCXX.h"
     19 #include "clang/AST/Expr.h"
     20 #include "clang/AST/ExprCXX.h"
     21 #include "clang/AST/StmtVisitor.h"
     22 
     23 namespace clang {
     24 
     25 class ASTContext;
     26 
     27 /// \brief 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     // Don't visit either child expression if the condition is dependent.
     53     if (E->getCond()->isValueDependent())
     54       return;
     55     // Only the selected subexpression matters; the other one is not evaluated.
     56     return this->Visit(E->getChosenSubExpr());
     57   }
     58 
     59   void VisitDesignatedInitExpr(DesignatedInitExpr *E) {
     60     // Only the actual initializer matters; the designators are all constant
     61     // expressions.
     62     return this->Visit(E->getInit());
     63   }
     64 
     65   void VisitCXXTypeidExpr(CXXTypeidExpr *E) {
     66     if (E->isPotentiallyEvaluated())
     67       return this->Visit(E->getExprOperand());
     68   }
     69 
     70   void VisitCallExpr(CallExpr *CE) {
     71     if (!CE->isUnevaluatedBuiltinCall(Context))
     72       return static_cast<ImplClass*>(this)->VisitExpr(CE);
     73   }
     74 
     75   void VisitLambdaExpr(LambdaExpr *LE) {
     76     // Only visit the capture initializers, and not the body.
     77     for (LambdaExpr::capture_init_iterator I = LE->capture_init_begin(),
     78                                            E = LE->capture_init_end();
     79          I != E; ++I)
     80       if (*I)
     81         this->Visit(*I);
     82   }
     83 
     84   /// \brief The basis case walks all of the children of the statement or
     85   /// expression, assuming they are all potentially evaluated.
     86   void VisitStmt(Stmt *S) {
     87     for (Stmt::child_range C = S->children(); C; ++C)
     88       if (*C)
     89         this->Visit(*C);
     90   }
     91 };
     92 
     93 }
     94 
     95 #endif // LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H
     96