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 
24 ExprDependence clang::computeDependence(FullExpr *E) {
25   return E->getSubExpr()->getDependence();
26 }
27 
28 ExprDependence clang::computeDependence(OpaqueValueExpr *E) {
29   auto D = toExprDependence(E->getType()->getDependence());
30   if (auto *S = E->getSourceExpr())
31     D |= S->getDependence();
32   assert(!(D & ExprDependence::UnexpandedPack));
33   return D;
34 }
35 
36 ExprDependence clang::computeDependence(ParenExpr *E) {
37   return E->getSubExpr()->getDependence();
38 }
39 
40 ExprDependence clang::computeDependence(UnaryOperator *E) {
41   return toExprDependence(E->getType()->getDependence()) |
42          E->getSubExpr()->getDependence();
43 }
44 
45 ExprDependence clang::computeDependence(UnaryExprOrTypeTraitExpr *E) {
46   // Never type-dependent (C++ [temp.dep.expr]p3).
47   // Value-dependent if the argument is type-dependent.
48   if (E->isArgumentType())
49     return turnTypeToValueDependence(
50         toExprDependence(E->getArgumentType()->getDependence()));
51 
52   auto ArgDeps = E->getArgumentExpr()->getDependence();
53   auto Deps = ArgDeps & ~ExprDependence::TypeValue;
54   // Value-dependent if the argument is type-dependent.
55   if (ArgDeps & ExprDependence::Type)
56     Deps |= ExprDependence::Value;
57   // Check to see if we are in the situation where alignof(decl) should be
58   // dependent because decl's alignment is dependent.
59   auto ExprKind = E->getKind();
60   if (ExprKind != UETT_AlignOf && ExprKind != UETT_PreferredAlignOf)
61     return Deps;
62   if ((Deps & ExprDependence::Value) && (Deps & ExprDependence::Instantiation))
63     return Deps;
64 
65   auto *NoParens = E->getArgumentExpr()->IgnoreParens();
66   const ValueDecl *D = nullptr;
67   if (const auto *DRE = dyn_cast<DeclRefExpr>(NoParens))
68     D = DRE->getDecl();
69   else if (const auto *ME = dyn_cast<MemberExpr>(NoParens))
70     D = ME->getMemberDecl();
71   if (!D)
72     return Deps;
73   for (const auto *I : D->specific_attrs<AlignedAttr>()) {
74     if (I->isAlignmentErrorDependent())
75       Deps |= ExprDependence::Error;
76     if (I->isAlignmentDependent())
77       Deps |= ExprDependence::ValueInstantiation;
78   }
79   return Deps;
80 }
81 
82 ExprDependence clang::computeDependence(ArraySubscriptExpr *E) {
83   return E->getLHS()->getDependence() | E->getRHS()->getDependence();
84 }
85 
86 ExprDependence clang::computeDependence(MatrixSubscriptExpr *E) {
87   return E->getBase()->getDependence() | E->getRowIdx()->getDependence() |
88          (E->getColumnIdx() ? E->getColumnIdx()->getDependence()
89                             : ExprDependence::None);
90 }
91 
92 ExprDependence clang::computeDependence(CompoundLiteralExpr *E) {
93   return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()) |
94          turnTypeToValueDependence(E->getInitializer()->getDependence());
95 }
96 
97 ExprDependence clang::computeDependence(CastExpr *E) {
98   // Cast expressions are type-dependent if the type is
99   // dependent (C++ [temp.dep.expr]p3).
100   // Cast expressions are value-dependent if the type is
101   // dependent or if the subexpression is value-dependent.
102   auto D = toExprDependence(E->getType()->getDependence());
103   if (E->getStmtClass() == Stmt::ImplicitCastExprClass) {
104     // An implicit cast expression doesn't (lexically) contain an
105     // unexpanded pack, even if its target type does.
106     D &= ~ExprDependence::UnexpandedPack;
107   }
108   if (auto *S = E->getSubExpr())
109     D |= S->getDependence() & ~ExprDependence::Type;
110   return D;
111 }
112 
113 ExprDependence clang::computeDependence(BinaryOperator *E) {
114   return E->getLHS()->getDependence() | E->getRHS()->getDependence();
115 }
116 
117 ExprDependence clang::computeDependence(ConditionalOperator *E) {
118   // The type of the conditional operator depends on the type of the conditional
119   // to support the GCC vector conditional extension. Additionally,
120   // [temp.dep.expr] does specify state that this should be dependent on ALL sub
121   // expressions.
122   return E->getCond()->getDependence() | E->getLHS()->getDependence() |
123          E->getRHS()->getDependence();
124 }
125 
126 ExprDependence clang::computeDependence(BinaryConditionalOperator *E) {
127   return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence();
128 }
129 
130 ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) {
131   auto D = toExprDependence(E->getType()->getDependence());
132   // Propagate dependence of the result.
133   if (const auto *CompoundExprResult =
134           dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult()))
135     if (const Expr *ResultExpr = CompoundExprResult->getExprStmt())
136       D |= ResultExpr->getDependence();
137   // Note: we treat a statement-expression in a dependent context as always
138   // being value- and instantiation-dependent. This matches the behavior of
139   // lambda-expressions and GCC.
140   if (TemplateDepth)
141     D |= ExprDependence::ValueInstantiation;
142   // A param pack cannot be expanded over stmtexpr boundaries.
143   return D & ~ExprDependence::UnexpandedPack;
144 }
145 
146 ExprDependence clang::computeDependence(ConvertVectorExpr *E) {
147   auto D = toExprDependence(E->getType()->getDependence()) |
148            E->getSrcExpr()->getDependence();
149   if (!E->getType()->isDependentType())
150     D &= ~ExprDependence::Type;
151   return D;
152 }
153 
154 ExprDependence clang::computeDependence(ChooseExpr *E) {
155   if (E->isConditionDependent())
156     return ExprDependence::TypeValueInstantiation |
157            E->getCond()->getDependence() | E->getLHS()->getDependence() |
158            E->getRHS()->getDependence();
159 
160   auto Cond = E->getCond()->getDependence();
161   auto Active = E->getLHS()->getDependence();
162   auto Inactive = E->getRHS()->getDependence();
163   if (!E->isConditionTrue())
164     std::swap(Active, Inactive);
165   // Take type- and value- dependency from the active branch. Propagate all
166   // other flags from all branches.
167   return (Active & ExprDependence::TypeValue) |
168          ((Cond | Active | Inactive) & ~ExprDependence::TypeValue);
169 }
170 
171 ExprDependence clang::computeDependence(ParenListExpr *P) {
172   auto D = ExprDependence::None;
173   for (auto *E : P->exprs())
174     D |= E->getDependence();
175   return D;
176 }
177 
178 ExprDependence clang::computeDependence(VAArgExpr *E) {
179   auto D =
180       toExprDependence(E->getWrittenTypeInfo()->getType()->getDependence()) |
181       (E->getSubExpr()->getDependence() & ~ExprDependence::Type);
182   return D & ~ExprDependence::Value;
183 }
184 
185 ExprDependence clang::computeDependence(NoInitExpr *E) {
186   return toExprDependence(E->getType()->getDependence()) &
187          (ExprDependence::Instantiation | ExprDependence::Error);
188 }
189 
190 ExprDependence clang::computeDependence(ArrayInitLoopExpr *E) {
191   auto D = E->getCommonExpr()->getDependence() |
192            E->getSubExpr()->getDependence() | ExprDependence::Instantiation;
193   if (!E->getType()->isInstantiationDependentType())
194     D &= ~ExprDependence::Instantiation;
195   return turnTypeToValueDependence(D);
196 }
197 
198 ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) {
199   return toExprDependence(E->getType()->getDependence()) &
200          ExprDependence::Instantiation;
201 }
202 
203 ExprDependence clang::computeDependence(ExtVectorElementExpr *E) {
204   return E->getBase()->getDependence();
205 }
206 
207 ExprDependence clang::computeDependence(BlockExpr *E) {
208   auto D = toExprDependence(E->getType()->getDependence());
209   if (E->getBlockDecl()->isDependentContext())
210     D |= ExprDependence::Instantiation;
211   return D & ~ExprDependence::UnexpandedPack;
212 }
213 
214 ExprDependence clang::computeDependence(AsTypeExpr *E) {
215   auto D = toExprDependence(E->getType()->getDependence()) |
216            E->getSrcExpr()->getDependence();
217   if (!E->getType()->isDependentType())
218     D &= ~ExprDependence::Type;
219   return D;
220 }
221 
222 ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) {
223   return E->getSemanticForm()->getDependence();
224 }
225 
226 ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) {
227   auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence());
228   D |= toExprDependence(E->getType()->getDependence()) &
229        (ExprDependence::Type | ExprDependence::Error);
230   return D;
231 }
232 
233 ExprDependence clang::computeDependence(CXXTypeidExpr *E) {
234   auto D = ExprDependence::None;
235   if (E->isTypeOperand())
236     D = toExprDependence(
237         E->getTypeOperandSourceInfo()->getType()->getDependence());
238   else
239     D = turnTypeToValueDependence(E->getExprOperand()->getDependence());
240   // typeid is never type-dependent (C++ [temp.dep.expr]p4)
241   return D & ~ExprDependence::Type;
242 }
243 
244 ExprDependence clang::computeDependence(MSPropertyRefExpr *E) {
245   return E->getBaseExpr()->getDependence() & ~ExprDependence::Type;
246 }
247 
248 ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) {
249   return E->getIdx()->getDependence();
250 }
251 
252 ExprDependence clang::computeDependence(CXXUuidofExpr *E) {
253   if (E->isTypeOperand())
254     return turnTypeToValueDependence(toExprDependence(
255         E->getTypeOperandSourceInfo()->getType()->getDependence()));
256 
257   return turnTypeToValueDependence(E->getExprOperand()->getDependence());
258 }
259 
260 ExprDependence clang::computeDependence(CXXThisExpr *E) {
261   // 'this' is type-dependent if the class type of the enclosing
262   // member function is dependent (C++ [temp.dep.expr]p2)
263   auto D = toExprDependence(E->getType()->getDependence());
264   assert(!(D & ExprDependence::UnexpandedPack));
265   return D;
266 }
267 
268 ExprDependence clang::computeDependence(CXXThrowExpr *E) {
269   auto *Op = E->getSubExpr();
270   if (!Op)
271     return ExprDependence::None;
272   return Op->getDependence() & ~ExprDependence::TypeValue;
273 }
274 
275 ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) {
276   return E->getSubExpr()->getDependence();
277 }
278 
279 ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) {
280   return toExprDependence(E->getType()->getDependence()) &
281          ~ExprDependence::TypeValue;
282 }
283 
284 ExprDependence clang::computeDependence(CXXDeleteExpr *E) {
285   return turnTypeToValueDependence(E->getArgument()->getDependence());
286 }
287 
288 ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) {
289   auto D = toExprDependence(E->getQueriedType()->getDependence());
290   if (auto *Dim = E->getDimensionExpression())
291     D |= Dim->getDependence();
292   return turnTypeToValueDependence(D);
293 }
294 
295 ExprDependence clang::computeDependence(ExpressionTraitExpr *E) {
296   // Never type-dependent.
297   auto D = E->getQueriedExpression()->getDependence() & ~ExprDependence::Type;
298   // Value-dependent if the argument is type-dependent.
299   if (E->getQueriedExpression()->isTypeDependent())
300     D |= ExprDependence::Value;
301   return D;
302 }
303 
304 ExprDependence clang::computeDependence(CXXNoexceptExpr *E, CanThrowResult CT) {
305   auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue;
306   if (CT == CT_Dependent)
307     D |= ExprDependence::ValueInstantiation;
308   return D;
309 }
310 
311 ExprDependence clang::computeDependence(PackExpansionExpr *E) {
312   return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) |
313          ExprDependence::TypeValueInstantiation;
314 }
315 
316 ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) {
317   return E->getReplacement()->getDependence();
318 }
319 
320 ExprDependence clang::computeDependence(CoroutineSuspendExpr *E) {
321   if (auto *Resume = E->getResumeExpr())
322     return (Resume->getDependence() &
323             (ExprDependence::TypeValue | ExprDependence::Error)) |
324            (E->getCommonExpr()->getDependence() & ~ExprDependence::TypeValue);
325   return E->getCommonExpr()->getDependence() |
326          ExprDependence::TypeValueInstantiation;
327 }
328 
329 ExprDependence clang::computeDependence(DependentCoawaitExpr *E) {
330   return E->getOperand()->getDependence() |
331          ExprDependence::TypeValueInstantiation;
332 }
333 
334 ExprDependence clang::computeDependence(ObjCBoxedExpr *E) {
335   return E->getSubExpr()->getDependence();
336 }
337 
338 ExprDependence clang::computeDependence(ObjCEncodeExpr *E) {
339   return toExprDependence(E->getEncodedType()->getDependence());
340 }
341 
342 ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) {
343   return turnTypeToValueDependence(E->getBase()->getDependence());
344 }
345 
346 ExprDependence clang::computeDependence(ObjCPropertyRefExpr *E) {
347   if (E->isObjectReceiver())
348     return E->getBase()->getDependence() & ~ExprDependence::Type;
349   if (E->isSuperReceiver())
350     return toExprDependence(E->getSuperReceiverType()->getDependence()) &
351            ~ExprDependence::TypeValue;
352   assert(E->isClassReceiver());
353   return ExprDependence::None;
354 }
355 
356 ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) {
357   return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence();
358 }
359 
360 ExprDependence clang::computeDependence(ObjCIsaExpr *E) {
361   return E->getBase()->getDependence() & ~ExprDependence::Type &
362          ~ExprDependence::UnexpandedPack;
363 }
364 
365 ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) {
366   return E->getSubExpr()->getDependence();
367 }
368 
369 ExprDependence clang::computeDependence(OMPArraySectionExpr *E) {
370   auto D = E->getBase()->getDependence();
371   if (auto *LB = E->getLowerBound())
372     D |= LB->getDependence();
373   if (auto *Len = E->getLength())
374     D |= Len->getDependence();
375   return D;
376 }
377 
378 ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) {
379   auto D = E->getBase()->getDependence() |
380            toExprDependence(E->getType()->getDependence());
381   for (Expr *Dim: E->getDimensions())
382     if (Dim)
383       D |= Dim->getDependence();
384   return D;
385 }
386 
387 ExprDependence clang::computeDependence(OMPIteratorExpr *E) {
388   auto D = toExprDependence(E->getType()->getDependence());
389   for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
390     if (auto *VD = cast_or_null<ValueDecl>(E->getIteratorDecl(I)))
391       D |= toExprDependence(VD->getType()->getDependence());
392     OMPIteratorExpr::IteratorRange IR = E->getIteratorRange(I);
393     if (Expr *BE = IR.Begin)
394       D |= BE->getDependence();
395     if (Expr *EE = IR.End)
396       D |= EE->getDependence();
397     if (Expr *SE = IR.Step)
398       D |= SE->getDependence();
399   }
400   return D;
401 }
402 
403 /// Compute the type-, value-, and instantiation-dependence of a
404 /// declaration reference
405 /// based on the declaration being referenced.
406 ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
407   auto Deps = ExprDependence::None;
408 
409   if (auto *NNS = E->getQualifier())
410     Deps |= toExprDependence(NNS->getDependence() &
411                              ~NestedNameSpecifierDependence::Dependent);
412 
413   if (auto *FirstArg = E->getTemplateArgs()) {
414     unsigned NumArgs = E->getNumTemplateArgs();
415     for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg)
416       Deps |= toExprDependence(Arg->getArgument().getDependence());
417   }
418 
419   auto *Decl = E->getDecl();
420   auto Type = E->getType();
421 
422   if (Decl->isParameterPack())
423     Deps |= ExprDependence::UnexpandedPack;
424   Deps |= toExprDependence(Type->getDependence()) & ExprDependence::Error;
425 
426   // (TD) C++ [temp.dep.expr]p3:
427   //   An id-expression is type-dependent if it contains:
428   //
429   // and
430   //
431   // (VD) C++ [temp.dep.constexpr]p2:
432   //  An identifier is value-dependent if it is:
433 
434   //  (TD)  - an identifier that was declared with dependent type
435   //  (VD)  - a name declared with a dependent type,
436   if (Type->isDependentType())
437     return Deps | ExprDependence::TypeValueInstantiation;
438   else if (Type->isInstantiationDependentType())
439     Deps |= ExprDependence::Instantiation;
440 
441   //  (TD)  - a conversion-function-id that specifies a dependent type
442   if (Decl->getDeclName().getNameKind() ==
443       DeclarationName::CXXConversionFunctionName) {
444     QualType T = Decl->getDeclName().getCXXNameType();
445     if (T->isDependentType())
446       return Deps | ExprDependence::TypeValueInstantiation;
447 
448     if (T->isInstantiationDependentType())
449       Deps |= ExprDependence::Instantiation;
450   }
451 
452   //  (VD)  - the name of a non-type template parameter,
453   if (isa<NonTypeTemplateParmDecl>(Decl))
454     return Deps | ExprDependence::ValueInstantiation;
455 
456   //  (VD) - a constant with integral or enumeration type and is
457   //         initialized with an expression that is value-dependent.
458   //  (VD) - a constant with literal type and is initialized with an
459   //         expression that is value-dependent [C++11].
460   //  (VD) - FIXME: Missing from the standard:
461   //       -  an entity with reference type and is initialized with an
462   //          expression that is value-dependent [C++11]
463   if (VarDecl *Var = dyn_cast<VarDecl>(Decl)) {
464     if ((Ctx.getLangOpts().CPlusPlus11
465              ? Var->getType()->isLiteralType(Ctx)
466              : Var->getType()->isIntegralOrEnumerationType()) &&
467         (Var->getType().isConstQualified() ||
468          Var->getType()->isReferenceType())) {
469       if (const Expr *Init = Var->getAnyInitializer()) {
470         if (Init->isValueDependent())
471           Deps |= ExprDependence::ValueInstantiation;
472         if (Init->containsErrors())
473           Deps |= ExprDependence::Error;
474       }
475     }
476 
477     // (VD) - FIXME: Missing from the standard:
478     //      -  a member function or a static data member of the current
479     //         instantiation
480     if (Var->isStaticDataMember() &&
481         Var->getDeclContext()->isDependentContext()) {
482       Deps |= ExprDependence::ValueInstantiation;
483       TypeSourceInfo *TInfo = Var->getFirstDecl()->getTypeSourceInfo();
484       if (TInfo->getType()->isIncompleteArrayType())
485         Deps |= ExprDependence::Type;
486     }
487 
488     return Deps;
489   }
490 
491   // (VD) - FIXME: Missing from the standard:
492   //      -  a member function or a static data member of the current
493   //         instantiation
494   if (isa<CXXMethodDecl>(Decl) && Decl->getDeclContext()->isDependentContext())
495     Deps |= ExprDependence::ValueInstantiation;
496   return Deps;
497 }
498 
499 ExprDependence clang::computeDependence(RecoveryExpr *E) {
500   // RecoveryExpr is
501   //   - always value-dependent, and therefore instantiation dependent
502   //   - contains errors (ExprDependence::Error), by definition
503   //   - type-dependent if we don't know the type (fallback to an opaque
504   //     dependent type), or the type is known and dependent, or it has
505   //     type-dependent subexpressions.
506   auto D = toExprDependence(E->getType()->getDependence()) |
507            ExprDependence::ErrorDependent;
508   // FIXME: remove the type-dependent bit from subexpressions, if the
509   // RecoveryExpr has a non-dependent type.
510   for (auto *S : E->subExpressions())
511     D |= S->getDependence();
512   return D;
513 }
514 
515 ExprDependence clang::computeDependence(PredefinedExpr *E) {
516   return toExprDependence(E->getType()->getDependence()) &
517          ~ExprDependence::UnexpandedPack;
518 }
519 
520 ExprDependence clang::computeDependence(CallExpr *E,
521                                         llvm::ArrayRef<Expr *> PreArgs) {
522   auto D = E->getCallee()->getDependence();
523   for (auto *A : llvm::makeArrayRef(E->getArgs(), E->getNumArgs())) {
524     if (A)
525       D |= A->getDependence();
526   }
527   for (auto *A : PreArgs)
528     D |= A->getDependence();
529   return D;
530 }
531 
532 ExprDependence clang::computeDependence(OffsetOfExpr *E) {
533   auto D = turnTypeToValueDependence(
534       toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()));
535   for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I)
536     D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence());
537   return D;
538 }
539 
540 ExprDependence clang::computeDependence(MemberExpr *E) {
541   auto *MemberDecl = E->getMemberDecl();
542   auto D = E->getBase()->getDependence();
543   if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
544     DeclContext *DC = MemberDecl->getDeclContext();
545     // dyn_cast_or_null is used to handle objC variables which do not
546     // have a declaration context.
547     CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
548     if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
549       if (!E->getType()->isDependentType())
550         D &= ~ExprDependence::Type;
551     }
552 
553     // Bitfield with value-dependent width is type-dependent.
554     if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
555       D |= ExprDependence::Type;
556     }
557   }
558   // FIXME: move remaining dependence computation from MemberExpr::Create()
559   return D;
560 }
561 
562 ExprDependence clang::computeDependence(InitListExpr *E) {
563   auto D = ExprDependence::None;
564   for (auto *A : E->inits())
565     D |= A->getDependence();
566   return D;
567 }
568 
569 ExprDependence clang::computeDependence(ShuffleVectorExpr *E) {
570   auto D = toExprDependence(E->getType()->getDependence());
571   for (auto *C : llvm::makeArrayRef(E->getSubExprs(), E->getNumSubExprs()))
572     D |= C->getDependence();
573   return D;
574 }
575 
576 ExprDependence clang::computeDependence(GenericSelectionExpr *E,
577                                         bool ContainsUnexpandedPack) {
578   auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack
579                                   : ExprDependence::None;
580   for (auto *AE : E->getAssocExprs())
581     D |= AE->getDependence() & ExprDependence::Error;
582   D |= E->getControllingExpr()->getDependence() & ExprDependence::Error;
583 
584   if (E->isResultDependent())
585     return D | ExprDependence::TypeValueInstantiation;
586   return D | (E->getResultExpr()->getDependence() &
587               ~ExprDependence::UnexpandedPack);
588 }
589 
590 ExprDependence clang::computeDependence(DesignatedInitExpr *E) {
591   auto Deps = E->getInit()->getDependence();
592   for (auto D : E->designators()) {
593     auto DesignatorDeps = ExprDependence::None;
594     if (D.isArrayDesignator())
595       DesignatorDeps |= E->getArrayIndex(D)->getDependence();
596     else if (D.isArrayRangeDesignator())
597       DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() |
598                         E->getArrayRangeEnd(D)->getDependence();
599     Deps |= DesignatorDeps;
600     if (DesignatorDeps & ExprDependence::TypeValue)
601       Deps |= ExprDependence::TypeValueInstantiation;
602   }
603   return Deps;
604 }
605 
606 ExprDependence clang::computeDependence(PseudoObjectExpr *O) {
607   auto D = O->getSyntacticForm()->getDependence();
608   for (auto *E : O->semantics())
609     D |= E->getDependence();
610   return D;
611 }
612 
613 ExprDependence clang::computeDependence(AtomicExpr *A) {
614   auto D = ExprDependence::None;
615   for (auto *E : llvm::makeArrayRef(A->getSubExprs(), A->getNumSubExprs()))
616     D |= E->getDependence();
617   return D;
618 }
619 
620 ExprDependence clang::computeDependence(CXXNewExpr *E) {
621   auto D = toExprDependence(E->getType()->getDependence());
622   auto Size = E->getArraySize();
623   if (Size.hasValue() && *Size)
624     D |= turnTypeToValueDependence((*Size)->getDependence());
625   if (auto *I = E->getInitializer())
626     D |= turnTypeToValueDependence(I->getDependence());
627   for (auto *A : E->placement_arguments())
628     D |= turnTypeToValueDependence(A->getDependence());
629   return D;
630 }
631 
632 ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) {
633   auto D = E->getBase()->getDependence();
634   if (!E->getDestroyedType().isNull())
635     D |= toExprDependence(E->getDestroyedType()->getDependence());
636   if (auto *ST = E->getScopeTypeInfo())
637     D |= turnTypeToValueDependence(
638         toExprDependence(ST->getType()->getDependence()));
639   if (auto *Q = E->getQualifier())
640     D |= toExprDependence(Q->getDependence() &
641                           ~NestedNameSpecifierDependence::Dependent);
642   return D;
643 }
644 
645 static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
646   auto D = ExprDependence::None;
647   if (Name.isInstantiationDependent())
648     D |= ExprDependence::Instantiation;
649   if (Name.containsUnexpandedParameterPack())
650     D |= ExprDependence::UnexpandedPack;
651   return D;
652 }
653 
654 ExprDependence
655 clang::computeDependence(OverloadExpr *E, bool KnownDependent,
656                          bool KnownInstantiationDependent,
657                          bool KnownContainsUnexpandedParameterPack) {
658   auto Deps = ExprDependence::None;
659   if (KnownDependent)
660     Deps |= ExprDependence::TypeValue;
661   if (KnownInstantiationDependent)
662     Deps |= ExprDependence::Instantiation;
663   if (KnownContainsUnexpandedParameterPack)
664     Deps |= ExprDependence::UnexpandedPack;
665   Deps |= getDependenceInExpr(E->getNameInfo());
666   if (auto *Q = E->getQualifier())
667     Deps |= toExprDependence(Q->getDependence() &
668                              ~NestedNameSpecifierDependence::Dependent);
669   for (auto *D : E->decls()) {
670     if (D->getDeclContext()->isDependentContext() ||
671         isa<UnresolvedUsingValueDecl>(D))
672       Deps |= ExprDependence::TypeValueInstantiation;
673   }
674   // If we have explicit template arguments, check for dependent
675   // template arguments and whether they contain any unexpanded pack
676   // expansions.
677   for (auto A : E->template_arguments())
678     Deps |= toExprDependence(A.getArgument().getDependence());
679   return Deps;
680 }
681 
682 ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) {
683   auto D = ExprDependence::TypeValue;
684   D |= getDependenceInExpr(E->getNameInfo());
685   if (auto *Q = E->getQualifier())
686     D |= toExprDependence(Q->getDependence());
687   for (auto A : E->template_arguments())
688     D |= toExprDependence(A.getArgument().getDependence());
689   return D;
690 }
691 
692 ExprDependence clang::computeDependence(CXXConstructExpr *E) {
693   auto D = toExprDependence(E->getType()->getDependence());
694   for (auto *A : E->arguments())
695     D |= A->getDependence() & ~ExprDependence::Type;
696   return D;
697 }
698 
699 ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
700   return E->getExpr()->getDependence();
701 }
702 
703 ExprDependence clang::computeDependence(LambdaExpr *E,
704                                         bool ContainsUnexpandedParameterPack) {
705   auto D = toExprDependence(E->getType()->getDependence());
706   if (ContainsUnexpandedParameterPack)
707     D |= ExprDependence::UnexpandedPack;
708   return D;
709 }
710 
711 ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) {
712   auto D = ExprDependence::ValueInstantiation;
713   D |= toExprDependence(E->getType()->getDependence());
714   for (auto *A : E->arguments())
715     D |= A->getDependence() &
716          (ExprDependence::UnexpandedPack | ExprDependence::Error);
717   return D;
718 }
719 
720 ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) {
721   auto D = ExprDependence::TypeValueInstantiation;
722   if (!E->isImplicitAccess())
723     D |= E->getBase()->getDependence();
724   if (auto *Q = E->getQualifier())
725     D |= toExprDependence(Q->getDependence());
726   D |= getDependenceInExpr(E->getMemberNameInfo());
727   for (auto A : E->template_arguments())
728     D |= toExprDependence(A.getArgument().getDependence());
729   return D;
730 }
731 
732 ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) {
733   return E->getSubExpr()->getDependence();
734 }
735 
736 ExprDependence clang::computeDependence(CXXFoldExpr *E) {
737   auto D = ExprDependence::TypeValueInstantiation;
738   for (const auto *C : {E->getLHS(), E->getRHS()}) {
739     if (C)
740       D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
741   }
742   return D;
743 }
744 
745 ExprDependence clang::computeDependence(TypeTraitExpr *E) {
746   auto D = ExprDependence::None;
747   for (const auto *A : E->getArgs())
748     D |=
749         toExprDependence(A->getType()->getDependence()) & ~ExprDependence::Type;
750   return D;
751 }
752 
753 ExprDependence clang::computeDependence(ConceptSpecializationExpr *E,
754                                         bool ValueDependent) {
755   auto TA = TemplateArgumentDependence::None;
756   const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
757                                TemplateArgumentDependence::UnexpandedPack;
758   for (const TemplateArgumentLoc &ArgLoc :
759        E->getTemplateArgsAsWritten()->arguments()) {
760     TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
761     if (TA == InterestingDeps)
762       break;
763   }
764 
765   ExprDependence D =
766       ValueDependent ? ExprDependence::Value : ExprDependence::None;
767   return D | toExprDependence(TA);
768 }
769 
770 ExprDependence clang::computeDependence(ObjCArrayLiteral *E) {
771   auto D = ExprDependence::None;
772   Expr **Elements = E->getElements();
773   for (unsigned I = 0, N = E->getNumElements(); I != N; ++I)
774     D |= turnTypeToValueDependence(Elements[I]->getDependence());
775   return D;
776 }
777 
778 ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) {
779   auto Deps = ExprDependence::None;
780   for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) {
781     auto KV = E->getKeyValueElement(I);
782     auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() |
783                                             KV.Value->getDependence());
784     if (KV.EllipsisLoc.isValid())
785       KVDeps &= ~ExprDependence::UnexpandedPack;
786     Deps |= KVDeps;
787   }
788   return Deps;
789 }
790 
791 ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
792   auto D = ExprDependence::None;
793   if (auto *R = E->getInstanceReceiver())
794     D |= R->getDependence();
795   else
796     D |= toExprDependence(E->getType()->getDependence());
797   for (auto *A : E->arguments())
798     D |= A->getDependence();
799   return D;
800 }
801