https://github.com/zyn0217 created https://github.com/llvm/llvm-project/pull/99840
This seems to be low-hanging fruit: We could remove all calls to `Context.getCanonicalTemplateArgument()` and gain a better diagnostic/AST. The non-canonical template arguments shouldn't make a difference when synthesizing a CTAD guide, so this is intended to be an NFC. Closes https://github.com/llvm/llvm-project/issues/79798 >From 1872f407ea30b8fd2f0226a280010b81e4a3ed57 Mon Sep 17 00:00:00 2001 From: Younan Zhang <zyn7...@gmail.com> Date: Mon, 22 Jul 2024 14:49:55 +0800 Subject: [PATCH] [Clang][NFCI] Prefer non-canonical template arguments for synthesized CTAD guides This seems to be low-hanging fruit: We could remove all calls to 'Context.getCanonicalTemplateArgument()' and gain a better diagnostic/AST. The non-canonical template arguments shouldn't make a difference when synthesizing a CTAD guide, so this is intended to be an NFC. --- clang/lib/Sema/SemaTemplateDeductionGuide.cpp | 25 +++---- clang/test/AST/ast-dump-ctad-alias.cpp | 34 +++++----- .../temp.deduct/temp.deduct.call/p3-0x.cpp | 2 +- clang/test/SemaCXX/cxx20-ctad-type-alias.cpp | 30 ++++---- clang/test/SemaTemplate/deduction-guide.cpp | 68 +++++++++---------- 5 files changed, 79 insertions(+), 80 deletions(-) diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp index 7dff2c8f98589..0602d07c6b9b0 100644 --- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp +++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp @@ -363,8 +363,7 @@ struct ConvertConstructorToDeductionGuideTransform { return nullptr; // Constraints require that we substitute depth-1 arguments // to match depths when substituted for evaluation later - Depth1Args.push_back(SemaRef.Context.getCanonicalTemplateArgument( - SemaRef.Context.getInjectedTemplateArg(NewParam))); + Depth1Args.push_back(SemaRef.Context.getInjectedTemplateArg(NewParam)); if (NestedPattern) { TemplateDeclInstantiator Instantiator(SemaRef, DC, @@ -379,8 +378,7 @@ struct ConvertConstructorToDeductionGuideTransform { "Unexpected template parameter depth"); AllParams.push_back(NewParam); - SubstArgs.push_back(SemaRef.Context.getCanonicalTemplateArgument( - SemaRef.Context.getInjectedTemplateArg(NewParam))); + SubstArgs.push_back(SemaRef.Context.getInjectedTemplateArg(NewParam)); } // Substitute new template parameters into requires-clause if present. @@ -795,8 +793,8 @@ buildAssociatedConstraints(Sema &SemaRef, FunctionTemplateDecl *F, /*NewIndex=*/AdjustedAliasTemplateArgs.size(), getTemplateParameterDepth(TP) + AdjustDepth); - auto NewTemplateArgument = Context.getCanonicalTemplateArgument( - Context.getInjectedTemplateArg(NewParam)); + TemplateArgument NewTemplateArgument = + Context.getInjectedTemplateArg(NewParam); AdjustedAliasTemplateArgs.push_back(NewTemplateArgument); } // Template arguments used to transform the template arguments in @@ -822,8 +820,8 @@ buildAssociatedConstraints(Sema &SemaRef, FunctionTemplateDecl *F, getTemplateParameterDepth(TP) + AdjustDepth); FirstUndeducedParamIdx += 1; assert(TemplateArgsForBuildingRC[Index].isNull()); - TemplateArgsForBuildingRC[Index] = Context.getCanonicalTemplateArgument( - Context.getInjectedTemplateArg(NewParam)); + TemplateArgsForBuildingRC[Index] = + Context.getInjectedTemplateArg(NewParam); continue; } TemplateArgumentLoc Input = @@ -923,8 +921,8 @@ Expr *buildIsDeducibleConstraint(Sema &SemaRef, /*NewIndex=*/TransformedTemplateArgs.size(), getTemplateParameterDepth(TP) + AdjustDepth); - auto NewTemplateArgument = Context.getCanonicalTemplateArgument( - Context.getInjectedTemplateArg(NewParam)); + TemplateArgument NewTemplateArgument = + Context.getInjectedTemplateArg(NewParam); TransformedTemplateArgs.push_back(NewTemplateArgument); } // Transformed the ReturnType to restore the uninstantiated depth. @@ -1087,8 +1085,8 @@ BuildDeductionGuideForTypeAlias(Sema &SemaRef, getTemplateParameterDepth(TP)); FPrimeTemplateParams.push_back(NewParam); - auto NewTemplateArgument = Context.getCanonicalTemplateArgument( - Context.getInjectedTemplateArg(NewParam)); + TemplateArgument NewTemplateArgument = + Context.getInjectedTemplateArg(NewParam); TransformedDeducedAliasArgs[AliasTemplateParamIdx] = NewTemplateArgument; } unsigned FirstUndeducedParamIdx = FPrimeTemplateParams.size(); @@ -1109,8 +1107,7 @@ BuildDeductionGuideForTypeAlias(Sema &SemaRef, assert(TemplateArgsForBuildingFPrime[FTemplateParamIdx].isNull() && "The argument must be null before setting"); TemplateArgsForBuildingFPrime[FTemplateParamIdx] = - Context.getCanonicalTemplateArgument( - Context.getInjectedTemplateArg(NewParam)); + Context.getInjectedTemplateArg(NewParam); } // To form a deduction guide f' from f, we leverage clang's instantiation diff --git a/clang/test/AST/ast-dump-ctad-alias.cpp b/clang/test/AST/ast-dump-ctad-alias.cpp index a088c0a7b0272..b1631f7822ce0 100644 --- a/clang/test/AST/ast-dump-ctad-alias.cpp +++ b/clang/test/AST/ast-dump-ctad-alias.cpp @@ -32,22 +32,24 @@ Out2<double>::AInner t(1.0); // CHECK-NEXT: | | |-UnresolvedLookupExpr {{.*}} '<dependent type>' lvalue (no ADL) = 'Concept' // CHECK-NEXT: | | | |-TemplateArgument type 'int' // CHECK-NEXT: | | | | `-BuiltinType {{.*}} 'int' -// CHECK-NEXT: | | | `-TemplateArgument type 'type-parameter-1-0' -// CHECK-NEXT: | | | `-TemplateTypeParmType {{.*}} 'type-parameter-1-0' dependent depth 1 index 0 +// CHECK-NEXT: | | | `-TemplateArgument type 'Y':'type-parameter-1-0' +// CHECK-NEXT: | | | `-TemplateTypeParmType {{.*}} 'Y' dependent depth 1 index 0 +// CHECK-NEXT: | | | `-TemplateTypeParm {{.*}} 'Y' // CHECK-NEXT: | | `-TypeTraitExpr {{.*}} 'bool' __is_deducible // CHECK-NEXT: | | |-DeducedTemplateSpecializationType {{.*}} 'Out2<double>::AInner' dependent // CHECK-NEXT: | | | `-name: 'Out2<double>::AInner' // CHECK-NEXT: | | | `-TypeAliasTemplateDecl {{.+}} AInner{{$}} -// CHECK-NEXT: | | `-ElaboratedType {{.*}} 'Inner<type-parameter-1-0>' sugar dependent -// CHECK-NEXT: | | `-TemplateSpecializationType {{.*}} 'Inner<type-parameter-1-0>' dependent +// CHECK-NEXT: | | `-ElaboratedType {{.*}} 'Inner<Y>' sugar dependent +// CHECK-NEXT: | | `-TemplateSpecializationType {{.*}} 'Inner<Y>' dependent // CHECK-NEXT: | | |-name: 'Inner':'Out<int>::Inner' qualified // CHECK-NEXT: | | | `-ClassTemplateDecl {{.+}} Inner{{$}} -// CHECK-NEXT: | | `-TemplateArgument type 'type-parameter-1-0' -// CHECK-NEXT: | | `-SubstTemplateTypeParmType {{.*}} 'type-parameter-1-0' +// CHECK-NEXT: | | `-TemplateArgument type 'Y' +// CHECK-NEXT: | | `-SubstTemplateTypeParmType {{.*}} 'Y' // CHECK-NEXT: | | |-FunctionTemplate {{.*}} '<deduction guide for Inner>' -// CHECK-NEXT: | | `-TemplateTypeParmType {{.*}} 'type-parameter-1-0' dependent depth 1 index 0 -// CHECK-NEXT: | |-CXXDeductionGuideDecl {{.*}} <deduction guide for AInner> 'auto (type-parameter-0-0) -> Inner<type-parameter-0-0>' -// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'type-parameter-0-0' +// CHECK-NEXT: | | `-TemplateTypeParmType {{.*}} 'Y' dependent depth 1 index 0 +// CHECK-NEXT: | | `-TemplateTypeParm {{.*}} 'Y' +// CHECK-NEXT: | |-CXXDeductionGuideDecl {{.*}} <deduction guide for AInner> 'auto (Y) -> Inner<Y>' +// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'Y' // CHECK-NEXT: | `-CXXDeductionGuideDecl {{.*}} used <deduction guide for AInner> 'auto (double) -> Inner<double>' implicit_instantiation // CHECK-NEXT: | |-TemplateArgument type 'double' // CHECK-NEXT: | | `-BuiltinType {{.*}} 'double' @@ -77,8 +79,8 @@ AFoo3 afoo3{0, 1}; // CHECK-NEXT: | |-UnresolvedLookupExpr {{.*}} '<dependent type>' lvalue (no ADL) = 'Concept' // CHECK-NEXT: | | |-TemplateArgument type 'int' // CHECK-NEXT: | | | `-BuiltinType {{.*}} 'int' -// CHECK-NEXT: | | `-TemplateArgument type 'type-parameter-0-1' -// CHECK-NEXT: | | `-TemplateTypeParmType {{.*}} 'type-parameter-0-1' dependent depth 0 index 1 +// CHECK-NEXT: | | `-TemplateArgument type 'V' +// CHECK-NEXT: | | `-TemplateTypeParmType {{.*}} 'V' dependent depth 0 index 1 template <typename... T1> struct Foo { @@ -88,16 +90,16 @@ struct Foo { template <typename...T2> using AFoo = Foo<T2...>; AFoo a(1, 2); -// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for AFoo> 'auto (type-parameter-0-0...) -> Foo<type-parameter-0-0...>' -// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'type-parameter-0-0...' pack +// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for AFoo> 'auto (T2...) -> Foo<T2...>' +// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'T2...' pack // CHECK-NEXT: | `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for AFoo> 'auto (int, int) -> Foo<int, int>' implicit_instantiation template <typename T> using BFoo = Foo<T, T>; BFoo b2(1.0, 2.0); -// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for BFoo> 'auto (type-parameter-0-0, type-parameter-0-0) -> Foo<type-parameter-0-0, type-parameter-0-0>' -// CHECK-NEXT: | | |-ParmVarDecl {{.*}} 'type-parameter-0-0' -// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'type-parameter-0-0' +// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for BFoo> 'auto (T, T) -> Foo<T, T>' +// CHECK-NEXT: | | |-ParmVarDecl {{.*}} 'T' +// CHECK-NEXT: | | `-ParmVarDecl {{.*}} 'T' // CHECK-NEXT: | `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for BFoo> 'auto (double, double) -> Foo<double, double>' implicit_instantiation namespace GH90209 { diff --git a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3-0x.cpp b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3-0x.cpp index ed445360c4fdd..b9ff26a7620db 100644 --- a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3-0x.cpp +++ b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p3-0x.cpp @@ -78,7 +78,7 @@ namespace std_example { template<class T> struct A { // expected-note {{candidate}} expected-note {{implicit deduction guide}} template<class U> A(T &&, U &&, int *); // expected-note {{[with T = int, U = int] not viable: expects an rvalue}} \ - // expected-note {{implicit deduction guide declared as 'template <class T, class U> A(T &&, type-parameter-0-1 &&, int *) -> A<T>'}} + // expected-note {{implicit deduction guide declared as 'template <class T, class U> A(T &&, U &&, int *) -> A<T>'}} A(T &&, int *); // expected-note {{requires 2}} \ // expected-note {{implicit deduction guide declared as 'template <class T> A(T &&, int *) -> A<T>'}} }; diff --git a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp index 2193be03ad9a3..5392573fcdb9d 100644 --- a/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp +++ b/clang/test/SemaCXX/cxx20-ctad-type-alias.cpp @@ -110,8 +110,8 @@ struct Foo { template <typename X, int Y> using Bar = Foo<X, sizeof(X)>; // expected-note {{candidate template ignored: couldn't infer template argument 'X'}} \ - // expected-note {{implicit deduction guide declared as 'template <typename X> requires __is_deducible(test9::Bar, Foo<type-parameter-0-0, sizeof(type-parameter-0-0)>) Bar(Foo<type-parameter-0-0, sizeof(type-parameter-0-0)>) -> Foo<type-parameter-0-0, sizeof(type-parameter-0-0)>'}} \ - // expected-note {{implicit deduction guide declared as 'template <typename X> requires __is_deducible(test9::Bar, Foo<type-parameter-0-0, sizeof(type-parameter-0-0)>) Bar(const type-parameter-0-0 (&)[sizeof(type-parameter-0-0)]) -> Foo<type-parameter-0-0, sizeof(type-parameter-0-0)>'}} \ + // expected-note {{implicit deduction guide declared as 'template <typename X> requires __is_deducible(test9::Bar, Foo<X, sizeof(X)>) Bar(Foo<X, sizeof(X)>) -> Foo<X, sizeof(X)>'}} \ + // expected-note {{implicit deduction guide declared as 'template <typename X> requires __is_deducible(test9::Bar, Foo<X, sizeof(X)>) Bar(const X (&)[sizeof(X)]) -> Foo<X, sizeof(X)>'}} \ // expected-note {{candidate template ignored: constraints not satisfied [with X = int]}} \ // expected-note {{cannot deduce template arguments for 'Bar' from 'Foo<int, 4UL>'}} @@ -138,13 +138,13 @@ namespace test11 { struct A {}; template<class T> struct Foo { T c; }; template<class X, class Y=A> -using AFoo = Foo<Y>; // expected-note {{candidate template ignored: could not match 'Foo<type-parameter-0-0>' against 'int'}} \ - // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<type-parameter-0-0>) AFoo(Foo<type-parameter-0-0>) -> Foo<type-parameter-0-0>'}} \ +using AFoo = Foo<Y>; // expected-note {{candidate template ignored: could not match 'Foo<Y>' against 'int'}} \ + // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<Y>) AFoo(Foo<Y>) -> Foo<Y>'}} \ // expected-note {{candidate template ignored: constraints not satisfied [with Y = int]}} \ // expected-note {{cannot deduce template arguments for 'AFoo' from 'Foo<int>'}} \ - // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<type-parameter-0-0>) AFoo(type-parameter-0-0) -> Foo<type-parameter-0-0>'}} \ + // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<Y>) AFoo(Y) -> Foo<Y>'}} \ // expected-note {{candidate function template not viable: requires 0 arguments, but 1 was provided}} \ - // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<type-parameter-0-0>) AFoo() -> Foo<type-parameter-0-0>'}} + // expected-note {{implicit deduction guide declared as 'template <class Y = A> requires __is_deducible(test11::AFoo, Foo<Y>) AFoo() -> Foo<Y>'}} AFoo s = {1}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments of 'AFoo'}} } // namespace test11 @@ -211,9 +211,9 @@ template<typename> concept False = false; template<False W> using BFoo = AFoo<W>; // expected-note {{candidate template ignored: constraints not satisfied [with V = int]}} \ // expected-note {{cannot deduce template arguments for 'BFoo' from 'Foo<int *>'}} \ - // expected-note {{implicit deduction guide declared as 'template <class V> requires __is_deducible(AFoo, Foo<type-parameter-0-0 *>) && __is_deducible(test15::BFoo, Foo<type-parameter-0-0 *>) BFoo(type-parameter-0-0 *) -> Foo<type-parameter-0-0 *>}} \ - // expected-note {{candidate template ignored: could not match 'Foo<type-parameter-0-0 *>' against 'int *'}} \ - // expected-note {{template <class V> requires __is_deducible(AFoo, Foo<type-parameter-0-0 *>) && __is_deducible(test15::BFoo, Foo<type-parameter-0-0 *>) BFoo(Foo<type-parameter-0-0 *>) -> Foo<type-parameter-0-0 *>}} + // expected-note {{implicit deduction guide declared as 'template <class V> requires __is_deducible(AFoo, Foo<V *>) && __is_deducible(test15::BFoo, Foo<V *>) BFoo(V *) -> Foo<V *>}} \ + // expected-note {{candidate template ignored: could not match 'Foo<V *>' against 'int *'}} \ + // expected-note {{template <class V> requires __is_deducible(AFoo, Foo<V *>) && __is_deducible(test15::BFoo, Foo<V *>) BFoo(Foo<V *>) -> Foo<V *>}} int i = 0; AFoo a1(&i); // OK, deduce Foo<int *> @@ -263,12 +263,12 @@ template<typename T> requires False<T> // expected-note {{because 'int' does not Foo(T) -> Foo<int>; template <typename U> -using Bar = Foo<U>; // expected-note {{could not match 'Foo<type-parameter-0-0>' against 'int'}} \ - // expected-note {{implicit deduction guide declared as 'template <typename U> requires __is_deducible(test18::Bar, Foo<type-parameter-0-0>) Bar(Foo<type-parameter-0-0>) -> Foo<type-parameter-0-0>'}} \ +using Bar = Foo<U>; // expected-note {{could not match 'Foo<U>' against 'int'}} \ + // expected-note {{implicit deduction guide declared as 'template <typename U> requires __is_deducible(test18::Bar, Foo<U>) Bar(Foo<U>) -> Foo<U>'}} \ // expected-note {{candidate template ignored: constraints not satisfied}} \ - // expected-note {{implicit deduction guide declared as 'template <typename T> requires False<type-parameter-0-0> && __is_deducible(test18::Bar, Foo<int>) Bar(type-parameter-0-0) -> Foo<int>'}} \ + // expected-note {{implicit deduction guide declared as 'template <typename T> requires False<T> && __is_deducible(test18::Bar, Foo<int>) Bar(T) -> Foo<int>'}} \ // expected-note {{candidate function template not viable}} \ - // expected-note {{implicit deduction guide declared as 'template <typename U> requires __is_deducible(test18::Bar, Foo<type-parameter-0-0>) Bar() -> Foo<type-parameter-0-0>'}} + // expected-note {{implicit deduction guide declared as 'template <typename U> requires __is_deducible(test18::Bar, Foo<U>) Bar() -> Foo<U>'}} Bar s = {1}; // expected-error {{no viable constructor or deduction guide for deduction of template arguments}} } // namespace test18 @@ -296,8 +296,8 @@ class Foo {}; // Verify that template template type parameter TTP is referenced/used in the // template arguments of the RHS. template <template<typename> typename TTP> -using Bar = Foo<K<TTP>>; // expected-note {{candidate template ignored: could not match 'Foo<K<template-parameter-0-0>>' against 'int'}} \ - // expected-note {{implicit deduction guide declared as 'template <template <typename> typename TTP> requires __is_deducible(test20::Bar, Foo<K<template-parameter-0-0>>) Bar(Foo<K<template-parameter-0-0>>) -> Foo<K<template-parameter-0-0>>'}} +using Bar = Foo<K<TTP>>; // expected-note {{candidate template ignored: could not match 'Foo<K<TTP>>' against 'int'}} \ + // expected-note {{implicit deduction guide declared as 'template <template <typename> typename TTP> requires __is_deducible(test20::Bar, Foo<K<TTP>>) Bar(Foo<K<TTP>>) -> Foo<K<TTP>>'}} template <class T> class Container {}; diff --git a/clang/test/SemaTemplate/deduction-guide.cpp b/clang/test/SemaTemplate/deduction-guide.cpp index 7b9ca4d83b020..043a4ccf56e36 100644 --- a/clang/test/SemaTemplate/deduction-guide.cpp +++ b/clang/test/SemaTemplate/deduction-guide.cpp @@ -68,7 +68,7 @@ using BT = B<char, 'x'>; // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 0 T // CHECK: |-NonTypeTemplateParmDecl {{.*}} 'T' depth 0 index 1 V // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 2 U -// CHECK: |-NonTypeTemplateParmDecl {{.*}} 'type-parameter-0-2' depth 0 index 3 W +// CHECK: |-NonTypeTemplateParmDecl {{.*}} 'U' depth 0 index 3 W // CHECK: |-CXXDeductionGuideDecl {{.*}} 'auto (X<W, V>) -> B<T, V>' // CHECK: | `-ParmVarDecl {{.*}} 'X<W, V>' // CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (X<nullptr, 'x'>) -> B<char, 'x'>' @@ -81,7 +81,7 @@ using BT = B<char, 'x'>; // CHECK: |-InjectedClassNameType {{.*}} 'B<T, V>' dependent // CHECK: `-TemplateSpecializationType {{.*}} 'X<W, V>' dependent // CHECK: |-TemplateArgument expr -// CHECK: | `-DeclRefExpr {{.*}} 'type-parameter-0-2' NonTypeTemplateParm {{.*}} 'W' 'type-parameter-0-2' +// CHECK: | `-DeclRefExpr {{.*}} 'U' NonTypeTemplateParm {{.*}} 'W' 'U' // CHECK: `-TemplateArgument expr // CHECK: `-DeclRefExpr {{.*}} 'T' NonTypeTemplateParm {{.*}} 'V' 'T' @@ -99,13 +99,13 @@ using CT = C<int>; // CHECK: | |-TemplateTypeParmDecl {{.*}} typename depth 1 index 0 X // CHECK: | `-NonTypeTemplateParmDecl {{.*}} 'X' depth 1 index 1 // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 2 U -// CHECK: |-NonTypeTemplateParmDecl {{.*}} 'type-parameter-0-2' depth 0 index 3 V +// CHECK: |-NonTypeTemplateParmDecl {{.*}} 'U' depth 0 index 3 V // CHECK: | `-TemplateArgument {{.*}} expr // CHECK: | `-IntegerLiteral {{.*}} 'int' 0 -// CHECK: |-CXXDeductionGuideDecl {{.*}} 'auto (A, Y<template-parameter-0-1>, type-parameter-0-2) -> C<A>' +// CHECK: |-CXXDeductionGuideDecl {{.*}} 'auto (A, Y<T>, U) -> C<A>' // CHECK: | |-ParmVarDecl {{.*}} 'A' -// CHECK: | |-ParmVarDecl {{.*}} 'Y<template-parameter-0-1>' -// CHECK: | `-ParmVarDecl {{.*}} 'type-parameter-0-2' +// CHECK: | |-ParmVarDecl {{.*}} 'Y<T>' +// CHECK: | `-ParmVarDecl {{.*}} 'U' // CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (int, Y<B>, int) -> C<int>' // CHECK: |-TemplateArgument type 'int' // CHECK: |-TemplateArgument template 'B' @@ -114,20 +114,20 @@ using CT = C<int>; // CHECK: |-ParmVarDecl {{.*}} 'int' // CHECK: |-ParmVarDecl {{.*}} 'Y<B>' // CHECK: `-ParmVarDecl {{.*}} 'int' -// CHECK: FunctionProtoType {{.*}} 'auto (A, Y<template-parameter-0-1>, type-parameter-0-2) -> C<A>' dependent trailing_return cdecl +// CHECK: FunctionProtoType {{.*}} 'auto (A, Y<T>, U) -> C<A>' dependent trailing_return cdecl // CHECK: |-InjectedClassNameType {{.*}} 'C<A>' dependent // CHECK: |-TemplateTypeParmType {{.*}} 'A' dependent depth 0 index 0 // CHECK: | `-TemplateTypeParm {{.*}} 'A' -// CHECK: |-ElaboratedType {{.*}} 'Y<template-parameter-0-1>' sugar dependent -// CHECK: | `-TemplateSpecializationType {{.*}} 'Y<template-parameter-0-1>' dependent +// CHECK: |-ElaboratedType {{.*}} 'Y<T>' sugar dependent +// CHECK: | `-TemplateSpecializationType {{.*}} 'Y<T>' dependent // CHECK: | `-TemplateArgument template -// CHECK: `-TemplateTypeParmType {{.*}} 'type-parameter-0-2' dependent depth 0 index 2 +// CHECK: `-TemplateTypeParmType {{.*}} 'U' dependent depth 0 index 2 template<typename ...T> struct D { // expected-note {{candidate}} \ // expected-note {{implicit deduction guide declared as 'template <typename ...T> D(D<T...>) -> D<T...>'}} template<typename... U> using B = int(int (*...p)(T, U)); template<typename U1, typename U2> D(B<U1, U2>*); // expected-note {{candidate}} \ - // expected-note {{implicit deduction guide declared as 'template <typename ...T, typename U1, typename U2> D(B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>'}} + // expected-note {{implicit deduction guide declared as 'template <typename ...T, typename U1, typename U2> D(B<U1, U2> *) -> D<T...>'}} }; int f(int(int, int), int(int, int)); // FIXME: We can't deduce this because we can't deduce through a @@ -141,14 +141,14 @@ using DT = D<int, int>; // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 0 ... T // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 1 U1 // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 2 U2 -// CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>' -// CHECK: `-ParmVarDecl {{.*}} 'B<type-parameter-0-1, type-parameter-0-2> *' -// CHECK: FunctionProtoType {{.*}} 'auto (B<type-parameter-0-1, type-parameter-0-2> *) -> D<T...>' dependent trailing_return +// CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (B<U1, U2> *) -> D<T...>' +// CHECK: `-ParmVarDecl {{.*}} 'B<U1, U2> *' +// CHECK: FunctionProtoType {{.*}} 'auto (B<U1, U2> *) -> D<T...>' dependent trailing_return // CHECK: |-InjectedClassNameType {{.*}} 'D<T...>' dependent -// CHECK: `-PointerType {{.*}} 'B<type-parameter-0-1, type-parameter-0-2> *' dependent -// CHECK: `-TemplateSpecializationType {{.*}} 'B<type-parameter-0-1, type-parameter-0-2>' sugar dependent alias -// CHECK: |-TemplateArgument type 'type-parameter-0-1' -// CHECK: |-TemplateArgument type 'type-parameter-0-2' +// CHECK: `-PointerType {{.*}} 'B<U1, U2> *' dependent +// CHECK: `-TemplateSpecializationType {{.*}} 'B<U1, U2>' sugar dependent alias +// CHECK: |-TemplateArgument type 'U1' +// CHECK: |-TemplateArgument type 'U2' // CHECK: `-FunctionProtoType {{.*}} 'int (int (*)(T, U)...)' dependent cdecl // CHECK: |-BuiltinType {{.*}} 'int' // CHECK: `-PackExpansionType {{.*}} 'int (*)(T, U)...' dependent expansions 2 @@ -232,17 +232,17 @@ F s(0); // CHECK: |-TemplateTypeParmDecl {{.*}} typename depth 0 index 1 U // CHECK: |-ParenExpr {{.*}} 'bool' // CHECK: | `-CXXBoolLiteralExpr {{.*}} 'bool' false -// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (type-parameter-0-1) -> F<>' -// CHECK: | `-ParmVarDecl {{.*}} 'type-parameter-0-1' +// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (U) -> F<>' +// CHECK: | `-ParmVarDecl {{.*}} 'U' // CHECK: `-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for F> 'auto (int) -> F<>' // CHECK: |-TemplateArgument integral ''x'' // CHECK: |-TemplateArgument type 'int' // CHECK: | `-BuiltinType {{.*}} 'int' // CHECK: `-ParmVarDecl {{.*}} 'int' -// CHECK: FunctionProtoType {{.*}} 'auto (type-parameter-0-1) -> F<>' dependent trailing_return cdecl +// CHECK: FunctionProtoType {{.*}} 'auto (U) -> F<>' dependent trailing_return cdecl // CHECK: |-InjectedClassNameType {{.*}} 'F<>' dependent // CHECK: | `-CXXRecord {{.*}} 'F' -// CHECK: `-TemplateTypeParmType {{.*}} 'type-parameter-0-1' dependent depth 0 index 1 +// CHECK: `-TemplateTypeParmType {{.*}} 'U' dependent depth 0 index 1 template<typename T> struct G { T t; }; @@ -259,7 +259,7 @@ AG ag = {1}; // Verify that the aggregate deduction guide for alias templates is built. // CHECK-LABEL: Dumping <deduction guide for AG> // CHECK: FunctionTemplateDecl -// CHECK: |-CXXDeductionGuideDecl {{.*}} 'auto (type-parameter-0-0) -> G<type-parameter-0-0>' +// CHECK: |-CXXDeductionGuideDecl {{.*}} 'auto (X) -> G<X>' // CHECK: `-CXXDeductionGuideDecl {{.*}} 'auto (int) -> G<int>' implicit_instantiation // CHECK: |-TemplateArgument type 'int' // CHECK: | `-BuiltinType {{.*}} 'int' @@ -281,7 +281,7 @@ struct Foo { template <typename U> using AFoo = Foo<G<U>>; // Verify that the require-clause from the Foo deduction guide is transformed. -// The D occurrence should be rewritten to G<type-parameter-0-0>. +// The D occurrence should be rewritten to G<U>. // // CHECK-LABEL: Dumping <deduction guide for AFoo> // CHECK: FunctionTemplateDecl {{.*}} implicit <deduction guide for AFoo> @@ -289,16 +289,16 @@ using AFoo = Foo<G<U>>; // CHECK-NEXT: |-BinaryOperator {{.*}} '&&' // CHECK-NEXT: | |-ParenExpr {{.*}} 'bool' // CHECK-NEXT: | | `-BinaryOperator {{.*}} 'bool' '==' -// CHECK-NEXT: | | |-UnaryExprOrTypeTraitExpr {{.*}} 'G<type-parameter-0-0>' +// CHECK-NEXT: | | |-UnaryExprOrTypeTraitExpr {{.*}} 'G<U>' // CHECK-NEXT: | | `-ImplicitCastExpr {{.*}} // CHECK-NEXT: | | `-IntegerLiteral {{.*}} // CHECK-NEXT: | `-TypeTraitExpr {{.*}} 'bool' __is_deducible // CHECK-NEXT: | |-DeducedTemplateSpecializationType {{.*}} 'AFoo' dependent // CHECK-NEXT: | | `-name: 'AFoo' // CHECK-NEXT: | | `-TypeAliasTemplateDecl {{.+}} AFoo -// CHECK-NEXT: | `-TemplateSpecializationType {{.*}} 'Foo<G<type-parameter-0-0>>' dependent -// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for AFoo> 'auto (G<type-parameter-0-0>) -> Foo<G<type-parameter-0-0>>' -// CHECK-NEXT: | `-ParmVarDecl {{.*}} 'G<type-parameter-0-0>' +// CHECK-NEXT: | `-TemplateSpecializationType {{.*}} 'Foo<G<U>>' dependent +// CHECK: |-CXXDeductionGuideDecl {{.*}} implicit <deduction guide for AFoo> 'auto (G<U>) -> Foo<G<U>>' +// CHECK-NEXT: | `-ParmVarDecl {{.*}} 'G<U>' // CHECK-NEXT: `-CXXDeductionGuideDecl {{.*}} implicit used <deduction guide for AFoo> 'auto (G<int>) -> Foo<G<int>>' implicit_instantiation // CHECK-NEXT: |-TemplateArgument type 'int' // CHECK-NEXT: | `-BuiltinType {{.*}} 'int' @@ -321,20 +321,20 @@ namespace TTP { // CHECK-NEXT: |-TemplateTypeParmDecl {{.+}} class depth 0 index 0 T{{$}} // CHECK-NEXT: |-TemplateTemplateParmDecl {{.+}} depth 0 index 1 TT{{$}} // CHECK-NEXT: | `-TemplateTypeParmDecl {{.+}} class depth 1 index 0{{$}} -// CHECK-NEXT: |-CXXDeductionGuideDecl {{.+}} 'auto (template-parameter-0-1<T>) -> B<T>'{{$}} -// CHECK-NEXT: | `-ParmVarDecl {{.+}} 'template-parameter-0-1<T>'{{$}} +// CHECK-NEXT: |-CXXDeductionGuideDecl {{.+}} 'auto (TT<T>) -> B<T>'{{$}} +// CHECK-NEXT: | `-ParmVarDecl {{.+}} 'TT<T>'{{$}} // CHECK-NEXT: `-CXXDeductionGuideDecl {{.+}} 'auto (A<int>) -> TTP::B<int>' // CHECK-NEXT: |-TemplateArgument type 'int' // CHECK-NEXT: | `-BuiltinType {{.+}} 'int'{{$}} // CHECK-NEXT: |-TemplateArgument template 'TTP::A'{{$}} // CHECK-NEXT: | `-ClassTemplateDecl {{.+}} A{{$}} // CHECK-NEXT: `-ParmVarDecl {{.+}} 'A<int>':'TTP::A<int>'{{$}} -// CHECK-NEXT: FunctionProtoType {{.+}} 'auto (template-parameter-0-1<T>) -> B<T>' dependent trailing_return cdecl{{$}} +// CHECK-NEXT: FunctionProtoType {{.+}} 'auto (TT<T>) -> B<T>' dependent trailing_return cdecl{{$}} // CHECK-NEXT: |-InjectedClassNameType {{.+}} 'B<T>' dependent{{$}} // CHECK-NEXT: | `-CXXRecord {{.+}} 'B'{{$}} -// CHECK-NEXT: `-ElaboratedType {{.+}} 'template-parameter-0-1<T>' sugar dependent{{$}} -// CHECK-NEXT: `-TemplateSpecializationType {{.+}} 'template-parameter-0-1<T>' dependent{{$}} -// CHECK-NEXT: |-name: 'template-parameter-0-1' qualified +// CHECK-NEXT: `-ElaboratedType {{.+}} 'TT<T>' sugar dependent{{$}} +// CHECK-NEXT: `-TemplateSpecializationType {{.+}} 'TT<T>' dependent{{$}} +// CHECK-NEXT: |-name: 'TT':'template-parameter-0-1' qualified // CHECK-NEXT: | `-TemplateTemplateParmDecl {{.+}} depth 0 index 1 // CHECK-NEXT: `-TemplateArgument type 'T':'type-parameter-0-0'{{$}} // CHECK-NEXT: `-TemplateTypeParmType {{.+}} 'T' dependent depth 0 index 0{{$}} _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
