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
48inline 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
58inline Expr *IgnoreImplicitCastsExtraSingleStep(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
75inline 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
91inline 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
101inline 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
111inline 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
125inline 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
137inline Expr *IgnoreImplicitAsWrittenSingleStep(Expr *E) {
138 if (auto *ICE = dyn_cast<ImplicitCastExpr>(Val: E))
139 return ICE->getSubExprAsWritten();
140
141 return IgnoreImplicitSingleStep(E);
142}
143
144inline Expr *IgnoreParensOnlySingleStep(Expr *E) {
145 if (auto *PE = dyn_cast<ParenExpr>(Val: E))
146 return PE->getSubExpr();
147 return E;
148}
149
150inline 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

source code of clang/include/clang/AST/IgnoreExpr.h