}
ExprDependence clang::computeDependence(OpaqueValueExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
if (auto *S = E->getSourceExpr())
D |= S->getDependence();
assert(!(D & ExprDependence::UnexpandedPack));
ExprDependence clang::computeDependence(UnaryOperator *E,
const ASTContext &Ctx) {
- ExprDependence Dep = toExprDependence(E->getType()->getDependence()) |
- E->getSubExpr()->getDependence();
+ ExprDependence Dep =
+ // FIXME: Do we need to look at the type?
+ toExprDependenceForImpliedType(E->getType()->getDependence()) |
+ E->getSubExpr()->getDependence();
// C++ [temp.dep.constexpr]p5:
// An expression of the form & qualified-id where the qualified-id names a
// Value-dependent if the argument is type-dependent.
if (E->isArgumentType())
return turnTypeToValueDependence(
- toExprDependence(E->getArgumentType()->getDependence()));
+ toExprDependenceAsWritten(E->getArgumentType()->getDependence()));
auto ArgDeps = E->getArgumentExpr()->getDependence();
auto Deps = ArgDeps & ~ExprDependence::TypeValue;
}
ExprDependence clang::computeDependence(CompoundLiteralExpr *E) {
- return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()) |
+ return toExprDependenceAsWritten(
+ E->getTypeSourceInfo()->getType()->getDependence()) |
+ toExprDependenceForImpliedType(E->getType()->getDependence()) |
turnTypeToValueDependence(E->getInitializer()->getDependence());
}
-ExprDependence clang::computeDependence(CastExpr *E) {
+ExprDependence clang::computeDependence(ImplicitCastExpr *E) {
+ // We model implicit conversions as combining the dependence of their
+ // subexpression, apart from its type, with the semantic portion of the
+ // target type.
+ ExprDependence D =
+ toExprDependenceForImpliedType(E->getType()->getDependence());
+ if (auto *S = E->getSubExpr())
+ D |= S->getDependence() & ~ExprDependence::Type;
+ return D;
+}
+
+ExprDependence clang::computeDependence(ExplicitCastExpr *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;
- }
+ //
+ // Note that we also need to consider the dependence of the actual type here,
+ // because when the type as written is a deduced type, that type is not
+ // dependent, but it may be deduced as a dependent type.
+ ExprDependence D =
+ toExprDependenceAsWritten(
+ cast<ExplicitCastExpr>(E)->getTypeAsWritten()->getDependence()) |
+ toExprDependenceForImpliedType(E->getType()->getDependence());
if (auto *S = E->getSubExpr())
D |= S->getDependence() & ~ExprDependence::Type;
return D;
}
ExprDependence clang::computeDependence(StmtExpr *E, unsigned TemplateDepth) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
// Propagate dependence of the result.
if (const auto *CompoundExprResult =
dyn_cast_or_null<ValueStmt>(E->getSubStmt()->getStmtExprResult()))
}
ExprDependence clang::computeDependence(ConvertVectorExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence()) |
+ auto D = toExprDependenceAsWritten(
+ E->getTypeSourceInfo()->getType()->getDependence()) |
E->getSrcExpr()->getDependence();
if (!E->getType()->isDependentType())
D &= ~ExprDependence::Type;
}
ExprDependence clang::computeDependence(VAArgExpr *E) {
- auto D =
- toExprDependence(E->getWrittenTypeInfo()->getType()->getDependence()) |
- (E->getSubExpr()->getDependence() & ~ExprDependence::Type);
+ auto D = toExprDependenceAsWritten(
+ E->getWrittenTypeInfo()->getType()->getDependence()) |
+ (E->getSubExpr()->getDependence() & ~ExprDependence::Type);
return D & ~ExprDependence::Value;
}
ExprDependence clang::computeDependence(NoInitExpr *E) {
- return toExprDependence(E->getType()->getDependence()) &
+ return toExprDependenceForImpliedType(E->getType()->getDependence()) &
(ExprDependence::Instantiation | ExprDependence::Error);
}
}
ExprDependence clang::computeDependence(ImplicitValueInitExpr *E) {
- return toExprDependence(E->getType()->getDependence()) &
+ return toExprDependenceForImpliedType(E->getType()->getDependence()) &
ExprDependence::Instantiation;
}
}
ExprDependence clang::computeDependence(BlockExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
if (E->getBlockDecl()->isDependentContext())
D |= ExprDependence::Instantiation;
- return D & ~ExprDependence::UnexpandedPack;
+ return D;
}
ExprDependence clang::computeDependence(AsTypeExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence()) |
+ // FIXME: AsTypeExpr doesn't store the type as written. Assume the expression
+ // type has identical sugar for now, so is a type-as-written.
+ auto D = toExprDependenceAsWritten(E->getType()->getDependence()) |
E->getSrcExpr()->getDependence();
if (!E->getType()->isDependentType())
D &= ~ExprDependence::Type;
ExprDependence clang::computeDependence(CXXStdInitializerListExpr *E) {
auto D = turnTypeToValueDependence(E->getSubExpr()->getDependence());
- D |= toExprDependence(E->getType()->getDependence()) &
- (ExprDependence::Type | ExprDependence::Error);
+ D |= toExprDependenceForImpliedType(E->getType()->getDependence());
return D;
}
ExprDependence clang::computeDependence(CXXTypeidExpr *E) {
auto D = ExprDependence::None;
if (E->isTypeOperand())
- D = toExprDependence(
+ D = toExprDependenceAsWritten(
E->getTypeOperandSourceInfo()->getType()->getDependence());
else
D = turnTypeToValueDependence(E->getExprOperand()->getDependence());
ExprDependence clang::computeDependence(CXXUuidofExpr *E) {
if (E->isTypeOperand())
- return turnTypeToValueDependence(toExprDependence(
+ return turnTypeToValueDependence(toExprDependenceAsWritten(
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());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
assert(!(D & ExprDependence::UnexpandedPack));
return D;
}
}
ExprDependence clang::computeDependence(CXXScalarValueInitExpr *E) {
- return toExprDependence(E->getType()->getDependence()) &
- ~ExprDependence::TypeValue;
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
+ if (auto *TSI = E->getTypeSourceInfo())
+ D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
+ return D;
}
ExprDependence clang::computeDependence(CXXDeleteExpr *E) {
}
ExprDependence clang::computeDependence(ArrayTypeTraitExpr *E) {
- auto D = toExprDependence(E->getQueriedType()->getDependence());
+ auto D = toExprDependenceAsWritten(E->getQueriedType()->getDependence());
if (auto *Dim = E->getDimensionExpression())
D |= Dim->getDependence();
return turnTypeToValueDependence(D);
}
ExprDependence clang::computeDependence(ObjCEncodeExpr *E) {
- return toExprDependence(E->getEncodedType()->getDependence());
+ return toExprDependenceAsWritten(E->getEncodedType()->getDependence());
}
ExprDependence clang::computeDependence(ObjCIvarRefExpr *E) {
if (E->isObjectReceiver())
return E->getBase()->getDependence() & ~ExprDependence::Type;
if (E->isSuperReceiver())
- return toExprDependence(E->getSuperReceiverType()->getDependence()) &
+ return toExprDependenceForImpliedType(
+ E->getSuperReceiverType()->getDependence()) &
~ExprDependence::TypeValue;
assert(E->isClassReceiver());
return ExprDependence::None;
}
ExprDependence clang::computeDependence(OMPArrayShapingExpr *E) {
- auto D = E->getBase()->getDependence() |
- toExprDependence(E->getType()->getDependence());
+ auto D = E->getBase()->getDependence();
for (Expr *Dim: E->getDimensions())
if (Dim)
- D |= Dim->getDependence();
+ D |= turnValueToTypeDependence(Dim->getDependence());
return D;
}
ExprDependence clang::computeDependence(OMPIteratorExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(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());
+ if (auto *DD = cast_or_null<DeclaratorDecl>(E->getIteratorDecl(I))) {
+ // If the type is omitted, it's 'int', and is not dependent in any way.
+ if (auto *TSI = DD->getTypeSourceInfo()) {
+ D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
+ }
+ }
OMPIteratorExpr::IteratorRange IR = E->getIteratorRange(I);
if (Expr *BE = IR.Begin)
D |= BE->getDependence();
if (Decl->isParameterPack())
Deps |= ExprDependence::UnexpandedPack;
- Deps |= toExprDependence(Type->getDependence()) & ExprDependence::Error;
+ Deps |= toExprDependenceForImpliedType(Type->getDependence()) &
+ ExprDependence::Error;
// C++ [temp.dep.expr]p3:
// An id-expression is type-dependent if it contains:
// - 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()) |
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence()) |
ExprDependence::ErrorDependent;
// FIXME: remove the type-dependent bit from subexpressions, if the
// RecoveryExpr has a non-dependent type.
}
ExprDependence clang::computeDependence(SYCLUniqueStableNameExpr *E) {
- return toExprDependence(E->getTypeSourceInfo()->getType()->getDependence());
+ return toExprDependenceAsWritten(
+ E->getTypeSourceInfo()->getType()->getDependence());
}
ExprDependence clang::computeDependence(PredefinedExpr *E) {
- return toExprDependence(E->getType()->getDependence()) &
- ~ExprDependence::UnexpandedPack;
+ return toExprDependenceForImpliedType(E->getType()->getDependence());
}
ExprDependence clang::computeDependence(CallExpr *E,
}
ExprDependence clang::computeDependence(OffsetOfExpr *E) {
- auto D = turnTypeToValueDependence(
- toExprDependence(E->getTypeSourceInfo()->getType()->getDependence()));
+ auto D = turnTypeToValueDependence(toExprDependenceAsWritten(
+ 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(ShuffleVectorExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
for (auto *C : llvm::makeArrayRef(E->getSubExprs(), E->getNumSubExprs()))
D |= C->getDependence();
return D;
}
ExprDependence clang::computeDependence(CXXNewExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceAsWritten(
+ E->getAllocatedTypeSourceInfo()->getType()->getDependence());
+ D |= toExprDependenceForImpliedType(E->getAllocatedType()->getDependence());
auto Size = E->getArraySize();
if (Size.hasValue() && *Size)
D |= turnTypeToValueDependence((*Size)->getDependence());
ExprDependence clang::computeDependence(CXXPseudoDestructorExpr *E) {
auto D = E->getBase()->getDependence();
- if (!E->getDestroyedType().isNull())
- D |= toExprDependence(E->getDestroyedType()->getDependence());
+ if (auto *TSI = E->getDestroyedTypeInfo())
+ D |= toExprDependenceAsWritten(TSI->getType()->getDependence());
if (auto *ST = E->getScopeTypeInfo())
D |= turnTypeToValueDependence(
- toExprDependence(ST->getType()->getDependence()));
+ toExprDependenceAsWritten(ST->getType()->getDependence()));
if (auto *Q = E->getQualifier())
D |= toExprDependence(Q->getDependence() &
~NestedNameSpecifierDependence::Dependent);
}
ExprDependence clang::computeDependence(CXXConstructExpr *E) {
- auto D = toExprDependence(E->getType()->getDependence());
+ ExprDependence D =
+ toExprDependenceForImpliedType(E->getType()->getDependence());
for (auto *A : E->arguments())
D |= A->getDependence() & ~ExprDependence::Type;
return D;
}
+ExprDependence clang::computeDependence(CXXTemporaryObjectExpr *E) {
+ CXXConstructExpr *BaseE = E;
+ return toExprDependenceAsWritten(
+ E->getTypeSourceInfo()->getType()->getDependence()) |
+ computeDependence(BaseE);
+}
+
ExprDependence clang::computeDependence(CXXDefaultInitExpr *E) {
return E->getExpr()->getDependence();
}
ExprDependence clang::computeDependence(LambdaExpr *E,
bool ContainsUnexpandedParameterPack) {
- auto D = toExprDependence(E->getType()->getDependence());
+ auto D = toExprDependenceForImpliedType(E->getType()->getDependence());
if (ContainsUnexpandedParameterPack)
D |= ExprDependence::UnexpandedPack;
return D;
ExprDependence clang::computeDependence(CXXUnresolvedConstructExpr *E) {
auto D = ExprDependence::ValueInstantiation;
- D |= toExprDependence(E->getType()->getDependence());
+ D |= toExprDependenceAsWritten(E->getTypeAsWritten()->getDependence());
+ D |= toExprDependenceForImpliedType(E->getType()->getDependence());
for (auto *A : E->arguments())
D |= A->getDependence() &
(ExprDependence::UnexpandedPack | ExprDependence::Error);
ExprDependence clang::computeDependence(TypeTraitExpr *E) {
auto D = ExprDependence::None;
for (const auto *A : E->getArgs())
- D |=
- toExprDependence(A->getType()->getDependence()) & ~ExprDependence::Type;
+ D |= toExprDependenceAsWritten(A->getType()->getDependence()) &
+ ~ExprDependence::Type;
return D;
}
if (auto *R = E->getInstanceReceiver())
D |= R->getDependence();
else
- D |= toExprDependence(E->getType()->getDependence());
+ D |= toExprDependenceForImpliedType(E->getType()->getDependence());
for (auto *A : E->arguments())
D |= A->getDependence();
return D;
--- /dev/null
+// RUN: %clang_cc1 -verify %s -std=c++17 -Wno-unused
+
+template<typename ...Ts> void PackInsideTypedefDeclaration() {
+ ([] {
+ typedef Ts Type;
+ (void)Type();
+ }(), ...);
+}
+template void PackInsideTypedefDeclaration<>();
+template void PackInsideTypedefDeclaration<int>();
+template void PackInsideTypedefDeclaration<int, float>();
+
+template<typename ...Ts> void PackInsideTypedefDeclarationInvalid() {
+ [] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
+ typedef Ts Type;
+ (void)Type();
+ };
+
+ ([] {
+ typedef Ts Type;
+ // A reference to a typedef containing an unexpanded pack does not
+ // itself contain an unexpanded pack.
+ f(Type()...); // expected-error {{does not contain any unexpanded}}
+ }, ...);
+}
+
+
+template<typename ...Ts> void PackInsideAliasDeclaration() {
+ ([] {
+ using Type = Ts;
+ (void)Type();
+ }(), ...);
+}
+template void PackInsideAliasDeclaration<>();
+template void PackInsideAliasDeclaration<int>();
+template void PackInsideAliasDeclaration<int, float>();
+
+template<typename ...Ts> void PackInsideAliasDeclarationInvalid() {
+ [] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
+ using Type = Ts;
+ (void)Type();
+ };
+ ([] {
+ using Type = Ts;
+ // A reference to an alias containing an unexpanded pack does not
+ // itself contain an unexpanded pack.
+ f(Type()...); // expected-error {{does not contain any unexpanded}}
+ }, ...);
+}
+
+
+template<typename ...Ts> void PackInsideUsingDeclaration() {
+ ([] {
+ struct A {
+ using Type = Ts;
+ };
+ struct B : A {
+ using typename A::Type;
+ };
+ (void)typename B::Type();
+ }(), ...);
+}
+template void PackInsideUsingDeclaration<>();
+template void PackInsideUsingDeclaration<int>();
+template void PackInsideUsingDeclaration<int, float>();
+
+template<typename ...Ts> void PackInsideUsingDeclarationInvalid() {
+ ([] {
+ struct A {
+ using Type = Ts;
+ };
+ struct B : A {
+ using typename A::Type...; // expected-error {{does not contain any unexpanded}}
+ };
+ }(), ...);
+}
+
+
+template<typename ...Ts> void PackInsideVarDeclaration() {
+ ([] {
+ Ts ts;
+ (void)ts;
+ }, ...);
+}
+template void PackInsideVarDeclaration<>();
+template void PackInsideVarDeclaration<int>();
+template void PackInsideVarDeclaration<int, float>();
+
+template<typename ...Ts> void PackInsideVarDeclarationInvalid() {
+ [] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
+ Ts ts;
+ (void)ts;
+ };
+}
+
+
+template<typename ...Ts> void PackInsideFunctionDeclaration() {
+ ([] {
+ Ts ts(Ts);
+ ts({});
+ }, ...);
+}
+template void PackInsideFunctionDeclaration<>();
+template void PackInsideFunctionDeclaration<int>();
+template void PackInsideFunctionDeclaration<int, float>();
+
+template<typename ...Ts> void PackInsideFunctionDeclarationInvalid() {
+ [] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
+ Ts ts(Ts);
+ ts({});
+ };
+}
+
+
+template<typename ...Ts> void PackInsideLocalClass() {
+ ([] {
+ class Local {
+ Ts ts;
+ };
+ Local l;
+ }, ...);
+}
+template void PackInsideLocalClass<>();
+template void PackInsideLocalClass<int>();
+template void PackInsideLocalClass<int, float>();
+
+template<typename ...Ts> void PackInsideLocalClassInvalid() {
+ [] { // expected-error {{contains unexpanded parameter pack 'Ts'}}
+ class Local {
+ Ts ts;
+ };
+ Local l;
+ };
+}
+
+template<typename T> using Int = int;
+struct AClass {};
+template<typename T> using Class = AClass;
+template<typename ...Ts> void HiddenPack() {
+ (Int<Ts>(), ...);
+ (Int<Ts>{}, ...);
+ (Class<Ts>(), ...);
+ (Class<Ts>{}, ...);
+
+ ([] {
+ Int<Ts>();
+ }, ...);
+ ([] {
+ Int<Ts>{};
+ }, ...);
+ ([] {
+ Class<Ts>();
+ }, ...);
+ ([] {
+ Class<Ts>{};
+ }, ...);
+}
+template void HiddenPack<>();
+template void HiddenPack<int>();
+template void HiddenPack<int, float>();
+
+template<typename ...Ts> void HiddenPackInvalid() {
+ Int<Ts>(); // expected-error {{unexpanded}}
+ Int<Ts>{}; // expected-error {{unexpanded}}
+ Class<Ts>(); // expected-error {{unexpanded}}
+ Class<Ts>{}; // expected-error {{unexpanded}}
+}