contrib/llvm/tools/clang/include/clang/AST/EvaluatedExprVisitor.h

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