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 129