clang 20.0.0git
IgnoreExpr.h
Go to the documentation of this file.
1//===--- IgnoreExpr.h - Ignore intermediate Expressions -----------------===//
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 common functions to ignore intermediate expression nodes
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_IGNOREEXPR_H
14#define LLVM_CLANG_AST_IGNOREEXPR_H
15
16#include "clang/AST/Expr.h"
17#include "clang/AST/ExprCXX.h"
18
19namespace clang {
20namespace detail {
21/// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *,
22/// Return Fn_n(...(Fn_1(E)))
23inline Expr *IgnoreExprNodesImpl(Expr *E) { return E; }
24template <typename FnTy, typename... FnTys>
25Expr *IgnoreExprNodesImpl(Expr *E, FnTy &&Fn, FnTys &&... Fns) {
26 return IgnoreExprNodesImpl(std::forward<FnTy>(Fn)(E),
27 std::forward<FnTys>(Fns)...);
28}
29} // namespace detail
30
31/// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *,
32/// Recursively apply each of the functions to E until reaching a fixed point.
33/// Note that a null E is valid; in this case nothing is done.
34template <typename... FnTys> Expr *IgnoreExprNodes(Expr *E, FnTys &&... Fns) {
35 Expr *LastE = nullptr;
36 while (E != LastE) {
37 LastE = E;
38 E = detail::IgnoreExprNodesImpl(E, std::forward<FnTys>(Fns)...);
39 }
40 return E;
41}
42
43template <typename... FnTys>
44const Expr *IgnoreExprNodes(const Expr *E, FnTys &&...Fns) {
45 return IgnoreExprNodes(const_cast<Expr *>(E), std::forward<FnTys>(Fns)...);
46}
47
49 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
50 return ICE->getSubExpr();
51
52 if (auto *FE = dyn_cast<FullExpr>(E))
53 return FE->getSubExpr();
54
55 return E;
56}
57
59 // FIXME: Skip MaterializeTemporaryExpr and SubstNonTypeTemplateParmExpr in
60 // addition to what IgnoreImpCasts() skips to account for the current
61 // behaviour of IgnoreParenImpCasts().
63 if (SubE != E)
64 return SubE;
65
66 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
67 return MTE->getSubExpr();
68
69 if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
70 return NTTP->getReplacement();
71
72 return E;
73}
74
76 if (auto *CE = dyn_cast<CastExpr>(E))
77 return CE->getSubExpr();
78
79 if (auto *FE = dyn_cast<FullExpr>(E))
80 return FE->getSubExpr();
81
82 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
83 return MTE->getSubExpr();
84
85 if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(E))
86 return NTTP->getReplacement();
87
88 return E;
89}
90
92 // Skip what IgnoreCastsSingleStep skips, except that only
93 // lvalue-to-rvalue casts are skipped.
94 if (auto *CE = dyn_cast<CastExpr>(E))
95 if (CE->getCastKind() != CK_LValueToRValue)
96 return E;
97
99}
100
102 if (auto *CE = dyn_cast<CastExpr>(E))
103 if (CE->getCastKind() == CK_DerivedToBase ||
104 CE->getCastKind() == CK_UncheckedDerivedToBase ||
105 CE->getCastKind() == CK_NoOp)
106 return CE->getSubExpr();
107
108 return E;
109}
110
113 if (SubE != E)
114 return SubE;
115
116 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
117 return MTE->getSubExpr();
118
119 if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
120 return BTE->getSubExpr();
121
122 return E;
123}
124
126 auto *CCE = dyn_cast<CXXConstructExpr>(E);
127 if (CCE && CCE->isElidable() && !isa<CXXTemporaryObjectExpr>(CCE)) {
128 unsigned NumArgs = CCE->getNumArgs();
129 if ((NumArgs == 1 ||
130 (NumArgs > 1 && CCE->getArg(1)->isDefaultArgument())) &&
131 !CCE->getArg(0)->isDefaultArgument() && !CCE->isListInitialization())
132 return CCE->getArg(0);
133 }
134 return E;
135}
136
138 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E))
139 return ICE->getSubExprAsWritten();
140
142}
143
145 if (auto *PE = dyn_cast<ParenExpr>(E))
146 return PE->getSubExpr();
147 return E;
148}
149
151 if (auto *PE = dyn_cast<ParenExpr>(E))
152 return PE->getSubExpr();
153
154 if (auto *UO = dyn_cast<UnaryOperator>(E)) {
155 if (UO->getOpcode() == UO_Extension)
156 return UO->getSubExpr();
157 }
158
159 else if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
160 if (!GSE->isResultDependent())
161 return GSE->getResultExpr();
162 }
163
164 else if (auto *CE = dyn_cast<ChooseExpr>(E)) {
165 if (!CE->isConditionDependent())
166 return CE->getChosenSubExpr();
167 }
168
169 else if (auto *PE = dyn_cast<PredefinedExpr>(E)) {
170 if (PE->isTransparent() && PE->getFunctionName())
171 return PE->getFunctionName();
172 }
173
174 return E;
175}
176
177} // namespace clang
178
179#endif // LLVM_CLANG_AST_IGNOREEXPR_H
Expr * E
Defines the clang::Expr interface and subclasses for C++ expressions.
This represents one expression.
Definition: Expr.h:110
Expr * IgnoreExprNodesImpl(Expr *E)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Return Fn_n(....
Definition: IgnoreExpr.h:23
The JSON file list parser is used to communicate input to InstallAPI.
Expr * IgnoreElidableImplicitConstructorSingleStep(Expr *E)
Definition: IgnoreExpr.h:125
Expr * IgnoreExprNodes(Expr *E, FnTys &&... Fns)
Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, Recursively apply each of the f...
Definition: IgnoreExpr.h:34
Expr * IgnoreImplicitCastsExtraSingleStep(Expr *E)
Definition: IgnoreExpr.h:58
Expr * IgnoreImplicitCastsSingleStep(Expr *E)
Definition: IgnoreExpr.h:48
Expr * IgnoreImplicitSingleStep(Expr *E)
Definition: IgnoreExpr.h:111
Expr * IgnoreParensSingleStep(Expr *E)
Definition: IgnoreExpr.h:150
Expr * IgnoreImplicitAsWrittenSingleStep(Expr *E)
Definition: IgnoreExpr.h:137
Expr * IgnoreCastsSingleStep(Expr *E)
Definition: IgnoreExpr.h:75
Expr * IgnoreLValueCastsSingleStep(Expr *E)
Definition: IgnoreExpr.h:91
Expr * IgnoreParensOnlySingleStep(Expr *E)
Definition: IgnoreExpr.h:144
Expr * IgnoreBaseCastsSingleStep(Expr *E)
Definition: IgnoreExpr.h:101