clang  14.0.0git
EvaluatedExprVisitor.h
Go to the documentation of this file.
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:
33 
34 public:
35  // Return whether this visitor should recurse into discarded statements for a
36  // 'constexpr-if'.
37  bool shouldVisitDiscardedStmt() const { return true; }
38 #define PTR(CLASS) typename Ptr<CLASS>::type
39 
41 
42  // Expressions that have no potentially-evaluated subexpressions (but may have
43  // other sub-expressions).
51 
53  // Only the base matters.
54  return this->Visit(E->getBase());
55  }
56 
58  // Don't visit either child expression if the condition is dependent.
59  if (E->getCond()->isValueDependent())
60  return;
61  // Only the selected subexpression matters; the other one is not evaluated.
62  return this->Visit(E->getChosenSubExpr());
63  }
64 
66  // The controlling expression of a generic selection is not evaluated.
67 
68  // Don't visit either child expression if the condition is type-dependent.
69  if (E->isResultDependent())
70  return;
71  // Only the selected subexpression matters; the other subexpressions and the
72  // controlling expression are not evaluated.
73  return this->Visit(E->getResultExpr());
74  }
75 
77  // Only the actual initializer matters; the designators are all constant
78  // expressions.
79  return this->Visit(E->getInit());
80  }
81 
83  if (E->isPotentiallyEvaluated())
84  return this->Visit(E->getExprOperand());
85  }
86 
89  return getDerived().VisitExpr(CE);
90  }
91 
93  // Only visit the capture initializers, and not the body.
94  for (LambdaExpr::const_capture_init_iterator I = LE->capture_init_begin(),
95  E = LE->capture_init_end();
96  I != E; ++I)
97  if (*I)
98  this->Visit(*I);
99  }
100 
101  /// The basis case walks all of the children of the statement or
102  /// expression, assuming they are all potentially evaluated.
103  void VisitStmt(PTR(Stmt) S) {
104  for (auto *SubStmt : S->children())
105  if (SubStmt)
106  this->Visit(SubStmt);
107  }
108 
109  void VisitIfStmt(PTR(IfStmt) If) {
111  if (auto SubStmt = If->getNondiscardedCase(Context)) {
112  if (*SubStmt)
113  this->Visit(*SubStmt);
114  return;
115  }
116  }
117 
118  getDerived().VisitStmt(If);
119  }
120 
121  ImplClass &getDerived() { return *static_cast<ImplClass *>(this); }
122 
123 #undef PTR
124 };
125 
126 /// EvaluatedExprVisitor - This class visits 'Expr *'s
127 template <typename ImplClass>
129  : public EvaluatedExprVisitorBase<std::add_pointer, ImplClass> {
130 public:
132  : EvaluatedExprVisitorBase<std::add_pointer, ImplClass>(Context) {}
133 };
134 
135 /// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
136 template <typename ImplClass>
138  : public EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass> {
139 public:
141  : EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass>(Context) {}
142 };
143 }
144 
145 #endif // LLVM_CLANG_AST_EVALUATEDEXPRVISITOR_H
clang::ExpressionTraitExpr
An expression trait intrinsic.
Definition: ExprCXX.h:2823
llvm
Definition: Dominators.h:30
clang::OffsetOfExpr
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition: Expr.h:2438
clang::EvaluatedExprVisitorBase::getDerived
ImplClass & getDerived()
Definition: EvaluatedExprVisitor.h:121
clang::EvaluatedExprVisitorBase::VisitExpressionTraitExpr
void VisitExpressionTraitExpr(PTR(ExpressionTraitExpr) E)
Definition: EvaluatedExprVisitor.h:47
clang::DesignatedInitExpr
Represents a C99 designated initializer expression.
Definition: Expr.h:5024
clang::CXXTypeidExpr::isPotentiallyEvaluated
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr....
Definition: ExprCXX.cpp:134
clang::EvaluatedExprVisitorBase::VisitCXXNoexceptExpr
void VisitCXXNoexceptExpr(PTR(CXXNoexceptExpr) E)
Definition: EvaluatedExprVisitor.h:50
clang::EvaluatedExprVisitorBase::VisitDeclRefExpr
void VisitDeclRefExpr(PTR(DeclRefExpr) E)
Definition: EvaluatedExprVisitor.h:44
clang::EvaluatedExprVisitorBase::VisitLambdaExpr
void VisitLambdaExpr(PTR(LambdaExpr) LE)
Definition: EvaluatedExprVisitor.h:92
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:839
DeclCXX.h
clang::IfStmt
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1904
clang::EvaluatedExprVisitorBase
Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexp...
Definition: EvaluatedExprVisitor.h:30
clang::IfStmt::getNondiscardedCase
Optional< const Stmt * > getNondiscardedCase(const ASTContext &Ctx) const
If this is an 'if constexpr', determine which substatement will be taken.
Definition: Stmt.cpp:1005
clang::EvaluatedExprVisitorBase::VisitChooseExpr
void VisitChooseExpr(PTR(ChooseExpr) E)
Definition: EvaluatedExprVisitor.h:57
clang::CXXTypeidExpr::getExprOperand
Expr * getExprOperand() const
Definition: ExprCXX.h:886
clang::EvaluatedExprVisitor::EvaluatedExprVisitor
EvaluatedExprVisitor(const ASTContext &Context)
Definition: EvaluatedExprVisitor.h:131
clang::EvaluatedExprVisitorBase::VisitGenericSelectionExpr
void VisitGenericSelectionExpr(PTR(GenericSelectionExpr) E)
Definition: EvaluatedExprVisitor.h:65
clang::EvaluatedExprVisitorBase::VisitCXXUuidofExpr
void VisitCXXUuidofExpr(PTR(CXXUuidofExpr) E)
Definition: EvaluatedExprVisitor.h:49
clang::UnaryExprOrTypeTraitExpr
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition: Expr.h:2543
clang::EvaluatedExprVisitorBase::shouldVisitDiscardedStmt
bool shouldVisitDiscardedStmt() const
Definition: EvaluatedExprVisitor.h:37
clang::ConstEvaluatedExprVisitor::ConstEvaluatedExprVisitor
ConstEvaluatedExprVisitor(const ASTContext &Context)
Definition: EvaluatedExprVisitor.h:140
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
clang::interp::LE
bool LE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:239
clang::EvaluatedExprVisitorBase::VisitIfStmt
void VisitIfStmt(PTR(IfStmt) If)
Definition: EvaluatedExprVisitor.h:109
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:212
PTR
#define PTR(CLASS)
Definition: EvaluatedExprVisitor.h:38
clang::EvaluatedExprVisitorBase::EvaluatedExprVisitorBase
EvaluatedExprVisitorBase(const ASTContext &Context)
Definition: EvaluatedExprVisitor.h:40
clang::StmtVisitorBase< Ptr, ImplClass, void >::Visit
void Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:43
clang::LambdaExpr::const_capture_init_iterator
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
Definition: ExprCXX.h:1978
Expr.h
clang::StmtVisitorBase
StmtVisitorBase - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:36
ExprCXX.h
clang::EvaluatedExprVisitorBase::VisitCXXTypeidExpr
void VisitCXXTypeidExpr(PTR(CXXTypeidExpr) E)
Definition: EvaluatedExprVisitor.h:82
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4520
clang::GenericSelectionExpr::isResultDependent
bool isResultDependent() const
Whether this generic selection is result-dependent.
Definition: Expr.h:5801
clang::MemberExpr::getBase
Expr * getBase() const
Definition: Expr.h:3239
clang::EvaluatedExprVisitorBase::VisitCallExpr
void VisitCallExpr(PTR(CallExpr) CE)
Definition: EvaluatedExprVisitor.h:87
clang::ChooseExpr::getChosenSubExpr
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4556
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5965
clang::CXXUuidofExpr
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1056
StmtVisitor.h
clang::ChooseExpr::getCond
Expr * getCond() const
Definition: Expr.h:4560
clang::EvaluatedExprVisitorBase::VisitDesignatedInitExpr
void VisitDesignatedInitExpr(PTR(DesignatedInitExpr) E)
Definition: EvaluatedExprVisitor.h:76
clang::CXXNoexceptExpr
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3997
clang::Expr::isValueDependent
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:168
std
Definition: Format.h:4034
clang::EvaluatedExprVisitorBase::VisitUnaryExprOrTypeTraitExpr
void VisitUnaryExprOrTypeTraitExpr(PTR(UnaryExprOrTypeTraitExpr) E)
Definition: EvaluatedExprVisitor.h:46
clang
Definition: CalledOnceCheck.h:17
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
clang::GenericSelectionExpr::getResultExpr
Expr * getResultExpr()
Return the result expression of this controlling expression.
Definition: Expr.h:5813
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5623
clang::ConstEvaluatedExprVisitor
ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
Definition: EvaluatedExprVisitor.h:137
clang::EvaluatedExprVisitorBase::VisitBlockExpr
void VisitBlockExpr(PTR(BlockExpr) E)
Definition: EvaluatedExprVisitor.h:48
clang::DesignatedInitExpr::getInit
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:5265
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3162
clang::EvaluatedExprVisitorBase::VisitStmt
void VisitStmt(PTR(Stmt) S)
The basis case walks all of the children of the statement or expression, assuming they are all potent...
Definition: EvaluatedExprVisitor.h:103
clang::EvaluatedExprVisitorBase::VisitMemberExpr
void VisitMemberExpr(PTR(MemberExpr) E)
Definition: EvaluatedExprVisitor.h:52
clang::EvaluatedExprVisitor
EvaluatedExprVisitor - This class visits 'Expr *'s.
Definition: EvaluatedExprVisitor.h:128
clang::EvaluatedExprVisitorBase::VisitOffsetOfExpr
void VisitOffsetOfExpr(PTR(OffsetOfExpr) E)
Definition: EvaluatedExprVisitor.h:45
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1217
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2795
clang::CallExpr::isUnevaluatedBuiltinCall
bool isUnevaluatedBuiltinCall(const ASTContext &Ctx) const
Returns true if this is a call to a builtin which does not evaluate side-effects within its arguments...
Definition: Expr.cpp:1507
clang::EvaluatedExprVisitorBase::Context
const ASTContext & Context
Definition: EvaluatedExprVisitor.h:32