This is an archive of the discontinued LLVM Phabricator instance.

Differential D110460

[clang] set templates as invalid when any of the parameters are invalid
ClosedPublic

Authored by mizvekov on Sep 24 2021, 5:09 PM.

Details

Reviewers
rsmith
Commits
rG37adc4f957c2: [clang] set templates as invalid when any of the parameters are invalid
Summary

See PR51872 for the original repro.

This fixes a crash when converting a templated constructor into a deduction
guide, in case any of the template parameters were invalid.

Signed-off-by: Matheus Izvekov <mizvekov@gmail.com>

Diff Detail

Event Timeline

mizvekov created this revision.Sep 24 2021, 5:09 PM
Harbormaster completed remote builds in B125674: Diff 375001.Sep 24 2021, 5:32 PM
mizvekov published this revision for review.Sep 24 2021, 6:37 PM
Herald added a project: Restricted Project. · View Herald TranscriptSep 24 2021, 6:37 PM
Herald added a subscriber: cfe-commits. · View Herald Transcript
mizvekov added a reviewer: rsmith.Sep 24 2021, 6:37 PM
rsmith accepted this revision.Sep 24 2021, 6:51 PM
This revision is now accepted and ready to land.Sep 24 2021, 6:51 PM
This revision was landed with ongoing or failed builds.Sep 24 2021, 7:04 PM
Closed by commit rG37adc4f957c2: [clang] set templates as invalid when any of the parameters are invalid (authored by mizvekov). · Explain Why
This revision was automatically updated to reflect the committed changes.
mizvekov added a commit: rG37adc4f957c2: [clang] set templates as invalid when any of the parameters are invalid.

Revision Contents

PathSize
clang/
lib/
AST/
76 lines
test/
SemaTemplate/
10 lines

Diff 375006

clang/lib/AST/DeclTemplate.cpp

