8c1f2d15b8
to dependent declarations. Treat an id-expression that names a local variable in a templated function as being instantiation-dependent. This addresses a language defect whereby a reference to a dependent declaration can be formed without any construct being value-dependent. Fixing that through value-dependence turns out to be problematic, so instead this patch takes the approach (proposed on the core reflector) of allowing the use of pointers or references to (but not values of) dependent declarations inside value-dependent expressions, and instead treating template arguments as dependent if they evaluate to a constant involving such dependent declarations. This ends up affecting a bunch of OpenMP tests, due to OpenMP imprecisely handling instantiation-dependent constructs, bailing out early instead of processing dependent constructs to the extent possible when handling the template.
854 lines
31 KiB
C++
854 lines
31 KiB
C++
//===- ComputeDependence.cpp ----------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ComputeDependence.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/DeclarationName.h"
|
|
#include "clang/AST/DependenceFlags.h"
|
|
#include "clang/AST/Expr.h"
|
|
#include "clang/AST/ExprCXX.h"
|
|
#include "clang/AST/ExprConcepts.h"
|
|
#include "clang/AST/ExprObjC.h"
|
|
#include "clang/AST/ExprOpenMP.h"
|
|
#include "clang/Basic/ExceptionSpecificationType.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
using namespace clang;
|
|
|
|
ExprDependence clang::computeDependence(FullExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(OpaqueValueExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
if (auto *S = E->getSourceExpr())
|
|
D |= S->getDependence();
|
|
assert(!(D & ExprDependence::UnexpandedPack));
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ParenExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(UnaryOperator *E,
|
|
const ASTContext &Ctx) {
|
|
ExprDependence Dep = toExprDependence(E->getType()->getDependence()) |
|
|
E->getSubExpr()->getDependence();
|
|
|
|
// C++ [temp.dep.constexpr]p5:
|
|
// An expression of the form & qualified-id where the qualified-id names a
|
|
// dependent member of the current instantiation is value-dependent. An
|
|
// expression of the form & cast-expression is also value-dependent if
|
|
// evaluating cast-expression as a core constant expression succeeds and
|
|
// the result of the evaluation refers to a templated entity that is an
|
|
// object with static or thread storage duration or a member function.
|
|
//
|
|
// What this amounts to is: constant-evaluate the operand and check whether it
|
|
// refers to a templated entity other than a variable with local storage.
|
|
if (Ctx.getLangOpts().CPlusPlus && E->getOpcode() == UO_AddrOf &&
|
|
!(Dep & ExprDependence::Value)) {
|
|
Expr::EvalResult Result;
|
|
SmallVector<PartialDiagnosticAt, 8> Diag;
|
|
Result.Diag = &Diag;
|
|
// FIXME: This doesn't enforce the C++98 constant expression rules.
|
|
if (E->getSubExpr()->EvaluateAsConstantExpr(Result, Ctx) && Diag.empty() &&
|
|
Result.Val.isLValue()) {
|
|
auto *VD = Result.Val.getLValueBase().dyn_cast<const ValueDecl *>();
|
|
if (VD && VD->isTemplated()) {
|
|
auto *VarD = dyn_cast<VarDecl>(VD);
|
|
if (!VarD || !VarD->hasLocalStorage())
|
|
Dep |= ExprDependence::ValueInstantiation;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Dep;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(UnaryExprOrTypeTraitExpr *E) {
|
|
// Never type-dependent (C++ [temp.dep.expr]p3).
|
|
// Value-dependent if the argument is type-dependent.
|
|
if (E->isArgumentType())
|
|
return turnTypeToValueDependence(
|
|
toExprDependence(E->getArgumentType()->getDependence()));
|
|
|
|
auto ArgDeps = E->getArgumentExpr()->getDependence();
|
|
auto Deps = ArgDeps & ~ExprDependence::TypeValue;
|
|
// Value-dependent if the argument is type-dependent.
|
|
if (ArgDeps & ExprDependence::Type)
|
|
Deps |= ExprDependence::Value;
|
|
// Check to see if we are in the situation where alignof(decl) should be
|
|
// dependent because decl's alignment is dependent.
|
|
auto ExprKind = E->getKind();
|
|
if (ExprKind != UETT_AlignOf && ExprKind != UETT_PreferredAlignOf)
|
|
return Deps;
|
|
if ((Deps & ExprDependence::Value) && (Deps & ExprDependence::Instantiation))
|
|
return Deps;
|
|
|
|
auto *NoParens = E->getArgumentExpr()->IgnoreParens();
|
|
const ValueDecl *D = nullptr;
|
|
if (const auto *DRE = dyn_cast<DeclRefExpr>(NoParens))
|
|
D = DRE->getDecl();
|
|
else if (const auto *ME = dyn_cast<MemberExpr>(NoParens))
|
|
D = ME->getMemberDecl();
|
|
if (!D)
|
|
return Deps;
|
|
for (const auto *I : D->specific_attrs<AlignedAttr>()) {
|
|
if (I->isAlignmentErrorDependent())
|
|
Deps |= ExprDependence::Error;
|
|
if (I->isAlignmentDependent())
|
|
Deps |= ExprDependence::ValueInstantiation;
|
|
}
|
|
return Deps;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ArraySubscriptExpr *E) {
|
|
return E->getLHS()->getDependence() | E->getRHS()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(MatrixSubscriptExpr *E) {
|
|
return E->getBase()->getDependence() | E->getRowIdx()->getDependence() |
|
|
(E->getColumnIdx() ? E->getColumnIdx()->getDependence()
|
|
: ExprDependence::None);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CompoundLiteralExpr *E) {
|
|
return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()) |
|
|
turnTypeToValueDependence(E->getInitializer()->getDependence());
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CastExpr *E) {
|
|
// Cast expressions are type-dependent if the type is
|
|
// dependent (C++ [temp.dep.expr]p3).
|
|
// Cast expressions are value-dependent if the type is
|
|
// dependent or if the subexpression is value-dependent.
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
if (E->getStmtClass() == Stmt::ImplicitCastExprClass) {
|
|
// An implicit cast expression doesn't (lexically) contain an
|
|
// unexpanded pack, even if its target type does.
|
|
D &= ~ExprDependence::UnexpandedPack;
|
|
}
|
|
if (auto *S = E->getSubExpr())
|
|
D |= S->getDependence() & ~ExprDependence::Type;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(BinaryOperator *E) {
|
|
return E->getLHS()->getDependence() | E->getRHS()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ConditionalOperator *E) {
|
|
// The type of the conditional operator depends on the type of the conditional
|
|
// to support the GCC vector conditional extension. Additionally,
|
|
// [temp.dep.expr] does specify state that this should be dependent on ALL sub
|
|
// expressions.
|
|
return E->getCond()->getDependence() | E->getLHS()->getDependence() |
|
|
E->getRHS()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(BinaryConditionalOperator *E) {
|
|
return E->getCommon()->getDependence() | E->getFalseExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
// Propagate dependence of the result.
|
|
if (const auto *CompoundExprResult =
|
|
dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult()))
|
|
if (const Expr *ResultExpr = CompoundExprResult->getExprStmt())
|
|
D |= ResultExpr->getDependence();
|
|
// Note: we treat a statement-expression in a dependent context as always
|
|
// being value- and instantiation-dependent. This matches the behavior of
|
|
// lambda-expressions and GCC.
|
|
if (TemplateDepth)
|
|
D |= ExprDependence::ValueInstantiation;
|
|
// A param pack cannot be expanded over stmtexpr boundaries.
|
|
return D & ~ExprDependence::UnexpandedPack;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ConvertVectorExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence()) |
|
|
E->getSrcExpr()->getDependence();
|
|
if (!E->getType()->isDependentType())
|
|
D &= ~ExprDependence::Type;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ChooseExpr *E) {
|
|
if (E->isConditionDependent())
|
|
return ExprDependence::TypeValueInstantiation |
|
|
E->getCond()->getDependence() | E->getLHS()->getDependence() |
|
|
E->getRHS()->getDependence();
|
|
|
|
auto Cond = E->getCond()->getDependence();
|
|
auto Active = E->getLHS()->getDependence();
|
|
auto Inactive = E->getRHS()->getDependence();
|
|
if (!E->isConditionTrue())
|
|
std::swap(Active, Inactive);
|
|
// Take type- and value- dependency from the active branch. Propagate all
|
|
// other flags from all branches.
|
|
return (Active & ExprDependence::TypeValue) |
|
|
((Cond | Active | Inactive) & ~ExprDependence::TypeValue);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ParenListExpr *P) {
|
|
auto D = ExprDependence::None;
|
|
for (auto *E : P->exprs())
|
|
D |= E->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(VAArgExpr *E) {
|
|
auto D =
|
|
toExprDependence(E->getWrittenTypeInfo()->getType()->getDependence()) |
|
|
(E->getSubExpr()->getDependence() & ~ExprDependence::Type);
|
|
return D & ~ExprDependence::Value;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(NoInitExpr *E) {
|
|
return toExprDependence(E->getType()->getDependence()) &
|
|
(ExprDependence::Instantiation | ExprDependence::Error);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ArrayInitLoopExpr *E) {
|
|
auto D = E->getCommonExpr()->getDependence() |
|
|
E->getSubExpr()->getDependence() | ExprDependence::Instantiation;
|
|
if (!E->getType()->isInstantiationDependentType())
|
|
D &= ~ExprDependence::Instantiation;
|
|
return turnTypeToValueDependence(D);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) {
|
|
return toExprDependence(E->getType()->getDependence()) &
|
|
ExprDependence::Instantiation;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ExtVectorElementExpr *E) {
|
|
return E->getBase()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(BlockExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
if (E->getBlockDecl()->isDependentContext())
|
|
D |= ExprDependence::Instantiation;
|
|
return D & ~ExprDependence::UnexpandedPack;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(AsTypeExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence()) |
|
|
E->getSrcExpr()->getDependence();
|
|
if (!E->getType()->isDependentType())
|
|
D &= ~ExprDependence::Type;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXRewrittenBinaryOperator *E) {
|
|
return E->getSemanticForm()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) {
|
|
auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence());
|
|
D |= toExprDependence(E->getType()->getDependence()) &
|
|
(ExprDependence::Type | ExprDependence::Error);
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXTypeidExpr *E) {
|
|
auto D = ExprDependence::None;
|
|
if (E->isTypeOperand())
|
|
D = toExprDependence(
|
|
E->getTypeOperandSourceInfo()->getType()->getDependence());
|
|
else
|
|
D = turnTypeToValueDependence(E->getExprOperand()->getDependence());
|
|
// typeid is never type-dependent (C++ [temp.dep.expr]p4)
|
|
return D & ~ExprDependence::Type;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(MSPropertyRefExpr *E) {
|
|
return E->getBaseExpr()->getDependence() & ~ExprDependence::Type;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(MSPropertySubscriptExpr *E) {
|
|
return E->getIdx()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXUuidofExpr *E) {
|
|
if (E->isTypeOperand())
|
|
return turnTypeToValueDependence(toExprDependence(
|
|
E->getTypeOperandSourceInfo()->getType()->getDependence()));
|
|
|
|
return turnTypeToValueDependence(E->getExprOperand()->getDependence());
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXThisExpr *E) {
|
|
// 'this' is type-dependent if the class type of the enclosing
|
|
// member function is dependent (C++ [temp.dep.expr]p2)
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
assert(!(D & ExprDependence::UnexpandedPack));
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXThrowExpr *E) {
|
|
auto *Op = E->getSubExpr();
|
|
if (!Op)
|
|
return ExprDependence::None;
|
|
return Op->getDependence() & ~ExprDependence::TypeValue;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXBindTemporaryExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) {
|
|
return toExprDependence(E->getType()->getDependence()) &
|
|
~ExprDependence::TypeValue;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXDeleteExpr *E) {
|
|
return turnTypeToValueDependence(E->getArgument()->getDependence());
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) {
|
|
auto D = toExprDependence(E->getQueriedType()->getDependence());
|
|
if (auto *Dim = E->getDimensionExpression())
|
|
D |= Dim->getDependence();
|
|
return turnTypeToValueDependence(D);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ExpressionTraitExpr *E) {
|
|
// Never type-dependent.
|
|
auto D = E->getQueriedExpression()->getDependence() & ~ExprDependence::Type;
|
|
// Value-dependent if the argument is type-dependent.
|
|
if (E->getQueriedExpression()->isTypeDependent())
|
|
D |= ExprDependence::Value;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXNoexceptExpr *E, CanThrowResult CT) {
|
|
auto D = E->getOperand()->getDependence() & ~ExprDependence::TypeValue;
|
|
if (CT == CT_Dependent)
|
|
D |= ExprDependence::ValueInstantiation;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(PackExpansionExpr *E) {
|
|
return (E->getPattern()->getDependence() & ~ExprDependence::UnexpandedPack) |
|
|
ExprDependence::TypeValueInstantiation;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(SubstNonTypeTemplateParmExpr *E) {
|
|
return E->getReplacement()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CoroutineSuspendExpr *E) {
|
|
if (auto *Resume = E->getResumeExpr())
|
|
return (Resume->getDependence() &
|
|
(ExprDependence::TypeValue | ExprDependence::Error)) |
|
|
(E->getCommonExpr()->getDependence() & ~ExprDependence::TypeValue);
|
|
return E->getCommonExpr()->getDependence() |
|
|
ExprDependence::TypeValueInstantiation;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(DependentCoawaitExpr *E) {
|
|
return E->getOperand()->getDependence() |
|
|
ExprDependence::TypeValueInstantiation;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCBoxedExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCEncodeExpr *E) {
|
|
return toExprDependence(E->getEncodedType()->getDependence());
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) {
|
|
return turnTypeToValueDependence(E->getBase()->getDependence());
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCPropertyRefExpr *E) {
|
|
if (E->isObjectReceiver())
|
|
return E->getBase()->getDependence() & ~ExprDependence::Type;
|
|
if (E->isSuperReceiver())
|
|
return toExprDependence(E->getSuperReceiverType()->getDependence()) &
|
|
~ExprDependence::TypeValue;
|
|
assert(E->isClassReceiver());
|
|
return ExprDependence::None;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCSubscriptRefExpr *E) {
|
|
return E->getBaseExpr()->getDependence() | E->getKeyExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCIsaExpr *E) {
|
|
return E->getBase()->getDependence() & ~ExprDependence::Type &
|
|
~ExprDependence::UnexpandedPack;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCIndirectCopyRestoreExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(OMPArraySectionExpr *E) {
|
|
auto D = E->getBase()->getDependence();
|
|
if (auto *LB = E->getLowerBound())
|
|
D |= LB->getDependence();
|
|
if (auto *Len = E->getLength())
|
|
D |= Len->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) {
|
|
auto D = E->getBase()->getDependence() |
|
|
toExprDependence(E->getType()->getDependence());
|
|
for (Expr *Dim: E->getDimensions())
|
|
if (Dim)
|
|
D |= Dim->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(OMPIteratorExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {
|
|
if (auto *VD = cast_or_null<ValueDecl>(E->getIteratorDecl(I)))
|
|
D |= toExprDependence(VD->getType()->getDependence());
|
|
OMPIteratorExpr::IteratorRange IR = E->getIteratorRange(I);
|
|
if (Expr *BE = IR.Begin)
|
|
D |= BE->getDependence();
|
|
if (Expr *EE = IR.End)
|
|
D |= EE->getDependence();
|
|
if (Expr *SE = IR.Step)
|
|
D |= SE->getDependence();
|
|
}
|
|
return D;
|
|
}
|
|
|
|
/// Compute the type-, value-, and instantiation-dependence of a
|
|
/// declaration reference
|
|
/// based on the declaration being referenced.
|
|
ExprDependence clang::computeDependence(DeclRefExpr *E, const ASTContext &Ctx) {
|
|
auto Deps = ExprDependence::None;
|
|
|
|
if (auto *NNS = E->getQualifier())
|
|
Deps |= toExprDependence(NNS->getDependence() &
|
|
~NestedNameSpecifierDependence::Dependent);
|
|
|
|
if (auto *FirstArg = E->getTemplateArgs()) {
|
|
unsigned NumArgs = E->getNumTemplateArgs();
|
|
for (auto *Arg = FirstArg, *End = FirstArg + NumArgs; Arg < End; ++Arg)
|
|
Deps |= toExprDependence(Arg->getArgument().getDependence() &
|
|
~TemplateArgumentDependence::Dependent);
|
|
}
|
|
|
|
auto *Decl = E->getDecl();
|
|
auto *Found = E->getFoundDecl();
|
|
auto Type = E->getType();
|
|
|
|
// FIXME: For a ParmVarDecl referenced in a function signature, we don't know
|
|
// its dependence yet!
|
|
if (!isa<ParmVarDecl>(Decl)) {
|
|
if (Decl->getDeclContext()->isDependentContext() ||
|
|
(Found && Found->getDeclContext()->isDependentContext()))
|
|
Deps |= ExprDependence::Instantiation;
|
|
}
|
|
if (Decl->isParameterPack())
|
|
Deps |= ExprDependence::UnexpandedPack;
|
|
Deps |= toExprDependence(Type->getDependence()) & ExprDependence::Error;
|
|
|
|
// C++ [temp.dep.expr]p3:
|
|
// An id-expression is type-dependent if it contains:
|
|
|
|
// - an identifier associated by name lookup with one or more declarations
|
|
// declared with a dependent type
|
|
//
|
|
// [The "or more" case is not modeled as a DeclRefExpr. There are a bunch
|
|
// more bullets here that we handle by treating the declaration as having a
|
|
// dependent type if they involve a placeholder type that can't be deduced.]
|
|
if (Type->isDependentType())
|
|
return Deps | ExprDependence::TypeValueInstantiation;
|
|
else if (Type->isInstantiationDependentType())
|
|
Deps |= ExprDependence::Instantiation;
|
|
|
|
// - a conversion-function-id that specifies a dependent type
|
|
if (Decl->getDeclName().getNameKind() ==
|
|
DeclarationName::CXXConversionFunctionName) {
|
|
QualType T = Decl->getDeclName().getCXXNameType();
|
|
if (T->isDependentType())
|
|
return Deps | ExprDependence::TypeValueInstantiation;
|
|
|
|
if (T->isInstantiationDependentType())
|
|
Deps |= ExprDependence::Instantiation;
|
|
}
|
|
|
|
// - a template-id that is dependent,
|
|
// - a nested-name-specifier or a qualified-id that names a member of an
|
|
// unknown specialization
|
|
// [These are not modeled as DeclRefExprs.]
|
|
|
|
// or if it names a dependent member of the current instantiation that is a
|
|
// static data member of type "array of unknown bound of T" for some T
|
|
// [handled below].
|
|
|
|
// C++ [temp.dep.constexpr]p2:
|
|
// An id-expression is value-dependent if:
|
|
|
|
// - it is type-dependent [handled above]
|
|
|
|
// - it is the name of a non-type template parameter,
|
|
if (isa<NonTypeTemplateParmDecl>(Decl))
|
|
return Deps | ExprDependence::ValueInstantiation;
|
|
|
|
// - it names a potentially-constant variable that is initialized with an
|
|
// expression that is value-dependent
|
|
if (const auto *Var = dyn_cast<VarDecl>(Decl)) {
|
|
if (Var->mightBeUsableInConstantExpressions(Ctx)) {
|
|
if (const Expr *Init = Var->getAnyInitializer()) {
|
|
if (Init->isValueDependent())
|
|
Deps |= ExprDependence::ValueInstantiation;
|
|
if (Init->containsErrors())
|
|
Deps |= ExprDependence::Error;
|
|
}
|
|
}
|
|
|
|
// - it names a static data member that is a dependent member of the
|
|
// current instantiation and is not initialized in a member-declarator,
|
|
if (Var->isStaticDataMember() &&
|
|
Var->getDeclContext()->isDependentContext() &&
|
|
!Var->getFirstDecl()->hasInit()) {
|
|
const VarDecl *First = Var->getFirstDecl();
|
|
TypeSourceInfo *TInfo = First->getTypeSourceInfo();
|
|
if (TInfo->getType()->isIncompleteArrayType()) {
|
|
Deps |= ExprDependence::TypeValueInstantiation;
|
|
} else if (!First->hasInit()) {
|
|
Deps |= ExprDependence::ValueInstantiation;
|
|
}
|
|
}
|
|
|
|
return Deps;
|
|
}
|
|
|
|
// - it names a static member function that is a dependent member of the
|
|
// current instantiation
|
|
//
|
|
// FIXME: It's unclear that the restriction to static members here has any
|
|
// effect: any use of a non-static member function name requires either
|
|
// forming a pointer-to-member or providing an object parameter, either of
|
|
// which makes the overall expression value-dependent.
|
|
if (auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
|
|
if (MD->isStatic() && Decl->getDeclContext()->isDependentContext())
|
|
Deps |= ExprDependence::ValueInstantiation;
|
|
}
|
|
|
|
return Deps;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(RecoveryExpr *E) {
|
|
// RecoveryExpr is
|
|
// - always value-dependent, and therefore instantiation dependent
|
|
// - contains errors (ExprDependence::Error), by definition
|
|
// - type-dependent if we don't know the type (fallback to an opaque
|
|
// dependent type), or the type is known and dependent, or it has
|
|
// type-dependent subexpressions.
|
|
auto D = toExprDependence(E->getType()->getDependence()) |
|
|
ExprDependence::ErrorDependent;
|
|
// FIXME: remove the type-dependent bit from subexpressions, if the
|
|
// RecoveryExpr has a non-dependent type.
|
|
for (auto *S : E->subExpressions())
|
|
D |= S->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(PredefinedExpr *E) {
|
|
return toExprDependence(E->getType()->getDependence()) &
|
|
~ExprDependence::UnexpandedPack;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CallExpr *E,
|
|
llvm::ArrayRef<Expr *> PreArgs) {
|
|
auto D = E->getCallee()->getDependence();
|
|
for (auto *A : llvm::makeArrayRef(E->getArgs(), E->getNumArgs())) {
|
|
if (A)
|
|
D |= A->getDependence();
|
|
}
|
|
for (auto *A : PreArgs)
|
|
D |= A->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(OffsetOfExpr *E) {
|
|
auto D = turnTypeToValueDependence(
|
|
toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()));
|
|
for (unsigned I = 0, N = E->getNumExpressions(); I < N; ++I)
|
|
D |= turnTypeToValueDependence(E->getIndexExpr(I)->getDependence());
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(MemberExpr *E) {
|
|
auto *MemberDecl = E->getMemberDecl();
|
|
auto D = E->getBase()->getDependence();
|
|
if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
|
|
DeclContext *DC = MemberDecl->getDeclContext();
|
|
// dyn_cast_or_null is used to handle objC variables which do not
|
|
// have a declaration context.
|
|
CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC);
|
|
if (RD && RD->isDependentContext() && RD->isCurrentInstantiation(DC)) {
|
|
if (!E->getType()->isDependentType())
|
|
D &= ~ExprDependence::Type;
|
|
}
|
|
|
|
// Bitfield with value-dependent width is type-dependent.
|
|
if (FD && FD->isBitField() && FD->getBitWidth()->isValueDependent()) {
|
|
D |= ExprDependence::Type;
|
|
}
|
|
}
|
|
// FIXME: move remaining dependence computation from MemberExpr::Create()
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(InitListExpr *E) {
|
|
auto D = ExprDependence::None;
|
|
for (auto *A : E->inits())
|
|
D |= A->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ShuffleVectorExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
for (auto *C : llvm::makeArrayRef(E->getSubExprs(), E->getNumSubExprs()))
|
|
D |= C->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(GenericSelectionExpr *E,
|
|
bool ContainsUnexpandedPack) {
|
|
auto D = ContainsUnexpandedPack ? ExprDependence::UnexpandedPack
|
|
: ExprDependence::None;
|
|
for (auto *AE : E->getAssocExprs())
|
|
D |= AE->getDependence() & ExprDependence::Error;
|
|
D |= E->getControllingExpr()->getDependence() & ExprDependence::Error;
|
|
|
|
if (E->isResultDependent())
|
|
return D | ExprDependence::TypeValueInstantiation;
|
|
return D | (E->getResultExpr()->getDependence() &
|
|
~ExprDependence::UnexpandedPack);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(DesignatedInitExpr *E) {
|
|
auto Deps = E->getInit()->getDependence();
|
|
for (auto D : E->designators()) {
|
|
auto DesignatorDeps = ExprDependence::None;
|
|
if (D.isArrayDesignator())
|
|
DesignatorDeps |= E->getArrayIndex(D)->getDependence();
|
|
else if (D.isArrayRangeDesignator())
|
|
DesignatorDeps |= E->getArrayRangeStart(D)->getDependence() |
|
|
E->getArrayRangeEnd(D)->getDependence();
|
|
Deps |= DesignatorDeps;
|
|
if (DesignatorDeps & ExprDependence::TypeValue)
|
|
Deps |= ExprDependence::TypeValueInstantiation;
|
|
}
|
|
return Deps;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(PseudoObjectExpr *O) {
|
|
auto D = O->getSyntacticForm()->getDependence();
|
|
for (auto *E : O->semantics())
|
|
D |= E->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(AtomicExpr *A) {
|
|
auto D = ExprDependence::None;
|
|
for (auto *E : llvm::makeArrayRef(A->getSubExprs(), A->getNumSubExprs()))
|
|
D |= E->getDependence();
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXNewExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
auto Size = E->getArraySize();
|
|
if (Size.hasValue() && *Size)
|
|
D |= turnTypeToValueDependence((*Size)->getDependence());
|
|
if (auto *I = E->getInitializer())
|
|
D |= turnTypeToValueDependence(I->getDependence());
|
|
for (auto *A : E->placement_arguments())
|
|
D |= turnTypeToValueDependence(A->getDependence());
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) {
|
|
auto D = E->getBase()->getDependence();
|
|
if (!E->getDestroyedType().isNull())
|
|
D |= toExprDependence(E->getDestroyedType()->getDependence());
|
|
if (auto *ST = E->getScopeTypeInfo())
|
|
D |= turnTypeToValueDependence(
|
|
toExprDependence(ST->getType()->getDependence()));
|
|
if (auto *Q = E->getQualifier())
|
|
D |= toExprDependence(Q->getDependence() &
|
|
~NestedNameSpecifierDependence::Dependent);
|
|
return D;
|
|
}
|
|
|
|
static inline ExprDependence getDependenceInExpr(DeclarationNameInfo Name) {
|
|
auto D = ExprDependence::None;
|
|
if (Name.isInstantiationDependent())
|
|
D |= ExprDependence::Instantiation;
|
|
if (Name.containsUnexpandedParameterPack())
|
|
D |= ExprDependence::UnexpandedPack;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence
|
|
clang::computeDependence(OverloadExpr *E, bool KnownDependent,
|
|
bool KnownInstantiationDependent,
|
|
bool KnownContainsUnexpandedParameterPack) {
|
|
auto Deps = ExprDependence::None;
|
|
if (KnownDependent)
|
|
Deps |= ExprDependence::TypeValue;
|
|
if (KnownInstantiationDependent)
|
|
Deps |= ExprDependence::Instantiation;
|
|
if (KnownContainsUnexpandedParameterPack)
|
|
Deps |= ExprDependence::UnexpandedPack;
|
|
Deps |= getDependenceInExpr(E->getNameInfo());
|
|
if (auto *Q = E->getQualifier())
|
|
Deps |= toExprDependence(Q->getDependence() &
|
|
~NestedNameSpecifierDependence::Dependent);
|
|
for (auto *D : E->decls()) {
|
|
if (D->getDeclContext()->isDependentContext() ||
|
|
isa<UnresolvedUsingValueDecl>(D))
|
|
Deps |= ExprDependence::TypeValueInstantiation;
|
|
}
|
|
// If we have explicit template arguments, check for dependent
|
|
// template arguments and whether they contain any unexpanded pack
|
|
// expansions.
|
|
for (auto A : E->template_arguments())
|
|
Deps |= toExprDependence(A.getArgument().getDependence());
|
|
return Deps;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(DependentScopeDeclRefExpr *E) {
|
|
auto D = ExprDependence::TypeValue;
|
|
D |= getDependenceInExpr(E->getNameInfo());
|
|
if (auto *Q = E->getQualifier())
|
|
D |= toExprDependence(Q->getDependence());
|
|
for (auto A : E->template_arguments())
|
|
D |= toExprDependence(A.getArgument().getDependence());
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXConstructExpr *E) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
for (auto *A : E->arguments())
|
|
D |= A->getDependence() & ~ExprDependence::Type;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
|
|
return E->getExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(LambdaExpr *E,
|
|
bool ContainsUnexpandedParameterPack) {
|
|
auto D = toExprDependence(E->getType()->getDependence());
|
|
if (ContainsUnexpandedParameterPack)
|
|
D |= ExprDependence::UnexpandedPack;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) {
|
|
auto D = ExprDependence::ValueInstantiation;
|
|
D |= toExprDependence(E->getType()->getDependence());
|
|
for (auto *A : E->arguments())
|
|
D |= A->getDependence() &
|
|
(ExprDependence::UnexpandedPack | ExprDependence::Error);
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXDependentScopeMemberExpr *E) {
|
|
auto D = ExprDependence::TypeValueInstantiation;
|
|
if (!E->isImplicitAccess())
|
|
D |= E->getBase()->getDependence();
|
|
if (auto *Q = E->getQualifier())
|
|
D |= toExprDependence(Q->getDependence());
|
|
D |= getDependenceInExpr(E->getMemberNameInfo());
|
|
for (auto A : E->template_arguments())
|
|
D |= toExprDependence(A.getArgument().getDependence());
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(MaterializeTemporaryExpr *E) {
|
|
return E->getSubExpr()->getDependence();
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(CXXFoldExpr *E) {
|
|
auto D = ExprDependence::TypeValueInstantiation;
|
|
for (const auto *C : {E->getLHS(), E->getRHS()}) {
|
|
if (C)
|
|
D |= C->getDependence() & ~ExprDependence::UnexpandedPack;
|
|
}
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(TypeTraitExpr *E) {
|
|
auto D = ExprDependence::None;
|
|
for (const auto *A : E->getArgs())
|
|
D |=
|
|
toExprDependence(A->getType()->getDependence()) & ~ExprDependence::Type;
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ConceptSpecializationExpr *E,
|
|
bool ValueDependent) {
|
|
auto TA = TemplateArgumentDependence::None;
|
|
const auto InterestingDeps = TemplateArgumentDependence::Instantiation |
|
|
TemplateArgumentDependence::UnexpandedPack;
|
|
for (const TemplateArgumentLoc &ArgLoc :
|
|
E->getTemplateArgsAsWritten()->arguments()) {
|
|
TA |= ArgLoc.getArgument().getDependence() & InterestingDeps;
|
|
if (TA == InterestingDeps)
|
|
break;
|
|
}
|
|
|
|
ExprDependence D =
|
|
ValueDependent ? ExprDependence::Value : ExprDependence::None;
|
|
return D | toExprDependence(TA);
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCArrayLiteral *E) {
|
|
auto D = ExprDependence::None;
|
|
Expr **Elements = E->getElements();
|
|
for (unsigned I = 0, N = E->getNumElements(); I != N; ++I)
|
|
D |= turnTypeToValueDependence(Elements[I]->getDependence());
|
|
return D;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCDictionaryLiteral *E) {
|
|
auto Deps = ExprDependence::None;
|
|
for (unsigned I = 0, N = E->getNumElements(); I < N; ++I) {
|
|
auto KV = E->getKeyValueElement(I);
|
|
auto KVDeps = turnTypeToValueDependence(KV.Key->getDependence() |
|
|
KV.Value->getDependence());
|
|
if (KV.EllipsisLoc.isValid())
|
|
KVDeps &= ~ExprDependence::UnexpandedPack;
|
|
Deps |= KVDeps;
|
|
}
|
|
return Deps;
|
|
}
|
|
|
|
ExprDependence clang::computeDependence(ObjCMessageExpr *E) {
|
|
auto D = ExprDependence::None;
|
|
if (auto *R = E->getInstanceReceiver())
|
|
D |= R->getDependence();
|
|
else
|
|
D |= toExprDependence(E->getType()->getDependence());
|
|
for (auto *A : E->arguments())
|
|
D |= A->getDependence();
|
|
return D;
|
|
}
|