[clang-format] Add enforcement of consistent `class`/typename` keyword for template arguments

[avogelsgesang]

Summary

Template argument types can be introduced using either the class or
the typename argument. While there are good arguments for both styles,
usually one wants to use one style consistently across a project.

This commit adds a TemplateArgumentKeyword option which can be used
to format all template arguments consistently using either the class
or the typename keyword.

Implementationwise, it closely follows in the footsteps of D69764, i.e.
it adds a new TemplateArgumentKeywordFixer pass which creates the
appropriate replacements.

[avogelsgesang]

Fix code formatting

[avogelsgesang]

Adding reviewers from D69764 to this change because I think it falls into the same category: It replaces tokens and could thereby potentially break code

[HazardyKnusperkeks]

Nice change, some small notes from me.

clang/docs/ClangFormatStyleOptions.rst

4003

Have you edited this by hand? It is on a different (the right) position than in Format.h.

clang/include/clang/Format/Format.h

1963

Please sort (as good as possible, I know some things are out of order).

clang/lib/Format/Format.cpp

144–145

This is what is printed in the documentation, if generated automatically.

1238

Drop this blank line.

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

46

I think you should rename it to TokenKindToReplace or something like that.
A is(BadToken) can be misleading.

50

Should never happen, right? Assert on that.

52

Why is that? It is certainly possible to have that configuration and we should not assert on possible user input. Either error out or handle it. I think we should be on the safe side an pretend auto is before 17. Add a note to the documentation about that.

81

assert on non nullness

94

Could be located outside of the loop.

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

168

Just to be sure add some tests with incomplete code? E.g.

template<typename

[avogelsgesang]

Thank you for the quick review, @HazardyKnusperkeks!

I addressed most of your comments by fixing my code.
In two cases, I think there was a misunderstanding and I didn't apply your proposed changes, yet.
See my inline replies re "assert on non nullness" and "typename vs Typename in configuration".
If you still think, I should apply your proposed changes, please let me know. I don't have strong opinions on those points and am happy to do so.

clang/docs/ClangFormatStyleOptions.rst

4003

No, this file is auto-generated using the dump_format_style.py script. Afaict, it sorts the entries alphabetically during generating the docs.

clang/include/clang/Format/Format.h

1963

moved after TabWidth

clang/lib/Format/Format.cpp

144–145

The documentation is currently automatically generated. I used the additional comments in Format.h to overwrite the "in configuration" values:

/// ...
TAS_Leave,
/// ...
TAS_Typename, // typename
/// ...
TAS_Class // class

Note the additional comments after TAS_Typename and TAS_Class. They overwrite the "in configuration" names used by dump_format_style.py. The same trick is used, e.g., for the LanguageStandard enum.

Given that using lowercase typename and class still allow for auto-generated documentation, do yous still want me to switch to uppercase Typename/Class?

Personally, I do prefer lowercase here because the language keywords are also lowercase. Are there any other reasons except for auto-generated documentation why you would prefer uppercase config values?

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

46

Good point! Done.

50

yes, this should be unreachable. I added an assert.

Out of curiosity/slightly off-topic: where does clang-format stand re "defensive programming"? "Fail fast, fail often", or rather "don't trust your callers and handle as many situations as possible as gracefully as possible"?

52

I was under the false impression that deriveLocalStyle in Format.cpp would always replace auto by one of the actual versions. I was wrong about that.

Thanks for catching this!

I updated the code and added a test case for this particular case

81

nullness was checked already in line 75:

if (Tok->isNot(TT_TemplateOpener) || !Tok->MatchingParen) {

Do you still want me to add this assert? Should I maybe restructure the code somehow to make it easier to understand? Or are you fine with leaving it as is?

94

I agree it could be moved outside the loop. Should it, though?

Having it inside the loop makes the code slightly easier to read by keeping the definition closer to its usage. And performancewise, I do trust the compiler to do a decent job here.

Or am I somehow misguided in my judgement here?

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

168

good point, added a couple of test cases for partial inputs, also including your particular example

[curdeius]

Looks nice already. Thanks for working on this.

clang/include/clang/Format/Format.h

3691

Nit.

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

56

Isn't it a better name?

66

Could we check KeepTemplateTypenameKW and early return here?
The optimizer might do some job, but I doubt it will get rid of the unnecessary finding of template keyword etc.
We could maybe avoid this variable altogether and return inside the switch, no?

70

Please finish comments with full stops, here and below.

76

clang/lib/Format/TemplateArgumentKeywordFixer.h

13

Or even better, make it closer to what's in cpp file.

37

Please make the comments consistent with other files.

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

88

Second argument can be removed if you add an overload having Expected=Code, so as to match verifyFormat in other files.

156

Don't repeat comments, please. It's the same as below in deduction guides test.

[avogelsgesang]

Thank you for your review, @curdeius!

I updated my change to address most of your comments.
Regarding "KeepTemplateTemplateKW", I think we had a misunderstanding (see replies to inline comments).
Could you take a 2nd look at those comments?

clang/include/clang/Format/Format.h

3691

Good catch!

I just copied that phrase from QualifierAlignment and overlooked that I also copied the typo. Fixed the typo in both locations.

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

56

This flag is actually about the usage of the class keyword instead of the typename keyword for template-template arguments.
true means: "Keep using the class instead of the typename keyword for template-template arguments."

I think the name KeepTemplateTypenameKW is wrong. "[...]TypenameKW = true" would mean "use typename instead of class" to me, and that's exactly the opposite way around.

As such, I think KeepTemplateTemplateKW is in fact the better name. If we want to make it even more explicit, we could also use KeepTemplateTemplateClassKW. What do you think?

66

I think you misunderstood the semantics of KeepTemplateTypenameKW? Or did I misunderstand your comment?

For both KeepTemplateTemplateKW = true and KeepTemplateTemplateKW = false, the loop below still reformats class to typename.

E.g., for the input

template<template<class> class X>

and KeepTemplateTemplateKW = true, we produce

template<template<typename> class X>

For the same input with KeepTemplateTemplateKW = false, we produce

template<template<typename> typename X>

70

Fixed here and all other places I could find in my change

clang/lib/Format/TemplateArgumentKeywordFixer.h

37

Consistent with which other files?
My comments here are consistent with NamespaceEndCommentsFixer.h and QualifierAlignmentFixer.h which I used for reference while writing this change

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

156

removed comment in both test cases. Reading it again, I agree that the comment didn't provide much value in the first place

[avogelsgesang]

Fix namespace comment

[avogelsgesang]

clang/lib/Format/TemplateArgumentKeywordFixer.h

37

ok, now I understood what you meant...
You meant consistency with the other files in this commit, in particular with the corresponding cpp file TemplateArgumentKeywordFixer.h.

Fun fact: I copied this inconsistency from NamespaceEndCommentsFixer.h/.cpp which also use different comment styles between .h and .cpp.

I updated my change to consistently use the // namespace style

[curdeius]

Thanks for addressing the comments quickly. I'll have one more thorough look in the coming days.

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

56

I did understand it correctly that it is about class keyword in template template parameters, but my brain somehow melted down the road:). You can keep the name as is.

66

As above, forget my previous comment.

[• Quuxplusone]

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

119

My personal recommended style is that the programmer uses template<class> consistently and therefore anytime you see the (more arcane) typename keyword it's probably necessary for (more arcane) reasons. You cover some arcane uses of typename above, but I think this one is conspicuously missing:
https://godbolt.org/z/fa9TM4nrr

template<class T, typename T::Nested V>
void f();

You can handle this by looking for :: after the identifier, and if you find it, then typename should be kept as-is. In fact, if you find any token other than , = > after the identifier, something arcane might be happening and it'd be best to keep typename as-is.

Vice versa, template<class C*> can't be rewritten as template<typename C*>; again, I think the right approach is to leave the human's choice alone if you see anything other than , = > after the identifier.

In general, the problems of "Can this typename be rewritten as class" and vice versa are probably undecidable, so don't get too carried away with trying to be perfect as long as you hit all the most common cases anyone can think of. https://quuxplusone.github.io/blog/2019/12/27/template-typename-fun/

[• Quuxplusone]

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

56

IIUC, it feels like the boolean should be named UseClassKWInTemplateTemplates, and it shouldn't have anything to do with Keeping the human's choice. If the human feeds you some C++17 code using template<template<class> typename T> and asks you to format it as C++14 with TAS_Typename, I think it would be quite appropriate to output template<template<typename> class T>. (Change class to typename because the human asked for TAS_Typename; change typename to class because C++14 implies UseClassKWInTemplateTemplates.)
Anyway, this should have a unit test too.

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

1903

Please don't change anything unrelated. You are very welcome to change this in a different patch.

3698

Also unrelated.

clang/lib/Format/Format.cpp

144–145

Okay, didn't know that.

Than I just have my personal opinion that I would use upper case, but you can choose what ever you want. :)

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

81

I meant assert on EndTok.

94

Most likely you are right. That's why I said could not should.

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

181

Can drop the second argument.

[curdeius]

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

56

IIUC, it feels like the boolean should be named UseClassKWInTemplateTemplates, and it shouldn't have anything to do with Keeping the human's choice. If the human feeds you some C++17 code using template<template<class> typename T> and asks you to format it as C++14 with TAS_Typename, I think it would be quite appropriate to output template<template<typename> class T>. (Change class to typename because the human asked for TAS_Typename; change typename to class because C++14 implies UseClassKWInTemplateTemplates.)
Anyway, this should have a unit test too.

56

+1

I think that generally you should change only the cases that match some pattern (e.g. typename/class followed by a single identifier without = nor ::, etc., similarly for template template parameters) instead of changing everything except some cases. This will be much less error-prone.
Also, please add tests as suggested above.

[HazardyKnusperkeks]

Will you still work on this?

[avogelsgesang]

Will you still work on this?

I don't know. I currently have more high-priority work, and don't know whether/when I will find time for this review again.
Also, I realized that I will have to read up more about class-template parameters, e.g. I don't quite understand https://quuxplusone.github.io/blog/2019/12/27/template-typename-fun/, yet.

So, if you are asking to figure out if you should still review this in more detail: No, for the time being you should not.
If you are asking because you would like to take over this commit and finish it so that it can land: Yes, I would be happy to hand this over

clang/docs/ClangFormatStyleOptions.rst

 
 **QualifierAlignment** (``QualifierAlignmentStyle``) :versionbadge:`clang-format 14`
   Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
 
   .. warning:: 
 
    Setting ``QualifierAlignment``  to something other than `Leave`, COULD
    lead to incorrect code formatting due to incorrect decisions made due to
-   clang-formats lack of complete semantic information.
+   clang-format's lack of complete semantic information.
    As such extra care should be taken to review code changes made by the use
    of this option.
 
   Possible values:
 
   * ``QAS_Leave`` (in configuration: ``Leave``)
     Don't change specifiers/qualifiers to either Left or Right alignment
     (default).
**StatementMacros** (``List of Strings``) :versionbadge:`clang-format 8`
   added; sometimes this is not the case, and this allows to make
   clang-format aware of such cases.
 
   For example: Q_UNUSED
 
 **TabWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of columns used for tab stops.
 
+**TemplateArgumentKeyword** (``TemplateArgumentStyle``) :versionbadge:`clang-format 14`
+  Keyword to use for template arguments (``class`` or ``typename``)
+
+  .. warning:: 
+
+   Setting ``TemplateArgumentKeyword``  to something other than `Leave`,
+   COULD lead to incorrect code formatting due to incorrect decisions made
+   due to clang-format's lack of complete semantic information. As such extra
+   care should be taken to review code changes made by the use of this
+   option.
+
+  Possible values:
+
+  * ``TAS_Leave`` (in configuration: ``Leave``)
+    Don't change `class` to `typename` or vice versa (default).
+
+    .. code-block:: c++
+
+       template<typename Key, class Value> class Map;
+       template<template<class X> class Y> f()
+
+  * ``TAS_Typename`` (in configuration: ``typename``)
+    Use `typename` instead of `class`.
+
+    .. code-block:: c++
+
+       template<typename Key, typename Value> class Map;
+       template<template<typename X> typename Y> f()
+
+  * ``TAS_Class`` (in configuration: ``class``)
+    Use `class` instead of `typename`.
+
+    .. code-block:: c++
+
+       template<class Key, class Value> class Map;
+       template<class<class X> class Y> f();
+
+
+
 **TypenameMacros** (``List of Strings``) :versionbadge:`clang-format 9`
   A vector of macros that should be interpreted as type declarations
   instead of as function calls.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 

clang/docs/ReleaseNotes.rst

- Option ``QualifierAlignment`` has been added in order to auto-arrange the
   `const` `volatile` `static` `inline` `constexpr` `restrict`
   in variable and parameter declarations to be either ``Right`` aligned
   or ``Left`` aligned or ``Custom`` using ``QualifierOrder``.
 
 - Option ``QualifierOrder`` has been added to allow the order
   `const` `volatile` `static` `inline` `constexpr` `restrict`
   to be controlled relative to the `type`.
 
+- Option ``TemplateArgumentKeyword`` has been added to enforce consistent
+  usage of either the ``class`` or the ``typename`` keyword when declaring
+  template arguments.
+
 - Add a ``Custom`` style to ``SpaceBeforeParens``, to better configure the
   space before parentheses. The custom options can be set using
   ``SpaceBeforeParensOptions``.
 
 - Improved C++20 Modules and Coroutines support.
 
 libclang
 --------

clang/include/clang/Format/Format.h

enum QualifierAlignmentStyle {
     /// \endcode
     QAS_Custom
   };
 
   /// Different ways to arrange specifiers and qualifiers (e.g. const/volatile).
   /// \warning
   ///  Setting ``QualifierAlignment``  to something other than `Leave`, COULD
   ///  lead to incorrect code formatting due to incorrect decisions made due to
-  ///  clang-formats lack of complete semantic information.
+  ///  clang-format's lack of complete semantic information.
   ///  As such extra care should be taken to review code changes made by the use
   ///  of this option.
   /// \endwarning
   /// \version 14
   QualifierAlignmentStyle QualifierAlignment;
 
   /// The order in which the qualifiers appear.
   /// Order is an array that can contain any of the following:
enum BreakInheritanceListStyle : unsigned char {
     ///        Base2
     ///    {};
     /// \endcode
     BILS_AfterColon,
     /// Break inheritance list only after the commas.
     /// \code
     ///    class Foo : Base1,
     ///                Base2
     ///    {};
     /// \endcode
     BILS_AfterComma,
   };
 
   /// The inheritance list style to use.
   /// \version 7
   BreakInheritanceListStyle BreakInheritanceList;
 
///    NS_TABLE_.*_END$"
   /// \endcode
   /// \version 12
   std::vector<std::string> StatementAttributeLikeMacros;
 
   /// The number of columns used for tab stops.
   /// \version 3.7
   unsigned TabWidth;
 
+  /// Different template argument styles.
+  enum TemplateArgumentStyle {
+    /// Don't change `class` to `typename` or vice versa (default).
+    /// \code
+    ///    template<typename Key, class Value> class Map;
+    ///    template<template<class X> class Y> f()
+    /// \endcode
+    TAS_Leave,
+    /// Use `typename` instead of `class`.
+    /// \code
+    ///    template<typename Key, typename Value> class Map;
+    ///    template<template<typename X> typename Y> f()
+    /// \endcode
+    TAS_Typename, // typename
+    /// Use `class` instead of `typename`.
+    /// \code
+    ///    template<class Key, class Value> class Map;
+    ///    template<class<class X> class Y> f();
+    /// \endcode
+    TAS_Class // class
+  };
+
+  /// Keyword to use for template arguments (``class`` or ``typename``)
+  /// \warning
+  ///  Setting ``TemplateArgumentKeyword``  to something other than `Leave`,
+  ///  COULD lead to incorrect code formatting due to incorrect decisions made
+  ///  due to clang-format's lack of complete semantic information. As such
+  ///  extra care should be taken to review code changes made by the use of this
+  ///  option.
+  /// \endwarning
+  /// \version 14
+  TemplateArgumentStyle TemplateArgumentKeyword;
+
+  /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
+  /// Also used as fallback if ``DeriveLineEnding`` is true.
+  /// \version 11
+  bool UseCRLF;
+
   /// Different ways to use tab in formatting.
   enum UseTabStyle : unsigned char {
     /// Never use tab.
     UT_Never,
     /// Use tabs only for indentation.
     UT_ForIndentation,
     /// Fill all leading whitespace with tabs, and use spaces for alignment that
     /// appears within a line (e.g. consecutive assignments and declarations).
     UT_ForContinuationAndIndentation,
     /// Use tabs for line continuation and indentation, and spaces for
     /// alignment.
     UT_AlignWithSpaces,
     /// Use tabs whenever we need to fill whitespace that spans at least from
     /// one tab stop to the next one.
     UT_Always
   };
 
-  /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
-  /// Also used as fallback if ``DeriveLineEnding`` is true.
-  /// \version 11
-  bool UseCRLF;
-
   /// The way to use tab characters in the resulting file.
   /// \version 3.7
   UseTabStyle UseTab;
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignArrayOfStructures == R.AlignArrayOfStructures &&
return AccessModifierOffset == R.AccessModifierOffset &&
                R.SpacesInLineCommentPrefix.Maximum &&
            SpacesInParentheses == R.SpacesInParentheses &&
            SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
            SpaceBeforeSquareBrackets == R.SpaceBeforeSquareBrackets &&
            BitFieldColonSpacing == R.BitFieldColonSpacing &&
            Standard == R.Standard &&
            StatementAttributeLikeMacros == R.StatementAttributeLikeMacros &&
            StatementMacros == R.StatementMacros && TabWidth == R.TabWidth &&
+           TemplateArgumentKeyword == R.TemplateArgumentKeyword &&
            UseTab == R.UseTab && UseCRLF == R.UseCRLF &&
            TypenameMacros == R.TypenameMacros;
   }
 
   llvm::Optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
 
   // Stores per-language styles. A FormatStyle instance inside has an empty
   // StyleSet. A FormatStyle instance returned by the Get method has its

clang/lib/Format/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangFormat
   AffectedRangeManager.cpp
   BreakableToken.cpp
   ContinuationIndenter.cpp
   Format.cpp
   FormatToken.cpp
   FormatTokenLexer.cpp
   MacroExpander.cpp
   NamespaceEndCommentsFixer.cpp
   QualifierAlignmentFixer.cpp
   SortJavaScriptImports.cpp
   TokenAnalyzer.cpp
   TokenAnnotator.cpp
+  TemplateArgumentKeywordFixer.cpp
   UnwrappedLineFormatter.cpp
   UnwrappedLineParser.cpp
   UsingDeclarationsSorter.cpp
   WhitespaceManager.cpp
 
   LINK_LIBS
   clangBasic
   clangLex
   clangToolingCore
   clangToolingInclusions
   )

clang/lib/Format/Format.cpp

 #include "AffectedRangeManager.h"
 #include "BreakableToken.h"
 #include "ContinuationIndenter.h"
 #include "FormatInternal.h"
 #include "FormatTokenLexer.h"
 #include "NamespaceEndCommentsFixer.h"
 #include "QualifierAlignmentFixer.h"
 #include "SortJavaScriptImports.h"
+#include "TemplateArgumentKeywordFixer.h"
 #include "TokenAnalyzer.h"
 #include "TokenAnnotator.h"
 #include "UnwrappedLineFormatter.h"
 #include "UnwrappedLineParser.h"
 #include "UsingDeclarationsSorter.h"
 #include "WhitespaceManager.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
struct ScalarEnumerationTraits<FormatStyle::QualifierAlignmentStyle> {
   static void enumeration(IO &IO, FormatStyle::QualifierAlignmentStyle &Value) {
     IO.enumCase(Value, "Leave", FormatStyle::QAS_Leave);
     IO.enumCase(Value, "Left", FormatStyle::QAS_Left);
     IO.enumCase(Value, "Right", FormatStyle::QAS_Right);
     IO.enumCase(Value, "Custom", FormatStyle::QAS_Custom);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::TemplateArgumentStyle> {
+  static void enumeration(IO &IO, FormatStyle::TemplateArgumentStyle &Value) {
+    IO.enumCase(Value, "Leave", FormatStyle::TAS_Leave);
+    IO.enumCase(Value, "typename", FormatStyle::TAS_Typename);
+    IO.enumCase(Value, "class", FormatStyle::TAS_Class);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::ShortFunctionStyle> {
   static void enumeration(IO &IO, FormatStyle::ShortFunctionStyle &Value) {
     IO.enumCase(Value, "None", FormatStyle::SFS_None);
     IO.enumCase(Value, "false", FormatStyle::SFS_None);
     IO.enumCase(Value, "All", FormatStyle::SFS_All);
     IO.enumCase(Value, "true", FormatStyle::SFS_All);
     IO.enumCase(Value, "Inline", FormatStyle::SFS_Inline);
     IO.enumCase(Value, "InlineOnly", FormatStyle::SFS_InlineOnly);
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("SpaceBeforeSquareBrackets",
                    Style.SpaceBeforeSquareBrackets);
     IO.mapOptional("BitFieldColonSpacing", Style.BitFieldColonSpacing);
     IO.mapOptional("Standard", Style.Standard);
     IO.mapOptional("StatementAttributeLikeMacros",
                    Style.StatementAttributeLikeMacros);
     IO.mapOptional("StatementMacros", Style.StatementMacros);
     IO.mapOptional("TabWidth", Style.TabWidth);
+    IO.mapOptional("TemplateArgumentKeyword", Style.TemplateArgumentKeyword);
     IO.mapOptional("TypenameMacros", Style.TypenameMacros);
     IO.mapOptional("UseCRLF", Style.UseCRLF);
     IO.mapOptional("UseTab", Style.UseTab);
     IO.mapOptional("WhitespaceSensitiveMacros",
                    Style.WhitespaceSensitiveMacros);
   }
 };
 
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.SpaceBeforeParensOptions.AfterIfMacros = true;
   LLVMStyle.SpaceBeforeRangeBasedForLoopColon = true;
   LLVMStyle.SpaceBeforeAssignmentOperators = true;
   LLVMStyle.SpaceBeforeCpp11BracedList = false;
   LLVMStyle.SpaceBeforeSquareBrackets = false;
   LLVMStyle.BitFieldColonSpacing = FormatStyle::BFCS_Both;
   LLVMStyle.SpacesInAngles = FormatStyle::SIAS_Never;
   LLVMStyle.SpacesInConditionalStatement = false;
+  LLVMStyle.TemplateArgumentKeyword = FormatStyle::TAS_Leave;
 
   LLVMStyle.PenaltyBreakAssignment = prec::Assignment;
   LLVMStyle.PenaltyBreakComment = 300;
   LLVMStyle.PenaltyBreakFirstLessLess = 120;
   LLVMStyle.PenaltyBreakString = 1000;
   LLVMStyle.PenaltyExcessCharacter = 1000000;
   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
   LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
if (Style.isCpp() && Style.QualifierAlignment != FormatStyle::QAS_Leave) {
     Passes.emplace_back([&](const Environment &Env) {
       return QualifierAlignmentFixer(Env, Expanded, Code, Ranges,
                                      FirstStartColumn, NextStartColumn,
                                      LastStartColumn, FileName)
           .process();
     });
   }
 
+  if (Style.isCpp() &&
+      Style.TemplateArgumentKeyword != FormatStyle::TAS_Leave) {
+    Passes.emplace_back([&](const Environment &Env) {
+      return TemplateArgumentKeywordFixer(Env, Expanded).process();
+    });
+  }
+
   if (Style.Language == FormatStyle::LK_Cpp) {
     if (Style.FixNamespaceComments)
       Passes.emplace_back([&](const Environment &Env) {
         return NamespaceEndCommentsFixer(Env, Expanded).process();
       });
 
     if (Style.SortUsingDeclarations)
       Passes.emplace_back([&](const Environment &Env) {

clang/lib/Format/TemplateArgumentKeywordFixer.h

+//===--- TemplateArgumentKeywordFixer.h ------------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file declares TemplateArgumentKeywordFixer, a TokenAnalyzer that
+/// enforces consistent usage of `typename` or `class` in template arguments.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LIB_FORMAT_TEMPLATEARGUMENTKEYWORDFIXER_H
+#define LLVM_CLANG_LIB_FORMAT_TEMPLATEARGUMENTKEYWORDFIXER_H
+
+#include "TokenAnalyzer.h"
+
+namespace clang {
+namespace format {
+
+class TemplateArgumentKeywordFixer : public TokenAnalyzer {
+public:
+  TemplateArgumentKeywordFixer(const Environment &Env,
+                               const FormatStyle &Style);
+
+  std::pair<tooling::Replacements, unsigned>
+  analyze(TokenAnnotator &Annotator,
+          SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+          FormatTokenLexer &Tokens) override;
+};
+
+} // namespace format
+} // namespace clang
+
+#endif

clang/lib/Format/TemplateArgumentKeywordFixer.cpp

+//===--- TemplateArgumentKeywordFixer.cpp -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file implements TemplateArgumentKeywordFixer, a TokenAnalyzer that
+/// enforces consistent usage of `typename` or `class` in template arguments.
+///
+//===----------------------------------------------------------------------===//
+
+#include "TemplateArgumentKeywordFixer.h"
+
+namespace clang {
+namespace format {
+
+TemplateArgumentKeywordFixer::TemplateArgumentKeywordFixer(
+    const Environment &Env, const FormatStyle &Style)
+    : TokenAnalyzer(Env, Style) {}
+
+static void replaceToken(const SourceManager &SourceMgr,
+                         tooling::Replacements &Fixes, const FormatToken *Tok,
+                         StringRef NewText) {
+  auto Range = CharSourceRange::getCharRange(Tok->getStartOfNonWhitespace(),
+                                             Tok->Tok.getEndLoc());
+  auto Replacement = tooling::Replacement(SourceMgr, Range, NewText);
+  auto Err = Fixes.add(Replacement);
+  if (Err)
+    llvm::errs() << "Error while replacing template argument keyword: "
+                 << llvm::toString(std::move(Err)) << "\n";
+}
+
+std::pair<tooling::Replacements, unsigned>
+TemplateArgumentKeywordFixer::analyze(
+    TokenAnnotator &Annotator, SmallVectorImpl<AnnotatedLine *> &AnnotatedLines,
+    FormatTokenLexer &Tokens) {
+  const SourceManager &SourceMgr = Env.getSourceManager();
+  AffectedRangeMgr.computeAffectedLines(AnnotatedLines);
+  tooling::Replacements Fixes;
+
+  StringRef ReplacementStr;
+  tok::TokenKind TokenKindToReplace;
+  bool KeepTemplateTemplateKW = false;
+  switch (Style.TemplateArgumentKeyword) {
+  case FormatStyle::TAS_Leave:
+    assert(false && "The `TemplateArgumentKeywordFixer` class should not be "
+                    "instantiated in the first place");
+    return {Fixes, 0};
+  case FormatStyle::TAS_Typename:
+    assert(Style.Standard != FormatStyle::LS_Auto);
+    // For `auto` language version, be conservative and assume we are < C++17.
+    KeepTemplateTemplateKW = (Style.Standard == FormatStyle::LS_Auto) ||
+                             (Style.Standard < FormatStyle::LS_Cpp17);
+    TokenKindToReplace = tok::kw_class;
+    ReplacementStr = "typename";
+    break;
+  case FormatStyle::TAS_Class:
+    TokenKindToReplace = tok::kw_typename;
+    ReplacementStr = "class";
+    break;
+  }
+
+  for (size_t I = 0, E = AnnotatedLines.size(); I != E; ++I) {
+    FormatToken *Tok = AnnotatedLines[I]->First;
+
+    // Find the first `template` keyword on this line.
+    while (Tok && Tok->isNot(tok::kw_template))
+      Tok = Tok->Next;
+    if (!Tok)
+      continue;
+
+    // Find the corresponding `<`. Might be on the next line.
+    Tok = Tok->Next;
+    while (!Tok && I < E)
+      Tok = AnnotatedLines[++I]->First;
+    if (Tok->isNot(TT_TemplateOpener) || !Tok->MatchingParen) {
+      // This is unexpected and indicates a syntax error.
+      // Just skip over this line and don't bother about it.
+      continue;
+    }
+    FormatToken *EndTok = Tok->MatchingParen;
+
+    // Loop over the remaining tokens in the argument list and
+    // replace every `class`/`typename` keyword.
+    while (Tok != EndTok) {
+      if (Tok->is(TokenKindToReplace)) {
+        if (!KeepTemplateTemplateKW ||
+            !Tok->Previous->ClosesTemplateDeclaration) {
+          replaceToken(SourceMgr, Fixes, Tok, ReplacementStr);
+        }
+      }
+
+      bool StartedDefaultArg = Tok->is(tok::equal);
+      auto advanceTok = [&]() {
+        Tok = Tok->Next;
+        while (!Tok && I < E)
+          Tok = AnnotatedLines[++I]->First;
+        assert(Tok && "Unexpected end of token stream before encountering "
+                      "matching parens");
+      };
+      advanceTok();
+      if (StartedDefaultArg) {
+        // Default arguments might contain legitimate uses of the `typename`
+        // keyword which must not be rewritten to `class`. Example:
+        // > `template<class X = typename T::Nested> class A;
+        // Skip over the complete default clause.
+        unsigned NestingLevel = Tok->NestingLevel;
+        while (NestingLevel != Tok->NestingLevel ||
+               !Tok->isOneOf(tok::comma, tok::greater)) {
+          advanceTok();
+        }
+      }
+    }
+  }
+
+  return {Fixes, 0};
+}
+
+} // namespace format
+} // namespace clang

