[clang] [Clang] Substitute for the type aliases inside of a CTAD guide (PR #94740)
Younan Zhang via cfe-commits
cfe-commits at lists.llvm.org
Fri Jun 7 06:12:34 PDT 2024
https://github.com/zyn0217 updated https://github.com/llvm/llvm-project/pull/94740
>From 2f60e51f2017e4448047f64983b2f22cdb67e816 Mon Sep 17 00:00:00 2001
From: Younan Zhang <zyn7109 at gmail.com>
Date: Fri, 7 Jun 2024 18:08:10 +0800
Subject: [PATCH 1/3] [Clang] Substitute for the type aliases inside of a CTAD
guide
---
clang/docs/ReleaseNotes.rst | 1 +
clang/lib/Sema/SemaTemplate.cpp | 96 +++++++++++++++++--
.../SemaTemplate/nested-deduction-guides.cpp | 70 ++++++++++++++
3 files changed, 160 insertions(+), 7 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 0c700d23257bf..3f6d040b0ddf1 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -823,6 +823,7 @@ Bug Fixes to C++ Support
differering by their constraints when only one of these function was variadic.
- Fix a crash when a variable is captured by a block nested inside a lambda. (Fixes #GH93625).
- Fixed a type constraint substitution issue involving a generic lambda expression. (#GH93821)
+- Fixed a CTAD substitution bug involving type aliases that reference outer template parameters. (#GH94614).
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 40a759ea330de..1e921dd26bd7d 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -2220,23 +2220,101 @@ namespace {
class ExtractTypeForDeductionGuide
: public TreeTransform<ExtractTypeForDeductionGuide> {
llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs;
+ ClassTemplateDecl *NestedPattern;
+ const MultiLevelTemplateArgumentList *OuterInstantiationArgs;
public:
typedef TreeTransform<ExtractTypeForDeductionGuide> Base;
ExtractTypeForDeductionGuide(
Sema &SemaRef,
- llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs)
- : Base(SemaRef), MaterializedTypedefs(MaterializedTypedefs) {}
+ llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs,
+ ClassTemplateDecl *NestedPattern,
+ const MultiLevelTemplateArgumentList *OuterInstantiationArgs)
+ : Base(SemaRef), MaterializedTypedefs(MaterializedTypedefs),
+ NestedPattern(NestedPattern),
+ OuterInstantiationArgs(OuterInstantiationArgs) {}
TypeSourceInfo *transform(TypeSourceInfo *TSI) { return TransformType(TSI); }
+ bool mightReferToOuterTemplateParameters(TypedefNameDecl *Typedef) {
+ if (!NestedPattern)
+ return false;
+
+ static auto WalkUp = [](DeclContext *DC, DeclContext *TargetDC) {
+ if (DC == TargetDC)
+ return true;
+ while (!DC->isTranslationUnit()) {
+ if (DC->Equals(TargetDC))
+ return true;
+ DC = DC->getParent();
+ }
+ return false;
+ };
+
+ if (WalkUp(Typedef->getDeclContext(), NestedPattern->getTemplatedDecl()))
+ return true;
+ if (WalkUp(NestedPattern->getTemplatedDecl(), Typedef->getDeclContext()))
+ return true;
+ return false;
+ }
+
+ QualType
+ RebuildTemplateSpecializationType(TemplateName Template,
+ SourceLocation TemplateNameLoc,
+ TemplateArgumentListInfo &TemplateArgs) {
+ if (!OuterInstantiationArgs ||
+ !isa_and_present<TypeAliasTemplateDecl>(Template.getAsTemplateDecl()))
+ return Base::RebuildTemplateSpecializationType(Template, TemplateNameLoc,
+ TemplateArgs);
+
+ auto *TATD = cast<TypeAliasTemplateDecl>(Template.getAsTemplateDecl());
+ auto *Pattern = TATD;
+ while (Pattern->getInstantiatedFromMemberTemplate())
+ Pattern = Pattern->getInstantiatedFromMemberTemplate();
+ if (!mightReferToOuterTemplateParameters(Pattern->getTemplatedDecl()))
+ return Base::RebuildTemplateSpecializationType(Template, TemplateNameLoc,
+ TemplateArgs);
+
+ Decl *NewD = SemaRef.SubstDecl(
+ TATD, SemaRef.getASTContext().getTranslationUnitDecl(),
+ *OuterInstantiationArgs);
+ if (!NewD)
+ return QualType();
+
+ auto *NewTATD = cast<TypeAliasTemplateDecl>(NewD);
+ MaterializedTypedefs.push_back(NewTATD->getTemplatedDecl());
+
+ return Base::RebuildTemplateSpecializationType(
+ TemplateName(NewTATD), TemplateNameLoc, TemplateArgs);
+ }
+
QualType TransformTypedefType(TypeLocBuilder &TLB, TypedefTypeLoc TL) {
ASTContext &Context = SemaRef.getASTContext();
TypedefNameDecl *OrigDecl = TL.getTypedefNameDecl();
TypedefNameDecl *Decl = OrigDecl;
// Transform the underlying type of the typedef and clone the Decl only if
// the typedef has a dependent context.
- if (OrigDecl->getDeclContext()->isDependentContext()) {
+ bool InDependentContext = OrigDecl->getDeclContext()->isDependentContext();
+
+ // A typedef/alias Decl within the NestedPattern may reference the outer
+ // template parameters. They're substituted with corresponding instantiation
+ // arguments here and in RebuildTemplateSpecializationType() above.
+ // Otherwise, we would have a CTAD guide with "dangling" template
+ // parameters.
+ // For example,
+ // template <class T> struct Outer {
+ // using Alias = S<T>;
+ // template <class U> struct Inner {
+ // Inner(Alias);
+ // };
+ // };
+ if (OuterInstantiationArgs && InDependentContext) {
+ Decl = cast_if_present<TypedefNameDecl>(SemaRef.SubstDecl(
+ OrigDecl, Context.getTranslationUnitDecl(), *OuterInstantiationArgs));
+ if (!Decl)
+ return QualType();
+ MaterializedTypedefs.push_back(Decl);
+ } else if (InDependentContext) {
TypeLocBuilder InnerTLB;
QualType Transformed =
TransformType(InnerTLB, OrigDecl->getTypeSourceInfo()->getTypeLoc());
@@ -2577,8 +2655,9 @@ struct ConvertConstructorToDeductionGuideTransform {
// defined outside of the surrounding class template. That is T in the
// above example.
if (NestedPattern) {
- NewParam = transformFunctionTypeParam(NewParam, OuterInstantiationArgs,
- MaterializedTypedefs);
+ NewParam = transformFunctionTypeParam(
+ NewParam, OuterInstantiationArgs, MaterializedTypedefs,
+ /*TransformingOuterPatterns=*/true);
if (!NewParam)
return QualType();
}
@@ -2630,7 +2709,8 @@ struct ConvertConstructorToDeductionGuideTransform {
ParmVarDecl *transformFunctionTypeParam(
ParmVarDecl *OldParam, MultiLevelTemplateArgumentList &Args,
- llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs) {
+ llvm::SmallVectorImpl<TypedefNameDecl *> &MaterializedTypedefs,
+ bool TransformingOuterPatterns = false) {
TypeSourceInfo *OldDI = OldParam->getTypeSourceInfo();
TypeSourceInfo *NewDI;
if (auto PackTL = OldDI->getTypeLoc().getAs<PackExpansionTypeLoc>()) {
@@ -2653,7 +2733,9 @@ struct ConvertConstructorToDeductionGuideTransform {
// members of the current instantiations with the definitions of those
// typedefs, avoiding triggering instantiation of the deduced type during
// deduction.
- NewDI = ExtractTypeForDeductionGuide(SemaRef, MaterializedTypedefs)
+ NewDI = ExtractTypeForDeductionGuide(
+ SemaRef, MaterializedTypedefs, NestedPattern,
+ TransformingOuterPatterns ? &Args : nullptr)
.transform(NewDI);
// Resolving a wording defect, we also inherit default arguments from the
diff --git a/clang/test/SemaTemplate/nested-deduction-guides.cpp b/clang/test/SemaTemplate/nested-deduction-guides.cpp
index 38410b93ead3b..ff432173200c7 100644
--- a/clang/test/SemaTemplate/nested-deduction-guides.cpp
+++ b/clang/test/SemaTemplate/nested-deduction-guides.cpp
@@ -16,3 +16,73 @@ using T = A<void>::B<int>;
using Copy = decltype(copy);
using Copy = A<void>::B<int>;
+
+namespace GH94614 {
+
+template <class, class> struct S {};
+
+struct trouble_1 {
+} constexpr t1;
+struct trouble_2 {
+} constexpr t2;
+struct trouble_3 {
+} constexpr t3;
+struct trouble_4 {
+} constexpr t4;
+struct trouble_5 {
+} constexpr t5;
+struct trouble_6 {
+} constexpr t6;
+struct trouble_7 {
+} constexpr t7;
+struct trouble_8 {
+} constexpr t8;
+struct trouble_9 {
+} constexpr t9;
+
+template <class U, class... T> struct Unrelated {
+ using Trouble = S<U, T...>;
+
+ template <class... V> using Trouble2 = S<V..., T...>;
+};
+
+template <class T, class U> struct Outer {
+ using Trouble = S<U, T>;
+
+ template <class V> using Trouble2 = S<V, T>;
+
+ template <class V> using Trouble3 = S<U, T>;
+
+ template <class V> struct Inner {
+ template <class W> struct Paranoid {
+ using Trouble4 = S<W, T>;
+
+ template <class... X> using Trouble5 = S<X..., T>;
+ };
+
+ Inner(trouble_1, V v, Trouble trouble) {}
+ Inner(trouble_2, V v, Trouble2<V> trouble) {}
+ Inner(trouble_3, V v, Trouble3<V> trouble) {}
+ Inner(trouble_4, V v, Unrelated<U, T>::template Trouble2<V> trouble) {}
+ Inner(trouble_5, V v, Unrelated<U, T>::Trouble trouble) {}
+ Inner(trouble_6, V v, Unrelated<V, T>::Trouble trouble) {}
+ Inner(trouble_7, V v, Paranoid<V>::Trouble4 trouble) {}
+ Inner(trouble_8, V v, Paranoid<V>::template Trouble5<V> trouble) {}
+ template <class W>
+ Inner(trouble_9, V v, W w, Paranoid<V>::template Trouble5<W> trouble) {}
+ };
+};
+
+S<int, char> s;
+
+Outer<char, int>::Inner _1(t1, 42, s);
+Outer<char, int>::Inner _2(t2, 42, s);
+Outer<char, int>::Inner _3(t3, 42, s);
+Outer<char, int>::Inner _4(t4, 42, s);
+Outer<char, int>::Inner _5(t5, 42, s);
+Outer<char, int>::Inner _6(t6, 42, s);
+Outer<char, int>::Inner _7(t7, 42, s);
+Outer<char, int>::Inner _8(t8, 42, s);
+Outer<char, int>::Inner _9(t9, 42, 24, s);
+
+} // namespace GH94614
>From 70b754ebebd8210c036e2db0901fcfbf6db422af Mon Sep 17 00:00:00 2001
From: Younan Zhang <zyn7109 at gmail.com>
Date: Fri, 7 Jun 2024 18:50:16 +0800
Subject: [PATCH 2/3] Add prior 'typename's
---
clang/test/SemaTemplate/nested-deduction-guides.cpp | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/clang/test/SemaTemplate/nested-deduction-guides.cpp b/clang/test/SemaTemplate/nested-deduction-guides.cpp
index ff432173200c7..913042810ae82 100644
--- a/clang/test/SemaTemplate/nested-deduction-guides.cpp
+++ b/clang/test/SemaTemplate/nested-deduction-guides.cpp
@@ -63,13 +63,13 @@ template <class T, class U> struct Outer {
Inner(trouble_1, V v, Trouble trouble) {}
Inner(trouble_2, V v, Trouble2<V> trouble) {}
Inner(trouble_3, V v, Trouble3<V> trouble) {}
- Inner(trouble_4, V v, Unrelated<U, T>::template Trouble2<V> trouble) {}
- Inner(trouble_5, V v, Unrelated<U, T>::Trouble trouble) {}
- Inner(trouble_6, V v, Unrelated<V, T>::Trouble trouble) {}
- Inner(trouble_7, V v, Paranoid<V>::Trouble4 trouble) {}
- Inner(trouble_8, V v, Paranoid<V>::template Trouble5<V> trouble) {}
+ Inner(trouble_4, V v, typename Unrelated<U, T>::template Trouble2<V> trouble) {}
+ Inner(trouble_5, V v, typename Unrelated<U, T>::Trouble trouble) {}
+ Inner(trouble_6, V v, typename Unrelated<V, T>::Trouble trouble) {}
+ Inner(trouble_7, V v, typename Paranoid<V>::Trouble4 trouble) {}
+ Inner(trouble_8, V v, typename Paranoid<V>::template Trouble5<V> trouble) {}
template <class W>
- Inner(trouble_9, V v, W w, Paranoid<V>::template Trouble5<W> trouble) {}
+ Inner(trouble_9, V v, W w, typename Paranoid<V>::template Trouble5<W> trouble) {}
};
};
>From f5a196a61b71ce6a002f2a25c26670d7d804cca1 Mon Sep 17 00:00:00 2001
From: Younan Zhang <zyn7109 at gmail.com>
Date: Fri, 7 Jun 2024 21:03:52 +0800
Subject: [PATCH 3/3] Give up if we exit a RecordDecl
---
clang/lib/Sema/SemaTemplate.cpp | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 1e921dd26bd7d..baf2f12bcbb07 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -2236,14 +2236,16 @@ class ExtractTypeForDeductionGuide
TypeSourceInfo *transform(TypeSourceInfo *TSI) { return TransformType(TSI); }
+ /// Returns true if it's safe to substitute \p Typedef with
+ /// \p OuterInstantiationArgs.
bool mightReferToOuterTemplateParameters(TypedefNameDecl *Typedef) {
if (!NestedPattern)
return false;
static auto WalkUp = [](DeclContext *DC, DeclContext *TargetDC) {
- if (DC == TargetDC)
+ if (DC->Equals(TargetDC))
return true;
- while (!DC->isTranslationUnit()) {
+ while (DC->isRecord()) {
if (DC->Equals(TargetDC))
return true;
DC = DC->getParent();
More information about the cfe-commits
mailing list