contrib/llvm-project/clang/include/clang/AST/EvaluatedExprVisitor.h

   1 //===--- EvaluatedExprVisitor.h - Evaluated expression visitor --*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file defines the EvaluatedExprVisitor class template, which visits
  10 //  the potentially-evaluated subexpressions of a potentially-evaluated
  11 //  expression.
  12 //
  13 //===----------------------------------------------------------------------===//
  14 #ifndef LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H
  15 #define LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H
  16
  17 #include "clang/AST/DeclCXX.h"
  18 #include "clang/AST/Expr.h"
  19 #include "clang/AST/ExprCXX.h"
  20 #include "clang/AST/StmtVisitor.h"
  21 #include "llvm/ADT/STLExtras.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<std::add_pointer, ImplClass> {
 113 public:
 114   explicit EvaluatedExprVisitor(const ASTContext &Context)
 115       : EvaluatedExprVisitorBase<std::add_pointer, ImplClass>(Context) {}
 116 };
 117
 118 /// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
 119 template <typename ImplClass>
 120 class ConstEvaluatedExprVisitor
 121     : public EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass> {
 122 public:
 123   explicit ConstEvaluatedExprVisitor(const ASTContext &Context)
 124       : EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass>(Context) {}
 125 };
 126 }
 127
 128 #endif // LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H