[clang-format] qualifier alignment setting is not respected on references to template type parameter

[alimpfard]

Given the following .clang-format (and clang-format 14.0.0)

---
Language: Cpp
QualifierAlignment: Right

the following snippet is not formatted correctly (it remains unchanged)

template <typename T> using Foo = const volatile T;

however the following does get replaced with the qualifiers moving to the right:

template <typename T> using Foo = const volatile int;
// turns into:
// template <typename T> using Foo = int const volatile;

[llvmbot]

@llvm/issue-subscribers-clang-format

[mydeveloperday]

I think this is a duplicate of #53981

[alimpfard]

The symptoms don't immediately seem to be the same (reference to typename vs argument), but I haven't tested with 28bb040 applied.

[mydeveloperday]

previously where we saw a ALL caps word like TYPE we assumed it to be a macro, this fix relaxes that a little and says a 1 word like T K U V can be considered an identifier and as such used in the qualifier alignment

[mydeveloperday]

Hmm... you may be correct the follow producer fails

TEST_F(QualifierFixerTest, TemplatesRightVolatile) {
  FormatStyle Style = getLLVMStyle();
  Style.QualifierAlignment = FormatStyle::QAS_Right;
  Style.QualifierOrder = {"type", "volatile", "const"};

  verifyFormat("template <typename T> using Foo = int volatile const;",
               "template <typename T> using Foo = const volatile int;", Style);
  verifyFormat("template <typename T> using Foo = T volatile const;",
               "template <typename T> using Foo = const volatile T;", Style);
}

[mydeveloperday]

This is really a special case that is not covered, take the following tests, the last one will fail because it does't have a "variable

  verifyFormat("int volatile const a;", "const volatile int a;", Style);
  verifyFormat("int volatile const Foo;", "const volatile int Foo;", Style);
  verifyFormat("int volatile const T;", "const volatile int T;", Style);
  verifyFormat("T volatile const;", "const volatile T;", Style);

but this would work,

verifyFormat("T volatile const;", "const volatile T;", Style);

To the same extent, this won't work because it doesn't see the T as a type but as an identifier

 verifyFormat("T volatile const a;", "const volatile T a;", Style);

we air on the side of caution for now, but in time we might find a way of doing this. Qualifier alignment is going to work much better with simple types. For us to have more confidence to make changes we may need to introduce the ability to give clang-format a little more type information to certain identifiers are types something like

QUALIFER_TYPES= [ 'T', 'Foo' ]

or maybe just reduce 'TypenameMacros'

[alimpfard]

🤔 Shouldn't clang-format be able to infer the fact that T is a type based on the fact that the "expression" it's in is a type specifier?
it appears to me that clang-format does have some concept of type-"expression" vs value-"expression" as these are formatted differently:

typedef T * V;    // typedef T* V;
typedef 4 * V;    // typedef 4 * V;
decltype(T * V);  // decltype(T * V); 

[rymiel]

This should be fixed by cd7ab4b