Template arguments can't be used in attributes

[abrachet]

constexpr int constexpr_var = 101;
[[gnu::constructor(constexpr_var)]] void a() {}

template <int TemplateArg>
[[gnu::constructor(TemplateArg)]] void b() {}

template void b<101>();

This code compiles fine with gcc, and clang can successfully compile a but errors on b with "'constructor' attribute requires an integer constant".

Note clang doesn't error on the instantiation of b but rather on the template definition. so even if the template void b<101>(); line is removed clang still gives an error.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

``` constexpr int constexpr_var = 101; [[gnu::constructor(constexpr_var)]] void a() {}

template <int TemplateArg>
[[gnu::constructor(TemplateArg)]] void b() {}

template void b<101>();

This code compiles fine with gcc, and clang can successfully compile `a` but errors on `b` with "'constructor' attribute requires an integer constant".

Note clang doesn't error on the instantiation of b but rather on the template definition. so even if the `template void b<101>();` line is removed clang still gives an error.
</details>

[shafik]

It looks like the diagnostic is from err_attribute_argument_type but not sure what the trigger code is right now.

CC @erichkeane @AaronBallman who may know if this is a purposeful restriction or not.

[abrachet]

It's in handleConstructorAttr which eventually bottoms out in getIntegerConstantExpr

[erichkeane]

It's in handleConstructorAttr which eventually bottoms out in getIntegerConstantExpr

Was just confirming that :) yeah, unfortunately the infrastructure to have attributes work with templates is pretty manual, so each individual attribute has to be programmed to work with template arguments individually. In this case, the handleConstructorAttr isn't template-aware, so it is just looking for an integral argument. You have to change the definition in Attr.td to be an ExprArgument, then set TemplateDependent, then I think the function gets re-called with the instantiated version.

There's quite a few examples on how to do it, but GuardedBy is pretty easy to copy, as this should be. Basically, the 'handle' function will be called 1x for uninstantiated, then 1x for each instantiation, and can be re-checked. This isn't a bad 'beginner' bug if this is important to you.

[llvmbot]

@llvm/issue-subscribers-good-first-issue

```c++ constexpr int constexpr_var = 101; [[gnu::constructor(constexpr_var)]] void a() {}

template <int TemplateArg>
[[gnu::constructor(TemplateArg)]] void b() {}

template void b<101>();

This code compiles fine with gcc, and clang can successfully compile `a` but errors on `b` with "'constructor' attribute requires an integer constant".

Note clang doesn't error on the instantiation of b but rather on the template definition. so even if the `template void b<101>();` line is removed clang still gives an error.
</details>

[jmintb]

Can I have a go at this? :)

[cor3ntin]

@jmintb Of course!

[erichkeane]

@jmintb : It actually looks like @abrachet has a review up to do this. See above.

[jmintb]

Ah yes I missed that, my bad

[abrachet]

@jmintb sorry for the late reply. Feel free to commandeer that patch. I likely won't have time to look at it for a little while

[erichkeane]

Unassigning as @jmintb seems to have not made progress on this in more than a year. Feel free to ask for reassignment if you wish to pick this up/pick this up again!