C++ constructor interpreted as function when rvalue and using parenthesis, preventing template deduction for aliases

[mld2443]

https://godbolt.org/z/fPvqG4Txx

template <int> class A {};
A() -> A<0>;

template <int ARG>
using B = A<ARG>;

static_assert(sizeof(B()));

GCC deduces B to be a type alias for A and interprets B() as instantiation using deduction guides. clang interprets rvalue as an alias to a function instead of a type constructor, and the template argument deductions are incorrectly rejected.

In order to convince clang that B is a type and not a function, we can use braced initialization, B{}.

clang and MSVC both consider this ill-formed, however I think GCC is correct here.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Matt (mld2443)

https://godbolt.org/z/fPvqG4Txx ```cpp template <int> class A {}; A() -> A<0>;

template <int ARG>
using B = A<ARG>;

static_assert(sizeof(B()));

GCC deduces `B` to be a type alias for `A` and interprets `B()` as instantiation using deduction guides. clang interprets rvalue as an alias to a function instead of a type constructor, and the template argument deductions are incorrectly rejected.

In order to convince clang that `B` is a type and not a function, we can use braced initialization, `B{}`.

clang and MSVC both consider this ill-formed, however I think GCC is correct here.
</details>

[keinflue]

I think Clang is correct here.

sizeof(B()) is ambiguous following the grammar.

The operand of sizeof can be a unary-expression, which (B()) is if B() is interpreted as functional-style cast.

But the operand can also be a parenthesized type-id and B() is a syntactically a type-id, because the name introduced by an alias template is a template-name ([temp.alias]/1), which is a (simple-)type-specifier usable in the type-id's type-specifier-seq.

Whenever a construct can be interpreted syntactically as type-id then this interpretation is chosen. See [dcl.ambig.res]/2.

So (B()) is not interpreted as expression, but it semantically fails as type-id later in the analysis.

[zygoloid]

I agree. B here is a type according to the grammar, so B() is interpreted as a function type.

(I wrote up a resolution to CWG2228 that would cause this to be allowed, but I haven't had time to follow up on it.)

[zygoloid]

The status of the corresponding language issue is tracked in EWG issue 1376. For now there's no clear suggestion that a language rule change will be made, so I'm closing this as "not planned". We can revisit if and when there's progress on the EWG issue.