1 //===- ComputeDependence.cpp ----------------------------------------------===//
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 #include "clang/AST/ComputeDependence.h"
10 #include "clang/AST/Attr.h"
11 #include "clang/AST/DeclCXX.h"
12 #include "clang/AST/DeclarationName.h"
13 #include "clang/AST/DependenceFlags.h"
14 #include "clang/AST/Expr.h"
15 #include "clang/AST/ExprCXX.h"
16 #include "clang/AST/ExprConcepts.h"
17 #include "clang/AST/ExprObjC.h"
18 #include "clang/AST/ExprOpenMP.h"
19 #include "clang/Basic/ExceptionSpecificationType.h"
20 #include "llvm/ADT/ArrayRef.h"
21
22 using namespace clang;
23
computeDependence(FullExpr * E)24 ExprDependence clang::computeDependence(FullExpr *E) {
25 return E->getSubExpr()->getDependence();
26 }
27
computeDependence(OpaqueValueExpr * E)28 ExprDependence clang::computeDependence(OpaqueValueExpr *E) {
29 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
30 if (auto *S = E->getSourceExpr())
31 D |= S->getDependence();
32 assert(!(D & ExprDependence::UnexpandedPack));
33 return D;
34 }
35
computeDependence(ParenExpr * E)36 ExprDependence clang::computeDependence(ParenExpr *E) {
37 return E->getSubExpr()->getDependence();
38 }
39
computeDependence(UnaryOperator * E,const ASTContext & Ctx)40 ExprDependence clang::computeDependence(UnaryOperator *E,
41 const ASTContext &Ctx) {
42 ExprDependence Dep =
43 // FIXME: Do we need to look at the type?
44 toExprDependenceForImpliedType(E->getType()->getDependence()) |
45 E->getSubExpr()->getDependence();
46
47 // C++ [temp.dep.constexpr]p5:
48 // An expression of the form & qualified-id where the qualified-id names a
49 // dependent member of the current instantiation is value-dependent. An
50 // expression of the form & cast-expression is also value-dependent if
51 // evaluating cast-expression as a core constant expression succeeds and
52 // the result of the evaluation refers to a templated entity that is an
53 // object with static or thread storage duration or a member function.
54 //
55 // What this amounts to is: constant-evaluate the operand and check whether it
56 // refers to a templated entity other than a variable with local storage.
57 if (Ctx.getLangOpts().CPlusPlus && E->getOpcode() == UO_AddrOf &&
58 !(Dep & ExprDependence::Value)) {
59 Expr::EvalResult Result;
60 SmallVector<PartialDiagnosticAt, 8> Diag;
61 Result.Diag = &Diag;
62 // FIXME: This doesn't enforce the C++98 constant expression rules.
63 if (E->getSubExpr()->EvaluateAsConstantExpr(Result, Ctx) && Diag.empty() &&
64 Result.Val.isLValue()) {
65 auto *VD = Result.Val.getLValueBase().dyn_cast<const ValueDecl *>();
66 if (VD && VD->isTemplated()) {
67 auto *VarD = dyn_cast<VarDecl>(VD);
68 if (!VarD || !VarD->hasLocalStorage())
69 Dep |= ExprDependence::Value;
70 }
71 }
72 }
73
74 return Dep;
75 }
76
computeDependence(UnaryExprOrTypeTraitExpr * E)77 ExprDependence clang::computeDependence(UnaryExprOrTypeTraitExpr *E) {
78 // Never type-dependent (C++ [temp.dep.expr]p3).
79 // Value-dependent if the argument is type-dependent.
80 if (E->isArgumentType())
81 return turnTypeToValueDependence(
82 toExprDependenceAsWritten(E->getArgumentType()->getDependence()));
83
84 auto ArgDeps = E->getArgumentExpr()->getDependence();
85 auto Deps = ArgDeps & ~ExprDependence::TypeValue;
86 // Value-dependent if the argument is type-dependent.
87 if (ArgDeps & ExprDependence::Type)
88 Deps |= ExprDependence::Value;
89 // Check to see if we are in the situation where alignof(decl) should be
90 // dependent because decl's alignment is dependent.
91 auto ExprKind = E->getKind();
92 if (ExprKind != UETT_AlignOf && ExprKind != UETT_PreferredAlignOf)
93 return Deps;
94 if ((Deps & ExprDependence::Value) && (Deps & ExprDependence::Instantiation))
95 return Deps;
96
97 auto *NoParens = E->getArgumentExpr()->IgnoreParens();
98 const ValueDecl *D = nullptr;
99 if (const auto *DRE = dyn_cast<DeclRefExpr>(NoParens))
100 D = DRE->getDecl();
101 else if (const auto *ME = dyn_cast<MemberExpr>(NoParens))
102 D = ME->getMemberDecl();
103 if (!D)
104 return Deps;
105 for (const auto *I : D->specific_attrs<AlignedAttr>()) {
106 if (I->isAlignmentErrorDependent())
107 Deps |= ExprDependence::Error;
108 if (I->isAlignmentDependent())
109 Deps |= ExprDependence::ValueInstantiation;
110 }
111 return Deps;
112 }
113
computeDependence(ArraySubscriptExpr * E)114 ExprDependence clang::computeDependence(ArraySubscriptExpr *E) {
115 return E->getLHS()->getDependence() | E->getRHS()->getDependence();
116 }
117
computeDependence(MatrixSubscriptExpr * E)118 ExprDependence clang::computeDependence(MatrixSubscriptExpr *E) {
119 return E->getBase()->getDependence() | E->getRowIdx()->getDependence() |
120 (E->getColumnIdx() ? E->getColumnIdx()->getDependence()
121 : ExprDependence::None);
122 }
123
computeDependence(CompoundLiteralExpr * E)124 ExprDependence clang::computeDependence(CompoundLiteralExpr *E) {
125 return toExprDependenceAsWritten(
126 E->getTypeSourceInfo()->getType()->getDependence()) |
127 toExprDependenceForImpliedType(E->getType()->getDependence()) |
128 turnTypeToValueDependence(E->getInitializer()->getDependence());
129 }
130
computeDependence(ImplicitCastExpr * E)131 ExprDependence clang::computeDependence(ImplicitCastExpr *E) {
132 // We model implicit conversions as combining the dependence of their
133 // subexpression, apart from its type, with the semantic portion of the
134 // target type.
135 ExprDependence D =
136 toExprDependenceForImpliedType(E->getType()->getDependence());
137 if (auto *S = E->getSubExpr())
138 D |= S->getDependence() & ~ExprDependence::Type;
139 return D;
140 }
141
computeDependence(ExplicitCastExpr * E)142 ExprDependence clang::computeDependence(ExplicitCastExpr *E) {
143 // Cast expressions are type-dependent if the type is
144 // dependent (C++ [temp.dep.expr]p3).
145 // Cast expressions are value-dependent if the type is
146 // dependent or if the subexpression is value-dependent.
147 //
148 // Note that we also need to consider the dependence of the actual type here,
149 // because when the type as written is a deduced type, that type is not
150 // dependent, but it may be deduced as a dependent type.
151 ExprDependence D =
152 toExprDependenceAsWritten(
153 cast<ExplicitCastExpr>(E)->getTypeAsWritten()->getDependence()) |
154 toExprDependenceForImpliedType(E->getType()->getDependence());
155 if (auto *S = E->getSubExpr())
156 D |= S->getDependence() & ~ExprDependence::Type;
157 return D;
158 }
159
computeDependence(BinaryOperator * E)160 ExprDependence clang::computeDependence(BinaryOperator *E) {
161 return E->getLHS()->getDependence() | E->getRHS()->getDependence();
162 }
163
computeDependence(ConditionalOperator * E)164 ExprDependence clang::computeDependence(ConditionalOperator *E) {
165 // The type of the conditional operator depends on the type of the conditional
166 // to support the GCC vector conditional extension. Additionally,
167 // [temp.dep.expr] does specify state that this should be dependent on ALL sub
168 // expressions.
169 return E->getCond()->getDependence() | E->getLHS()->getDependence() |
170 E->getRHS()->getDependence();
171 }
172
computeDependence(BinaryConditionalOperator * E)173 ExprDependence clang::computeDependence(BinaryConditionalOperator *E) {
174 return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence();
175 }
176
computeDependence(StmtExpr * E,unsigned TemplateDepth)177 ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) {
178 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
179 // Propagate dependence of the result.
180 if (const auto *CompoundExprResult =
181 dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult()))
182 if (const Expr *ResultExpr = CompoundExprResult->getExprStmt())
183 D |= ResultExpr->getDependence();
184 // Note: we treat a statement-expression in a dependent context as always
185 // being value- and instantiation-dependent. This matches the behavior of
186 // lambda-expressions and GCC.
187 if (TemplateDepth)
188 D |= ExprDependence::ValueInstantiation;
189 // A param pack cannot be expanded over stmtexpr boundaries.
190 return D & ~ExprDependence::UnexpandedPack;
191 }
192
computeDependence(ConvertVectorExpr * E)193 ExprDependence clang::computeDependence(ConvertVectorExpr *E) {
194 auto D = toExprDependenceAsWritten(
195 E->getTypeSourceInfo()->getType()->getDependence()) |
196 E->getSrcExpr()->getDependence();
197 if (!E->getType()->isDependentType())
198 D &= ~ExprDependence::Type;
199 return D;
200 }
201
computeDependence(ChooseExpr * E)202 ExprDependence clang::computeDependence(ChooseExpr *E) {
203 if (E->isConditionDependent())
204 return ExprDependence::TypeValueInstantiation |
205 E->getCond()->getDependence() | E->getLHS()->getDependence() |
206 E->getRHS()->getDependence();
207
208 auto Cond = E->getCond()->getDependence();
209 auto Active = E->getLHS()->getDependence();
210 auto Inactive = E->getRHS()->getDependence();
211 if (!E->isConditionTrue())
212 std::swap(Active, Inactive);
213 // Take type- and value- dependency from the active branch. Propagate all
214 // other flags from all branches.
215 return (Active & ExprDependence::TypeValue) |
216 ((Cond | Active | Inactive) & ~ExprDependence::TypeValue);
217 }
218
computeDependence(ParenListExpr * P)219 ExprDependence clang::computeDependence(ParenListExpr *P) {
220 auto D = ExprDependence::None;
221 for (auto *E : P->exprs())
222 D |= E->getDependence();
223 return D;
224 }
225
computeDependence(VAArgExpr * E)226 ExprDependence clang::computeDependence(VAArgExpr *E) {
227 auto D = toExprDependenceAsWritten(
228 E->getWrittenTypeInfo()->getType()->getDependence()) |
229 (E->getSubExpr()->getDependence() & ~ExprDependence::Type);
230 return D;
231 }
232
computeDependence(NoInitExpr * E)233 ExprDependence clang::computeDependence(NoInitExpr *E) {
234 return toExprDependenceForImpliedType(E->getType()->getDependence()) &
235 (ExprDependence::Instantiation | ExprDependence::Error);
236 }
237
computeDependence(ArrayInitLoopExpr * E)238 ExprDependence clang::computeDependence(ArrayInitLoopExpr *E) {
239 auto D = E->getCommonExpr()->getDependence() |
240 E->getSubExpr()->getDependence() | ExprDependence::Instantiation;
241 if (!E->getType()->isInstantiationDependentType())
242 D &= ~ExprDependence::Instantiation;
243 return turnTypeToValueDependence(D);
244 }
245
computeDependence(ImplicitValueInitExpr * E)246 ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) {
247 return toExprDependenceForImpliedType(E->getType()->getDependence()) &
248 ExprDependence::Instantiation;
249 }
250
computeDependence(ExtVectorElementExpr * E)251 ExprDependence clang::computeDependence(ExtVectorElementExpr *E) {
252 return E->getBase()->getDependence();
253 }
254
computeDependence(BlockExpr * E)255 ExprDependence clang::computeDependence(BlockExpr *E) {
256 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
257 if (E->getBlockDecl()->isDependentContext())
258 D |= ExprDependence::Instantiation;
259 return D;
260 }
261
computeDependence(AsTypeExpr * E)262 ExprDependence clang::computeDependence(AsTypeExpr *E) {
263 // FIXME: AsTypeExpr doesn't store the type as written. Assume the expression
264 // type has identical sugar for now, so is a type-as-written.
265 auto D = toExprDependenceAsWritten(E->getType()->getDependence()) |
266 E->getSrcExpr()->getDependence();
267 if (!E->getType()->isDependentType())
268 D &= ~ExprDependence::Type;
269 return D;
270 }
271
computeDependence(CXXRewrittenBinaryOperator * E)272 ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) {
273 return E->getSemanticForm()->getDependence();
274 }
275
computeDependence(CXXStdInitializerListExpr * E)276 ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) {
277 auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence());
278 D |= toExprDependenceForImpliedType(E->getType()->getDependence());
279 return D;
280 }
281
computeDependence(CXXTypeidExpr * E)282 ExprDependence clang::computeDependence(CXXTypeidExpr *E) {
283 auto D = ExprDependence::None;
284 if (E->isTypeOperand())
285 D = toExprDependenceAsWritten(
286 E->getTypeOperandSourceInfo()->getType()->getDependence());
287 else
288 D = turnTypeToValueDependence(E->getExprOperand()->getDependence());
289 // typeid is never type-dependent (C++ [temp.dep.expr]p4)
290 return D & ~ExprDependence::Type;
291 }
292
computeDependence(MSPropertyRefExpr * E)293 ExprDependence clang::computeDependence(MSPropertyRefExpr *E) {
294 return E->getBaseExpr()->getDependence() & ~ExprDependence::Type;
295 }
296
computeDependence(MSPropertySubscriptExpr * E)297 ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) {
298 return E->getIdx()->getDependence();
299 }
300
computeDependence(CXXUuidofExpr * E)301 ExprDependence clang::computeDependence(CXXUuidofExpr *E) {
302 if (E->isTypeOperand())
303 return turnTypeToValueDependence(toExprDependenceAsWritten(
304 E->getTypeOperandSourceInfo()->getType()->getDependence()));
305
306 return turnTypeToValueDependence(E->getExprOperand()->getDependence());
307 }
308
computeDependence(CXXThisExpr * E)309 ExprDependence clang::computeDependence(CXXThisExpr *E) {
310 // 'this' is type-dependent if the class type of the enclosing
311 // member function is dependent (C++ [temp.dep.expr]p2)
312 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
313 assert(!(D & ExprDependence::UnexpandedPack));
314 return D;
315 }
316
computeDependence(CXXThrowExpr * E)317 ExprDependence clang::computeDependence(CXXThrowExpr *E) {
318 auto *Op = E->getSubExpr();
319 if (!Op)
320 return ExprDependence::None;
321 return Op->getDependence() & ~ExprDependence::TypeValue;
322 }
323
computeDependence(CXXBindTemporaryExpr * E)324 ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) {
325 return E->getSubExpr()->getDependence();
326 }
327
computeDependence(CXXScalarValueInitExpr * E)328 ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) {
329 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
330 if (auto *TSI = E->getTypeSourceInfo())
331 D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
332 return D;
333 }
334
computeDependence(CXXDeleteExpr * E)335 ExprDependence clang::computeDependence(CXXDeleteExpr *E) {
336 return turnTypeToValueDependence(E->getArgument()->getDependence());
337 }
338
computeDependence(ArrayTypeTraitExpr * E)339 ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) {
340 auto D = toExprDependenceAsWritten(E->getQueriedType()->getDependence());
341 if (auto *Dim = E->getDimensionExpression())
342 D |= Dim->getDependence();
343 return turnTypeToValueDependence(D);
344 }
345
computeDependence(ExpressionTraitExpr * E)346 ExprDependence clang::computeDependence(ExpressionTraitExpr *E) {
347 // Never type-dependent.
348 auto D = E->getQueriedExpression()->getDependence() & ~ExprDependence::Type;
349 // Value-dependent if the argument is type-dependent.
350 if (E->getQueriedExpression()->isTypeDependent())
351 D |= ExprDependence::Value;
352 return D;
353 }
354
computeDependence(CXXNoexceptExpr * E,CanThrowResult CT)355 ExprDependence clang::computeDependence(CXXNoexceptExpr *E, CanThrowResult CT) {
356 auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue;
357 if (CT == CT_Dependent)
358 D |= ExprDependence::ValueInstantiation;
359 return D;
360 }
361
computeDependence(PackExpansionExpr * E)362 ExprDependence clang::computeDependence(PackExpansionExpr *E) {
363 return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) |
364 ExprDependence::TypeValueInstantiation;
365 }
366
computeDependence(SubstNonTypeTemplateParmExpr * E)367 ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) {
368 return E->getReplacement()->getDependence();
369 }
370
computeDependence(CoroutineSuspendExpr * E)371 ExprDependence clang::computeDependence(CoroutineSuspendExpr *E) {
372 if (auto *Resume = E->getResumeExpr())
373 return (Resume->getDependence() &
374 (ExprDependence::TypeValue | ExprDependence::Error)) |
375 (E->getCommonExpr()->getDependence() & ~ExprDependence::TypeValue);
376 return E->getCommonExpr()->getDependence() |
377 ExprDependence::TypeValueInstantiation;
378 }
379
computeDependence(DependentCoawaitExpr * E)380 ExprDependence clang::computeDependence(DependentCoawaitExpr *E) {
381 return E->getOperand()->getDependence() |
382 ExprDependence::TypeValueInstantiation;
383 }
384
computeDependence(ObjCBoxedExpr * E)385 ExprDependence clang::computeDependence(ObjCBoxedExpr *E) {
386 return E->getSubExpr()->getDependence();
387 }
388
computeDependence(ObjCEncodeExpr * E)389 ExprDependence clang::computeDependence(ObjCEncodeExpr *E) {
390 return toExprDependenceAsWritten(E->getEncodedType()->getDependence());
391 }
392
computeDependence(ObjCIvarRefExpr * E)393 ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) {
394 return turnTypeToValueDependence(E->getBase()->getDependence());
395 }
396
computeDependence(ObjCPropertyRefExpr * E)397 ExprDependence clang::computeDependence(ObjCPropertyRefExpr *E) {
398 if (E->isObjectReceiver())
399 return E->getBase()->getDependence() & ~ExprDependence::Type;
400 if (E->isSuperReceiver())
401 return toExprDependenceForImpliedType(
402 E->getSuperReceiverType()->getDependence()) &
403 ~ExprDependence::TypeValue;
404 assert(E->isClassReceiver());
405 return ExprDependence::None;
406 }
407
computeDependence(ObjCSubscriptRefExpr * E)408 ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) {
409 return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence();
410 }
411
computeDependence(ObjCIsaExpr * E)412 ExprDependence clang::computeDependence(ObjCIsaExpr *E) {
413 return E->getBase()->getDependence() & ~ExprDependence::Type &
414 ~ExprDependence::UnexpandedPack;
415 }
416
computeDependence(ObjCIndirectCopyRestoreExpr * E)417 ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) {
418 return E->getSubExpr()->getDependence();
419 }
420
computeDependence(OMPArraySectionExpr * E)421 ExprDependence clang::computeDependence(OMPArraySectionExpr *E) {
422 auto D = E->getBase()->getDependence();
423 if (auto *LB = E->getLowerBound())
424 D |= LB->getDependence();
425 if (auto *Len = E->getLength())
426 D |= Len->getDependence();
427 return D;
428 }
429
computeDependence(OMPArrayShapingExpr * E)430 ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) {
431 auto D = E->getBase()->getDependence();
432 for (Expr *Dim: E->getDimensions())
433 if (Dim)
434 D |= turnValueToTypeDependence(Dim->getDependence());
435 return D;
436 }
437
computeDependence(OMPIteratorExpr * E)438 ExprDependence clang::computeDependence(OMPIteratorExpr *E) {
439 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
440 for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
441 if (auto *DD = cast_or_null<DeclaratorDecl>(E->getIteratorDecl(I))) {
442 // If the type is omitted, it's 'int', and is not dependent in any way.
443 if (auto *TSI = DD->getTypeSourceInfo()) {
444 D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
445 }
446 }
447 OMPIteratorExpr::IteratorRange IR = E->getIteratorRange(I);
448 if (Expr *BE = IR.Begin)
449 D |= BE->getDependence();
450 if (Expr *EE = IR.End)
451 D |= EE->getDependence();
452 if (Expr *SE = IR.Step)
453 D |= SE->getDependence();
454 }
455 return D;
456 }
457
458 /// Compute the type-, value-, and instantiation-dependence of a
459 /// declaration reference
460 /// based on the declaration being referenced.
computeDependence(DeclRefExpr * E,const ASTContext & Ctx)461 ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
462 auto Deps = ExprDependence::None;
463
464 if (auto *NNS = E->getQualifier())
465 Deps |= toExprDependence(NNS->getDependence() &
466 ~NestedNameSpecifierDependence::Dependent);
467
468 if (auto *FirstArg = E->getTemplateArgs()) {
469 unsigned NumArgs = E->getNumTemplateArgs();
470 for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg)
471 Deps |= toExprDependence(Arg->getArgument().getDependence());
472 }
473
474 auto *Decl = E->getDecl();
475 auto Type = E->getType();
476
477 if (Decl->isParameterPack())
478 Deps |= ExprDependence::UnexpandedPack;
479 Deps |= toExprDependenceForImpliedType(Type->getDependence()) &
480 ExprDependence::Error;
481
482 // C++ [temp.dep.expr]p3:
483 // An id-expression is type-dependent if it contains:
484
485 // - an identifier associated by name lookup with one or more declarations
486 // declared with a dependent type
487 // - an identifier associated by name lookup with an entity captured by
488 // copy ([expr.prim.lambda.capture])
489 // in a lambda-expression that has an explicit object parameter whose
490 // type is dependent ([dcl.fct]),
491 //
492 // [The "or more" case is not modeled as a DeclRefExpr. There are a bunch
493 // more bullets here that we handle by treating the declaration as having a
494 // dependent type if they involve a placeholder type that can't be deduced.]
495 if (Type->isDependentType())
496 Deps |= ExprDependence::TypeValueInstantiation;
497 else if (Type->isInstantiationDependentType())
498 Deps |= ExprDependence::Instantiation;
499
500 // - an identifier associated by name lookup with an entity captured by
501 // copy ([expr.prim.lambda.capture])
502 if (E->isCapturedByCopyInLambdaWithExplicitObjectParameter())
503 Deps |= ExprDependence::Type;
504
505 // - a conversion-function-id that specifies a dependent type
506 if (Decl->getDeclName().getNameKind() ==
507 DeclarationName::CXXConversionFunctionName) {
508 QualType T = Decl->getDeclName().getCXXNameType();
509 if (T->isDependentType())
510 return Deps | ExprDependence::TypeValueInstantiation;
511
512 if (T->isInstantiationDependentType())
513 Deps |= ExprDependence::Instantiation;
514 }
515
516 // - a template-id that is dependent,
517 // - a nested-name-specifier or a qualified-id that names a member of an
518 // unknown specialization
519 // [These are not modeled as DeclRefExprs.]
520
521 // or if it names a dependent member of the current instantiation that is a
522 // static data member of type "array of unknown bound of T" for some T
523 // [handled below].
524
525 // C++ [temp.dep.constexpr]p2:
526 // An id-expression is value-dependent if:
527
528 // - it is type-dependent [handled above]
529
530 // - it is the name of a non-type template parameter,
531 if (isa<NonTypeTemplateParmDecl>(Decl))
532 return Deps | ExprDependence::ValueInstantiation;
533
534 // - it names a potentially-constant variable that is initialized with an
535 // expression that is value-dependent
536 if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
537 if (const Expr *Init = Var->getAnyInitializer()) {
538 if (Init->containsErrors())
539 Deps |= ExprDependence::Error;
540
541 if (Var->mightBeUsableInConstantExpressions(Ctx) &&
542 Init->isValueDependent())
543 Deps |= ExprDependence::ValueInstantiation;
544 }
545
546 // - it names a static data member that is a dependent member of the
547 // current instantiation and is not initialized in a member-declarator,
548 if (Var->isStaticDataMember() &&
549 Var->getDeclContext()->isDependentContext() &&
550 !Var->getFirstDecl()->hasInit()) {
551 const VarDecl *First = Var->getFirstDecl();
552 TypeSourceInfo *TInfo = First->getTypeSourceInfo();
553 if (TInfo->getType()->isIncompleteArrayType()) {
554 Deps |= ExprDependence::TypeValueInstantiation;
555 } else if (!First->hasInit()) {
556 Deps |= ExprDependence::ValueInstantiation;
557 }
558 }
559
560 return Deps;
561 }
562
563 // - it names a static member function that is a dependent member of the
564 // current instantiation
565 //
566 // FIXME: It's unclear that the restriction to static members here has any
567 // effect: any use of a non-static member function name requires either
568 // forming a pointer-to-member or providing an object parameter, either of
569 // which makes the overall expression value-dependent.
570 if (auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
571 if (MD->isStatic() && Decl->getDeclContext()->isDependentContext())
572 Deps |= ExprDependence::ValueInstantiation;
573 }
574
575 return Deps;
576 }
577
computeDependence(RecoveryExpr * E)578 ExprDependence clang::computeDependence(RecoveryExpr *E) {
579 // RecoveryExpr is
580 // - always value-dependent, and therefore instantiation dependent
581 // - contains errors (ExprDependence::Error), by definition
582 // - type-dependent if we don't know the type (fallback to an opaque
583 // dependent type), or the type is known and dependent, or it has
584 // type-dependent subexpressions.
585 auto D = toExprDependenceAsWritten(E->getType()->getDependence()) |
586 ExprDependence::ErrorDependent;
587 // FIXME: remove the type-dependent bit from subexpressions, if the
588 // RecoveryExpr has a non-dependent type.
589 for (auto *S : E->subExpressions())
590 D |= S->getDependence();
591 return D;
592 }
593
computeDependence(SYCLUniqueStableNameExpr * E)594 ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) {
595 return toExprDependenceAsWritten(
596 E->getTypeSourceInfo()->getType()->getDependence());
597 }
598
computeDependence(PredefinedExpr * E)599 ExprDependence clang::computeDependence(PredefinedExpr *E) {
600 return toExprDependenceForImpliedType(E->getType()->getDependence());
601 }
602
computeDependence(CallExpr * E,llvm::ArrayRef<Expr * > PreArgs)603 ExprDependence clang::computeDependence(CallExpr *E,
604 llvm::ArrayRef<Expr *> PreArgs) {
605 auto D = E->getCallee()->getDependence();
606 if (E->getType()->isDependentType())
607 D |= ExprDependence::Type;
608 for (auto *A : llvm::ArrayRef(E->getArgs(), E->getNumArgs())) {
609 if (A)
610 D |= A->getDependence();
611 }
612 for (auto *A : PreArgs)
613 D |= A->getDependence();
614 return D;
615 }
616
computeDependence(OffsetOfExpr * E)617 ExprDependence clang::computeDependence(OffsetOfExpr *E) {
618 auto D = turnTypeToValueDependence(toExprDependenceAsWritten(
619 E->getTypeSourceInfo()->getType()->getDependence()));
620 for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I)
621 D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence());
622 return D;
623 }
624
getDependenceInExpr(DeclarationNameInfo Name)625 static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
626 auto D = ExprDependence::None;
627 if (Name.isInstantiationDependent())
628 D |= ExprDependence::Instantiation;
629 if (Name.containsUnexpandedParameterPack())
630 D |= ExprDependence::UnexpandedPack;
631 return D;
632 }
633
computeDependence(MemberExpr * E)634 ExprDependence clang::computeDependence(MemberExpr *E) {
635 auto D = E->getBase()->getDependence();
636 D |= getDependenceInExpr(E->getMemberNameInfo());
637
638 if (auto *NNS = E->getQualifier())
639 D |= toExprDependence(NNS->getDependence() &
640 ~NestedNameSpecifierDependence::Dependent);
641
642 auto *MemberDecl = E->getMemberDecl();
643 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
644 DeclContext *DC = MemberDecl->getDeclContext();
645 // dyn_cast_or_null is used to handle objC variables which do not
646 // have a declaration context.
647 CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
648 if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
649 if (!E->getType()->isDependentType())
650 D &= ~ExprDependence::Type;
651 }
652
653 // Bitfield with value-dependent width is type-dependent.
654 if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
655 D |= ExprDependence::Type;
656 }
657 }
658 // FIXME: move remaining dependence computation from MemberExpr::Create()
659 return D;
660 }
661
computeDependence(InitListExpr * E)662 ExprDependence clang::computeDependence(InitListExpr *E) {
663 auto D = ExprDependence::None;
664 for (auto *A : E->inits())
665 D |= A->getDependence();
666 return D;
667 }
668
computeDependence(ShuffleVectorExpr * E)669 ExprDependence clang::computeDependence(ShuffleVectorExpr *E) {
670 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
671 for (auto *C : llvm::ArrayRef(E->getSubExprs(), E->getNumSubExprs()))
672 D |= C->getDependence();
673 return D;
674 }
675
computeDependence(GenericSelectionExpr * E,bool ContainsUnexpandedPack)676 ExprDependence clang::computeDependence(GenericSelectionExpr *E,
677 bool ContainsUnexpandedPack) {
678 auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack
679 : ExprDependence::None;
680 for (auto *AE : E->getAssocExprs())
681 D |= AE->getDependence() & ExprDependence::Error;
682
683 if (E->isExprPredicate())
684 D |= E->getControllingExpr()->getDependence() & ExprDependence::Error;
685 else
686 D |= toExprDependenceAsWritten(
687 E->getControllingType()->getType()->getDependence());
688
689 if (E->isResultDependent())
690 return D | ExprDependence::TypeValueInstantiation;
691 return D | (E->getResultExpr()->getDependence() &
692 ~ExprDependence::UnexpandedPack);
693 }
694
computeDependence(DesignatedInitExpr * E)695 ExprDependence clang::computeDependence(DesignatedInitExpr *E) {
696 auto Deps = E->getInit()->getDependence();
697 for (const auto &D : E->designators()) {
698 auto DesignatorDeps = ExprDependence::None;
699 if (D.isArrayDesignator())
700 DesignatorDeps |= E->getArrayIndex(D)->getDependence();
701 else if (D.isArrayRangeDesignator())
702 DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() |
703 E->getArrayRangeEnd(D)->getDependence();
704 Deps |= DesignatorDeps;
705 if (DesignatorDeps & ExprDependence::TypeValue)
706 Deps |= ExprDependence::TypeValueInstantiation;
707 }
708 return Deps;
709 }
710
computeDependence(PseudoObjectExpr * O)711 ExprDependence clang::computeDependence(PseudoObjectExpr *O) {
712 auto D = O->getSyntacticForm()->getDependence();
713 for (auto *E : O->semantics())
714 D |= E->getDependence();
715 return D;
716 }
717
computeDependence(AtomicExpr * A)718 ExprDependence clang::computeDependence(AtomicExpr *A) {
719 auto D = ExprDependence::None;
720 for (auto *E : llvm::ArrayRef(A->getSubExprs(), A->getNumSubExprs()))
721 D |= E->getDependence();
722 return D;
723 }
724
computeDependence(CXXNewExpr * E)725 ExprDependence clang::computeDependence(CXXNewExpr *E) {
726 auto D = toExprDependenceAsWritten(
727 E->getAllocatedTypeSourceInfo()->getType()->getDependence());
728 D |= toExprDependenceForImpliedType(E->getAllocatedType()->getDependence());
729 auto Size = E->getArraySize();
730 if (Size && *Size)
731 D |= turnTypeToValueDependence((*Size)->getDependence());
732 if (auto *I = E->getInitializer())
733 D |= turnTypeToValueDependence(I->getDependence());
734 for (auto *A : E->placement_arguments())
735 D |= turnTypeToValueDependence(A->getDependence());
736 return D;
737 }
738
computeDependence(CXXPseudoDestructorExpr * E)739 ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) {
740 auto D = E->getBase()->getDependence();
741 if (auto *TSI = E->getDestroyedTypeInfo())
742 D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
743 if (auto *ST = E->getScopeTypeInfo())
744 D |= turnTypeToValueDependence(
745 toExprDependenceAsWritten(ST->getType()->getDependence()));
746 if (auto *Q = E->getQualifier())
747 D |= toExprDependence(Q->getDependence() &
748 ~NestedNameSpecifierDependence::Dependent);
749 return D;
750 }
751
752 ExprDependence
computeDependence(OverloadExpr * E,bool KnownDependent,bool KnownInstantiationDependent,bool KnownContainsUnexpandedParameterPack)753 clang::computeDependence(OverloadExpr *E, bool KnownDependent,
754 bool KnownInstantiationDependent,
755 bool KnownContainsUnexpandedParameterPack) {
756 auto Deps = ExprDependence::None;
757 if (KnownDependent)
758 Deps |= ExprDependence::TypeValue;
759 if (KnownInstantiationDependent)
760 Deps |= ExprDependence::Instantiation;
761 if (KnownContainsUnexpandedParameterPack)
762 Deps |= ExprDependence::UnexpandedPack;
763 Deps |= getDependenceInExpr(E->getNameInfo());
764 if (auto *Q = E->getQualifier())
765 Deps |= toExprDependence(Q->getDependence() &
766 ~NestedNameSpecifierDependence::Dependent);
767 for (auto *D : E->decls()) {
768 if (D->getDeclContext()->isDependentContext() ||
769 isa<UnresolvedUsingValueDecl>(D))
770 Deps |= ExprDependence::TypeValueInstantiation;
771 }
772 // If we have explicit template arguments, check for dependent
773 // template arguments and whether they contain any unexpanded pack
774 // expansions.
775 for (const auto &A : E->template_arguments())
776 Deps |= toExprDependence(A.getArgument().getDependence());
777 return Deps;
778 }
779
computeDependence(DependentScopeDeclRefExpr * E)780 ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) {
781 auto D = ExprDependence::TypeValue;
782 D |= getDependenceInExpr(E->getNameInfo());
783 if (auto *Q = E->getQualifier())
784 D |= toExprDependence(Q->getDependence());
785 for (const auto &A : E->template_arguments())
786 D |= toExprDependence(A.getArgument().getDependence());
787 return D;
788 }
789
computeDependence(CXXConstructExpr * E)790 ExprDependence clang::computeDependence(CXXConstructExpr *E) {
791 ExprDependence D =
792 toExprDependenceForImpliedType(E->getType()->getDependence());
793 for (auto *A : E->arguments())
794 D |= A->getDependence() & ~ExprDependence::Type;
795 return D;
796 }
797
computeDependence(CXXTemporaryObjectExpr * E)798 ExprDependence clang::computeDependence(CXXTemporaryObjectExpr *E) {
799 CXXConstructExpr *BaseE = E;
800 return toExprDependenceAsWritten(
801 E->getTypeSourceInfo()->getType()->getDependence()) |
802 computeDependence(BaseE);
803 }
804
computeDependence(CXXDefaultInitExpr * E)805 ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
806 return E->getExpr()->getDependence();
807 }
808
computeDependence(CXXDefaultArgExpr * E)809 ExprDependence clang::computeDependence(CXXDefaultArgExpr *E) {
810 return E->getExpr()->getDependence();
811 }
812
computeDependence(LambdaExpr * E,bool ContainsUnexpandedParameterPack)813 ExprDependence clang::computeDependence(LambdaExpr *E,
814 bool ContainsUnexpandedParameterPack) {
815 auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
816 if (ContainsUnexpandedParameterPack)
817 D |= ExprDependence::UnexpandedPack;
818 return D;
819 }
820
computeDependence(CXXUnresolvedConstructExpr * E)821 ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) {
822 auto D = ExprDependence::ValueInstantiation;
823 D |= toExprDependenceAsWritten(E->getTypeAsWritten()->getDependence());
824 D |= toExprDependenceForImpliedType(E->getType()->getDependence());
825 for (auto *A : E->arguments())
826 D |= A->getDependence() &
827 (ExprDependence::UnexpandedPack | ExprDependence::Error);
828 return D;
829 }
830
computeDependence(CXXDependentScopeMemberExpr * E)831 ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) {
832 auto D = ExprDependence::TypeValueInstantiation;
833 if (!E->isImplicitAccess())
834 D |= E->getBase()->getDependence();
835 if (auto *Q = E->getQualifier())
836 D |= toExprDependence(Q->getDependence());
837 D |= getDependenceInExpr(E->getMemberNameInfo());
838 for (const auto &A : E->template_arguments())
839 D |= toExprDependence(A.getArgument().getDependence());
840 return D;
841 }
842
computeDependence(MaterializeTemporaryExpr * E)843 ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) {
844 return E->getSubExpr()->getDependence();
845 }
846
computeDependence(CXXFoldExpr * E)847 ExprDependence clang::computeDependence(CXXFoldExpr *E) {
848 auto D = ExprDependence::TypeValueInstantiation;
849 for (const auto *C : {E->getLHS(), E->getRHS()}) {
850 if (C)
851 D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
852 }
853 return D;
854 }
855
computeDependence(CXXParenListInitExpr * E)856 ExprDependence clang::computeDependence(CXXParenListInitExpr *E) {
857 auto D = ExprDependence::None;
858 for (const auto *A : E->getInitExprs())
859 D |= A->getDependence();
860 return D;
861 }
862
computeDependence(TypeTraitExpr * E)863 ExprDependence clang::computeDependence(TypeTraitExpr *E) {
864 auto D = ExprDependence::None;
865 for (const auto *A : E->getArgs())
866 D |= toExprDependenceAsWritten(A->getType()->getDependence()) &
867 ~ExprDependence::Type;
868 return D;
869 }
870
computeDependence(ConceptSpecializationExpr * E,bool ValueDependent)871 ExprDependence clang::computeDependence(ConceptSpecializationExpr *E,
872 bool ValueDependent) {
873 auto TA = TemplateArgumentDependence::None;
874 const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
875 TemplateArgumentDependence::UnexpandedPack;
876 for (const TemplateArgumentLoc &ArgLoc :
877 E->getTemplateArgsAsWritten()->arguments()) {
878 TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
879 if (TA == InterestingDeps)
880 break;
881 }
882
883 ExprDependence D =
884 ValueDependent ? ExprDependence::Value : ExprDependence::None;
885 auto Res = D | toExprDependence(TA);
886 if(!ValueDependent && E->getSatisfaction().ContainsErrors)
887 Res |= ExprDependence::Error;
888 return Res;
889 }
890
computeDependence(ObjCArrayLiteral * E)891 ExprDependence clang::computeDependence(ObjCArrayLiteral *E) {
892 auto D = ExprDependence::None;
893 Expr **Elements = E->getElements();
894 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I)
895 D |= turnTypeToValueDependence(Elements[I]->getDependence());
896 return D;
897 }
898
computeDependence(ObjCDictionaryLiteral * E)899 ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) {
900 auto Deps = ExprDependence::None;
901 for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) {
902 auto KV = E->getKeyValueElement(I);
903 auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() |
904 KV.Value->getDependence());
905 if (KV.EllipsisLoc.isValid())
906 KVDeps &= ~ExprDependence::UnexpandedPack;
907 Deps |= KVDeps;
908 }
909 return Deps;
910 }
911
computeDependence(ObjCMessageExpr * E)912 ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
913 auto D = ExprDependence::None;
914 if (auto *R = E->getInstanceReceiver())
915 D |= R->getDependence();
916 else
917 D |= toExprDependenceForImpliedType(E->getType()->getDependence());
918 for (auto *A : E->arguments())
919 D |= A->getDependence();
920 return D;
921 }
922