Using a designated-initializer-list as a template argument makes the function call ambiguous

[ckwastra]

Test code (CE):

struct A {
  int a;
};
struct B {
  int b;
};
template <A> void f();
template <B> void f();

// ✓ - GCC/Clang: OK
// ✗ - EDG:
//     - error: expected an expression
//     - error: expected a ")"
// ✗ - MSVC: https://developercommunity.visualstudio.com/t/Using-an-initializer-list-as-a-template/10994813
using T1 = decltype(f<{.a = 42}>());
using T2 = decltype(f<A{.a = 42}>()); // OK

// ✓ - GCC: OK
// ✗ - Clang:
//     - error: call to 'f' is ambiguous
//     - note: candidate function [with $0 = A{0}]
//     - note: candidate function [with $0 = B{42}]
// ✗ - EDG/MSVC: same as for `T1` above
using T3 = decltype(f<{.b = 42}>());
using T4 = decltype(f<B{.b = 42}>()); // OK

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: Vincent X (ckwastra)

Test code ([CE](https://godbolt.org/z/a1xqKPxdd)):

struct A {
  int a;
};
struct B {
  int b;
};
template <A> void f();
template <B> void f();

// ✓ - GCC/Clang: OK
// ✗ - EDG:
//     - error: expected an expression
//     - error: expected a ")"
// ✗ - MSVC: https://developercommunity.visualstudio.com/t/Using-an-initializer-list-as-a-template/10994813
using T1 = decltype(f<{.a = 42}>());
using T2 = decltype(f<A{.a = 42}>()); // OK

// ✓ - GCC: OK
// ✗ - Clang:
//     - error: call to 'f' is ambiguous
//     - note: candidate function [with $0 = A{0}]
//     - note: candidate function [with $0 = B{42}]
// ✗ - EDG/MSVC: same as for `T1` above
using T3 = decltype(f<{.b = 42}>());
using T4 = decltype(f<B{.b = 42}>()); // OK

[Backl1ght]

while processing using T1 = decltype(f<{.a = 42}>());, f has 2 candidates: instantiated f<A> and uninstantiated f<B>, only the first one is viable.

while processing using T3 = decltype(f<{.b = 42}>());, f has 2 candidates: instantiated f<A> and instantiated f<B>, both of them are viable.

This is why we success on T1 but fail on T3.

I also find something interesting, if we change the order of template <A> void f(); and template <B> void f();, we will success on T3 but fail on T1.

[Backl1ght]

There are something wrong here, as we can init a A usnig {.b = 42}, but can not init a B using {.a = 42}.

llvm-project/clang/lib/Sema/SemaTemplate.cpp

Lines 7281 to 7290 in 577b519

	if (isa<InitListExpr>(DeductionArg) || ParamType->isRecordType()) {
	InitializationKind Kind = InitializationKind::CreateForInit(
	StartLoc, /*DirectInit=*/false, DeductionArg);
	Expr *Inits[1] = {DeductionArg};
	InitializedEntity Entity =
	InitializedEntity::InitializeTemplateParameter(ParamType, Param);
	InitializationSequence InitSeq(*this, Entity, Kind, Inits);
	ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Inits);
	if (Result.isInvalid() || !Result.get())
	return ExprError();

[Backl1ght]

After performing check of init a variable of type B using {.b =42}, we cache KnownField. While performaning check of init a variable of A using {.b = 42}, we use the cache and does not check whether the designator field match or not.

llvm-project/clang/lib/Sema/SemaInit.cpp

Lines 2939 to 2957 in 545c302

	FieldDecl *KnownField = D->getFieldDecl();
	if (!KnownField) {
	const IdentifierInfo *FieldName = D->getFieldName();
	ValueDecl *VD = SemaRef.tryLookupUnambiguousFieldDecl(RD, FieldName);
	if (auto *FD = dyn_cast_if_present<FieldDecl>(VD)) {
	KnownField = FD;
	} else if (auto *IFD = dyn_cast_if_present<IndirectFieldDecl>(VD)) {
	// In verify mode, don't modify the original.
	if (VerifyOnly)
	DIE = CloneDesignatedInitExpr(SemaRef, DIE);
	ExpandAnonymousFieldDesignator(SemaRef, DIE, DesigIdx, IFD);
	D = DIE->getDesignator(DesigIdx);
	KnownField = cast<FieldDecl>(*IFD->chain_begin());
	}
	if (!KnownField) {
	if (VerifyOnly) {
	++Index;
	return true; // No typo correction when just trying this out.
	}