clang 18.0.0git
ComputeDependence.cpp
Go to the documentation of this file.
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
10#include "clang/AST/Attr.h"
11#include "clang/AST/DeclCXX.h"
14#include "clang/AST/Expr.h"
15#include "clang/AST/ExprCXX.h"
17#include "clang/AST/ExprObjC.h"
20#include "llvm/ADT/ArrayRef.h"
21
22using namespace clang;
23
25 return E->getSubExpr()->getDependence();
26}
27
30 if (auto *S = E->getSourceExpr())
31 D |= S->getDependence();
32 assert(!(D & ExprDependence::UnexpandedPack));
33 return D;
34}
35
37 return E->getSubExpr()->getDependence();
38}
39
41 const ASTContext &Ctx) {
42 ExprDependence Dep =
43 // FIXME: Do we need to look at the type?
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;
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
78 // Never type-dependent (C++ [temp.dep.expr]p3).
79 // Value-dependent if the argument is type-dependent.
80 if (E->isArgumentType())
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
115 return E->getLHS()->getDependence() | E->getRHS()->getDependence();
116}
117
119 return E->getBase()->getDependence() | E->getRowIdx()->getDependence() |
121 : ExprDependence::None);
122}
123
129}
130
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.
137 if (auto *S = E->getSubExpr())
138 D |= S->getDependence() & ~ExprDependence::Type;
139 return D;
140}
141
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.
153 cast<ExplicitCastExpr>(E)->getTypeAsWritten()->getDependence()) |
155 if (auto *S = E->getSubExpr())
156 D |= S->getDependence() & ~ExprDependence::Type;
157 return D;
158}
159
161 return E->getLHS()->getDependence() | E->getRHS()->getDependence();
162}
163
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
174 return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence();
175}
176
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
197 if (!E->getType()->isDependentType())
199 return D;
200}
201
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
220 auto D = ExprDependence::None;
221 for (auto *E : P->exprs())
222 D |= E->getDependence();
223 return D;
224}
225
230 return D;
231}
232
235 (ExprDependence::Instantiation | ExprDependence::Error);
236}
237
239 auto D = E->getCommonExpr()->getDependence() |
240 E->getSubExpr()->getDependence() | ExprDependence::Instantiation;
242 D &= ~ExprDependence::Instantiation;
244}
245
248 ExprDependence::Instantiation;
249}
250
252 return E->getBase()->getDependence();
253}
254
258 D |= ExprDependence::Instantiation;
259 return D;
260}
261
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.
267 if (!E->getType()->isDependentType())
269 return D;
270}
271
273 return E->getSemanticForm()->getDependence();
274}
275
279 return D;
280}
281
283 auto D = ExprDependence::None;
284 if (E->isTypeOperand())
287 else
289 // typeid is never type-dependent (C++ [temp.dep.expr]p4)
290 return D & ~ExprDependence::Type;
291}
292
295}
296
298 return E->getIdx()->getDependence();
299}
300
302 if (E->isTypeOperand())
305
307}
308
310 // 'this' is type-dependent if the class type of the enclosing
311 // member function is dependent (C++ [temp.dep.expr]p2)
313 assert(!(D & ExprDependence::UnexpandedPack));
314 return D;
315}
316
318 auto *Op = E->getSubExpr();
319 if (!Op)
320 return ExprDependence::None;
321 return Op->getDependence() & ~ExprDependence::TypeValue;
322}
323
325 return E->getSubExpr()->getDependence();
326}
327
330 if (auto *TSI = E->getTypeSourceInfo())
331 D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
332 return D;
333}
334
337}
338
341 if (auto *Dim = E->getDimensionExpression())
342 D |= Dim->getDependence();
344}
345
347 // Never type-dependent.
349 // Value-dependent if the argument is type-dependent.
351 D |= ExprDependence::Value;
352 return D;
353}
354
356 auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue;
357 if (CT == CT_Dependent)
358 D |= ExprDependence::ValueInstantiation;
359 return D;
360}
361
363 return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) |
364 ExprDependence::TypeValueInstantiation;
365}
366
368 return E->getReplacement()->getDependence();
369}
370
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
381 return E->getOperand()->getDependence() |
382 ExprDependence::TypeValueInstantiation;
383}
384
386 return E->getSubExpr()->getDependence();
387}
388
391}
392
395}
396
398 if (E->isObjectReceiver())
400 if (E->isSuperReceiver())
403 ~ExprDependence::TypeValue;
404 assert(E->isClassReceiver());
405 return ExprDependence::None;
406}
407
409 return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence();
410}
411
414 ~ExprDependence::UnexpandedPack;
415}
416
418 return E->getSubExpr()->getDependence();
419}
420
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
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
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 }
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.
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;
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;
498 Deps |= ExprDependence::Instantiation;
499
500 // - an identifier associated by name lookup with an entity captured by
501 // copy ([expr.prim.lambda.capture])
503 Deps |= ExprDependence::Type;
504
505 // - a conversion-function-id that specifies a dependent type
506 if (Decl->getDeclName().getNameKind() ==
508 QualType T = Decl->getDeclName().getCXXNameType();
509 if (T->isDependentType())
510 return Deps | ExprDependence::TypeValueInstantiation;
511
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
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.
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
597}
598
601}
602
604 llvm::ArrayRef<Expr *> PreArgs) {
605 auto D = E->getCallee()->getDependence();
606 for (auto *A : llvm::ArrayRef(E->getArgs(), E->getNumArgs())) {
607 if (A)
608 D |= A->getDependence();
609 }
610 for (auto *A : PreArgs)
611 D |= A->getDependence();
612 return D;
613}
614
618 for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I)
620 return D;
621}
622
624 auto D = ExprDependence::None;
625 if (Name.isInstantiationDependent())
626 D |= ExprDependence::Instantiation;
627 if (Name.containsUnexpandedParameterPack())
628 D |= ExprDependence::UnexpandedPack;
629 return D;
630}
631
633 auto D = E->getBase()->getDependence();
635
636 if (auto *NNS = E->getQualifier())
637 D |= toExprDependence(NNS->getDependence() &
638 ~NestedNameSpecifierDependence::Dependent);
639
640 auto *MemberDecl = E->getMemberDecl();
641 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
642 DeclContext *DC = MemberDecl->getDeclContext();
643 // dyn_cast_or_null is used to handle objC variables which do not
644 // have a declaration context.
645 CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
646 if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
647 if (!E->getType()->isDependentType())
649 }
650
651 // Bitfield with value-dependent width is type-dependent.
652 if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
653 D |= ExprDependence::Type;
654 }
655 }
656 // FIXME: move remaining dependence computation from MemberExpr::Create()
657 return D;
658}
659
661 auto D = ExprDependence::None;
662 for (auto *A : E->inits())
663 D |= A->getDependence();
664 return D;
665}
666
669 for (auto *C : llvm::ArrayRef(E->getSubExprs(), E->getNumSubExprs()))
670 D |= C->getDependence();
671 return D;
672}
673
675 bool ContainsUnexpandedPack) {
676 auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack
677 : ExprDependence::None;
678 for (auto *AE : E->getAssocExprs())
679 D |= AE->getDependence() & ExprDependence::Error;
680
681 if (E->isExprPredicate())
682 D |= E->getControllingExpr()->getDependence() & ExprDependence::Error;
683 else
686
687 if (E->isResultDependent())
688 return D | ExprDependence::TypeValueInstantiation;
689 return D | (E->getResultExpr()->getDependence() &
690 ~ExprDependence::UnexpandedPack);
691}
692
694 auto Deps = E->getInit()->getDependence();
695 for (const auto &D : E->designators()) {
696 auto DesignatorDeps = ExprDependence::None;
697 if (D.isArrayDesignator())
698 DesignatorDeps |= E->getArrayIndex(D)->getDependence();
699 else if (D.isArrayRangeDesignator())
700 DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() |
702 Deps |= DesignatorDeps;
703 if (DesignatorDeps & ExprDependence::TypeValue)
704 Deps |= ExprDependence::TypeValueInstantiation;
705 }
706 return Deps;
707}
708
710 auto D = O->getSyntacticForm()->getDependence();
711 for (auto *E : O->semantics())
712 D |= E->getDependence();
713 return D;
714}
715
717 auto D = ExprDependence::None;
718 for (auto *E : llvm::ArrayRef(A->getSubExprs(), A->getNumSubExprs()))
719 D |= E->getDependence();
720 return D;
721}
722
727 auto Size = E->getArraySize();
728 if (Size && *Size)
729 D |= turnTypeToValueDependence((*Size)->getDependence());
730 if (auto *I = E->getInitializer())
731 D |= turnTypeToValueDependence(I->getDependence());
732 for (auto *A : E->placement_arguments())
733 D |= turnTypeToValueDependence(A->getDependence());
734 return D;
735}
736
738 auto D = E->getBase()->getDependence();
739 if (auto *TSI = E->getDestroyedTypeInfo())
740 D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
741 if (auto *ST = E->getScopeTypeInfo())
743 toExprDependenceAsWritten(ST->getType()->getDependence()));
744 if (auto *Q = E->getQualifier())
745 D |= toExprDependence(Q->getDependence() &
746 ~NestedNameSpecifierDependence::Dependent);
747 return D;
748}
749
752 bool KnownInstantiationDependent,
753 bool KnownContainsUnexpandedParameterPack) {
754 auto Deps = ExprDependence::None;
755 if (KnownDependent)
756 Deps |= ExprDependence::TypeValue;
757 if (KnownInstantiationDependent)
758 Deps |= ExprDependence::Instantiation;
759 if (KnownContainsUnexpandedParameterPack)
760 Deps |= ExprDependence::UnexpandedPack;
761 Deps |= getDependenceInExpr(E->getNameInfo());
762 if (auto *Q = E->getQualifier())
763 Deps |= toExprDependence(Q->getDependence() &
764 ~NestedNameSpecifierDependence::Dependent);
765 for (auto *D : E->decls()) {
766 if (D->getDeclContext()->isDependentContext() ||
767 isa<UnresolvedUsingValueDecl>(D))
768 Deps |= ExprDependence::TypeValueInstantiation;
769 }
770 // If we have explicit template arguments, check for dependent
771 // template arguments and whether they contain any unexpanded pack
772 // expansions.
773 for (const auto &A : E->template_arguments())
774 Deps |= toExprDependence(A.getArgument().getDependence());
775 return Deps;
776}
777
779 auto D = ExprDependence::TypeValue;
781 if (auto *Q = E->getQualifier())
782 D |= toExprDependence(Q->getDependence());
783 for (const auto &A : E->template_arguments())
784 D |= toExprDependence(A.getArgument().getDependence());
785 return D;
786}
787
791 for (auto *A : E->arguments())
792 D |= A->getDependence() & ~ExprDependence::Type;
793 return D;
794}
795
797 CXXConstructExpr *BaseE = E;
800 computeDependence(BaseE);
801}
802
804 return E->getExpr()->getDependence();
805}
806
808 return E->getExpr()->getDependence();
809}
810
812 bool ContainsUnexpandedParameterPack) {
814 if (ContainsUnexpandedParameterPack)
815 D |= ExprDependence::UnexpandedPack;
816 return D;
817}
818
820 auto D = ExprDependence::ValueInstantiation;
823 for (auto *A : E->arguments())
824 D |= A->getDependence() &
825 (ExprDependence::UnexpandedPack | ExprDependence::Error);
826 return D;
827}
828
830 auto D = ExprDependence::TypeValueInstantiation;
831 if (!E->isImplicitAccess())
832 D |= E->getBase()->getDependence();
833 if (auto *Q = E->getQualifier())
834 D |= toExprDependence(Q->getDependence());
836 for (const auto &A : E->template_arguments())
837 D |= toExprDependence(A.getArgument().getDependence());
838 return D;
839}
840
842 return E->getSubExpr()->getDependence();
843}
844
846 auto D = ExprDependence::TypeValueInstantiation;
847 for (const auto *C : {E->getLHS(), E->getRHS()}) {
848 if (C)
849 D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
850 }
851 return D;
852}
853
855 auto D = ExprDependence::None;
856 for (const auto *A : E->getInitExprs())
857 D |= A->getDependence();
858 return D;
859}
860
862 auto D = ExprDependence::None;
863 for (const auto *A : E->getArgs())
864 D |= toExprDependenceAsWritten(A->getType()->getDependence()) &
866 return D;
867}
868
870 bool ValueDependent) {
871 auto TA = TemplateArgumentDependence::None;
872 const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
873 TemplateArgumentDependence::UnexpandedPack;
874 for (const TemplateArgumentLoc &ArgLoc :
876 TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
877 if (TA == InterestingDeps)
878 break;
879 }
880
882 ValueDependent ? ExprDependence::Value : ExprDependence::None;
883 auto Res = D | toExprDependence(TA);
884 if(!ValueDependent && E->getSatisfaction().ContainsErrors)
885 Res |= ExprDependence::Error;
886 return Res;
887}
888
890 auto D = ExprDependence::None;
891 Expr **Elements = E->getElements();
892 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I)
893 D |= turnTypeToValueDependence(Elements[I]->getDependence());
894 return D;
895}
896
898 auto Deps = ExprDependence::None;
899 for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) {
900 auto KV = E->getKeyValueElement(I);
901 auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() |
902 KV.Value->getDependence());
903 if (KV.EllipsisLoc.isValid())
904 KVDeps &= ~ExprDependence::UnexpandedPack;
905 Deps |= KVDeps;
906 }
907 return Deps;
908}
909
911 auto D = ExprDependence::None;
912 if (auto *R = E->getInstanceReceiver())
913 D |= R->getDependence();
914 else
916 for (auto *A : E->arguments())
917 D |= A->getDependence();
918 return D;
919}
StringRef P
static ExprDependence getDependenceInExpr(DeclarationNameInfo Name)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the ExceptionSpecificationType enumeration and various utility functions.
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines Expressions and AST nodes for C++2a concepts.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
const LangOptions & getLangOpts() const
Definition: ASTContext.h:767
Represents a loop initializing the elements of an array.
Definition: Expr.h:5522
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Definition: Expr.h:5537
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:5542
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2691
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Definition: Expr.h:2720
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition: ExprCXX.h:2849
QualType getQueriedType() const
Definition: ExprCXX.h:2891
Expr * getDimensionExpression() const
Definition: ExprCXX.h:2897
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:6245
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:6264
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition: Expr.h:6448
Expr ** getSubExprs()
Definition: Expr.h:6525
static unsigned getNumSubExprs(AtomicOp Op)
Determine the number of arguments the specified atomic builtin should have.
Definition: Expr.cpp:4882
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4263
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:4317
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:4298
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3862
Expr * getLHS() const
Definition: Expr.h:3911
Expr * getRHS() const
Definition: Expr.h:3913
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:6184
const BlockDecl * getBlockDecl() const
Definition: Expr.h:6196
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1475
const Expr * getSubExpr() const
Definition: ExprCXX.h:1497
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1530
arg_range arguments()
Definition: ExprCXX.h:1654
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1254
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1361
Expr * getExpr()
Get the initialization expression that will be used.
Definition: ExprCXX.cpp:1035
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2494
Expr * getArgument()
Definition: ExprCXX.h:2535
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3658
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3795
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
Definition: ExprCXX.h:3769
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3752
bool isImplicitAccess() const
True if this is an implicit access, i.e.
Definition: ExprCXX.h:3744
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3863
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4705
Expr * getRHS() const
Definition: ExprCXX.h:4740
Expr * getLHS() const
Definition: ExprCXX.h:4739
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2227
llvm::iterator_range< arg_iterator > placement_arguments()
Definition: ExprCXX.h:2440
QualType getAllocatedType() const
Definition: ExprCXX.h:2305
std::optional< Expr * > getArraySize()
This might return std::nullopt even if isArray() returns true, since there might not be an array size...
Definition: ExprCXX.h:2340
TypeSourceInfo * getAllocatedTypeSourceInfo() const
Definition: ExprCXX.h:2309
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:2410
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:4101
Expr * getOperand() const
Definition: ExprCXX.h:4118
Represents a list-initialization with parenthesis.
Definition: ExprCXX.h:4827
ArrayRef< Expr * > getInitExprs()
Definition: ExprCXX.h:4867
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2613
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
Definition: ExprCXX.h:2707
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
Definition: ExprCXX.h:2691
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
Definition: ExprCXX.h:2671
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
bool isCurrentInstantiation(const DeclContext *CurContext) const
Determine whether this dependent class is a current instantiation, when viewed from within the given ...
A rewritten comparison expression that was originally written using operator syntax.
Definition: ExprCXX.h:283
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
Definition: ExprCXX.h:301
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Definition: ExprCXX.h:2165
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:2184
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:797
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1869
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1898
Represents the this expression in C++.
Definition: ExprCXX.h:1148
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1192
const Expr * getSubExpr() const
Definition: ExprCXX.h:1212
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:845
bool isTypeOperand() const
Definition: ExprCXX.h:881
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:888
Expr * getExprOperand() const
Definition: ExprCXX.h:892
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3532
QualType getTypeAsWritten() const
Retrieve the type that is being constructed, as specified in the source code.
Definition: ExprCXX.h:3566
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1062
Expr * getExprOperand() const
Definition: ExprCXX.h:1103
bool isTypeOperand() const
Definition: ExprCXX.h:1092
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:1099
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2847
Expr * getCallee()
Definition: Expr.h:2997
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:3025
Expr ** getArgs()
Retrieve the call arguments.
Definition: Expr.h:3028
Expr * getSubExpr()
Definition: Expr.h:3567
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4580
Expr * getLHS() const
Definition: Expr.h:4622
bool isConditionDependent() const
Definition: Expr.h:4610
bool isConditionTrue() const
isConditionTrue - Return whether the condition is true (i.e.
Definition: Expr.h:4603
Expr * getRHS() const
Definition: Expr.h:4624
Expr * getCond() const
Definition: Expr.h:4620
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3447
const Expr * getInitializer() const
Definition: Expr.h:3470
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:3480
Stmt * getStmtExprResult()
Definition: Stmt.h:1717
Represents the specialization of a concept - evaluates to a prvalue of type bool.
Definition: ExprConcepts.h:42
const ASTTemplateArgumentListInfo * getTemplateArgsAsWritten() const
Definition: ExprConcepts.h:98
const ASTConstraintSatisfaction & getSatisfaction() const
Get elaborated satisfaction info about the template arguments' satisfaction of the named concept.
Definition: ExprConcepts.h:133
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4201
Expr * getLHS() const
Definition: Expr.h:4235
Expr * getCond() const
getCond - Return the expression representing the condition for the ?: operator.
Definition: Expr.h:4224
Expr * getRHS() const
Definition: Expr.h:4236
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:4521
TypeSourceInfo * getTypeSourceInfo() const
getTypeSourceInfo - Return the destination type.
Definition: Expr.h:4544
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:4541
Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...
Definition: ExprCXX.h:4944
Expr * getResumeExpr() const
Definition: ExprCXX.h:5005
Expr * getCommonExpr() const
Definition: ExprCXX.h:4990
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1435
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1278
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1248
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: Expr.h:1417
bool isCapturedByCopyInLambdaWithExplicitObjectParameter() const
Definition: Expr.h:1458
ValueDecl * getDecl()
Definition: Expr.h:1316
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
Definition: Expr.h:1409
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1343
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:220
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:563
DeclContext * getDeclContext()
Definition: DeclBase.h:453
Represents a 'co_await' expression while the type of the promise is dependent.
Definition: ExprCXX.h:5069
Expr * getOperand() const
Definition: ExprCXX.h:5092
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3298
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3406
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
Definition: ExprCXX.h:3350
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:3334
Represents a C99 designated initializer expression.
Definition: Expr.h:5103
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:4578
llvm::MutableArrayRef< Designator > designators()
Definition: Expr.h:5336
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:4573
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:4568
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:5371
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:3752
This represents one expression.
Definition: Expr.h:110
bool isTypeDependent() const
Determines whether the type of this expression depends on.
Definition: Expr.h:186
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:3027
bool EvaluateAsConstantExpr(EvalResult &Result, const ASTContext &Ctx, ConstantExprKind Kind=ConstantExprKind::Normal) const
Evaluate an expression that is required to be a constant expression.
QualType getType() const
Definition: Expr.h:142
ExprDependence getDependence() const
Definition: Expr.h:156
An expression trait intrinsic.
Definition: ExprCXX.h:2920
Expr * getQueriedExpression() const
Definition: ExprCXX.h:2959
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:6124
const Expr * getBase() const
Definition: Expr.h:6141
Represents a member of a struct/union/class.
Definition: Decl.h:3015
FullExpr - Represents a "full-expression" node.
Definition: Expr.h:1026
const Expr * getSubExpr() const
Definition: Expr.h:1039
Represents a C11 generic selection.
Definition: Expr.h:5736
TypeSourceInfo * getControllingType()
Return the controlling type of this generic selection expression.
Definition: Expr.h:6011
ArrayRef< Expr * > getAssocExprs() const
Definition: Expr.h:6031
bool isExprPredicate() const
Whether this generic selection uses an expression as its controlling argument.
Definition: Expr.h:5992
Expr * getResultExpr()
Return the result expression of this controlling expression.
Definition: Expr.h:6020
bool isResultDependent() const
Whether this generic selection is result-dependent.
Definition: Expr.h:5988
Expr * getControllingExpr()
Return the controlling expression of this generic selection expression.
Definition: Expr.h:5999
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3677
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5611
Describes an C or C++ initializer list.
Definition: Expr.h:4858
ArrayRef< Expr * > inits()
Definition: Expr.h:4898
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1938
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:929
Expr * getBaseExpr() const
Definition: ExprCXX.h:982
MS property subscript expression.
Definition: ExprCXX.h:1000
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4593
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
Definition: ExprCXX.h:4610
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Definition: Expr.h:2769
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:3210
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:3289
Expr * getBase() const
Definition: Expr.h:3283
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name.
Definition: Expr.h:3317
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
Definition: Expr.h:3383
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:5431
OpenMP 5.0 [2.1.5, Array Sections].
Definition: ExprOpenMP.h:56
Expr * getLength()
Get length of array section.
Definition: ExprOpenMP.h:102
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Definition: ExprOpenMP.h:85
Expr * getLowerBound()
Get lower bound of array section.
Definition: ExprOpenMP.h:94
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
Definition: ExprOpenMP.h:148
Expr * getBase()
Fetches base expression of array shaping expression.
Definition: ExprOpenMP.h:214
ArrayRef< Expr * > getDimensions() const
Fetches the dimensions for array shaping expression.
Definition: ExprOpenMP.h:204
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
Definition: ExprOpenMP.h:275
IteratorRange getIteratorRange(unsigned I)
Gets the iterator range for the given iterator.
Definition: Expr.cpp:5110
unsigned numOfIterators() const
Returns number of iterator definitions.
Definition: ExprOpenMP.h:399
Decl * getIteratorDecl(unsigned I)
Gets the iterator declaration for the given iterator.
Definition: Expr.cpp:5106
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Definition: ExprObjC.h:191
Expr ** getElements()
Retrieve elements of array of literals.
Definition: ExprObjC.h:220
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:228
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:127
Expr * getSubExpr()
Definition: ExprObjC.h:143
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:309
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:360
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:362
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:410
QualType getEncodedType() const
Definition: ExprObjC.h:429
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1575
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1491
Expr * getBase() const
Definition: ExprObjC.h:1516
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:549
const Expr * getBase() const
Definition: ExprObjC.h:583
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:945
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1260
llvm::iterator_range< arg_iterator > arguments()
Definition: ExprObjC.h:1462
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:617
const Expr * getBase() const
Definition: ExprObjC.h:755
bool isObjectReceiver() const
Definition: ExprObjC.h:774
QualType getSuperReceiverType() const
Definition: ExprObjC.h:766
bool isClassReceiver() const
Definition: ExprObjC.h:776
bool isSuperReceiver() const
Definition: ExprObjC.h:775
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:844
Expr * getKeyExpr() const
Definition: ExprObjC.h:886
Expr * getBaseExpr() const
Definition: ExprObjC.h:883
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition: Expr.h:2492
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:2553
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2532
unsigned getNumExpressions() const
Definition: Expr.h:2568
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1156
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:1206
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition: ExprCXX.h:2979
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:3094
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
Definition: ExprCXX.h:3085
llvm::iterator_range< decls_iterator > decls() const
Definition: ExprCXX.h:3077
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3145
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4155
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:4184
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2157
const Expr * getSubExpr() const
Definition: Expr.h:2172
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:2014
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6316
ArrayRef< Expr * > semantics()
Definition: Expr.h:6395
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:6358
A (possibly-)qualified type.
Definition: Type.h:736
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition: Expr.h:6646
ArrayRef< Expr * > subExpressions()
Definition: Expr.h:6653
TypeSourceInfo * getTypeSourceInfo()
Definition: Expr.h:2118
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition: Expr.h:4453
Expr ** getSubExprs()
Retrieve the array of expressions.
Definition: Expr.h:4490
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
Definition: Expr.h:4487
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:4405
CompoundStmt * getSubStmt()
Definition: Expr.h:4422
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4349
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:495
A container of type source information.
Definition: Type.h:6752
QualType getType() const
Return the type wrapped by this type source info.
Definition: Type.h:6763
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2764
ArrayRef< TypeSourceInfo * > getArgs() const
Retrieve the argument types.
Definition: ExprCXX.h:2820
The base class of the type hierarchy.
Definition: Type.h:1602
bool isIncompleteArrayType() const
Definition: Type.h:7107
bool isInstantiationDependentType() const
Determine whether this type is an instantiation-dependent type, meaning that the type involves a temp...
Definition: Type.h:2429
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2421
TypeDependence getDependence() const
Definition: Type.h:2410
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition: Expr.h:2595
QualType getArgumentType() const
Definition: Expr.h:2638
bool isArgumentType() const
Definition: Expr.h:2637
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2627
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2210
Expr * getSubExpr() const
Definition: Expr.h:2255
Opcode getOpcode() const
Definition: Expr.h:2250
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4689
TypeSourceInfo * getWrittenTypeInfo() const
Definition: Expr.h:4713
const Expr * getSubExpr() const
Definition: Expr.h:4705
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:704
const Expr * getExprStmt() const
Definition: Stmt.cpp:403
Represents a variable declaration or definition.
Definition: Decl.h:916
ExprDependence toExprDependence(TemplateArgumentDependence TA)
Computes dependencies of a reference with the name having template arguments with TA dependencies.
CanThrowResult
Possible results from evaluation of a noexcept expression.
ExprDependence turnTypeToValueDependence(ExprDependence D)
ExprDependence toExprDependenceAsWritten(TypeDependence D)
ExprDependence computeDependence(FullExpr *E)
ExprDependence turnValueToTypeDependence(ExprDependence D)
ExprDependence toExprDependenceForImpliedType(TypeDependence D)
llvm::ArrayRef< TemplateArgumentLoc > arguments() const
Definition: TemplateBase.h:681
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspon...
EvalResult is a struct with detailed info about an evaluated expression.
Definition: Expr.h:629
Iterator range representation begin:end[:step].
Definition: ExprOpenMP.h:278