Show First 20 Lines • Show All 159 Lines • ▼ Show 20 Linesunsigned TemplateParameterList::getDepth() const {
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm)) if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(FirstParm))
return TTP->getDepth(); return TTP->getDepth();
else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm)) else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(FirstParm))
return NTTP->getDepth(); return NTTP->getDepth();
else else
return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth(); return cast<TemplateTemplateParmDecl>(FirstParm)->getDepth();
} }
static void AdoptTemplateParameterList(TemplateParameterList *Params, static bool AdoptTemplateParameterList(TemplateParameterList *Params,
DeclContext *Owner) { DeclContext *Owner) {
bool Invalid = false;
for (NamedDecl *P : *Params) { for (NamedDecl *P : *Params) {
P->setDeclContext(Owner); P->setDeclContext(Owner);
if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P)) if (const auto *TTP = dyn_cast<TemplateTemplateParmDecl>(P))
AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner); if (AdoptTemplateParameterList(TTP->getTemplateParameters(), Owner))
Invalid = true;
if (P->isInvalidDecl())
Invalid = true;
} }
return Invalid;
} }
void TemplateParameterList:: void TemplateParameterList::
getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const { getAssociatedConstraints(llvm::SmallVectorImpl<const Expr *> &AC) const {
if (HasConstrainedParameters) if (HasConstrainedParameters)
for (const NamedDecl *Param : *this) { for (const NamedDecl *Param : *this) {
if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) { if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param)) {
if (const auto *TC = TTP->getTypeConstraint()) if (const auto *TC = TTP->getTypeConstraint())
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines if (ASTMutationListener *L = getASTMutationListener())
L->AddedCXXTemplateSpecialization(cast<Derived>(this), L->AddedCXXTemplateSpecialization(cast<Derived>(this),
SETraits::getDecl(Entry)); SETraits::getDecl(Entry));
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// FunctionTemplateDecl Implementation // FunctionTemplateDecl Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
FunctionTemplateDecl *FunctionTemplateDecl::Create(ASTContext &C, FunctionTemplateDecl *
DeclContext *DC, FunctionTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
SourceLocation L,
DeclarationName Name, DeclarationName Name,
TemplateParameterList *Params, TemplateParameterList *Params, NamedDecl *Decl) {
NamedDecl *Decl) { bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
AdoptTemplateParameterList(Params, cast<DeclContext>(Decl)); auto *TD = new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl);
return new (C, DC) FunctionTemplateDecl(C, DC, L, Name, Params, Decl); if (Invalid)
TD->setInvalidDecl();
return TD;
} }
FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C, FunctionTemplateDecl *FunctionTemplateDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(), return new (C, ID) FunctionTemplateDecl(C, nullptr, SourceLocation(),
DeclarationName(), nullptr, nullptr); DeclarationName(), nullptr, nullptr);
} }
▲ Show 20 Lines • Show All 75 Lines • ▼ Show 20 Linesvoid FunctionTemplateDecl::mergePrevDecl(FunctionTemplateDecl *Prev) {
Base::Common = PrevCommon; Base::Common = PrevCommon;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ClassTemplateDecl Implementation // ClassTemplateDecl Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, ClassTemplateDecl *ClassTemplateDecl::Create(ASTContext &C, DeclContext *DC,
DeclContext *DC,
SourceLocation L, SourceLocation L,
DeclarationName Name, DeclarationName Name,
TemplateParameterList *Params, TemplateParameterList *Params,
NamedDecl *Decl) { NamedDecl *Decl) {
AdoptTemplateParameterList(Params, cast<DeclContext>(Decl)); bool Invalid = AdoptTemplateParameterList(Params, cast<DeclContext>(Decl));
auto *TD = new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl);
return new (C, DC) ClassTemplateDecl(C, DC, L, Name, Params, Decl); if (Invalid)
TD->setInvalidDecl();
return TD;
} }
ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C, ClassTemplateDecl *ClassTemplateDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(), return new (C, ID) ClassTemplateDecl(C, nullptr, SourceLocation(),
DeclarationName(), nullptr, nullptr); DeclarationName(), nullptr, nullptr);
} }
▲ Show 20 Lines • Show All 542 Lines • ▼ Show 20 Lines
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// ConceptDecl Implementation // ConceptDecl Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC, ConceptDecl *ConceptDecl::Create(ASTContext &C, DeclContext *DC,
SourceLocation L, DeclarationName Name, SourceLocation L, DeclarationName Name,
TemplateParameterList *Params, TemplateParameterList *Params,
Expr *ConstraintExpr) { Expr *ConstraintExpr) {
AdoptTemplateParameterList(Params, DC); bool Invalid = AdoptTemplateParameterList(Params, DC);
return new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr); auto *TD = new (C, DC) ConceptDecl(DC, L, Name, Params, ConstraintExpr);
if (Invalid)
TD->setInvalidDecl();
return TD;
} }
ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C, ConceptDecl *ConceptDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(), ConceptDecl *Result = new (C, ID) ConceptDecl(nullptr, SourceLocation(),
DeclarationName(), DeclarationName(),
nullptr, nullptr); nullptr, nullptr);
Show All 16 LinesClassTemplatePartialSpecializationDecl(ASTContext &Context, TagKind TK,
const ASTTemplateArgumentListInfo *ArgInfos, const ASTTemplateArgumentListInfo *ArgInfos,
ClassTemplatePartialSpecializationDecl *PrevDecl) ClassTemplatePartialSpecializationDecl *PrevDecl)
: ClassTemplateSpecializationDecl(Context, : ClassTemplateSpecializationDecl(Context,
ClassTemplatePartialSpecialization, ClassTemplatePartialSpecialization,
TK, DC, StartLoc, IdLoc, TK, DC, StartLoc, IdLoc,
SpecializedTemplate, Args, PrevDecl), SpecializedTemplate, Args, PrevDecl),
TemplateParams(Params), ArgsAsWritten(ArgInfos), TemplateParams(Params), ArgsAsWritten(ArgInfos),
InstantiatedFromMember(nullptr, false) { InstantiatedFromMember(nullptr, false) {
AdoptTemplateParameterList(Params, this); if (AdoptTemplateParameterList(Params, this))
setInvalidDecl();
} }
ClassTemplatePartialSpecializationDecl * ClassTemplatePartialSpecializationDecl *
ClassTemplatePartialSpecializationDecl:: ClassTemplatePartialSpecializationDecl::
Create(ASTContext &Context, TagKind TK,DeclContext *DC, Create(ASTContext &Context, TagKind TK,DeclContext *DC,
SourceLocation StartLoc, SourceLocation IdLoc, SourceLocation StartLoc, SourceLocation IdLoc,
TemplateParameterList *Params, TemplateParameterList *Params,
ClassTemplateDecl *SpecializedTemplate, ClassTemplateDecl *SpecializedTemplate,
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 LinesFriendTemplateDecl *FriendTemplateDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
return new (C, ID) FriendTemplateDecl(EmptyShell()); return new (C, ID) FriendTemplateDecl(EmptyShell());
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// TypeAliasTemplateDecl Implementation // TypeAliasTemplateDecl Implementation
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
TypeAliasTemplateDecl *TypeAliasTemplateDecl::Create(ASTContext &C, TypeAliasTemplateDecl *
DeclContext *DC, TypeAliasTemplateDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
SourceLocation L,
DeclarationName Name, DeclarationName Name,
TemplateParameterList *Params, TemplateParameterList *Params, NamedDecl *Decl) {
NamedDecl *Decl) { bool Invalid = AdoptTemplateParameterList(Params, DC);
AdoptTemplateParameterList(Params, DC); auto *TD = new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl);
return new (C, DC) TypeAliasTemplateDecl(C, DC, L, Name, Params, Decl); if (Invalid)
TD->setInvalidDecl();
return TD;
} }
TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C, TypeAliasTemplateDecl *TypeAliasTemplateDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(), return new (C, ID) TypeAliasTemplateDecl(C, nullptr, SourceLocation(),
DeclarationName(), nullptr, nullptr); DeclarationName(), nullptr, nullptr);
} }
Show All 30 LinesVarTemplateDecl *VarTemplateDecl::getDefinition() {
} }
return nullptr; return nullptr;
} }
VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC, VarTemplateDecl *VarTemplateDecl::Create(ASTContext &C, DeclContext *DC,
SourceLocation L, DeclarationName Name, SourceLocation L, DeclarationName Name,
TemplateParameterList *Params, TemplateParameterList *Params,
VarDecl *Decl) { VarDecl *Decl) {
AdoptTemplateParameterList(Params, DC); bool Invalid = AdoptTemplateParameterList(Params, DC);
return new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl); auto *TD = new (C, DC) VarTemplateDecl(C, DC, L, Name, Params, Decl);
if (Invalid)
TD->setInvalidDecl();
return TD;
} }
VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C, VarTemplateDecl *VarTemplateDecl::CreateDeserialized(ASTContext &C,
unsigned ID) { unsigned ID) {
return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(), return new (C, ID) VarTemplateDecl(C, nullptr, SourceLocation(),
DeclarationName(), nullptr, nullptr); DeclarationName(), nullptr, nullptr);
} }
▲ Show 20 Lines • Show All 165 Lines • ▼ Show 20 LinesVarTemplatePartialSpecializationDecl::VarTemplatePartialSpecializationDecl(
VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
StorageClass S, ArrayRef<TemplateArgument> Args, StorageClass S, ArrayRef<TemplateArgument> Args,
const ASTTemplateArgumentListInfo *ArgInfos) const ASTTemplateArgumentListInfo *ArgInfos)
: VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context, : VarTemplateSpecializationDecl(VarTemplatePartialSpecialization, Context,
DC, StartLoc, IdLoc, SpecializedTemplate, T, DC, StartLoc, IdLoc, SpecializedTemplate, T,
TInfo, S, Args), TInfo, S, Args),
TemplateParams(Params), ArgsAsWritten(ArgInfos), TemplateParams(Params), ArgsAsWritten(ArgInfos),
InstantiatedFromMember(nullptr, false) { InstantiatedFromMember(nullptr, false) {
// TODO: The template parameters should be in DC by now. Verify. if (AdoptTemplateParameterList(Params, DC))
// AdoptTemplateParameterList(Params, DC); setInvalidDecl();
} }
VarTemplatePartialSpecializationDecl * VarTemplatePartialSpecializationDecl *
VarTemplatePartialSpecializationDecl::Create( VarTemplatePartialSpecializationDecl::Create(
ASTContext &Context, DeclContext *DC, SourceLocation StartLoc, ASTContext &Context, DeclContext *DC, SourceLocation StartLoc,
SourceLocation IdLoc, TemplateParameterList *Params, SourceLocation IdLoc, TemplateParameterList *Params,
VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo, VarTemplateDecl *SpecializedTemplate, QualType T, TypeSourceInfo *TInfo,
StorageClass S, ArrayRef<TemplateArgument> Args, StorageClass S, ArrayRef<TemplateArgument> Args,
▲ Show 20 Lines • Show All 155 Lines • Show Last 20 Lines

clang/test/SemaTemplate/deduction-crash.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
template <typename InputT, typename OutputT> template <typename InputT, typename OutputT>
OutputT SourceSelectionRequirement<InputT, OutputT>:: OutputT SourceSelectionRequirement<InputT, OutputT>::
evaluateSelectionRequirement<void>(InputT &&Value) { // expected-error {{cannot specialize a member of an unspecialized template}} evaluateSelectionRequirement<void>(InputT &&Value) { // expected-error {{cannot specialize a member of an unspecialized template}}
return Value; return Value;
} }
} }
namespace PR51872_part1 {
template<int> class T1 { template <struct U1> T1(); };
// expected-error@-1 {{non-type template parameter has incomplete type 'struct U1'}}
// expected-note@-2 {{forward declaration of 'PR51872_part1::U1'}}
T1 t1 = 0;
// expected-error@-1 {{no viable constructor or deduction guide for deduction of template arguments of 'T1'}}
// expected-note@-6 {{candidate template ignored: could not match 'T1<>' against 'int'}}
}