xref: /freebsd/contrib/llvm-project/clang/lib/AST/ComputeDependence.cpp (revision 9f23cbd6cae82fd77edfad7173432fa8dccd0a95)
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 = toExprDependenceForImpliedType(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                                         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 
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 
114 ExprDependence clang::computeDependence(ArraySubscriptExpr *E) {
115   return E->getLHS()->getDependence() | E->getRHS()->getDependence();
116 }
117 
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 
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 
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 
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 
160 ExprDependence clang::computeDependence(BinaryOperator *E) {
161   return E->getLHS()->getDependence() | E->getRHS()->getDependence();
162 }
163 
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 
173 ExprDependence clang::computeDependence(BinaryConditionalOperator *E) {
174   return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence();
175 }
176 
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 
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 
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 
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 
226 ExprDependence clang::computeDependence(VAArgExpr *E) {
227   auto D = toExprDependenceAsWritten(
228                E->getWrittenTypeInfo()->getType()->getDependence()) |
229            (E->getSubExpr()->getDependence() & ~ExprDependence::Type);
230   return D & ~ExprDependence::Value;
231 }
232 
233 ExprDependence clang::computeDependence(NoInitExpr *E) {
234   return toExprDependenceForImpliedType(E->getType()->getDependence()) &
235          (ExprDependence::Instantiation | ExprDependence::Error);
236 }
237 
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 
246 ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) {
247   return toExprDependenceForImpliedType(E->getType()->getDependence()) &
248          ExprDependence::Instantiation;
249 }
250 
251 ExprDependence clang::computeDependence(ExtVectorElementExpr *E) {
252   return E->getBase()->getDependence();
253 }
254 
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 
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 
272 ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) {
273   return E->getSemanticForm()->getDependence();
274 }
275 
276 ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) {
277   auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence());
278   D |= toExprDependenceForImpliedType(E->getType()->getDependence());
279   return D;
280 }
281 
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 
293 ExprDependence clang::computeDependence(MSPropertyRefExpr *E) {
294   return E->getBaseExpr()->getDependence() & ~ExprDependence::Type;
295 }
296 
297 ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) {
298   return E->getIdx()->getDependence();
299 }
300 
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 
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 
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 
324 ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) {
325   return E->getSubExpr()->getDependence();
326 }
327 
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 
335 ExprDependence clang::computeDependence(CXXDeleteExpr *E) {
336   return turnTypeToValueDependence(E->getArgument()->getDependence());
337 }
338 
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 
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 
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 
362 ExprDependence clang::computeDependence(PackExpansionExpr *E) {
363   return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) |
364          ExprDependence::TypeValueInstantiation;
365 }
366 
367 ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) {
368   return E->getReplacement()->getDependence();
369 }
370 
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 
380 ExprDependence clang::computeDependence(DependentCoawaitExpr *E) {
381   return E->getOperand()->getDependence() |
382          ExprDependence::TypeValueInstantiation;
383 }
384 
385 ExprDependence clang::computeDependence(ObjCBoxedExpr *E) {
386   return E->getSubExpr()->getDependence();
387 }
388 
389 ExprDependence clang::computeDependence(ObjCEncodeExpr *E) {
390   return toExprDependenceAsWritten(E->getEncodedType()->getDependence());
391 }
392 
393 ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) {
394   return turnTypeToValueDependence(E->getBase()->getDependence());
395 }
396 
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 
408 ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) {
409   return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence();
410 }
411 
412 ExprDependence clang::computeDependence(ObjCIsaExpr *E) {
413   return E->getBase()->getDependence() & ~ExprDependence::Type &
414          ~ExprDependence::UnexpandedPack;
415 }
416 
417 ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) {
418   return E->getSubExpr()->getDependence();
419 }
420 
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 
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 
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.
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   //
488   // [The "or more" case is not modeled as a DeclRefExpr. There are a bunch
489   // more bullets here that we handle by treating the declaration as having a
490   // dependent type if they involve a placeholder type that can't be deduced.]
491   if (Type->isDependentType())
492     Deps |= ExprDependence::TypeValueInstantiation;
493   else if (Type->isInstantiationDependentType())
494     Deps |= ExprDependence::Instantiation;
495 
496   //    - a conversion-function-id that specifies a dependent type
497   if (Decl->getDeclName().getNameKind() ==
498       DeclarationName::CXXConversionFunctionName) {
499     QualType T = Decl->getDeclName().getCXXNameType();
500     if (T->isDependentType())
501       return Deps | ExprDependence::TypeValueInstantiation;
502 
503     if (T->isInstantiationDependentType())
504       Deps |= ExprDependence::Instantiation;
505   }
506 
507   //   - a template-id that is dependent,
508   //   - a nested-name-specifier or a qualified-id that names a member of an
509   //     unknown specialization
510   //   [These are not modeled as DeclRefExprs.]
511 
512   //   or if it names a dependent member of the current instantiation that is a
513   //   static data member of type "array of unknown bound of T" for some T
514   //   [handled below].
515 
516   // C++ [temp.dep.constexpr]p2:
517   //  An id-expression is value-dependent if:
518 
519   //    - it is type-dependent [handled above]
520 
521   //    - it is the name of a non-type template parameter,
522   if (isa<NonTypeTemplateParmDecl>(Decl))
523     return Deps | ExprDependence::ValueInstantiation;
524 
525   //   - it names a potentially-constant variable that is initialized with an
526   //     expression that is value-dependent
527   if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
528     if (const Expr *Init = Var->getAnyInitializer()) {
529       if (Init->containsErrors())
530         Deps |= ExprDependence::Error;
531 
532       if (Var->mightBeUsableInConstantExpressions(Ctx) &&
533           Init->isValueDependent())
534         Deps |= ExprDependence::ValueInstantiation;
535     }
536 
537     // - it names a static data member that is a dependent member of the
538     //   current instantiation and is not initialized in a member-declarator,
539     if (Var->isStaticDataMember() &&
540         Var->getDeclContext()->isDependentContext() &&
541         !Var->getFirstDecl()->hasInit()) {
542       const VarDecl *First = Var->getFirstDecl();
543       TypeSourceInfo *TInfo = First->getTypeSourceInfo();
544       if (TInfo->getType()->isIncompleteArrayType()) {
545         Deps |= ExprDependence::TypeValueInstantiation;
546       } else if (!First->hasInit()) {
547         Deps |= ExprDependence::ValueInstantiation;
548       }
549     }
550 
551     return Deps;
552   }
553 
554   //   - it names a static member function that is a dependent member of the
555   //     current instantiation
556   //
557   // FIXME: It's unclear that the restriction to static members here has any
558   // effect: any use of a non-static member function name requires either
559   // forming a pointer-to-member or providing an object parameter, either of
560   // which makes the overall expression value-dependent.
561   if (auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
562     if (MD->isStatic() && Decl->getDeclContext()->isDependentContext())
563       Deps |= ExprDependence::ValueInstantiation;
564   }
565 
566   return Deps;
567 }
568 
569 ExprDependence clang::computeDependence(RecoveryExpr *E) {
570   // RecoveryExpr is
571   //   - always value-dependent, and therefore instantiation dependent
572   //   - contains errors (ExprDependence::Error), by definition
573   //   - type-dependent if we don't know the type (fallback to an opaque
574   //     dependent type), or the type is known and dependent, or it has
575   //     type-dependent subexpressions.
576   auto D = toExprDependenceAsWritten(E->getType()->getDependence()) |
577            ExprDependence::ErrorDependent;
578   // FIXME: remove the type-dependent bit from subexpressions, if the
579   // RecoveryExpr has a non-dependent type.
580   for (auto *S : E->subExpressions())
581     D |= S->getDependence();
582   return D;
583 }
584 
585 ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) {
586   return toExprDependenceAsWritten(
587       E->getTypeSourceInfo()->getType()->getDependence());
588 }
589 
590 ExprDependence clang::computeDependence(PredefinedExpr *E) {
591   return toExprDependenceForImpliedType(E->getType()->getDependence());
592 }
593 
594 ExprDependence clang::computeDependence(CallExpr *E,
595                                         llvm::ArrayRef<Expr *> PreArgs) {
596   auto D = E->getCallee()->getDependence();
597   for (auto *A : llvm::ArrayRef(E->getArgs(), E->getNumArgs())) {
598     if (A)
599       D |= A->getDependence();
600   }
601   for (auto *A : PreArgs)
602     D |= A->getDependence();
603   return D;
604 }
605 
606 ExprDependence clang::computeDependence(OffsetOfExpr *E) {
607   auto D = turnTypeToValueDependence(toExprDependenceAsWritten(
608       E->getTypeSourceInfo()->getType()->getDependence()));
609   for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I)
610     D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence());
611   return D;
612 }
613 
614 ExprDependence clang::computeDependence(MemberExpr *E) {
615   auto *MemberDecl = E->getMemberDecl();
616   auto D = E->getBase()->getDependence();
617   if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
618     DeclContext *DC = MemberDecl->getDeclContext();
619     // dyn_cast_or_null is used to handle objC variables which do not
620     // have a declaration context.
621     CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
622     if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
623       if (!E->getType()->isDependentType())
624         D &= ~ExprDependence::Type;
625     }
626 
627     // Bitfield with value-dependent width is type-dependent.
628     if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
629       D |= ExprDependence::Type;
630     }
631   }
632   // FIXME: move remaining dependence computation from MemberExpr::Create()
633   return D;
634 }
635 
636 ExprDependence clang::computeDependence(InitListExpr *E) {
637   auto D = ExprDependence::None;
638   for (auto *A : E->inits())
639     D |= A->getDependence();
640   return D;
641 }
642 
643 ExprDependence clang::computeDependence(ShuffleVectorExpr *E) {
644   auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
645   for (auto *C : llvm::ArrayRef(E->getSubExprs(), E->getNumSubExprs()))
646     D |= C->getDependence();
647   return D;
648 }
649 
650 ExprDependence clang::computeDependence(GenericSelectionExpr *E,
651                                         bool ContainsUnexpandedPack) {
652   auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack
653                                   : ExprDependence::None;
654   for (auto *AE : E->getAssocExprs())
655     D |= AE->getDependence() & ExprDependence::Error;
656   D |= E->getControllingExpr()->getDependence() & ExprDependence::Error;
657 
658   if (E->isResultDependent())
659     return D | ExprDependence::TypeValueInstantiation;
660   return D | (E->getResultExpr()->getDependence() &
661               ~ExprDependence::UnexpandedPack);
662 }
663 
664 ExprDependence clang::computeDependence(DesignatedInitExpr *E) {
665   auto Deps = E->getInit()->getDependence();
666   for (auto D : E->designators()) {
667     auto DesignatorDeps = ExprDependence::None;
668     if (D.isArrayDesignator())
669       DesignatorDeps |= E->getArrayIndex(D)->getDependence();
670     else if (D.isArrayRangeDesignator())
671       DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() |
672                         E->getArrayRangeEnd(D)->getDependence();
673     Deps |= DesignatorDeps;
674     if (DesignatorDeps & ExprDependence::TypeValue)
675       Deps |= ExprDependence::TypeValueInstantiation;
676   }
677   return Deps;
678 }
679 
680 ExprDependence clang::computeDependence(PseudoObjectExpr *O) {
681   auto D = O->getSyntacticForm()->getDependence();
682   for (auto *E : O->semantics())
683     D |= E->getDependence();
684   return D;
685 }
686 
687 ExprDependence clang::computeDependence(AtomicExpr *A) {
688   auto D = ExprDependence::None;
689   for (auto *E : llvm::ArrayRef(A->getSubExprs(), A->getNumSubExprs()))
690     D |= E->getDependence();
691   return D;
692 }
693 
694 ExprDependence clang::computeDependence(CXXNewExpr *E) {
695   auto D = toExprDependenceAsWritten(
696       E->getAllocatedTypeSourceInfo()->getType()->getDependence());
697   D |= toExprDependenceForImpliedType(E->getAllocatedType()->getDependence());
698   auto Size = E->getArraySize();
699   if (Size && *Size)
700     D |= turnTypeToValueDependence((*Size)->getDependence());
701   if (auto *I = E->getInitializer())
702     D |= turnTypeToValueDependence(I->getDependence());
703   for (auto *A : E->placement_arguments())
704     D |= turnTypeToValueDependence(A->getDependence());
705   return D;
706 }
707 
708 ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) {
709   auto D = E->getBase()->getDependence();
710   if (auto *TSI = E->getDestroyedTypeInfo())
711     D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
712   if (auto *ST = E->getScopeTypeInfo())
713     D |= turnTypeToValueDependence(
714         toExprDependenceAsWritten(ST->getType()->getDependence()));
715   if (auto *Q = E->getQualifier())
716     D |= toExprDependence(Q->getDependence() &
717                           ~NestedNameSpecifierDependence::Dependent);
718   return D;
719 }
720 
721 static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
722   auto D = ExprDependence::None;
723   if (Name.isInstantiationDependent())
724     D |= ExprDependence::Instantiation;
725   if (Name.containsUnexpandedParameterPack())
726     D |= ExprDependence::UnexpandedPack;
727   return D;
728 }
729 
730 ExprDependence
731 clang::computeDependence(OverloadExpr *E, bool KnownDependent,
732                          bool KnownInstantiationDependent,
733                          bool KnownContainsUnexpandedParameterPack) {
734   auto Deps = ExprDependence::None;
735   if (KnownDependent)
736     Deps |= ExprDependence::TypeValue;
737   if (KnownInstantiationDependent)
738     Deps |= ExprDependence::Instantiation;
739   if (KnownContainsUnexpandedParameterPack)
740     Deps |= ExprDependence::UnexpandedPack;
741   Deps |= getDependenceInExpr(E->getNameInfo());
742   if (auto *Q = E->getQualifier())
743     Deps |= toExprDependence(Q->getDependence() &
744                              ~NestedNameSpecifierDependence::Dependent);
745   for (auto *D : E->decls()) {
746     if (D->getDeclContext()->isDependentContext() ||
747         isa<UnresolvedUsingValueDecl>(D))
748       Deps |= ExprDependence::TypeValueInstantiation;
749   }
750   // If we have explicit template arguments, check for dependent
751   // template arguments and whether they contain any unexpanded pack
752   // expansions.
753   for (auto A : E->template_arguments())
754     Deps |= toExprDependence(A.getArgument().getDependence());
755   return Deps;
756 }
757 
758 ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) {
759   auto D = ExprDependence::TypeValue;
760   D |= getDependenceInExpr(E->getNameInfo());
761   if (auto *Q = E->getQualifier())
762     D |= toExprDependence(Q->getDependence());
763   for (auto A : E->template_arguments())
764     D |= toExprDependence(A.getArgument().getDependence());
765   return D;
766 }
767 
768 ExprDependence clang::computeDependence(CXXConstructExpr *E) {
769   ExprDependence D =
770       toExprDependenceForImpliedType(E->getType()->getDependence());
771   for (auto *A : E->arguments())
772     D |= A->getDependence() & ~ExprDependence::Type;
773   return D;
774 }
775 
776 ExprDependence clang::computeDependence(CXXTemporaryObjectExpr *E) {
777   CXXConstructExpr *BaseE = E;
778   return toExprDependenceAsWritten(
779              E->getTypeSourceInfo()->getType()->getDependence()) |
780          computeDependence(BaseE);
781 }
782 
783 ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
784   return E->getExpr()->getDependence();
785 }
786 
787 ExprDependence clang::computeDependence(CXXDefaultArgExpr *E) {
788   return E->getExpr()->getDependence();
789 }
790 
791 ExprDependence clang::computeDependence(LambdaExpr *E,
792                                         bool ContainsUnexpandedParameterPack) {
793   auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
794   if (ContainsUnexpandedParameterPack)
795     D |= ExprDependence::UnexpandedPack;
796   return D;
797 }
798 
799 ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) {
800   auto D = ExprDependence::ValueInstantiation;
801   D |= toExprDependenceAsWritten(E->getTypeAsWritten()->getDependence());
802   D |= toExprDependenceForImpliedType(E->getType()->getDependence());
803   for (auto *A : E->arguments())
804     D |= A->getDependence() &
805          (ExprDependence::UnexpandedPack | ExprDependence::Error);
806   return D;
807 }
808 
809 ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) {
810   auto D = ExprDependence::TypeValueInstantiation;
811   if (!E->isImplicitAccess())
812     D |= E->getBase()->getDependence();
813   if (auto *Q = E->getQualifier())
814     D |= toExprDependence(Q->getDependence());
815   D |= getDependenceInExpr(E->getMemberNameInfo());
816   for (auto A : E->template_arguments())
817     D |= toExprDependence(A.getArgument().getDependence());
818   return D;
819 }
820 
821 ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) {
822   return E->getSubExpr()->getDependence();
823 }
824 
825 ExprDependence clang::computeDependence(CXXFoldExpr *E) {
826   auto D = ExprDependence::TypeValueInstantiation;
827   for (const auto *C : {E->getLHS(), E->getRHS()}) {
828     if (C)
829       D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
830   }
831   return D;
832 }
833 
834 ExprDependence clang::computeDependence(CXXParenListInitExpr *E) {
835   auto D = ExprDependence::None;
836   for (const auto *A : E->getInitExprs())
837     D |= A->getDependence();
838   return D;
839 }
840 
841 ExprDependence clang::computeDependence(TypeTraitExpr *E) {
842   auto D = ExprDependence::None;
843   for (const auto *A : E->getArgs())
844     D |= toExprDependenceAsWritten(A->getType()->getDependence()) &
845          ~ExprDependence::Type;
846   return D;
847 }
848 
849 ExprDependence clang::computeDependence(ConceptSpecializationExpr *E,
850                                         bool ValueDependent) {
851   auto TA = TemplateArgumentDependence::None;
852   const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
853                                TemplateArgumentDependence::UnexpandedPack;
854   for (const TemplateArgumentLoc &ArgLoc :
855        E->getTemplateArgsAsWritten()->arguments()) {
856     TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
857     if (TA == InterestingDeps)
858       break;
859   }
860 
861   ExprDependence D =
862       ValueDependent ? ExprDependence::Value : ExprDependence::None;
863   auto Res = D | toExprDependence(TA);
864   if(!ValueDependent && E->getSatisfaction().ContainsErrors)
865     Res |= ExprDependence::Error;
866   return Res;
867 }
868 
869 ExprDependence clang::computeDependence(ObjCArrayLiteral *E) {
870   auto D = ExprDependence::None;
871   Expr **Elements = E->getElements();
872   for (unsigned I = 0, N = E->getNumElements(); I != N; ++I)
873     D |= turnTypeToValueDependence(Elements[I]->getDependence());
874   return D;
875 }
876 
877 ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) {
878   auto Deps = ExprDependence::None;
879   for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) {
880     auto KV = E->getKeyValueElement(I);
881     auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() |
882                                             KV.Value->getDependence());
883     if (KV.EllipsisLoc.isValid())
884       KVDeps &= ~ExprDependence::UnexpandedPack;
885     Deps |= KVDeps;
886   }
887   return Deps;
888 }
889 
890 ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
891   auto D = ExprDependence::None;
892   if (auto *R = E->getInstanceReceiver())
893     D |= R->getDependence();
894   else
895     D |= toExprDependenceForImpliedType(E->getType()->getDependence());
896   for (auto *A : E->arguments())
897     D |= A->getDependence();
898   return D;
899 }
900