Revert "[Concepts] Placeholder constraints and abbreviated templates"
This reverts commit e57a9abc4b01fa69fe81ace8df70517983b6cbac.
Parser/cxx2a-placeholder-type-constraint.cpp has MSan failures.
Present at 7b81c3f8793d30a4285095a9b67dcfca2117916c:
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap-msan/builds/17133/steps/check-clang%20msan/logs/stdio
not present at eaa594f4ec54eba52b03fd9f1c789b214c66a753:
http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap-msan/builds/17132/steps/check-clang%20msan/logs/stdio
Stack trace:
```
==57032==WARNING: MemorySanitizer: use-of-uninitialized-value
#0 0xccfe016 in clang::AutoTypeLoc::getLocalSourceRange() const /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/include/clang/AST/TypeLoc.h:2036:19
#1 0xcc56758 in CheckDeducedPlaceholderConstraints(clang::Sema&, clang::AutoType const&, clang::AutoTypeLoc, clang::QualType) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaTemplateDeduction.cpp:4505:56
#2 0xcc550ce in clang::Sema::DeduceAutoType(clang::TypeLoc, clang::Expr*&, clang::QualType&, llvm::Optional<unsigned int>, bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaTemplateDeduction.cpp:4707:11
#3 0xcc52407 in clang::Sema::DeduceAutoType(clang::TypeSourceInfo*, clang::Expr*&, clang::QualType&, llvm::Optional<unsigned int>, bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaTemplateDeduction.cpp:4457:10
#4 0xba38332 in clang::Sema::deduceVarTypeFromInitializer(clang::VarDecl*, clang::DeclarationName, clang::QualType, clang::TypeSourceInfo*, clang::SourceRange, bool, clang::Expr*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaDecl.cpp:11351:7
#5 0xba3a8a9 in clang::Sema::DeduceVariableDeclarationType(clang::VarDecl*, bool, clang::Expr*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaDecl.cpp:11385:26
#6 0xba3c520 in clang::Sema::AddInitializerToDecl(clang::Decl*, clang::Expr*, bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Sema/SemaDecl.cpp:11725:9
#7 0xb39c498 in clang::Parser::ParseDeclarationAfterDeclaratorAndAttributes(clang::Declarator&, clang::Parser::ParsedTemplateInfo const&, clang::Parser::ForRangeInit*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:2399:17
#8 0xb394d80 in clang::Parser::ParseDeclGroup(clang::ParsingDeclSpec&, clang::DeclaratorContext, clang::SourceLocation*, clang::Parser::ForRangeInit*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:2128:21
#9 0xb383bbf in clang::Parser::ParseSimpleDeclaration(clang::DeclaratorContext, clang::SourceLocation&, clang::Parser::ParsedAttributesWithRange&, bool, clang::Parser::ForRangeInit*, clang::SourceLocation*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:1848:10
#10 0xb383129 in clang::Parser::ParseDeclaration(clang::DeclaratorContext, clang::SourceLocation&, clang::Parser::ParsedAttributesWithRange&, clang::SourceLocation*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/llvm/include/llvm/ADT/PointerUnion.h
#11 0xb53a388 in clang::Parser::ParseStatementOrDeclarationAfterAttributes(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*, clang::Parser::ParsedAttributesWithRange&) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseStmt.cpp:221:13
#12 0xb539309 in clang::Parser::ParseStatementOrDeclaration(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseStmt.cpp:106:20
#13 0xb55610e in clang::Parser::ParseCompoundStatementBody(bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseStmt.cpp:1079:11
#14 0xb559529 in clang::Parser::ParseFunctionStatementBody(clang::Decl*, clang::Parser::ParseScope&) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseStmt.cpp:2204:21
#15 0xb33c13e in clang::Parser::ParseFunctionDefinition(clang::ParsingDeclarator&, clang::Parser::ParsedTemplateInfo const&, clang::Parser::LateParsedAttrList*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/Parser.cpp:1339:10
#16 0xb394703 in clang::Parser::ParseDeclGroup(clang::ParsingDeclSpec&, clang::DeclaratorContext, clang::SourceLocation*, clang::Parser::ForRangeInit*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseDecl.cpp:2068:11
#17 0xb338e52 in clang::Parser::ParseDeclOrFunctionDefInternal(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec&, clang::AccessSpecifier) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/Parser.cpp:1099:10
#18 0xb337674 in clang::Parser::ParseDeclarationOrFunctionDefinition(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec*, clang::AccessSpecifier) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/Parser.cpp:1115:12
#19 0xb334a96 in clang::Parser::ParseExternalDeclaration(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/Parser.cpp:935:12
#20 0xb32f12a in clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/Parser.cpp:686:12
#21 0xb31e193 in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Parse/ParseAST.cpp:158:20
#22 0x80263f0 in clang::FrontendAction::Execute() /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:936:8
#23 0x7f2a257 in clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/Frontend/CompilerInstance.cpp:965:33
#24 0x8288bef in clang::ExecuteCompilerInvocation(clang::CompilerInstance*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp:290:25
#25 0xad44c2 in cc1_main(llvm::ArrayRef<char const*>, char const*, void*) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/tools/driver/cc1_main.cpp:239:15
#26 0xacd76a in ExecuteCC1Tool(llvm::ArrayRef<char const*>) /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/tools/driver/driver.cpp:325:12
#27 0xacc9fd in main /b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm-project/clang/tools/driver/driver.cpp:398:12
#28 0x7f7d82cdb2e0 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x202e0)
#29 0xa4dde9 in _start (/b/sanitizer-x86_64-linux-bootstrap-msan/build/llvm_build_msan/bin/clang-11+0xa4dde9)
```
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 6d1db38..a514292 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -716,61 +716,6 @@
RequiresClause->Profile(ID, C, /*Canonical=*/true);
}
-static Expr *
-canonicalizeImmediatelyDeclaredConstraint(const ASTContext &C, Expr *IDC,
- QualType ConstrainedType) {
- // This is a bit ugly - we need to form a new immediately-declared
- // constraint that references the new parameter; this would ideally
- // require semantic analysis (e.g. template<C T> struct S {}; - the
- // converted arguments of C<T> could be an argument pack if C is
- // declared as template<typename... T> concept C = ...).
- // We don't have semantic analysis here so we dig deep into the
- // ready-made constraint expr and change the thing manually.
- ConceptSpecializationExpr *CSE;
- if (const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))
- CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());
- else
- CSE = cast<ConceptSpecializationExpr>(IDC);
- ArrayRef<TemplateArgument> OldConverted = CSE->getTemplateArguments();
- SmallVector<TemplateArgument, 3> NewConverted;
- NewConverted.reserve(OldConverted.size());
- if (OldConverted.front().getKind() == TemplateArgument::Pack) {
- // The case:
- // template<typename... T> concept C = true;
- // template<C<int> T> struct S; -> constraint is C<{T, int}>
- NewConverted.push_back(ConstrainedType);
- for (auto &Arg : OldConverted.front().pack_elements().drop_front(1))
- NewConverted.push_back(Arg);
- TemplateArgument NewPack(NewConverted);
-
- NewConverted.clear();
- NewConverted.push_back(NewPack);
- assert(OldConverted.size() == 1 &&
- "Template parameter pack should be the last parameter");
- } else {
- assert(OldConverted.front().getKind() == TemplateArgument::Type &&
- "Unexpected first argument kind for immediately-declared "
- "constraint");
- NewConverted.push_back(ConstrainedType);
- for (auto &Arg : OldConverted.drop_front(1))
- NewConverted.push_back(Arg);
- }
- Expr *NewIDC = ConceptSpecializationExpr::Create(
- C, NestedNameSpecifierLoc(), /*TemplateKWLoc=*/SourceLocation(),
- CSE->getConceptNameInfo(), /*FoundDecl=*/CSE->getNamedConcept(),
- CSE->getNamedConcept(),
- // Actually canonicalizing a TemplateArgumentLoc is difficult so we
- // simply omit the ArgsAsWritten
- /*ArgsAsWritten=*/nullptr, NewConverted, nullptr);
-
- if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))
- NewIDC = new (C) CXXFoldExpr(OrigFold->getType(), SourceLocation(), NewIDC,
- BinaryOperatorKind::BO_LAnd,
- SourceLocation(), /*RHS=*/nullptr,
- SourceLocation(), /*NumExpansions=*/None);
- return NewIDC;
-}
-
TemplateTemplateParmDecl *
ASTContext::getCanonicalTemplateTemplateParmDecl(
TemplateTemplateParmDecl *TTP) const {
@@ -798,23 +743,68 @@
TTP->isExpandedParameterPack() ?
llvm::Optional<unsigned>(TTP->getNumExpansionParameters()) : None);
if (const auto *TC = TTP->getTypeConstraint()) {
+ // This is a bit ugly - we need to form a new immediately-declared
+ // constraint that references the new parameter; this would ideally
+ // require semantic analysis (e.g. template<C T> struct S {}; - the
+ // converted arguments of C<T> could be an argument pack if C is
+ // declared as template<typename... T> concept C = ...).
+ // We don't have semantic analysis here so we dig deep into the
+ // ready-made constraint expr and change the thing manually.
+ Expr *IDC = TC->getImmediatelyDeclaredConstraint();
+ ConceptSpecializationExpr *CSE;
+ if (const auto *Fold = dyn_cast<CXXFoldExpr>(IDC))
+ CSE = cast<ConceptSpecializationExpr>(Fold->getLHS());
+ else
+ CSE = cast<ConceptSpecializationExpr>(IDC);
+ ArrayRef<TemplateArgument> OldConverted = CSE->getTemplateArguments();
+ SmallVector<TemplateArgument, 3> NewConverted;
+ NewConverted.reserve(OldConverted.size());
+
QualType ParamAsArgument(NewTTP->getTypeForDecl(), 0);
- Expr *NewIDC = canonicalizeImmediatelyDeclaredConstraint(
- *this, TC->getImmediatelyDeclaredConstraint(),
- ParamAsArgument);
- TemplateArgumentListInfo CanonArgsAsWritten;
- if (auto *Args = TC->getTemplateArgsAsWritten())
- for (const auto &ArgLoc : Args->arguments())
- CanonArgsAsWritten.addArgument(
- TemplateArgumentLoc(ArgLoc.getArgument(),
- TemplateArgumentLocInfo()));
+ if (OldConverted.front().getKind() == TemplateArgument::Pack) {
+ // The case:
+ // template<typename... T> concept C = true;
+ // template<C<int> T> struct S; -> constraint is C<{T, int}>
+ NewConverted.push_back(ParamAsArgument);
+ for (auto &Arg : OldConverted.front().pack_elements().drop_front(1))
+ NewConverted.push_back(Arg);
+ TemplateArgument NewPack(NewConverted);
+
+ NewConverted.clear();
+ NewConverted.push_back(NewPack);
+ assert(OldConverted.size() == 1 &&
+ "Template parameter pack should be the last parameter");
+ } else {
+ assert(OldConverted.front().getKind() == TemplateArgument::Type &&
+ "Unexpected first argument kind for immediately-declared "
+ "constraint");
+ NewConverted.push_back(ParamAsArgument);
+ for (auto &Arg : OldConverted.drop_front(1))
+ NewConverted.push_back(Arg);
+ }
+ Expr *NewIDC = ConceptSpecializationExpr::Create(*this,
+ NestedNameSpecifierLoc(), /*TemplateKWLoc=*/SourceLocation(),
+ CSE->getConceptNameInfo(), /*FoundDecl=*/CSE->getNamedConcept(),
+ CSE->getNamedConcept(),
+ // Actually canonicalizing a TemplateArgumentLoc is difficult so we
+ // simply omit the ArgsAsWritten
+ /*ArgsAsWritten=*/nullptr, NewConverted, nullptr);
+
+ if (auto *OrigFold = dyn_cast<CXXFoldExpr>(IDC))
+ NewIDC = new (*this) CXXFoldExpr(OrigFold->getType(),
+ SourceLocation(), NewIDC,
+ BinaryOperatorKind::BO_LAnd,
+ SourceLocation(), /*RHS=*/nullptr,
+ SourceLocation(),
+ /*NumExpansions=*/None);
+
NewTTP->setTypeConstraint(
NestedNameSpecifierLoc(),
DeclarationNameInfo(TC->getNamedConcept()->getDeclName(),
SourceLocation()), /*FoundDecl=*/nullptr,
// Actually canonicalizing a TemplateArgumentLoc is difficult so we
// simply omit the ArgsAsWritten
- TC->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);
+ CSE->getNamedConcept(), /*ArgsAsWritten=*/nullptr, NewIDC);
}
CanonParams.push_back(NewTTP);
} else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
@@ -849,13 +839,6 @@
NTTP->isParameterPack(),
TInfo);
}
- if (AutoType *AT = T->getContainedAutoType()) {
- if (AT->isConstrained()) {
- Param->setPlaceholderTypeConstraint(
- canonicalizeImmediatelyDeclaredConstraint(
- *this, NTTP->getPlaceholderTypeConstraint(), T));
- }
- }
CanonParams.push_back(Param);
} else
@@ -960,7 +943,7 @@
Builtin::Context &builtins)
: ConstantArrayTypes(this_()), FunctionProtoTypes(this_()),
TemplateSpecializationTypes(this_()),
- DependentTemplateSpecializationTypes(this_()), AutoTypes(this_()),
+ DependentTemplateSpecializationTypes(this_()),
SubstTemplateTemplateParmPacks(this_()),
CanonTemplateTemplateParms(this_()), SourceMgr(SM), LangOpts(LOpts),
SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
@@ -5141,29 +5124,21 @@
/// getAutoType - Return the uniqued reference to the 'auto' type which has been
/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
/// canonical deduced-but-dependent 'auto' type.
-QualType
-ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
- bool IsDependent, bool IsPack,
- ConceptDecl *TypeConstraintConcept,
- ArrayRef<TemplateArgument> TypeConstraintArgs) const {
+QualType ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
+ bool IsDependent, bool IsPack) const {
assert((!IsPack || IsDependent) && "only use IsPack for a dependent pack");
- if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto &&
- !TypeConstraintConcept && !IsDependent)
+ if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto && !IsDependent)
return getAutoDeductType();
// Look in the folding set for an existing type.
void *InsertPos = nullptr;
llvm::FoldingSetNodeID ID;
- AutoType::Profile(ID, *this, DeducedType, Keyword, IsDependent,
- TypeConstraintConcept, TypeConstraintArgs);
+ AutoType::Profile(ID, DeducedType, Keyword, IsDependent, IsPack);
if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(AT, 0);
- void *Mem = Allocate(sizeof(AutoType) +
- sizeof(TemplateArgument) * TypeConstraintArgs.size(),
- TypeAlignment);
- auto *AT = new (Mem) AutoType(DeducedType, Keyword, IsDependent, IsPack,
- TypeConstraintConcept, TypeConstraintArgs);
+ auto *AT = new (*this, TypeAlignment)
+ AutoType(DeducedType, Keyword, IsDependent, IsPack);
Types.push_back(AT);
if (InsertPos)
AutoTypes.InsertNode(AT, InsertPos);
@@ -5225,8 +5200,7 @@
if (AutoDeductTy.isNull())
AutoDeductTy = QualType(
new (*this, TypeAlignment) AutoType(QualType(), AutoTypeKeyword::Auto,
- /*dependent*/false, /*pack*/false,
- /*concept*/nullptr, /*args*/{}),
+ /*dependent*/false, /*pack*/false),
0);
return AutoDeductTy;
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 9dd20e2..b67d101 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -1366,21 +1366,9 @@
if (!ToDeducedTypeOrErr)
return ToDeducedTypeOrErr.takeError();
- ExpectedDecl ToTypeConstraintConcept = import(T->getTypeConstraintConcept());
- if (!ToTypeConstraintConcept)
- return ToTypeConstraintConcept.takeError();
-
- SmallVector<TemplateArgument, 2> ToTemplateArgs;
- ArrayRef<TemplateArgument> FromTemplateArgs = T->getTypeConstraintArguments();
- if (Error Err = ImportTemplateArguments(FromTemplateArgs.data(),
- FromTemplateArgs.size(),
- ToTemplateArgs))
- return std::move(Err);
-
- return Importer.getToContext().getAutoType(
- *ToDeducedTypeOrErr, T->getKeyword(), /*IsDependent*/false,
- /*IsPack=*/false, cast_or_null<ConceptDecl>(*ToTypeConstraintConcept),
- ToTemplateArgs);
+ return Importer.getToContext().getAutoType(*ToDeducedTypeOrErr,
+ T->getKeyword(),
+ /*IsDependent*/false);
}
ExpectedType ASTNodeImporter::VisitInjectedClassNameType(
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp
index 91a2f3a..db48405 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -729,31 +729,11 @@
return false;
break;
- case Type::Auto: {
- auto *Auto1 = cast<AutoType>(T1);
- auto *Auto2 = cast<AutoType>(T2);
- if (!IsStructurallyEquivalent(Context, Auto1->getDeducedType(),
- Auto2->getDeducedType()))
+ case Type::Auto:
+ if (!IsStructurallyEquivalent(Context, cast<AutoType>(T1)->getDeducedType(),
+ cast<AutoType>(T2)->getDeducedType()))
return false;
- if (Auto1->isConstrained() != Auto2->isConstrained())
- return false;
- if (Auto1->isConstrained()) {
- if (Auto1->getTypeConstraintConcept() !=
- Auto2->getTypeConstraintConcept())
- return false;
- ArrayRef<TemplateArgument> Auto1Args =
- Auto1->getTypeConstraintArguments();
- ArrayRef<TemplateArgument> Auto2Args =
- Auto2->getTypeConstraintArguments();
- if (Auto1Args.size() != Auto2Args.size())
- return false;
- for (unsigned I = 0, N = Auto1Args.size(); I != N; ++I) {
- if (!IsStructurallyEquivalent(Context, Auto1Args[I], Auto2Args[I]))
- return false;
- }
- }
break;
- }
case Type::DeducedTemplateSpecialization: {
const auto *DT1 = cast<DeducedTemplateSpecializationType>(T1);
diff --git a/clang/lib/AST/DeclTemplate.cpp b/clang/lib/AST/DeclTemplate.cpp
index 9bd3b64..58ce49a 100755
--- a/clang/lib/AST/DeclTemplate.cpp
+++ b/clang/lib/AST/DeclTemplate.cpp
@@ -164,15 +164,10 @@
void TemplateParameterList::
getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
if (HasConstrainedParameters)
- for (const NamedDecl *Param : *this) {
- if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
+ for (const NamedDecl *Param : *this)
+ if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
if (const auto *TC = TTP->getTypeConstraint())
AC.push_back(TC->getImmediatelyDeclaredConstraint());
- } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
- if (const Expr *E = NTTP->getPlaceholderTypeConstraint())
- AC.push_back(E);
- }
- }
if (HasRequiresClause)
AC.push_back(getRequiresClause());
}
@@ -692,14 +687,8 @@
unsigned D, unsigned P, IdentifierInfo *Id,
QualType T, bool ParameterPack,
TypeSourceInfo *TInfo) {
- AutoType *AT =
- C.getLangOpts().ConceptsTS ? T->getContainedAutoType() : nullptr;
- return new (C, DC,
- additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
- Expr *>(0,
- AT && AT->isConstrained() ? 1 : 0))
- NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, ParameterPack,
- TInfo);
+ return new (C, DC) NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id,
+ T, ParameterPack, TInfo);
}
NonTypeTemplateParmDecl *NonTypeTemplateParmDecl::Create(
@@ -707,34 +696,26 @@
SourceLocation IdLoc, unsigned D, unsigned P, IdentifierInfo *Id,
QualType T, TypeSourceInfo *TInfo, ArrayRef<QualType> ExpandedTypes,
ArrayRef<TypeSourceInfo *> ExpandedTInfos) {
- AutoType *AT = TInfo->getType()->getContainedAutoType();
return new (C, DC,
- additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
- Expr *>(
- ExpandedTypes.size(), AT && AT->isConstrained() ? 1 : 0))
+ additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
+ ExpandedTypes.size()))
NonTypeTemplateParmDecl(DC, StartLoc, IdLoc, D, P, Id, T, TInfo,
ExpandedTypes, ExpandedTInfos);
}
NonTypeTemplateParmDecl *
-NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
- bool HasTypeConstraint) {
- return new (C, ID, additionalSizeToAlloc<std::pair<QualType,
- TypeSourceInfo *>,
- Expr *>(0,
- HasTypeConstraint ? 1 : 0))
- NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
- 0, 0, nullptr, QualType(), false, nullptr);
+NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
+ return new (C, ID) NonTypeTemplateParmDecl(nullptr, SourceLocation(),
+ SourceLocation(), 0, 0, nullptr,
+ QualType(), false, nullptr);
}
NonTypeTemplateParmDecl *
NonTypeTemplateParmDecl::CreateDeserialized(ASTContext &C, unsigned ID,
- unsigned NumExpandedTypes,
- bool HasTypeConstraint) {
+ unsigned NumExpandedTypes) {
auto *NTTP =
- new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>,
- Expr *>(
- NumExpandedTypes, HasTypeConstraint ? 1 : 0))
+ new (C, ID, additionalSizeToAlloc<std::pair<QualType, TypeSourceInfo *>>(
+ NumExpandedTypes))
NonTypeTemplateParmDecl(nullptr, SourceLocation(), SourceLocation(),
0, 0, nullptr, QualType(), nullptr, None,
None);
diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp
index 1f9ff9e..27fdca1 100644
--- a/clang/lib/AST/ODRHash.cpp
+++ b/clang/lib/AST/ODRHash.cpp
@@ -857,13 +857,6 @@
void VisitAutoType(const AutoType *T) {
ID.AddInteger((unsigned)T->getKeyword());
- ID.AddInteger(T->isConstrained());
- if (T->isConstrained()) {
- AddDecl(T->getTypeConstraintConcept());
- ID.AddInteger(T->getNumArgs());
- for (const auto &TA : T->getTypeConstraintArguments())
- Hash.AddTemplateArgument(TA);
- }
VisitDeducedType(T);
}
diff --git a/clang/lib/AST/TemplateBase.cpp b/clang/lib/AST/TemplateBase.cpp
index 6f0ebf2..db16c2a 100644
--- a/clang/lib/AST/TemplateBase.cpp
+++ b/clang/lib/AST/TemplateBase.cpp
@@ -561,7 +561,7 @@
}
const ASTTemplateArgumentListInfo *
-ASTTemplateArgumentListInfo::Create(const ASTContext &C,
+ASTTemplateArgumentListInfo::Create(ASTContext &C,
const TemplateArgumentListInfo &List) {
std::size_t size = totalSizeToAlloc<TemplateArgumentLoc>(List.size());
void *Mem = C.Allocate(size, alignof(ASTTemplateArgumentListInfo));
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index c9b5718..965ad17 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -1201,11 +1201,6 @@
OS << " decltype(auto)";
if (!T->isDeduced())
OS << " undeduced";
- if (T->isConstrained()) {
- dumpDeclRef(T->getTypeConstraintConcept());
- for (const auto &Arg : T->getTypeConstraintArguments())
- VisitTemplateArgument(Arg);
- }
}
void TextNodeDumper::VisitTemplateSpecializationType(
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 5099494..c5ad711 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -1114,9 +1114,7 @@
return QualType(T, 0);
return Ctx.getAutoType(deducedType, T->getKeyword(),
- T->isDependentType(), /*IsPack=*/false,
- T->getTypeConstraintConcept(),
- T->getTypeConstraintArguments());
+ T->isDependentType());
}
// FIXME: Non-trivial to implement, but important for C++
@@ -4160,35 +4158,3 @@
/*HasUnsignedPadding=*/false);
APFixedPoint(Val, FXSema).toString(Str);
}
-
-AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
- bool IsDeducedAsDependent, bool IsDeducedAsPack,
- ConceptDecl *TypeConstraintConcept,
- ArrayRef<TemplateArgument> TypeConstraintArgs)
- : DeducedType(Auto, DeducedAsType, IsDeducedAsDependent,
- IsDeducedAsDependent, IsDeducedAsPack) {
- AutoTypeBits.Keyword = (unsigned)Keyword;
- AutoTypeBits.NumArgs = TypeConstraintArgs.size();
- this->TypeConstraintConcept = TypeConstraintConcept;
- if (TypeConstraintConcept) {
- TemplateArgument *ArgBuffer = getArgBuffer();
- for (const TemplateArgument &Arg : TypeConstraintArgs) {
- if (Arg.containsUnexpandedParameterPack())
- setContainsUnexpandedParameterPack();
-
- new (ArgBuffer++) TemplateArgument(Arg);
- }
- }
-}
-
-void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
- QualType Deduced, AutoTypeKeyword Keyword,
- bool IsDependent, ConceptDecl *CD,
- ArrayRef<TemplateArgument> Arguments) {
- ID.AddPointer(Deduced.getAsOpaquePtr());
- ID.AddInteger((unsigned)Keyword);
- ID.AddBoolean(IsDependent);
- ID.AddPointer(CD);
- for (const TemplateArgument &Arg : Arguments)
- Arg.Profile(ID, Context);
-}
diff --git a/clang/lib/AST/TypeLoc.cpp b/clang/lib/AST/TypeLoc.cpp
index 665a86f..6e67ca8 100644
--- a/clang/lib/AST/TypeLoc.cpp
+++ b/clang/lib/AST/TypeLoc.cpp
@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include "clang/AST/TypeLoc.h"
-#include "clang/AST/DeclTemplate.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Expr.h"
@@ -590,97 +589,3 @@
}
}
}
-
-DeclarationNameInfo AutoTypeLoc::getConceptNameInfo() const {
- return DeclarationNameInfo(getNamedConcept()->getDeclName(),
- getLocalData()->ConceptNameLoc);
-}
-
-void AutoTypeLoc::initializeLocal(ASTContext &Context, SourceLocation Loc) {
- setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
- setTemplateKWLoc(Loc);
- setConceptNameLoc(Loc);
- setFoundDecl(nullptr);
- setRAngleLoc(Loc);
- setLAngleLoc(Loc);
- TemplateSpecializationTypeLoc::initializeArgLocs(Context, getNumArgs(),
- getTypePtr()->getArgs(),
- getArgInfos(), Loc);
- setNameLoc(Loc);
-}
-
-
-namespace {
-
- class GetContainedAutoTypeLocVisitor :
- public TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc> {
- public:
- using TypeLocVisitor<GetContainedAutoTypeLocVisitor, TypeLoc>::Visit;
-
- TypeLoc VisitAutoTypeLoc(AutoTypeLoc TL) {
- return TL;
- }
-
- // Only these types can contain the desired 'auto' type.
-
- TypeLoc VisitElaboratedTypeLoc(ElaboratedTypeLoc T) {
- return Visit(T.getNamedTypeLoc());
- }
-
- TypeLoc VisitQualifiedTypeLoc(QualifiedTypeLoc T) {
- return Visit(T.getUnqualifiedLoc());
- }
-
- TypeLoc VisitPointerTypeLoc(PointerTypeLoc T) {
- return Visit(T.getPointeeLoc());
- }
-
- TypeLoc VisitBlockPointerTypeLoc(BlockPointerTypeLoc T) {
- return Visit(T.getPointeeLoc());
- }
-
- TypeLoc VisitReferenceTypeLoc(ReferenceTypeLoc T) {
- return Visit(T.getPointeeLoc());
- }
-
- TypeLoc VisitMemberPointerTypeLoc(MemberPointerTypeLoc T) {
- return Visit(T.getPointeeLoc());
- }
-
- TypeLoc VisitArrayTypeLoc(ArrayTypeLoc T) {
- return Visit(T.getElementLoc());
- }
-
- TypeLoc VisitFunctionTypeLoc(FunctionTypeLoc T) {
- return Visit(T.getReturnLoc());
- }
-
- TypeLoc VisitParenTypeLoc(ParenTypeLoc T) {
- return Visit(T.getInnerLoc());
- }
-
- TypeLoc VisitAttributedTypeLoc(AttributedTypeLoc T) {
- return Visit(T.getModifiedLoc());
- }
-
- TypeLoc VisitMacroQualifiedTypeLoc(MacroQualifiedTypeLoc T) {
- return Visit(T.getInnerLoc());
- }
-
- TypeLoc VisitAdjustedTypeLoc(AdjustedTypeLoc T) {
- return Visit(T.getOriginalLoc());
- }
-
- TypeLoc VisitPackExpansionTypeLoc(PackExpansionTypeLoc T) {
- return Visit(T.getPatternLoc());
- }
- };
-
-} // namespace
-
-AutoTypeLoc TypeLoc::getContainedAutoTypeLoc() const {
- TypeLoc Res = GetContainedAutoTypeLocVisitor().Visit(*this);
- if (Res.isNull())
- return AutoTypeLoc();
- return Res.getAs<AutoTypeLoc>();
-}
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index 1495162..3a00a6c 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -1046,13 +1046,6 @@
if (!T->getDeducedType().isNull()) {
printBefore(T->getDeducedType(), OS);
} else {
- if (T->isConstrained()) {
- OS << T->getTypeConstraintConcept()->getName();
- auto Args = T->getTypeConstraintArguments();
- if (!Args.empty())
- printTemplateArgumentList(OS, Args, Policy);
- OS << ' ';
- }
switch (T->getKeyword()) {
case AutoTypeKeyword::Auto: OS << "auto"; break;
case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break;
@@ -1241,18 +1234,20 @@
void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T,
raw_ostream &OS) {
- TemplateTypeParmDecl *D = T->getDecl();
- if (D && D->isImplicit()) {
- if (auto *TC = D->getTypeConstraint()) {
- TC->print(OS, Policy);
- OS << ' ';
- }
- OS << "auto";
- } else if (IdentifierInfo *Id = T->getIdentifier())
+ if (IdentifierInfo *Id = T->getIdentifier())
OS << Id->getName();
- else
- OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
+ else {
+ bool IsLambdaAutoParam = false;
+ if (auto D = T->getDecl()) {
+ if (auto M = dyn_cast_or_null<CXXMethodDecl>(D->getDeclContext()))
+ IsLambdaAutoParam = D->isImplicit() && M->getParent()->isLambda();
+ }
+ if (IsLambdaAutoParam)
+ OS << "auto";
+ else
+ OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex();
+ }
spaceBeforePlaceHolder(OS);
}
diff --git a/clang/lib/Parse/ParseCXXInlineMethods.cpp b/clang/lib/Parse/ParseCXXInlineMethods.cpp
index a759657..f8b5fec 100644
--- a/clang/lib/Parse/ParseCXXInlineMethods.cpp
+++ b/clang/lib/Parse/ParseCXXInlineMethods.cpp
@@ -133,9 +133,7 @@
LexedMethod* LM = new LexedMethod(this, FnD);
getCurrentClass().LateParsedDeclarations.push_back(LM);
- LM->TemplateScope = getCurScope()->isTemplateParamScope() ||
- (FnD && isa<FunctionTemplateDecl>(FnD) &&
- cast<FunctionTemplateDecl>(FnD)->isAbbreviated());
+ LM->TemplateScope = getCurScope()->isTemplateParamScope();
CachedTokens &Toks = LM->Toks;
tok::TokenKind kind = Tok.getKind();
diff --git a/clang/lib/Parse/ParseDecl.cpp b/clang/lib/Parse/ParseDecl.cpp
index 4af993c..065a82b 100644
--- a/clang/lib/Parse/ParseDecl.cpp
+++ b/clang/lib/Parse/ParseDecl.cpp
@@ -2962,7 +2962,6 @@
case Sema::NC_ContextIndependentExpr:
case Sema::NC_VarTemplate:
case Sema::NC_FunctionTemplate:
- case Sema::NC_Concept:
// Might be a redeclaration of a prior entity.
break;
}
@@ -3194,18 +3193,6 @@
continue;
}
- if (Next.is(tok::annot_template_id) &&
- static_cast<TemplateIdAnnotation *>(Next.getAnnotationValue())
- ->Kind == TNK_Concept_template &&
- GetLookAheadToken(2).isOneOf(tok::kw_auto, tok::kw_decltype)) {
- DS.getTypeSpecScope() = SS;
- // This is a qualified placeholder-specifier, e.g., ::C<int> auto ...
- // Consume the scope annotation and continue to consume the template-id
- // as a placeholder-specifier.
- ConsumeAnnotationToken();
- continue;
- }
-
if (Next.is(tok::annot_typename)) {
DS.getTypeSpecScope() = SS;
ConsumeAnnotationToken(); // The C++ scope.
@@ -3248,10 +3235,6 @@
// C++ doesn't have implicit int. Diagnose it as a typo w.r.t. to the
// typename.
if (!TypeRep) {
- if (TryAnnotateTypeConstraint())
- goto DoneWithDeclSpec;
- if (isTypeConstraintAnnotation())
- continue;
// Eat the scope spec so the identifier is current.
ConsumeAnnotationToken();
ParsedAttributesWithRange Attrs(AttrFactory);
@@ -3401,10 +3384,6 @@
// If this is not a typedef name, don't parse it as part of the declspec,
// it must be an implicit int or an error.
if (!TypeRep) {
- if (TryAnnotateTypeConstraint())
- goto DoneWithDeclSpec;
- if (isTypeConstraintAnnotation())
- continue;
ParsedAttributesWithRange Attrs(AttrFactory);
if (ParseImplicitInt(DS, nullptr, TemplateInfo, AS, DSContext, Attrs)) {
if (!Attrs.empty()) {
@@ -3454,51 +3433,9 @@
continue;
}
- // type-name or placeholder-specifier
+ // type-name
case tok::annot_template_id: {
TemplateIdAnnotation *TemplateId = takeTemplateIdAnnotation(Tok);
- if (TemplateId->Kind == TNK_Concept_template) {
- if (NextToken().is(tok::identifier)) {
- Diag(Loc, diag::err_placeholder_expected_auto_or_decltype_auto)
- << FixItHint::CreateInsertion(NextToken().getLocation(), "auto");
- // Attempt to continue as if 'auto' was placed here.
- isInvalid = DS.SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID,
- TemplateId, Policy);
- break;
- }
- if (!NextToken().isOneOf(tok::kw_auto, tok::kw_decltype))
- goto DoneWithDeclSpec;
- ConsumeAnnotationToken();
- SourceLocation AutoLoc = Tok.getLocation();
- if (TryConsumeToken(tok::kw_decltype)) {
- BalancedDelimiterTracker Tracker(*this, tok::l_paren);
- if (Tracker.consumeOpen()) {
- // Something like `void foo(Iterator decltype i)`
- Diag(Tok, diag::err_expected) << tok::l_paren;
- } else {
- if (!TryConsumeToken(tok::kw_auto)) {
- // Something like `void foo(Iterator decltype(int) i)`
- Tracker.skipToEnd();
- Diag(Tok, diag::err_placeholder_expected_auto_or_decltype_auto)
- << FixItHint::CreateReplacement(SourceRange(AutoLoc,
- Tok.getLocation()),
- "auto");
- } else {
- Tracker.consumeClose();
- }
- }
- ConsumedEnd = Tok.getLocation();
- // Even if something went wrong above, continue as if we've seen
- // `decltype(auto)`.
- isInvalid = DS.SetTypeSpecType(TST_decltype_auto, Loc, PrevSpec,
- DiagID, TemplateId, Policy);
- } else {
- isInvalid = DS.SetTypeSpecType(TST_auto, Loc, PrevSpec, DiagID,
- TemplateId, Policy);
- }
- break;
- }
-
if (TemplateId->Kind != TNK_Type_template &&
TemplateId->Kind != TNK_Undeclared_template) {
// This template-id does not refer to a type name, so we're
@@ -6090,12 +6027,11 @@
while (1) {
if (Tok.is(tok::l_paren)) {
- bool IsFunctionDeclaration = D.isFunctionDeclaratorAFunctionDeclaration();
// Enter function-declaration scope, limiting any declarators to the
// function prototype scope, including parameter declarators.
ParseScope PrototypeScope(this,
Scope::FunctionPrototypeScope|Scope::DeclScope|
- (IsFunctionDeclaration
+ (D.isFunctionDeclaratorAFunctionDeclaration()
? Scope::FunctionDeclarationScope : 0));
// The paren may be part of a C++ direct initializer, eg. "int x(1);".
@@ -6114,12 +6050,7 @@
ParsedAttributes attrs(AttrFactory);
BalancedDelimiterTracker T(*this, tok::l_paren);
T.consumeOpen();
- if (IsFunctionDeclaration)
- Actions.ActOnStartFunctionDeclarationDeclarator(D,
- TemplateParameterDepth);
ParseFunctionDeclarator(D, attrs, T, IsAmbiguous);
- if (IsFunctionDeclaration)
- Actions.ActOnFinishFunctionDeclarationDeclarator(D);
PrototypeScope.Exit();
} else if (Tok.is(tok::l_square)) {
ParseBracketDeclarator(D);
diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp
index f872aa3..9c7d3c5 100644
--- a/clang/lib/Parse/ParseDeclCXX.cpp
+++ b/clang/lib/Parse/ParseDeclCXX.cpp
@@ -2642,8 +2642,6 @@
}
ParsingDeclarator DeclaratorInfo(*this, DS, DeclaratorContext::MemberContext);
- if (TemplateInfo.TemplateParams)
- DeclaratorInfo.setTemplateParameterLists(TemplateParams);
VirtSpecifiers VS;
// Hold late-parsed attributes so we can attach a Decl to them later.
diff --git a/clang/lib/Parse/ParseTemplate.cpp b/clang/lib/Parse/ParseTemplate.cpp
index e96baec..2ac8be4 100644
--- a/clang/lib/Parse/ParseTemplate.cpp
+++ b/clang/lib/Parse/ParseTemplate.cpp
@@ -240,8 +240,6 @@
// Parse the declarator.
ParsingDeclarator DeclaratorInfo(*this, DS, (DeclaratorContext)Context);
- if (TemplateInfo.TemplateParams)
- DeclaratorInfo.setTemplateParameterLists(*TemplateInfo.TemplateParams);
ParseDeclarator(DeclaratorInfo);
// Error parsing the declarator?
if (!DeclaratorInfo.hasName()) {
@@ -603,7 +601,6 @@
/// typename
///
NamedDecl *Parser::ParseTemplateParameter(unsigned Depth, unsigned Position) {
-
switch (isStartOfTemplateTypeParameter()) {
case TPResult::True:
// Is there just a typo in the input code? ('typedef' instead of
@@ -621,6 +618,7 @@
}
return ParseTypeParameter(Depth, Position);
+
case TPResult::False:
break;
@@ -680,6 +678,7 @@
bool Parser::TryAnnotateTypeConstraint() {
if (!getLangOpts().ConceptsTS)
return false;
+
CXXScopeSpec SS;
bool WasScopeAnnotation = Tok.is(tok::annot_cxxscope);
if (ParseOptionalCXXScopeSpecifier(
diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp
index ad0a15b..79e9681 100644
--- a/clang/lib/Parse/ParseTentative.cpp
+++ b/clang/lib/Parse/ParseTentative.cpp
@@ -1313,18 +1313,6 @@
Parser::TPResult
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
bool *InvalidAsDeclSpec) {
- auto IsPlaceholderSpecifier = [&] (TemplateIdAnnotation *TemplateId,
- int Lookahead) {
- // We have a placeholder-constraint (we check for 'auto' or 'decltype' to
- // distinguish 'C<int>;' from 'C<int> auto c = 1;')
- return TemplateId->Kind == TNK_Concept_template &&
- GetLookAheadToken(Lookahead + 1).isOneOf(tok::kw_auto, tok::kw_decltype,
- // If we have an identifier here, the user probably forgot the
- // 'auto' in the placeholder constraint, e.g. 'C<int> x = 2;'
- // This will be diagnosed nicely later, so disambiguate as a
- // declaration.
- tok::identifier);
- };
switch (Tok.getKind()) {
case tok::identifier: {
// Check for need to substitute AltiVec __vector keyword
@@ -1528,8 +1516,6 @@
*InvalidAsDeclSpec = NextToken().is(tok::l_paren);
return TPResult::Ambiguous;
}
- if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/0))
- return TPResult::True;
if (TemplateId->Kind != TNK_Type_template)
return TPResult::False;
CXXScopeSpec SS;
@@ -1543,13 +1529,6 @@
if (TryAnnotateTypeOrScopeToken())
return TPResult::Error;
if (!Tok.is(tok::annot_typename)) {
- if (Tok.is(tok::annot_cxxscope) &&
- NextToken().is(tok::annot_template_id)) {
- TemplateIdAnnotation *TemplateId =
- takeTemplateIdAnnotation(NextToken());
- if (IsPlaceholderSpecifier(TemplateId, /*Lookahead=*/1))
- return TPResult::True;
- }
// If the next token is an identifier or a type qualifier, then this
// can't possibly be a valid expression either.
if (Tok.is(tok::annot_cxxscope) && NextToken().is(tok::identifier)) {
diff --git a/clang/lib/Parse/Parser.cpp b/clang/lib/Parse/Parser.cpp
index 0b778bd..0194c24 100644
--- a/clang/lib/Parse/Parser.cpp
+++ b/clang/lib/Parse/Parser.cpp
@@ -1136,7 +1136,6 @@
// Poison SEH identifiers so they are flagged as illegal in function bodies.
PoisonSEHIdentifiersRAIIObject PoisonSEHIdentifiers(*this, true);
const DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
- TemplateParameterDepthRAII CurTemplateDepthTracker(TemplateParameterDepth);
// If this is C90 and the declspecs were completely missing, fudge in an
// implicit int. We do this here because this is the only place where
@@ -1263,15 +1262,6 @@
// safe because we're always the sole owner.
D.getMutableDeclSpec().abort();
- // With abbreviated function templates - we need to explicitly add depth to
- // account for the implicit template parameter list induced by the template.
- if (auto *Template = dyn_cast_or_null<FunctionTemplateDecl>(Res))
- if (Template->isAbbreviated() &&
- Template->getTemplateParameters()->getParam(0)->isImplicit())
- // First template parameter is implicit - meaning no explicit template
- // parameter list was specified.
- CurTemplateDepthTracker.addDepth(1);
-
if (TryConsumeToken(tok::equal)) {
assert(getLangOpts().CPlusPlus && "Only C++ function definitions have '='");
@@ -1742,20 +1732,6 @@
return ANK_Error;
return ANK_Success;
}
- case Sema::NC_Concept: {
- UnqualifiedId Id;
- Id.setIdentifier(Name, NameLoc);
- if (Next.is(tok::less))
- // We have a concept name followed by '<'. Consume the identifier token so
- // we reach the '<' and annotate it.
- ConsumeToken();
- if (AnnotateTemplateIdToken(
- TemplateTy::make(Classification.getTemplateName()),
- Classification.getTemplateNameKind(), SS, SourceLocation(), Id,
- /*AllowTypeAnnotation=*/false, /*TypeConstraint=*/true))
- return ANK_Error;
- return ANK_Success;
- }
}
// Unable to classify the name, but maybe we can annotate a scope specifier.
diff --git a/clang/lib/Sema/DeclSpec.cpp b/clang/lib/Sema/DeclSpec.cpp
index 94d8797..639231c 100644
--- a/clang/lib/Sema/DeclSpec.cpp
+++ b/clang/lib/Sema/DeclSpec.cpp
@@ -784,15 +784,6 @@
return false;
}
-bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec,
- unsigned &DiagID, TemplateIdAnnotation *Rep,
- const PrintingPolicy &Policy) {
- assert(T == TST_auto || T == TST_decltype_auto);
- ConstrainedAuto = true;
- TemplateIdRep = Rep;
- return SetTypeSpecType(T, Loc, PrevSpec, DiagID, Policy);
-}
-
bool DeclSpec::SetTypeSpecType(TST T, SourceLocation Loc,
const char *&PrevSpec,
unsigned &DiagID,
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
index 9cfce5a..7eb8c8d 100644
--- a/clang/lib/Sema/Sema.cpp
+++ b/clang/lib/Sema/Sema.cpp
@@ -52,21 +52,6 @@
ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
-IdentifierInfo *
-Sema::InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName,
- unsigned int Index) {
- std::string InventedName;
- llvm::raw_string_ostream OS(InventedName);
-
- if (!ParamName)
- OS << "auto:" << Index + 1;
- else
- OS << ParamName->getName() << ":auto";
-
- OS.flush();
- return &Context.Idents.get(OS.str());
-}
-
PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
const Preprocessor &PP) {
PrintingPolicy Policy = Context.getPrintingPolicy();
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 0bf4903..372f3d1 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -10,7 +10,6 @@
//
//===----------------------------------------------------------------------===//
-#include "TreeTransform.h"
#include "TypeLocBuilder.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
@@ -1154,10 +1153,6 @@
return ParsedType::make(T);
}
- if (isa<ConceptDecl>(FirstDecl))
- return NameClassification::Concept(
- TemplateName(cast<TemplateDecl>(FirstDecl)));
-
// We can have a type template here if we're classifying a template argument.
if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) &&
!isa<VarTemplateDecl>(FirstDecl))
@@ -8661,21 +8656,11 @@
NamedDecl*
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
TypeSourceInfo *TInfo, LookupResult &Previous,
- MultiTemplateParamsArg TemplateParamListsRef,
+ MultiTemplateParamsArg TemplateParamLists,
bool &AddToScope) {
QualType R = TInfo->getType();
assert(R->isFunctionType());
- SmallVector<TemplateParameterList *, 4> TemplateParamLists;
- for (TemplateParameterList *TPL : TemplateParamListsRef)
- TemplateParamLists.push_back(TPL);
- if (TemplateParameterList *Invented = D.getInventedTemplateParameterList()) {
- if (!TemplateParamLists.empty() &&
- Invented->getDepth() == TemplateParamLists.back()->getDepth())
- TemplateParamLists.back() = Invented;
- else
- TemplateParamLists.push_back(Invented);
- }
// TODO: consider using NameInfo for diagnostic.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
@@ -8755,16 +8740,15 @@
// Match up the template parameter lists with the scope specifier, then
// determine whether we have a template or a template specialization.
bool Invalid = false;
- TemplateParameterList *TemplateParams =
- MatchTemplateParametersToScopeSpecifier(
- D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(),
- D.getCXXScopeSpec(),
- D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
- ? D.getName().TemplateId
- : nullptr,
- TemplateParamLists, isFriend, isMemberSpecialization,
- Invalid);
- if (TemplateParams) {
+ if (TemplateParameterList *TemplateParams =
+ MatchTemplateParametersToScopeSpecifier(
+ D.getDeclSpec().getBeginLoc(), D.getIdentifierLoc(),
+ D.getCXXScopeSpec(),
+ D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId
+ ? D.getName().TemplateId
+ : nullptr,
+ TemplateParamLists, isFriend, isMemberSpecialization,
+ Invalid)) {
if (TemplateParams->size() > 0) {
// This is a function template
@@ -8797,8 +8781,7 @@
// For source fidelity, store the other template param lists.
if (TemplateParamLists.size() > 1) {
NewFD->setTemplateParameterListsInfo(Context,
- ArrayRef<TemplateParameterList *>(TemplateParamLists)
- .drop_back(1));
+ TemplateParamLists.drop_back(1));
}
} else {
// This is a function template specialization.
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 523daf3..d1e720e 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -17386,50 +17386,3 @@
return NewPD;
}
-
-void Sema::ActOnStartFunctionDeclarationDeclarator(
- Declarator &Declarator, unsigned TemplateParameterDepth) {
- auto &Info = InventedParameterInfos.emplace_back();
- TemplateParameterList *ExplicitParams = nullptr;
- ArrayRef<TemplateParameterList *> ExplicitLists =
- Declarator.getTemplateParameterLists();
- if (!ExplicitLists.empty()) {
- bool IsMemberSpecialization, IsInvalid;
- ExplicitParams = MatchTemplateParametersToScopeSpecifier(
- Declarator.getBeginLoc(), Declarator.getIdentifierLoc(),
- Declarator.getCXXScopeSpec(), /*TemplateId=*/nullptr,
- ExplicitLists, /*IsFriend=*/false, IsMemberSpecialization, IsInvalid,
- /*SuppressDiagnostic=*/true);
- }
- if (ExplicitParams) {
- Info.AutoTemplateParameterDepth = ExplicitParams->getDepth();
- for (NamedDecl *Param : *ExplicitParams)
- Info.TemplateParams.push_back(Param);
- Info.NumExplicitTemplateParams = ExplicitParams->size();
- } else {
- Info.AutoTemplateParameterDepth = TemplateParameterDepth;
- Info.NumExplicitTemplateParams = 0;
- }
-}
-
-void Sema::ActOnFinishFunctionDeclarationDeclarator(Declarator &Declarator) {
- auto &FSI = InventedParameterInfos.back();
- if (FSI.TemplateParams.size() > FSI.NumExplicitTemplateParams) {
- if (FSI.NumExplicitTemplateParams != 0) {
- TemplateParameterList *ExplicitParams =
- Declarator.getTemplateParameterLists().back();
- Declarator.setInventedTemplateParameterList(
- TemplateParameterList::Create(
- Context, ExplicitParams->getTemplateLoc(),
- ExplicitParams->getLAngleLoc(), FSI.TemplateParams,
- ExplicitParams->getRAngleLoc(),
- ExplicitParams->getRequiresClause()));
- } else {
- Declarator.setInventedTemplateParameterList(
- TemplateParameterList::Create(
- Context, SourceLocation(), SourceLocation(), FSI.TemplateParams,
- SourceLocation(), /*RequiresClause=*/nullptr));
- }
- }
- InventedParameterInfos.pop_back();
-}
diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp
index ae89b14..c2d14a4 100644
--- a/clang/lib/Sema/SemaLambda.cpp
+++ b/clang/lib/Sema/SemaLambda.cpp
@@ -791,8 +791,7 @@
// deduce against.
QualType DeductType = Context.getAutoDeductType();
TypeLocBuilder TLB;
- AutoTypeLoc TL = TLB.push<AutoTypeLoc>(DeductType);
- TL.setNameLoc(Loc);
+ TLB.pushTypeSpec(DeductType).setNameLoc(Loc);
if (ByRef) {
DeductType = BuildReferenceType(DeductType, true, Loc, Id);
assert(!DeductType.isNull() && "can't build reference to auto");
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 2f44f8f..2d87e7b 100755
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -1088,50 +1088,6 @@
ConstrainedParameter, EllipsisLoc);
}
-template<typename ArgumentLocAppender>
-static ExprResult formImmediatelyDeclaredConstraint(
- Sema &S, NestedNameSpecifierLoc NS, DeclarationNameInfo NameInfo,
- ConceptDecl *NamedConcept, SourceLocation LAngleLoc,
- SourceLocation RAngleLoc, QualType ConstrainedType,
- SourceLocation ParamNameLoc, ArgumentLocAppender Appender,
- SourceLocation EllipsisLoc) {
-
- TemplateArgumentListInfo ConstraintArgs;
- ConstraintArgs.addArgument(
- S.getTrivialTemplateArgumentLoc(TemplateArgument(ConstrainedType),
- /*NTTPType=*/QualType(), ParamNameLoc));
-
- ConstraintArgs.setRAngleLoc(RAngleLoc);
- ConstraintArgs.setLAngleLoc(LAngleLoc);
- Appender(ConstraintArgs);
-
- // C++2a [temp.param]p4:
- // [...] This constraint-expression E is called the immediately-declared
- // constraint of T. [...]
- CXXScopeSpec SS;
- SS.Adopt(NS);
- ExprResult ImmediatelyDeclaredConstraint = S.CheckConceptTemplateId(
- SS, /*TemplateKWLoc=*/SourceLocation(), NameInfo,
- /*FoundDecl=*/NamedConcept, NamedConcept, &ConstraintArgs);
- if (ImmediatelyDeclaredConstraint.isInvalid() || !EllipsisLoc.isValid())
- return ImmediatelyDeclaredConstraint;
-
- // C++2a [temp.param]p4:
- // [...] If T is not a pack, then E is E', otherwise E is (E' && ...).
- //
- // We have the following case:
- //
- // template<typename T> concept C1 = true;
- // template<C1... T> struct s1;
- //
- // The constraint: (C1<T> && ...)
- return S.BuildCXXFoldExpr(/*LParenLoc=*/SourceLocation(),
- ImmediatelyDeclaredConstraint.get(), BO_LAnd,
- EllipsisLoc, /*RHS=*/nullptr,
- /*RParenLoc=*/SourceLocation(),
- /*NumExpansions=*/None);
-}
-
/// Attach a type-constraint to a template parameter.
/// \returns true if an error occured. This can happen if the
/// immediately-declared constraint could not be formed (e.g. incorrect number
@@ -1150,21 +1106,51 @@
*TemplateArgs) : nullptr;
QualType ParamAsArgument(ConstrainedParameter->getTypeForDecl(), 0);
+ TemplateArgumentListInfo ConstraintArgs;
+ ConstraintArgs.addArgument(
+ TemplateArgumentLoc(
+ TemplateArgument(ParamAsArgument),
+ TemplateArgumentLocInfo(
+ Context.getTrivialTypeSourceInfo(ParamAsArgument,
+ ConstrainedParameter->getLocation()))));
+ if (TemplateArgs) {
+ ConstraintArgs.setRAngleLoc(TemplateArgs->getRAngleLoc());
+ ConstraintArgs.setLAngleLoc(TemplateArgs->getLAngleLoc());
+ for (const TemplateArgumentLoc &ArgLoc : TemplateArgs->arguments())
+ ConstraintArgs.addArgument(ArgLoc);
+ }
- ExprResult ImmediatelyDeclaredConstraint =
- formImmediatelyDeclaredConstraint(
- *this, NS, NameInfo, NamedConcept,
- TemplateArgs ? TemplateArgs->getLAngleLoc() : SourceLocation(),
- TemplateArgs ? TemplateArgs->getRAngleLoc() : SourceLocation(),
- ParamAsArgument, ConstrainedParameter->getLocation(),
- [&] (TemplateArgumentListInfo &ConstraintArgs) {
- if (TemplateArgs)
- for (const auto &ArgLoc : TemplateArgs->arguments())
- ConstraintArgs.addArgument(ArgLoc);
- }, EllipsisLoc);
+ // C++2a [temp.param]p4:
+ // [...] This constraint-expression E is called the immediately-declared
+ // constraint of T. [...]
+ CXXScopeSpec SS;
+ SS.Adopt(NS);
+ ExprResult ImmediatelyDeclaredConstraint = CheckConceptTemplateId(SS,
+ /*TemplateKWLoc=*/SourceLocation(), NameInfo, /*FoundDecl=*/NamedConcept,
+ NamedConcept, &ConstraintArgs);
if (ImmediatelyDeclaredConstraint.isInvalid())
return true;
+ if (ConstrainedParameter->isParameterPack()) {
+ // C++2a [temp.param]p4:
+ // [...] If T is not a pack, then E is E', otherwise E is (E' && ...).
+ //
+ // We have the following case:
+ //
+ // template<typename T> concept C1 = true;
+ // template<C1... T> struct s1;
+ //
+ // The constraint: (C1<T> && ...)
+ ImmediatelyDeclaredConstraint =
+ BuildCXXFoldExpr(/*LParenLoc=*/SourceLocation(),
+ ImmediatelyDeclaredConstraint.get(), BO_LAnd,
+ EllipsisLoc, /*RHS=*/nullptr,
+ /*RParenLoc=*/SourceLocation(),
+ /*NumExpansions=*/None).get();
+ if (ImmediatelyDeclaredConstraint.isInvalid())
+ return true;
+ }
+
ConstrainedParameter->setTypeConstraint(NS, NameInfo,
/*FoundDecl=*/NamedConcept,
NamedConcept, ArgsAsWritten,
@@ -1172,38 +1158,6 @@
return false;
}
-bool Sema::AttachTypeConstraint(AutoTypeLoc TL, NonTypeTemplateParmDecl *NTTP,
- SourceLocation EllipsisLoc) {
- if (NTTP->getType() != TL.getType() ||
- TL.getAutoKeyword() != AutoTypeKeyword::Auto) {
- Diag(NTTP->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
- diag::err_unsupported_placeholder_constraint)
- << NTTP->getTypeSourceInfo()->getTypeLoc().getSourceRange();
- return true;
- }
- // FIXME: Concepts: This should be the type of the placeholder, but this is
- // unclear in the wording right now.
- DeclRefExpr *Ref = BuildDeclRefExpr(NTTP, NTTP->getType(), VK_RValue,
- NTTP->getLocation());
- if (!Ref)
- return true;
- ExprResult ImmediatelyDeclaredConstraint =
- formImmediatelyDeclaredConstraint(
- *this, TL.getNestedNameSpecifierLoc(), TL.getConceptNameInfo(),
- TL.getNamedConcept(), TL.getLAngleLoc(), TL.getRAngleLoc(),
- BuildDecltypeType(Ref, NTTP->getLocation()), NTTP->getLocation(),
- [&] (TemplateArgumentListInfo &ConstraintArgs) {
- for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
- ConstraintArgs.addArgument(TL.getArgLoc(I));
- }, EllipsisLoc);
- if (ImmediatelyDeclaredConstraint.isInvalid() ||
- !ImmediatelyDeclaredConstraint.isUsable())
- return true;
-
- NTTP->setPlaceholderTypeConstraint(ImmediatelyDeclaredConstraint.get());
- return false;
-}
-
/// Check that the type of a non-type template parameter is
/// well-formed.
///
@@ -1365,11 +1319,6 @@
TInfo);
Param->setAccess(AS_public);
- if (AutoTypeLoc TL = TInfo->getTypeLoc().getContainedAutoTypeLoc())
- if (TL.isConstrained())
- if (AttachTypeConstraint(TL, Param, D.getEllipsisLoc()))
- Invalid = true;
-
if (Invalid)
Param->setInvalidDecl();
@@ -2813,7 +2762,7 @@
SourceLocation DeclStartLoc, SourceLocation DeclLoc, const CXXScopeSpec &SS,
TemplateIdAnnotation *TemplateId,
ArrayRef<TemplateParameterList *> ParamLists, bool IsFriend,
- bool &IsMemberSpecialization, bool &Invalid, bool SuppressDiagnostic) {
+ bool &IsMemberSpecialization, bool &Invalid) {
IsMemberSpecialization = false;
Invalid = false;
@@ -2921,9 +2870,8 @@
auto CheckExplicitSpecialization = [&](SourceRange Range, bool Recovery) {
if (SawNonEmptyTemplateParameterList) {
- if (!SuppressDiagnostic)
- Diag(DeclLoc, diag::err_specialize_member_of_template)
- << !Recovery << Range;
+ Diag(DeclLoc, diag::err_specialize_member_of_template)
+ << !Recovery << Range;
Invalid = true;
IsMemberSpecialization = false;
return true;
@@ -2944,10 +2892,9 @@
else
ExpectedTemplateLoc = DeclStartLoc;
- if (!SuppressDiagnostic)
- Diag(DeclLoc, diag::err_template_spec_needs_header)
- << Range
- << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
+ Diag(DeclLoc, diag::err_template_spec_needs_header)
+ << Range
+ << FixItHint::CreateInsertion(ExpectedTemplateLoc, "template<> ");
return false;
};
@@ -3037,13 +2984,12 @@
if (ParamIdx < ParamLists.size()) {
if (ParamLists[ParamIdx]->size() > 0) {
// The header has template parameters when it shouldn't. Complain.
- if (!SuppressDiagnostic)
- Diag(ParamLists[ParamIdx]->getTemplateLoc(),
- diag::err_template_param_list_matches_nontemplate)
- << T
- << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
- ParamLists[ParamIdx]->getRAngleLoc())
- << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
+ Diag(ParamLists[ParamIdx]->getTemplateLoc(),
+ diag::err_template_param_list_matches_nontemplate)
+ << T
+ << SourceRange(ParamLists[ParamIdx]->getLAngleLoc(),
+ ParamLists[ParamIdx]->getRAngleLoc())
+ << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
Invalid = true;
return nullptr;
}
@@ -3079,7 +3025,7 @@
if (ExpectedTemplateParams &&
!TemplateParameterListsAreEqual(ParamLists[ParamIdx],
ExpectedTemplateParams,
- !SuppressDiagnostic, TPL_TemplateMatch))
+ true, TPL_TemplateMatch))
Invalid = true;
if (!Invalid &&
@@ -3091,10 +3037,9 @@
continue;
}
- if (!SuppressDiagnostic)
- Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
- << T
- << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
+ Diag(DeclLoc, diag::err_template_spec_needs_template_parameters)
+ << T
+ << getRangeOfTypeInNestedNameSpecifier(Context, T, SS);
Invalid = true;
continue;
}
@@ -3130,18 +3075,16 @@
AllExplicitSpecHeaders = false;
}
- if (!SuppressDiagnostic)
- Diag(ParamLists[ParamIdx]->getTemplateLoc(),
- AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
- : diag::err_template_spec_extra_headers)
- << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
- ParamLists[ParamLists.size() - 2]->getRAngleLoc());
+ Diag(ParamLists[ParamIdx]->getTemplateLoc(),
+ AllExplicitSpecHeaders ? diag::warn_template_spec_extra_headers
+ : diag::err_template_spec_extra_headers)
+ << SourceRange(ParamLists[ParamIdx]->getTemplateLoc(),
+ ParamLists[ParamLists.size() - 2]->getRAngleLoc());
// If there was a specialization somewhere, such that 'template<>' is
// not required, and there were any 'template<>' headers, note where the
// specialization occurred.
- if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader &&
- !SuppressDiagnostic)
+ if (ExplicitSpecLoc.isValid() && HasAnyExplicitSpecHeader)
Diag(ExplicitSpecLoc,
diag::note_explicit_template_spec_does_not_need_header)
<< NestedTypes.back();
@@ -6587,12 +6530,7 @@
DeductionArg = PE->getPattern();
if (DeduceAutoType(
Context.getTrivialTypeSourceInfo(ParamType, Param->getLocation()),
- DeductionArg, ParamType, Depth,
- // We do not check constraints right now because the
- // immediately-declared constraint of the auto type is also an
- // associated constraint, and will be checked along with the other
- // associated constraints after checking the template argument list.
- /*IgnoreConstraints=*/true) == DAR_Failed) {
+ DeductionArg, ParamType, Depth) == DAR_Failed) {
Diag(Arg->getExprLoc(),
diag::err_non_type_template_parm_type_deduction_failure)
<< Param->getDeclName() << Param->getType() << Arg->getType()
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 394c81c..048a50a 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -4414,10 +4414,9 @@
QualType Result = SemaRef.Context.getAutoType(
Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull(),
- ReplacementIsPack, TL.getTypePtr()->getTypeConstraintConcept(),
- TL.getTypePtr()->getTypeConstraintArguments());
+ ReplacementIsPack);
auto NewTL = TLB.push<AutoTypeLoc>(Result);
- NewTL.copy(TL);
+ NewTL.setNameLoc(TL.getNameLoc());
return Result;
}
@@ -4452,10 +4451,9 @@
Sema::DeduceAutoResult
Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, QualType &Result,
- Optional<unsigned> DependentDeductionDepth,
- bool IgnoreConstraints) {
+ Optional<unsigned> DependentDeductionDepth) {
return DeduceAutoType(Type->getTypeLoc(), Init, Result,
- DependentDeductionDepth, IgnoreConstraints);
+ DependentDeductionDepth);
}
/// Attempt to produce an informative diagostic explaining why auto deduction
@@ -4483,49 +4481,6 @@
}
}
-static Sema::DeduceAutoResult
-CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
- AutoTypeLoc TypeLoc, QualType Deduced) {
- ConstraintSatisfaction Satisfaction;
- ConceptDecl *Concept = Type.getTypeConstraintConcept();
- TemplateArgumentListInfo TemplateArgs(TypeLoc.getLAngleLoc(),
- TypeLoc.getRAngleLoc());
- TemplateArgs.addArgument(
- TemplateArgumentLoc(TemplateArgument(Deduced),
- S.Context.getTrivialTypeSourceInfo(
- Deduced, TypeLoc.getNameLoc())));
- for (unsigned I = 0, C = TypeLoc.getNumArgs(); I != C; ++I)
- TemplateArgs.addArgument(TypeLoc.getArgLoc(I));
-
- llvm::SmallVector<TemplateArgument, 4> Converted;
- if (S.CheckTemplateArgumentList(Concept, SourceLocation(), TemplateArgs,
- /*PartialTemplateArgs=*/false, Converted))
- return Sema::DAR_FailedAlreadyDiagnosed;
- if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()},
- Converted, TypeLoc.getLocalSourceRange(),
- Satisfaction))
- return Sema::DAR_FailedAlreadyDiagnosed;
- if (!Satisfaction.IsSatisfied) {
- std::string Buf;
- llvm::raw_string_ostream OS(Buf);
- OS << "'" << Concept->getName();
- if (TypeLoc.hasExplicitTemplateArgs()) {
- OS << "<";
- for (const auto &Arg : Type.getTypeConstraintArguments())
- Arg.print(S.getPrintingPolicy(), OS);
- OS << ">";
- }
- OS << "'";
- OS.flush();
- S.Diag(TypeLoc.getConceptNameLoc(),
- diag::err_placeholder_constraints_not_satisfied)
- << Deduced << Buf << TypeLoc.getLocalSourceRange();
- S.DiagnoseUnsatisfiedConstraint(Satisfaction);
- return Sema::DAR_FailedAlreadyDiagnosed;
- }
- return Sema::DAR_Succeeded;
-}
-
/// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
///
/// Note that this is done even if the initializer is dependent. (This is
@@ -4540,12 +4495,9 @@
/// dependent cases. This is necessary for template partial ordering with
/// 'auto' template parameters. The value specified is the template
/// parameter depth at which we should perform 'auto' deduction.
-/// \param IgnoreConstraints Set if we should not fail if the deduced type does
-/// not satisfy the type-constraint in the auto type.
Sema::DeduceAutoResult
Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
- Optional<unsigned> DependentDeductionDepth,
- bool IgnoreConstraints) {
+ Optional<unsigned> DependentDeductionDepth) {
if (Init->getType()->isNonOverloadPlaceholderType()) {
ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
if (NonPlaceholder.isInvalid())
@@ -4586,14 +4538,6 @@
return DAR_FailedAlreadyDiagnosed;
// FIXME: Support a non-canonical deduced type for 'auto'.
Deduced = Context.getCanonicalType(Deduced);
- if (AT->isConstrained() && !IgnoreConstraints) {
- auto ConstraintsResult =
- CheckDeducedPlaceholderConstraints(*this, *AT,
- Type.getContainedAutoTypeLoc(),
- Deduced);
- if (ConstraintsResult != DAR_Succeeded)
- return ConstraintsResult;
- }
Result = SubstituteDeducedTypeTransform(*this, Deduced).Apply(Type);
if (Result.isNull())
return DAR_FailedAlreadyDiagnosed;
@@ -4701,17 +4645,6 @@
return DAR_FailedAlreadyDiagnosed;
}
- if (const auto *AT = Type.getType()->getAs<AutoType>()) {
- if (AT->isConstrained() && !IgnoreConstraints) {
- auto ConstraintsResult =
- CheckDeducedPlaceholderConstraints(*this, *AT,
- Type.getContainedAutoTypeLoc(),
- DeducedType);
- if (ConstraintsResult != DAR_Succeeded)
- return ConstraintsResult;
- }
- }
-
Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type);
if (Result.isNull())
return DAR_FailedAlreadyDiagnosed;
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 8fd7491..7d60298 100755
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -2685,16 +2685,6 @@
D->getDepth() - TemplateArgs.getNumSubstitutedLevels(),
D->getPosition(), D->getIdentifier(), T, D->isParameterPack(), DI);
- if (AutoTypeLoc AutoLoc = DI->getTypeLoc().getContainedAutoTypeLoc())
- if (AutoLoc.isConstrained())
- if (SemaRef.AttachTypeConstraint(
- AutoLoc, Param,
- IsExpandedParameterPack
- ? DI->getTypeLoc().getAs<PackExpansionTypeLoc>()
- .getEllipsisLoc()
- : SourceLocation()))
- Invalid = true;
-
Param->setAccess(AS_public);
Param->setImplicit(D->isImplicit());
if (Invalid)
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 02ca73e..efb4437 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -11,7 +11,6 @@
//===----------------------------------------------------------------------===//
#include "TypeLocBuilder.h"
-#include "TreeTransform.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTMutationListener.h"
@@ -28,7 +27,6 @@
#include "clang/Sema/DeclSpec.h"
#include "clang/Sema/DelayedDiagnostic.h"
#include "clang/Sema/Lookup.h"
-#include "clang/Sema/ParsedTemplate.h"
#include "clang/Sema/ScopeInfo.h"
#include "clang/Sema/SemaInternal.h"
#include "clang/Sema/Template.h"
@@ -1253,26 +1251,6 @@
return OpenCLAccessAttr::Keyword_read_only;
}
-static QualType ConvertConstrainedAutoDeclSpecToType(Sema &S, DeclSpec &DS,
- AutoTypeKeyword AutoKW) {
- assert(DS.isConstrainedAuto());
- TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
- TemplateArgumentListInfo TemplateArgsInfo;
- TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
- TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
- ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
- TemplateId->NumArgs);
- S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
- llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
- for (auto &ArgLoc : TemplateArgsInfo.arguments())
- TemplateArgs.push_back(ArgLoc.getArgument());
- return S.Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false,
- /*IsPack=*/false,
- cast<ConceptDecl>(TemplateId->Template.get()
- .getAsTemplateDecl()),
- TemplateArgs);
-}
-
/// Convert the specified declspec to the appropriate type
/// object.
/// \param state Specifies the declarator containing the declaration specifier
@@ -1617,11 +1595,6 @@
break;
case DeclSpec::TST_auto:
- if (DS.isConstrainedAuto()) {
- Result = ConvertConstrainedAutoDeclSpecToType(S, DS,
- AutoTypeKeyword::Auto);
- break;
- }
Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false);
break;
@@ -1630,12 +1603,6 @@
break;
case DeclSpec::TST_decltype_auto:
- if (DS.isConstrainedAuto()) {
- Result =
- ConvertConstrainedAutoDeclSpecToType(S, DS,
- AutoTypeKeyword::DecltypeAuto);
- break;
- }
Result = Context.getAutoType(QualType(), AutoTypeKeyword::DecltypeAuto,
/*IsDependent*/ false);
break;
@@ -2954,87 +2921,6 @@
D.getDeclSpec().getUnalignedSpecLoc());
}
-static void CopyTypeConstraintFromAutoType(Sema &SemaRef, const AutoType *Auto,
- AutoTypeLoc AutoLoc,
- TemplateTypeParmDecl *TP,
- SourceLocation EllipsisLoc) {
-
- TemplateArgumentListInfo TAL(AutoLoc.getLAngleLoc(), AutoLoc.getRAngleLoc());
- for (unsigned Idx = 0; Idx < AutoLoc.getNumArgs(); ++Idx)
- TAL.addArgument(AutoLoc.getArgLoc(Idx));
-
- SemaRef.AttachTypeConstraint(
- AutoLoc.getNestedNameSpecifierLoc(), AutoLoc.getConceptNameInfo(),
- AutoLoc.getNamedConcept(),
- AutoLoc.hasExplicitTemplateArgs() ? &TAL : nullptr, TP, EllipsisLoc);
-}
-
-static QualType InventTemplateParameter(
- TypeProcessingState &state, QualType T, TypeSourceInfo *TSI, AutoType *Auto,
- InventedTemplateParameterInfo &Info) {
- Sema &S = state.getSema();
- Declarator &D = state.getDeclarator();
-
- const unsigned TemplateParameterDepth = Info.AutoTemplateParameterDepth;
- const unsigned AutoParameterPosition = Info.TemplateParams.size();
- const bool IsParameterPack = D.hasEllipsis();
-
- // If auto is mentioned in a lambda parameter or abbreviated function
- // template context, convert it to a template parameter type.
-
- // Create the TemplateTypeParmDecl here to retrieve the corresponding
- // template parameter type. Template parameters are temporarily added
- // to the TU until the associated TemplateDecl is created.
- TemplateTypeParmDecl *InventedTemplateParam =
- TemplateTypeParmDecl::Create(
- S.Context, S.Context.getTranslationUnitDecl(),
- /*KeyLoc=*/D.getDeclSpec().getTypeSpecTypeLoc(),
- /*NameLoc=*/D.getIdentifierLoc(),
- TemplateParameterDepth, AutoParameterPosition,
- S.InventAbbreviatedTemplateParameterTypeName(
- D.getIdentifier(), AutoParameterPosition), false,
- IsParameterPack, /*HasTypeConstraint=*/Auto->isConstrained());
- InventedTemplateParam->setImplicit();
- Info.TemplateParams.push_back(InventedTemplateParam);
- // Attach type constraints
- if (Auto->isConstrained()) {
- if (TSI) {
- CopyTypeConstraintFromAutoType(
- S, Auto, TSI->getTypeLoc().getContainedAutoTypeLoc(),
- InventedTemplateParam, D.getEllipsisLoc());
- } else {
- TemplateIdAnnotation *TemplateId = D.getDeclSpec().getRepAsTemplateId();
- TemplateArgumentListInfo TemplateArgsInfo;
- if (TemplateId->LAngleLoc.isValid()) {
- ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
- TemplateId->NumArgs);
- S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
- }
- S.AttachTypeConstraint(
- D.getDeclSpec().getTypeSpecScope().getWithLocInContext(S.Context),
- DeclarationNameInfo(DeclarationName(TemplateId->Name),
- TemplateId->TemplateNameLoc),
- cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl()),
- TemplateId->LAngleLoc.isValid() ? &TemplateArgsInfo : nullptr,
- InventedTemplateParam, D.getEllipsisLoc());
- }
- }
-
- // If TSI is nullptr, this is a constrained declspec auto and the type
- // constraint will be attached later in TypeSpecLocFiller
-
- // Replace the 'auto' in the function parameter with this invented
- // template type parameter.
- // FIXME: Retain some type sugar to indicate that this was written
- // as 'auto'?
- return state.ReplaceAutoType(
- T, QualType(InventedTemplateParam->getTypeForDecl(), 0));
-}
-
-static TypeSourceInfo *
-GetTypeSourceInfoForDeclarator(TypeProcessingState &State,
- QualType T, TypeSourceInfo *ReturnTypeInfo);
-
static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state,
TypeSourceInfo *&ReturnTypeInfo) {
Sema &SemaRef = state.getSema();
@@ -3105,43 +2991,46 @@
break;
case DeclaratorContext::ObjCParameterContext:
case DeclaratorContext::ObjCResultContext:
+ case DeclaratorContext::PrototypeContext:
Error = 0;
break;
case DeclaratorContext::RequiresExprContext:
- Error = 22;
+ Error = 21;
break;
- case DeclaratorContext::PrototypeContext:
- case DeclaratorContext::LambdaExprParameterContext: {
- InventedTemplateParameterInfo *Info = nullptr;
- if (D.getContext() == DeclaratorContext::PrototypeContext) {
- // With concepts we allow 'auto' in function parameters.
- if (!SemaRef.getLangOpts().ConceptsTS || !Auto ||
- Auto->getKeyword() != AutoTypeKeyword::Auto) {
- Error = 0;
- break;
- } else if (!SemaRef.getCurScope()->isFunctionDeclarationScope()) {
- Error = 21;
- break;
- } else if (D.hasTrailingReturnType()) {
- // This might be OK, but we'll need to convert the trailing return
- // type later.
- break;
- }
+ case DeclaratorContext::LambdaExprParameterContext:
+ // In C++14, generic lambdas allow 'auto' in their parameters.
+ if (!SemaRef.getLangOpts().CPlusPlus14 ||
+ !Auto || Auto->getKeyword() != AutoTypeKeyword::Auto)
+ Error = 16;
+ else {
+ // If auto is mentioned in a lambda parameter context, convert it to a
+ // template parameter type.
+ sema::LambdaScopeInfo *LSI = SemaRef.getCurLambda();
+ assert(LSI && "No LambdaScopeInfo on the stack!");
+ const unsigned TemplateParameterDepth = LSI->AutoTemplateParameterDepth;
+ const unsigned AutoParameterPosition = LSI->TemplateParams.size();
+ const bool IsParameterPack = D.hasEllipsis();
- Info = &SemaRef.InventedParameterInfos.back();
- } else {
- // In C++14, generic lambdas allow 'auto' in their parameters.
- if (!SemaRef.getLangOpts().CPlusPlus14 || !Auto ||
- Auto->getKeyword() != AutoTypeKeyword::Auto) {
- Error = 16;
- break;
- }
- Info = SemaRef.getCurLambda();
- assert(Info && "No LambdaScopeInfo on the stack!");
+ // Create the TemplateTypeParmDecl here to retrieve the corresponding
+ // template parameter type. Template parameters are temporarily added
+ // to the TU until the associated TemplateDecl is created.
+ TemplateTypeParmDecl *CorrespondingTemplateParam =
+ TemplateTypeParmDecl::Create(
+ SemaRef.Context, SemaRef.Context.getTranslationUnitDecl(),
+ /*KeyLoc*/ SourceLocation(), /*NameLoc*/ D.getBeginLoc(),
+ TemplateParameterDepth, AutoParameterPosition,
+ /*Identifier*/ nullptr, false, IsParameterPack,
+ /*HasTypeConstraint=*/false);
+ CorrespondingTemplateParam->setImplicit();
+ LSI->TemplateParams.push_back(CorrespondingTemplateParam);
+ // Replace the 'auto' in the function parameter with this invented
+ // template type parameter.
+ // FIXME: Retain some type sugar to indicate that this was written
+ // as 'auto'.
+ T = state.ReplaceAutoType(
+ T, QualType(CorrespondingTemplateParam->getTypeForDecl(), 0));
}
- T = InventTemplateParameter(state, T, nullptr, Auto, *Info);
break;
- }
case DeclaratorContext::MemberContext: {
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static ||
D.isFunctionDeclarator())
@@ -4143,6 +4032,10 @@
return false;
}
+static TypeSourceInfo *
+GetTypeSourceInfoForDeclarator(TypeProcessingState &State,
+ QualType T, TypeSourceInfo *ReturnTypeInfo);
+
static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state,
QualType declSpecType,
TypeSourceInfo *TInfo) {
@@ -4718,8 +4611,7 @@
} else if (D.getContext() != DeclaratorContext::LambdaExprContext &&
(T.hasQualifiers() || !isa<AutoType>(T) ||
cast<AutoType>(T)->getKeyword() !=
- AutoTypeKeyword::Auto ||
- cast<AutoType>(T)->isConstrained())) {
+ AutoTypeKeyword::Auto)) {
S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
diag::err_trailing_return_without_auto)
<< T << D.getDeclSpec().getSourceRange();
@@ -4730,12 +4622,7 @@
// An error occurred parsing the trailing return type.
T = Context.IntTy;
D.setInvalidType(true);
- } else if (S.getLangOpts().ConceptsTS)
- // Handle cases like: `auto f() -> auto` or `auto f() -> C auto`.
- if (AutoType *Auto = T->getContainedAutoType())
- if (S.getCurScope()->isFunctionDeclarationScope())
- T = InventTemplateParameter(state, T, TInfo, Auto,
- S.InventedParameterInfos.back());
+ }
} else {
// This function type is not the type of the entity being declared,
// so checking the 'auto' is not the responsibility of this chunk.
@@ -5355,8 +5242,7 @@
//
// We represent function parameter packs as function parameters whose
// type is a pack expansion.
- if (!T->containsUnexpandedParameterPack() &&
- (!LangOpts.ConceptsTS || !T->getContainedAutoType())) {
+ if (!T->containsUnexpandedParameterPack()) {
S.Diag(D.getEllipsisLoc(),
diag::err_function_parameter_pack_without_parameter_packs)
<< T << D.getSourceRange();
@@ -5564,15 +5450,14 @@
namespace {
class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
- Sema &SemaRef;
ASTContext &Context;
TypeProcessingState &State;
const DeclSpec &DS;
public:
- TypeSpecLocFiller(Sema &S, ASTContext &Context, TypeProcessingState &State,
+ TypeSpecLocFiller(ASTContext &Context, TypeProcessingState &State,
const DeclSpec &DS)
- : SemaRef(S), Context(Context), State(State), DS(DS) {}
+ : Context(Context), State(State), DS(DS) {}
void VisitAttributedTypeLoc(AttributedTypeLoc TL) {
Visit(TL.getModifiedLoc());
@@ -5700,32 +5585,6 @@
TL.copy(
TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>());
}
- void VisitAutoTypeLoc(AutoTypeLoc TL) {
- assert(DS.getTypeSpecType() == TST_auto ||
- DS.getTypeSpecType() == TST_decltype_auto ||
- DS.getTypeSpecType() == TST_auto_type ||
- DS.getTypeSpecType() == TST_unspecified);
- TL.setNameLoc(DS.getTypeSpecTypeLoc());
- if (!DS.isConstrainedAuto())
- return;
- TemplateIdAnnotation *TemplateId = DS.getRepAsTemplateId();
- if (DS.getTypeSpecScope().isNotEmpty())
- TL.setNestedNameSpecifierLoc(
- DS.getTypeSpecScope().getWithLocInContext(Context));
- else
- TL.setNestedNameSpecifierLoc(NestedNameSpecifierLoc());
- TL.setConceptNameLoc(TemplateId->TemplateNameLoc);
- TL.setLAngleLoc(TemplateId->LAngleLoc);
- TL.setRAngleLoc(TemplateId->RAngleLoc);
- if (TemplateId->NumArgs == 0)
- return;
- TemplateArgumentListInfo TemplateArgsInfo;
- ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
- TemplateId->NumArgs);
- SemaRef.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
- for (unsigned I = 0; I < TemplateId->NumArgs; ++I)
- TL.setArgLocInfo(I, TemplateArgsInfo.arguments()[I].getLocInfo());
- }
void VisitTagTypeLoc(TagTypeLoc TL) {
TL.setNameLoc(DS.getTypeSpecTypeNameLoc());
}
@@ -5995,7 +5854,7 @@
assert(TL.getFullDataSize() == CurrTL.getFullDataSize());
memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize());
} else {
- TypeSpecLocFiller(S, S.Context, State, D.getDeclSpec()).Visit(CurrTL);
+ TypeSpecLocFiller(S.Context, State, D.getDeclSpec()).Visit(CurrTL);
}
return TInfo;
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index d610535..1f72511 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -951,16 +951,12 @@
/// Build a new C++11 auto type.
///
/// By default, builds a new AutoType with the given deduced type.
- QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword,
- ConceptDecl *TypeConstraintConcept,
- ArrayRef<TemplateArgument> TypeConstraintArgs) {
+ QualType RebuildAutoType(QualType Deduced, AutoTypeKeyword Keyword) {
// Note, IsDependent is always false here: we implicitly convert an 'auto'
// which has been deduced to a dependent type into an undeduced 'auto', so
// that we'll retry deduction after the transformation.
return SemaRef.Context.getAutoType(Deduced, Keyword,
- /*IsDependent*/ false, /*IsPack=*/false,
- TypeConstraintConcept,
- TypeConstraintArgs);
+ /*IsDependent*/ false);
}
/// By default, builds a new DeducedTemplateSpecializationType with the given
@@ -4504,10 +4500,7 @@
Deduced =
SemaRef.Context.getQualifiedType(Deduced.getUnqualifiedType(), Qs);
T = SemaRef.Context.getAutoType(Deduced, AutoTy->getKeyword(),
- AutoTy->isDependentType(),
- /*isPack=*/false,
- AutoTy->getTypeConstraintConcept(),
- AutoTy->getTypeConstraintArguments());
+ AutoTy->isDependentType());
} else {
// Otherwise, complain about the addition of a qualifier to an
// already-qualified type.
@@ -5240,29 +5233,21 @@
PackExpansionTypeLoc ExpansionTL = TL.castAs<PackExpansionTypeLoc>();
TypeLoc Pattern = ExpansionTL.getPatternLoc();
SemaRef.collectUnexpandedParameterPacks(Pattern, Unexpanded);
+ assert(Unexpanded.size() > 0 && "Could not find parameter packs!");
// Determine whether we should expand the parameter packs.
bool ShouldExpand = false;
bool RetainExpansion = false;
- Optional<unsigned> OrigNumExpansions;
- if (Unexpanded.size() > 0) {
- OrigNumExpansions = ExpansionTL.getTypePtr()->getNumExpansions();
- NumExpansions = OrigNumExpansions;
- if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
- Pattern.getSourceRange(),
- Unexpanded,
- ShouldExpand,
- RetainExpansion,
- NumExpansions)) {
- return true;
- }
- } else {
-#ifndef NDEBUG
- const AutoType *AT =
- Pattern.getType().getTypePtr()->getContainedAutoType();
- assert((AT && (!AT->isDeduced() || AT->getDeducedType().isNull())) &&
- "Could not find parameter packs or undeduced auto type!");
-#endif
+ Optional<unsigned> OrigNumExpansions =
+ ExpansionTL.getTypePtr()->getNumExpansions();
+ NumExpansions = OrigNumExpansions;
+ if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
+ Pattern.getSourceRange(),
+ Unexpanded,
+ ShouldExpand,
+ RetainExpansion,
+ NumExpansions)) {
+ return true;
}
if (ShouldExpand) {
@@ -5322,9 +5307,6 @@
indexAdjustment,
NumExpansions,
/*ExpectParameterPack=*/true);
- assert(NewParm->isParameterPack() &&
- "Parameter pack no longer a parameter pack after "
- "transformation.");
} else {
NewParm = getDerived().TransformFunctionTypeParam(
OldParm, indexAdjustment, None, /*ExpectParameterPack=*/ false);
@@ -5830,6 +5812,32 @@
}
template<typename Derived>
+QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
+ AutoTypeLoc TL) {
+ const AutoType *T = TL.getTypePtr();
+ QualType OldDeduced = T->getDeducedType();
+ QualType NewDeduced;
+ if (!OldDeduced.isNull()) {
+ NewDeduced = getDerived().TransformType(OldDeduced);
+ if (NewDeduced.isNull())
+ return QualType();
+ }
+
+ QualType Result = TL.getType();
+ if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
+ T->isDependentType()) {
+ Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword());
+ if (Result.isNull())
+ return QualType();
+ }
+
+ AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
+ NewTL.setNameLoc(TL.getNameLoc());
+
+ return Result;
+}
+
+template<typename Derived>
QualType TreeTransform<Derived>::TransformDeducedTemplateSpecializationType(
TypeLocBuilder &TLB, DeducedTemplateSpecializationTypeLoc TL) {
const DeducedTemplateSpecializationType *T = TL.getTypePtr();
@@ -6090,71 +6098,6 @@
}
};
-template<typename Derived>
-QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
- AutoTypeLoc TL) {
- const AutoType *T = TL.getTypePtr();
- QualType OldDeduced = T->getDeducedType();
- QualType NewDeduced;
- if (!OldDeduced.isNull()) {
- NewDeduced = getDerived().TransformType(OldDeduced);
- if (NewDeduced.isNull())
- return QualType();
- }
-
- ConceptDecl *NewCD = nullptr;
- TemplateArgumentListInfo NewTemplateArgs;
- NestedNameSpecifierLoc NewNestedNameSpec;
- if (TL.getTypePtr()->isConstrained()) {
- NewCD = cast_or_null<ConceptDecl>(
- getDerived().TransformDecl(
- TL.getConceptNameLoc(),
- TL.getTypePtr()->getTypeConstraintConcept()));
-
- NewTemplateArgs.setLAngleLoc(TL.getLAngleLoc());
- NewTemplateArgs.setRAngleLoc(TL.getRAngleLoc());
- typedef TemplateArgumentLocContainerIterator<AutoTypeLoc> ArgIterator;
- if (getDerived().TransformTemplateArguments(ArgIterator(TL, 0),
- ArgIterator(TL,
- TL.getNumArgs()),
- NewTemplateArgs))
- return QualType();
-
- if (TL.getNestedNameSpecifierLoc()) {
- NewNestedNameSpec
- = getDerived().TransformNestedNameSpecifierLoc(
- TL.getNestedNameSpecifierLoc());
- if (!NewNestedNameSpec)
- return QualType();
- }
- }
-
- QualType Result = TL.getType();
- if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
- T->isDependentType()) {
- llvm::SmallVector<TemplateArgument, 4> NewArgList;
- NewArgList.reserve(NewArgList.size());
- for (const auto &ArgLoc : NewTemplateArgs.arguments())
- NewArgList.push_back(ArgLoc.getArgument());
- Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
- NewArgList);
- if (Result.isNull())
- return QualType();
- }
-
- AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
- NewTL.setNameLoc(TL.getNameLoc());
- NewTL.setNestedNameSpecifierLoc(NewNestedNameSpec);
- NewTL.setTemplateKWLoc(TL.getTemplateKWLoc());
- NewTL.setConceptNameLoc(TL.getConceptNameLoc());
- NewTL.setFoundDecl(TL.getFoundDecl());
- NewTL.setLAngleLoc(TL.getLAngleLoc());
- NewTL.setRAngleLoc(TL.getRAngleLoc());
- for (unsigned I = 0; I < TL.getNumArgs(); ++I)
- NewTL.setArgLocInfo(I, NewTemplateArgs.arguments()[I].getLocInfo());
-
- return Result;
-}
template <typename Derived>
QualType TreeTransform<Derived>::TransformTemplateSpecializationType(
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 5351ac3..342ac20 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -6576,17 +6576,6 @@
void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
TL.setNameLoc(readSourceLocation());
- if (Reader.readBool()) {
- TL.setNestedNameSpecifierLoc(ReadNestedNameSpecifierLoc());
- TL.setTemplateKWLoc(readSourceLocation());
- TL.setConceptNameLoc(readSourceLocation());
- TL.setFoundDecl(Reader.readDeclAs<NamedDecl>());
- TL.setLAngleLoc(readSourceLocation());
- TL.setRAngleLoc(readSourceLocation());
- for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
- TL.setArgLocInfo(i, Reader.readTemplateArgumentLocInfo(
- TL.getTypePtr()->getArg(i).getKind()));
- }
}
void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index 093b69a..4fd079e 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -2317,12 +2317,12 @@
D->setDeclaredWithTypename(Record.readInt());
- if (Record.readBool()) {
+ if (Record.readInt()) {
NestedNameSpecifierLoc NNS = Record.readNestedNameSpecifierLoc();
DeclarationNameInfo DN = Record.readDeclarationNameInfo();
- ConceptDecl *NamedConcept = Record.readDeclAs<ConceptDecl>();
+ ConceptDecl *NamedConcept = cast<ConceptDecl>(Record.readDecl());
const ASTTemplateArgumentListInfo *ArgsAsWritten = nullptr;
- if (Record.readBool())
+ if (Record.readInt())
ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
Expr *ImmediatelyDeclaredConstraint = Record.readExpr();
D->setTypeConstraint(NNS, DN, /*FoundDecl=*/nullptr, NamedConcept,
@@ -2340,8 +2340,6 @@
// TemplateParmPosition.
D->setDepth(Record.readInt());
D->setPosition(Record.readInt());
- if (D->hasPlaceholderTypeConstraint())
- D->setPlaceholderTypeConstraint(Record.readExpr());
if (D->isExpandedParameterPack()) {
auto TypesAndInfos =
D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
@@ -3825,19 +3823,13 @@
HasTypeConstraint);
break;
}
- case DECL_NON_TYPE_TEMPLATE_PARM: {
- bool HasTypeConstraint = Record.readInt();
- D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID,
- HasTypeConstraint);
+ case DECL_NON_TYPE_TEMPLATE_PARM:
+ D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
break;
- }
- case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK: {
- bool HasTypeConstraint = Record.readInt();
+ case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID,
- Record.readInt(),
- HasTypeConstraint);
+ Record.readInt());
break;
- }
case DECL_TEMPLATE_TEMPLATE_PARM:
D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
break;
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index 79f7d57..c216b14 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -349,18 +349,6 @@
void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
Record.AddSourceLocation(TL.getNameLoc());
- Record.push_back(TL.isConstrained());
- if (TL.isConstrained()) {
- Record.AddNestedNameSpecifierLoc(TL.getNestedNameSpecifierLoc());
- Record.AddSourceLocation(TL.getTemplateKWLoc());
- Record.AddSourceLocation(TL.getConceptNameLoc());
- Record.AddDeclRef(TL.getFoundDecl());
- Record.AddSourceLocation(TL.getLAngleLoc());
- Record.AddSourceLocation(TL.getRAngleLoc());
- for (unsigned I = 0; I < TL.getNumArgs(); ++I)
- Record.AddTemplateArgumentLocInfo(TL.getTypePtr()->getArg(I).getKind(),
- TL.getArgLocInfo(I));
- }
}
void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
diff --git a/clang/lib/Serialization/ASTWriterDecl.cpp b/clang/lib/Serialization/ASTWriterDecl.cpp
index 472136d..459e617 100644
--- a/clang/lib/Serialization/ASTWriterDecl.cpp
+++ b/clang/lib/Serialization/ASTWriterDecl.cpp
@@ -1675,8 +1675,6 @@
// For an expanded parameter pack, record the number of expansion types here
// so that it's easier for deserialization to allocate the right amount of
// memory.
- Expr *TypeConstraint = D->getPlaceholderTypeConstraint();
- Record.push_back(!!TypeConstraint);
if (D->isExpandedParameterPack())
Record.push_back(D->getNumExpansionTypes());
@@ -1684,8 +1682,6 @@
// TemplateParmPosition.
Record.push_back(D->getDepth());
Record.push_back(D->getPosition());
- if (TypeConstraint)
- Record.AddStmt(TypeConstraint);
if (D->isExpandedParameterPack()) {
for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {