Help with integral template argument suffix and cast printing


I am a little stuck with and would really appreciate any help.

I am trying to get the proper suffixes in the error messages for the following two examples -

template struct S {};
template<> struct S<1> { using type = int };
S<1L>::type t;

which should give the error message with a suffix -
error: no type named ‘type’ in ‘S<1L>’; did you mean ‘S<1>::type’?


template struct enable_if_unsigned_long_long {};
template <> struct enable_if_unsigned_long_long<1> { typedef int type; };
void test_unsigned_long_long() { enable_if_unsigned_long_long<2>::type i; }

which should give no suffix in the error message -
error: no type named ‘type’ in ‘enable_if_unsigned_int<2>’; did you mean ‘enable_if_unsigned_int<1>::type’?

I am trying to find the correct combination that would enable suffix in the first case, but not in the second case. I have been tinkering with checks for DeducedType and DependentType, but always either the suffixes are disabled for both the cases, or enabled for both the cases.

Can anyone please provide any insight on how to proceed?


I would try replacing

else if (auto *DT = T->getContainedDeducedType())


else if (auto *DT = T->getAs())

I think that is what you want anyway, since getContainedDeducedType seems to look not only through type sugar but through pointee types, array element types, etc.

To be sure, your example still should have worked using getContainedDeducedType but I think GetContainedDeducedTypeVisitor may have a problem in its implementation: it doesn’t handle all the possible sugar types. In this case, you probably have a SubstTemplateTypeParmType, and I don’t see a VisitSubstTemplateTypeParmType implementation in there anywhere, so it is probably returning nullptr instead of desugaring and continuing to search. That’s my best guess anyway from my perusal.

If this change works, it is probably another reason to replace stuff like GetContainedDeducedTypeVisitor with a more advanced getAs(), with an extra template param that would allow you to look through e.g. pointee types, element types, function return types etc. when desired.

If that doesn’t work though, disregard. Good luck,


That change does not work :frowning:

Thanks though!

The issue may be that the proper sugar isn’t being stored in the integral type when the TemplateArgument is created, so that there is no way to distinguish a non-deduced BuiltInType from a deduced one.

The type of the NonTypeTemplateParmDecl N in

template struct S {}` is an AutoType — so far so good.

But the type of the integral TemplateArgument ‘1’ in S<1>, though, seems to be a BuiltInType — no sugar atop it, nothing to distinguish it from the situation where N had a BuiltInType instead of an AutoType.

If I understand DeducedTypes correctly, when they are substituted, they should remain as sugar atop the substitution (someone correct me if I’m wrong), and that does not seem to happen here.

If others agree this is the issue, I would imagine you will have to dig around to figure out where the template argument is being created, and wrap the integral’s type in an AutoType. Then testing if getAs() before testing getAs() should tell you when your BuiltInType was deduced.

That’s my last best guess anyway. Good luck,


This is where we get the Integral type from the TemplateArgument -

I tried -
bool flag = false;
if (auto *autoT = T->getAs()) {
flag = true;

But flag is not true for the example -

template struct S {};
template<> struct S<1> { using type = int };
S<1L>::type t;

Am I making a mistake in getting the AutoType?

You’re not making a mistake, the template argument was not constructed with the proper type sugar, which means there’s nothing you can do to distinguish deduced from non-deduced template arguments as is.

I think the following will solve it; change line to the following:

QualType CanonParamType = Context.getCanonicalType(ParamType);

// FIXME: this renders CanonParamType non-canonical, but…why do we need
// a canonical type in the first place to construct template args?
// Seems to just lose type sugar info prematurely.
if (Param->getType()->getAs())
CanonParamType = Context.getAutoType(CanonParamType, AutoTypeKeyword::Auto,
false, false);


  • |

See if that gets your thing to work (both T->getAs() and T->getAs() should return non-null for deduced builtins, allowing you to T->getAs() use distinguish deduced from non-deduced), then see if it breaks any others tests (it shouldn’t, because nothing should depend on template arguments being constructed with a canonical type at that point — I think we should be able to get rid of CanonParamType and use ParamType in its place in that function).

Good luck,


Actually ParamType may already be constructed with the proper AutoType sugar, so just try changing that line to

QualType CanonParamType = ParamType;

  • |

If that works and doesn’t break any tests, then get rid of CanonParamType and replace it with ParamType in that function.

  • Dave

That worked! Thanks. I have updated the diff in
(I tried to add you as a reviewer, but I was unable to find your phabricator id)