clang/unittests/Format/CMakeLists.txt

add_clang_unittest(FormatTests
   FormatTestTableGen.cpp
   FormatTestTextProto.cpp
   MacroExpanderTest.cpp
   NamespaceEndCommentsFixerTest.cpp
   QualifierFixerTest.cpp
   SortImportsTestJS.cpp
   SortImportsTestJava.cpp
   SortIncludesTest.cpp
+  TemplateArgumentKeywordFixerTest.cpp
   UsingDeclarationsSorterTest.cpp
   TokenAnnotatorTest.cpp
   )
 
 clang_target_link_libraries(FormatTests
   PRIVATE
   clangBasic
   clangFormat
   clangRewrite
   clangToolingCore
   )

clang/unittests/Format/TemplateArgumentKeywordFixerTest.cpp

+//===- unittest/Format/TemplateArgumentKeywordFixerTest.cpp ---------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Format/Format.h"
+
+#include "FormatTestUtils.h"
+#include "TestLexer.h"
+#include "gtest/gtest.h"
+
+#include "../../lib/Format/TemplateArgumentKeywordFixer.h"
+
+using testing::ScopedTrace;
+
+namespace clang {
+namespace format {
+namespace {
+
+class TemplateArgumentKeywordFixerTest : public ::testing::Test {
+protected:
+  std::string format(llvm::StringRef Code,
+                     const std::vector<tooling::Range> &Ranges,
+                     const FormatStyle &Style) {
+    LLVM_DEBUG(llvm::errs() << "---\n");
+    LLVM_DEBUG(llvm::errs() << Code << "\n\n");
+    FormattingAttemptStatus Status;
+    tooling::Replacements Replaces =
+        reformat(Style, Code, Ranges, "<stdin>", &Status);
+    EXPECT_TRUE(Status.FormatComplete);
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(Result));
+    LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
+  }
+
+  std::string format(llvm::StringRef Code, const FormatStyle &Style) {
+    return format(Code,
+                  /*Ranges=*/{1, tooling::Range(0, Code.size())}, Style);
+  }
+
+  void _verifyFormat(const char *File, int Line, llvm::StringRef Expected,
+                     llvm::StringRef Code, const FormatStyle &Style) {
+    ScopedTrace t(File, Line, ::testing::Message() << Code.str());
+    EXPECT_EQ(Expected.str(), format(Expected, Style))
+        << "Expected code is not stable";
+    EXPECT_EQ(Expected.str(), format(Code, Style));
+    EXPECT_EQ(Expected.str(), format(test::messUp(Code), Style));
+  }
+
+  void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
+                     const FormatStyle &Style) {
+    _verifyFormat(File, Line, Code, Code, Style);
+  }
+};
+
+#define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
+
+TEST_F(TemplateArgumentKeywordFixerTest, DisabledByDefault) {
+  FormatStyle Style = getLLVMStyle();
+  EXPECT_EQ(Style.TemplateArgumentKeyword, FormatStyle::TAS_Leave);
+  verifyFormat("template <class X> class A", "template <class X> class A",
+               Style);
+  verifyFormat("template <typename X> class A", "template <typename X> class A",
+               Style);
+  verifyFormat("template <typename X, class Y> class A",
+               "template <typename X, class Y> class A", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsAsClass) {
+  FormatStyle Style = getLLVMStyle();
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Class;
+  verifyFormat("template <class X> class A", "template <class X> class A",
+               Style);
+  verifyFormat("template <class X> class A", "template <typename X> class A",
+               Style);
+  verifyFormat("template <class X, class Y> class A;",
+               "template <typename X, typename Y> class A;", Style);
+  verifyFormat("template <class X, class Y> class A;",
+               "template <class X, typename Y> class A;", Style);
+  verifyFormat("template <template <class X> class Y> class A;",
+               "template <template <typename X> typename Y> class A;", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, ClassLeavesOtherTypenames) {
+  FormatStyle Style = getLLVMStyle();
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Class;
+  // `typename` outside of a template should stay unchanged.
+  verifyFormat("typename T::nested", Style);
+  // `typename` inside a template should stay unchanged if it refers to a nested
+  // type.
+  verifyFormat(
+      "template <class X, class Y = typename X::Nested> class A;",
+      "template <typename X, typename Y = typename X::Nested> class A;", Style);
+  // A legitimate `typename` might also occur in a nested list, directly after
+  // the `,` token It's not sufficient to just check for a comma in front of
+  // `typename`.
+  verifyFormat("template <class X, class Y = X<X, typename X::Nested>, class Z "
+               "= void> class A;",
+               "template <typename X, typename Y = X<X, typename X::Nested>, "
+               "typename Z = void> class A;",
+               Style);
+  // `typename` might also occur in a function call, not only in a type.
+  verifyFormat("template <class X, int Y = func<typename Y::type>(), class Z = "
+               "void> class A;",
+               "template <typename X, int Y = func<typename Y::type>(), "
+               "typename Z = void> class A;",
+               Style);
+  // `typename` might also occur in function call arguments, outside the
+  // template list.
+  verifyFormat("template <class X, int Y = func(typename X::type{42}), class "
+               "Z> class A;",
+               "template <typename X, int Y = func(typename X::type{42}), "
+               "typename Z> class A;",
+               Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsAsTypename) {
+  FormatStyle Style = getLLVMStyle();
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  verifyFormat("template <typename X> class A", "template <class X> class A",
+               Style);
+  verifyFormat("template <typename X> class A", "template <typename X> class A",
+               Style);
+  verifyFormat("template <typename X, typename Y> class A;",
+               "template <class X, class Y> class A;", Style);
+  verifyFormat("template <typename X, typename Y> class A;",
+               "template <typename X, class Y> class A;", Style);
+  verifyFormat("template <template <typename X> typename Y> class A;",
+               "template <template <class X> class Y> class A;", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsAsTypenameCpp14) {
+  FormatStyle Style = getLLVMStyle();
+  Style.Standard = FormatStyle::LS_Cpp14;
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  // In C++14, template-template arguments must not use `typename`!
+  verifyFormat("template <template <typename X> class Y> class A;",
+               "template <template <class X> class Y> class A;", Style);
+  // When `class` is preferred, we replace both `typename`s, also in C++14.
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Class;
+  verifyFormat("template <template <class X> class Y> class A;",
+               "template <template <typename X> typename Y> class A;", Style);
+
+  // In `auto` mode, we are conservative and still are C++14 compatible.
+  Style.Standard = FormatStyle::LS_Auto;
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  verifyFormat("template <template <typename X> class Y> class A;",
+               "template <template <class X> class Y> class A;", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsUsing) {
+  FormatStyle Style = getLLVMStyle();
+  Style.Standard = FormatStyle::LS_Cpp14;
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  // We also format template argument lists for `using`.
+  verifyFormat("template <typename T> using A = B<T[]>;",
+               "template <class T> using A = B<T[]>; ", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsDeductionGuides) {
+  FormatStyle Style = getLLVMStyle();
+  Style.Standard = FormatStyle::LS_Cpp14;
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  // We also format template argument lists for deduction guides.
+  verifyFormat("template <typename T> A(const T &, const T &) -> A<T &>;",
+               "template <class T> A(const T &, const T &) -> A<T &>;", Style);
+}
+
+TEST_F(TemplateArgumentKeywordFixerTest, FormatsPartialCode) {
+  FormatStyle Style = getLLVMStyle();
+  // We use C++14 mode for those cases as it is the most complicated one.
+  Style.Standard = FormatStyle::LS_Cpp14;
+  Style.TemplateArgumentKeyword = FormatStyle::TAS_Typename;
+  // The expectations for partial code is: don't crash, don't mangle code.
+  // We do not expect partial code to be actually rewritten from `class` to
+  // `typename`.
+  verifyFormat("template", "template", Style);
+  verifyFormat("template <", "template<", Style);
+  verifyFormat("template <clas", "template<clas", Style);
+  verifyFormat("template <class", "template<class", Style);
+  verifyFormat("template <class X", "template<class X", Style);
+  // As soon as we see the closing `>`, we format the whole thing.
+  verifyFormat("template <typename X>", "template<class X>", Style);
+  verifyFormat("template <typename X> class", "template<class X> class", Style);
+  verifyFormat("template <typename X> class A", "template<class X> class A",
+               Style);
+
+  // Similar test case for template-template arguments.
+  verifyFormat("template", "template", Style);
+  verifyFormat("template <", "template<", Style);
+  verifyFormat("template <templat", "template<templat", Style);
+  verifyFormat("template <template <", "template<template<", Style);
+  verifyFormat("template <template <clas", "template<template<clas", Style);
+  verifyFormat("template <template <class", "template<template<class", Style);
+  // We still don't replace `class` by `typename`, because the outer `<` are
+  // unmatched. This is an implementation detail and should one of your changes
+  // modifies the behavor here, feel freee to just update the test case.
+  verifyFormat("template <template <class>", "template<template<class>", Style);
+  verifyFormat("template <template <class> class",
+               "template<template<class> class", Style);
+  verifyFormat("template <template <class> class X",
+               "template<template<class> class X", Style);
+  // As soon as we see the closing `>`, we format `class` as `typename`, but
+  // only where C++14 permits it.
+  verifyFormat("template <template <typename> class X>",
+               "template<template<class> class X>", Style);
+  verifyFormat("template <template <typename> class X> class",
+               "template<template<class> class X> class", Style);
+  verifyFormat("template <template <typename> class X> class A",
+               "template<template<class> class X> class A", Style);
+}
+
+} // namespace
+} // namespace format
+} // namespace clang