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 | |
19 | namespace clang { |
20 | namespace detail { |
21 | /// Given an expression E and functions Fn_1,...,Fn_n : Expr * -> Expr *, |
22 | /// Return Fn_n(...(Fn_1(E))) |
23 | inline Expr *IgnoreExprNodesImpl(Expr *E) { return E; } |
24 | template <typename FnTy, typename... FnTys> |
25 | Expr *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. |
34 | template <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 | |
43 | template <typename... FnTys> |
44 | const Expr *IgnoreExprNodes(const Expr *E, FnTys &&...Fns) { |
45 | return IgnoreExprNodes(const_cast<Expr *>(E), std::forward<FnTys>(Fns)...); |
46 | } |
47 | |
48 | inline Expr *IgnoreImplicitCastsSingleStep(Expr *E) { |
49 | if (auto *ICE = dyn_cast<ImplicitCastExpr>(Val: E)) |
50 | return ICE->getSubExpr(); |
51 | |
52 | if (auto *FE = dyn_cast<FullExpr>(Val: E)) |
53 | return FE->getSubExpr(); |
54 | |
55 | return E; |
56 | } |
57 | |
58 | inline Expr *(Expr *E) { |
59 | // FIXME: Skip MaterializeTemporaryExpr and SubstNonTypeTemplateParmExpr in |
60 | // addition to what IgnoreImpCasts() skips to account for the current |
61 | // behaviour of IgnoreParenImpCasts(). |
62 | Expr *SubE = IgnoreImplicitCastsSingleStep(E); |
63 | if (SubE != E) |
64 | return SubE; |
65 | |
66 | if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Val: E)) |
67 | return MTE->getSubExpr(); |
68 | |
69 | if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(Val: E)) |
70 | return NTTP->getReplacement(); |
71 | |
72 | return E; |
73 | } |
74 | |
75 | inline Expr *IgnoreCastsSingleStep(Expr *E) { |
76 | if (auto *CE = dyn_cast<CastExpr>(Val: E)) |
77 | return CE->getSubExpr(); |
78 | |
79 | if (auto *FE = dyn_cast<FullExpr>(Val: E)) |
80 | return FE->getSubExpr(); |
81 | |
82 | if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Val: E)) |
83 | return MTE->getSubExpr(); |
84 | |
85 | if (auto *NTTP = dyn_cast<SubstNonTypeTemplateParmExpr>(Val: E)) |
86 | return NTTP->getReplacement(); |
87 | |
88 | return E; |
89 | } |
90 | |
91 | inline Expr *IgnoreLValueCastsSingleStep(Expr *E) { |
92 | // Skip what IgnoreCastsSingleStep skips, except that only |
93 | // lvalue-to-rvalue casts are skipped. |
94 | if (auto *CE = dyn_cast<CastExpr>(Val: E)) |
95 | if (CE->getCastKind() != CK_LValueToRValue) |
96 | return E; |
97 | |
98 | return IgnoreCastsSingleStep(E); |
99 | } |
100 | |
101 | inline Expr *IgnoreBaseCastsSingleStep(Expr *E) { |
102 | if (auto *CE = dyn_cast<CastExpr>(Val: 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 | |
111 | inline Expr *IgnoreImplicitSingleStep(Expr *E) { |
112 | Expr *SubE = IgnoreImplicitCastsSingleStep(E); |
113 | if (SubE != E) |
114 | return SubE; |
115 | |
116 | if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(Val: E)) |
117 | return MTE->getSubExpr(); |
118 | |
119 | if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(Val: E)) |
120 | return BTE->getSubExpr(); |
121 | |
122 | return E; |
123 | } |
124 | |
125 | inline Expr *IgnoreElidableImplicitConstructorSingleStep(Expr *E) { |
126 | auto *CCE = dyn_cast<CXXConstructExpr>(Val: E); |
127 | if (CCE && CCE->isElidable() && !isa<CXXTemporaryObjectExpr>(Val: CCE)) { |
128 | unsigned NumArgs = CCE->getNumArgs(); |
129 | if ((NumArgs == 1 || |
130 | (NumArgs > 1 && CCE->getArg(Arg: 1)->isDefaultArgument())) && |
131 | !CCE->getArg(Arg: 0)->isDefaultArgument() && !CCE->isListInitialization()) |
132 | return CCE->getArg(Arg: 0); |
133 | } |
134 | return E; |
135 | } |
136 | |
137 | inline Expr *IgnoreImplicitAsWrittenSingleStep(Expr *E) { |
138 | if (auto *ICE = dyn_cast<ImplicitCastExpr>(Val: E)) |
139 | return ICE->getSubExprAsWritten(); |
140 | |
141 | return IgnoreImplicitSingleStep(E); |
142 | } |
143 | |
144 | inline Expr *IgnoreParensOnlySingleStep(Expr *E) { |
145 | if (auto *PE = dyn_cast<ParenExpr>(Val: E)) |
146 | return PE->getSubExpr(); |
147 | return E; |
148 | } |
149 | |
150 | inline Expr *IgnoreParensSingleStep(Expr *E) { |
151 | if (auto *PE = dyn_cast<ParenExpr>(Val: E)) |
152 | return PE->getSubExpr(); |
153 | |
154 | if (auto *UO = dyn_cast<UnaryOperator>(Val: E)) { |
155 | if (UO->getOpcode() == UO_Extension) |
156 | return UO->getSubExpr(); |
157 | } |
158 | |
159 | else if (auto *GSE = dyn_cast<GenericSelectionExpr>(Val: E)) { |
160 | if (!GSE->isResultDependent()) |
161 | return GSE->getResultExpr(); |
162 | } |
163 | |
164 | else if (auto *CE = dyn_cast<ChooseExpr>(Val: E)) { |
165 | if (!CE->isConditionDependent()) |
166 | return CE->getChosenSubExpr(); |
167 | } |
168 | |
169 | else if (auto *PE = dyn_cast<PredefinedExpr>(Val: 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 |
180 | |