clang  9.0.0svn
Go to the documentation of this file.
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 //===----------------------------------------------------------------------===//
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 #include "llvm/ADT/STLExtras.h"
24 namespace clang {
26 class ASTContext;
28 /// Given a potentially-evaluated expression, this visitor visits all
29 /// of its potentially-evaluated subexpressions, recursively.
30 template<template <typename> class Ptr, typename ImplClass>
31 class EvaluatedExprVisitorBase : public StmtVisitorBase<Ptr, ImplClass, void> {
32 protected:
35 public:
36 #define PTR(CLASS) typename Ptr<CLASS>::type
38  explicit EvaluatedExprVisitorBase(const ASTContext &Context) : Context(Context) { }
40  // Expressions that have no potentially-evaluated subexpressions (but may have
41  // other sub-expressions).
51  // Only the base matters.
52  return this->Visit(E->getBase());
53  }
56  // Don't visit either child expression if the condition is dependent.
57  if (E->getCond()->isValueDependent())
58  return;
59  // Only the selected subexpression matters; the other one is not evaluated.
60  return this->Visit(E->getChosenSubExpr());
61  }
64  // The controlling expression of a generic selection is not evaluated.
66  // Don't visit either child expression if the condition is type-dependent.
67  if (E->isResultDependent())
68  return;
69  // Only the selected subexpression matters; the other subexpressions and the
70  // controlling expression are not evaluated.
71  return this->Visit(E->getResultExpr());
72  }
75  // Only the actual initializer matters; the designators are all constant
76  // expressions.
77  return this->Visit(E->getInit());
78  }
81  if (E->isPotentiallyEvaluated())
82  return this->Visit(E->getExprOperand());
83  }
86  if (!CE->isUnevaluatedBuiltinCall(Context))
87  return static_cast<ImplClass*>(this)->VisitExpr(CE);
88  }
91  // Only visit the capture initializers, and not the body.
93  E = LE->capture_init_end();
94  I != E; ++I)
95  if (*I)
96  this->Visit(*I);
97  }
99  /// The basis case walks all of the children of the statement or
100  /// expression, assuming they are all potentially evaluated.
101  void VisitStmt(PTR(Stmt) S) {
102  for (auto *SubStmt : S->children())
103  if (SubStmt)
104  this->Visit(SubStmt);
105  }
107 #undef PTR
108 };
110 /// EvaluatedExprVisitor - This class visits 'Expr *'s
111 template <typename ImplClass>
113  : public EvaluatedExprVisitorBase<std::add_pointer, ImplClass> {
114 public:
115  explicit EvaluatedExprVisitor(const ASTContext &Context)
116  : EvaluatedExprVisitorBase<std::add_pointer, ImplClass>(Context) {}
117 };
119 /// ConstEvaluatedExprVisitor - This class visits 'const Expr *'s.
120 template <typename ImplClass>
122  : public EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass> {
123 public:
124  explicit ConstEvaluatedExprVisitor(const ASTContext &Context)
125  : EvaluatedExprVisitorBase<llvm::make_const_ptr, ImplClass>(Context) {}
126 };
127 }
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4025
EvaluatedExprVisitor - This class visits &#39;Expr *&#39;s.
Expr * getCond() const
Definition: Expr.h:4029
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
Stmt - This represents one statement.
Definition: Stmt.h:66
Expr * getBase() const
Definition: Expr.h:2774
#define PTR(CLASS)
const Expr * getResultExpr() const
The generic selection&#39;s result expression.
Definition: Expr.h:5093
Expr * getExprOperand() const
Definition: ExprCXX.h:726
Defines the clang::Expr interface and subclasses for C++ expressions.
void VisitDesignatedInitExpr(PTR(DesignatedInitExpr) E)
Represents a C99 designated initializer expression.
Definition: Expr.h:4426
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4660
Definition: Format.h:2072
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:669
void VisitBlockExpr(PTR(BlockExpr) E)
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1794
child_range children()
Definition: Stmt.cpp:237
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1649
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:1390
EvaluatedExprVisitor(const ASTContext &Context)
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2229
EvaluatedExprVisitorBase(const ASTContext &Context)
void VisitGenericSelectionExpr(PTR(GenericSelectionExpr) E)
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5184
ConstEvaluatedExprVisitor(const ASTContext &Context)
void VisitCXXTypeidExpr(PTR(CXXTypeidExpr) E)
void VisitCallExpr(PTR(CallExpr) CE)
void VisitDeclRefExpr(PTR(DeclRefExpr) E)
void VisitExpressionTraitExpr(PTR(ExpressionTraitExpr) E)
void VisitLambdaExpr(PTR(LambdaExpr) LE)
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:150
void VisitCXXNoexceptExpr(PTR(CXXNoexceptExpr) E)
An expression trait intrinsic.
Definition: ExprCXX.h:2580
Represents a C11 generic selection.
Definition: Expr.h:5017
Dataflow Directional Tag Classes.
void VisitUnaryExprOrTypeTraitExpr(PTR(UnaryExprOrTypeTraitExpr) E)
bool isResultDependent() const
Whether this generic selection is result-dependent.
Definition: Expr.h:5081
ConstEvaluatedExprVisitor - This class visits &#39;const Expr *&#39;s.
void VisitCXXUuidofExpr(PTR(CXXUuidofExpr) E)
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3719
StmtVisitorBase - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:36
Given a potentially-evaluated expression, this visitor visits all of its potentially-evaluated subexp...
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
MemberExpr - [C99] Structure and Union Members.
Definition: Expr.h:2689
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3984
void VisitMemberExpr(PTR(MemberExpr) E)
CallExpr - Represents a function call (C99, C++ []).
Definition: Expr.h:2403
void Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:43
void VisitChooseExpr(PTR(ChooseExpr) E)
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1806
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1048
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
Definition: ExprCXX.h:1780
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2124
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:887
bool isPotentiallyEvaluated() const
Determine whether this typeid has a type operand which is potentially evaluated, per C++11 [expr...
Definition: ExprCXX.cpp:62
void VisitOffsetOfExpr(PTR(OffsetOfExpr) E)
void VisitStmt(PTR(Stmt) S)
The basis case walks all of the children of the statement or expression, assuming they are all potent...