Class template argument deduction with using fails, apparently incorrectly

[geometrian]

Consider the following simple C++20 example:

template< class Tval, class Targ >
struct Foo {
	Foo( Targ arg ) {}
};

template< class Targ >
using FooF = Foo< float, Targ >;

void test() {
	FooF foo( 6 );
}

GCC and MSVC compile it happily. However, Clang (tested 18.0.0 d328512) claims the using doesn't amount to a class template:

<source>:10:7: error: alias template 'FooF' requires template arguments; argument deduction only allowed for class templates
   10 |         FooF foo( 6 );
      |              ^

This is a bit strange—it's true the using is not a class template per-se, but it is an alias for one. Indeed, my reading of the documentation (emphasis mine):

When a function-style cast or declaration of a variable uses the name of an alias template A without an argument list as the type specifier, where A is defined as an alias of B, the scope of B is non-dependent, and B is either a class template or a similarly-defined alias template, deduction will proceed in the same way as for class templates

—suggests that it should work, but I am not enough of a language lawyer to say for sure.

[llvmbot]

@llvm/issue-subscribers-c-17

Author: Ian Mallett (geometrian)

Consider the following simple C++20 example: ```cpp template< class Tval, class Targ > struct Foo { Foo( Targ arg ) {} };

template< class Targ >
using FooF = Foo< float, Targ >;

void test() {
FooF foo( 6 );
}

GCC and MSVC compile it happily. However, Clang (tested 18.0.0 d3285123bc9c2e170c8aa7e418c132119bc7aaf1) claims the `using` doesn't amount to a class template:
```text
<source>:10:7: error: alias template 'FooF' requires template arguments; argument deduction only allowed for class templates
   10 |         FooF foo( 6 );
      |              ^

This is a bit strange—it's true the using is not a class template per-se, but it is an alias for one. Indeed, my reading of the documentation (emphasis mine):
> When a function-style cast or declaration of a variable uses the name of an alias template A without an argument list as the type specifier, where A is defined as an alias of B<ArgList>, the scope of B is non-dependent, and B is either a class template or a similarly-defined alias template, deduction will proceed in the same way as for class templates

—suggests that it should work, but I am not enough of a language lawyer to say for sure.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Ian Mallett (geometrian)

Consider the following simple C++20 example: ```cpp template< class Tval, class Targ > struct Foo { Foo( Targ arg ) {} };

template< class Targ >
using FooF = Foo< float, Targ >;

void test() {
FooF foo( 6 );
}

GCC and MSVC compile it happily. However, Clang (tested 18.0.0 d3285123bc9c2e170c8aa7e418c132119bc7aaf1) claims the `using` doesn't amount to a class template:
```text
<source>:10:7: error: alias template 'FooF' requires template arguments; argument deduction only allowed for class templates
   10 |         FooF foo( 6 );
      |              ^

This is a bit strange—it's true the using is not a class template per-se, but it is an alias for one. Indeed, my reading of the documentation (emphasis mine):
> When a function-style cast or declaration of a variable uses the name of an alias template A without an argument list as the type specifier, where A is defined as an alias of B<ArgList>, the scope of B is non-dependent, and B is either a class template or a similarly-defined alias template, deduction will proceed in the same way as for class templates

—suggests that it should work, but I am not enough of a language lawyer to say for sure.

[Backl1ght]

I think this is p1814r0, which is not yet implemented in clang.

[shafik]

Confirmed: https://godbolt.org/z/74db3E5Tq

[llvmbot]

@llvm/issue-subscribers-c-20

Author: Ian Mallett (geometrian)

Consider the following simple C++20 example: ```cpp template< class Tval, class Targ > struct Foo { Foo( Targ arg ) {} };

template< class Targ >
using FooF = Foo< float, Targ >;

void test() {
FooF foo( 6 );
}

GCC and MSVC compile it happily. However, Clang (tested 18.0.0 d3285123bc9c2e170c8aa7e418c132119bc7aaf1) claims the `using` doesn't amount to a class template:
```text
<source>:10:7: error: alias template 'FooF' requires template arguments; argument deduction only allowed for class templates
   10 |         FooF foo( 6 );
      |              ^

This is a bit strange—it's true the using is not a class template per-se, but it is an alias for one. Indeed, my reading of the documentation (emphasis mine):
> When a function-style cast or declaration of a variable uses the name of an alias template A without an argument list as the type specifier, where A is defined as an alias of B<ArgList>, the scope of B is non-dependent, and B is either a class template or a similarly-defined alias template, deduction will proceed in the same way as for class templates

—suggests that it should work, but I am not enough of a language lawyer to say for sure.

[hokein]

This is a missing feature in clang which is already tracking in #54051. I'm closing it as this is a duplication.

[hokein]

@Backl1ght, I see you self-assigned to this issue, are you working on it? (I also have a plan to look at it).

[Backl1ght]

@hokein I'd like to work on it, but I have little time recently. I think it would be better if you can pick it up.