[clang-format] Adds 'friend' to QualifierOrder.

[red1bluelost]

Summary

For cases of defining friend functions, qualifier ordering can allow multiple
positions for the 'friend' token.

c++
struct S {
  int i;

  friend constexpr auto operator<=>(const S&, const S&) noexcept = default;
};

• 1. Changes
• Adds friend to getTokenFromQualifier
• Updates documentation in Format.h and ClangFormatStyleOptions.rst
• Adds tests to QualifierFixerTest.cpp

Testing

Ran FormatTest with no errors.

GitHub Issue

https://github.com/llvm/llvm-project/issues/59450

[MyDeveloperDay]

I guess in principle this looks ok, but lets see what the others think @owenpan , @HazardyKnusperkeks

[HazardyKnusperkeks]

I'm normally way more lenient than the most to add features, but here I have to ask do you want it so that you can get friend always as first, or do you really want to be able to put friend anywhere in the sequence? If only the first, I'd say we do that without adding this option.

I had actually to look up that you can put friend basically anywhere, all examples, tutorials, etc. put it in front. I would discourage that clang-format puts it anywhere else, even though it is valid C++.

Technically: Do we need/want a config parse test for friend?

[red1bluelost]

I would always want it first. I agree that friend would always go first. Had I not accidentally typed in the wrong order I probably wouldn't have know friend could be in any position.

In the case of putting friend always first, would we want a user facing option to enable/disable moving it to first, do it always without an user option, or something else?

[red1bluelost]

In D139801#3988790, @HazardyKnusperkeks wrote:

If only the first, I'd say we do that without adding this option.

I'll work on doing this without adding the option. (Just reread and noticed you had answered what I asked in my previous comment.)

[HazardyKnusperkeks]

In D139801#3989284, @red1bluelost wrote:

In D139801#3988790, @HazardyKnusperkeks wrote:

If only the first, I'd say we do that without adding this option.

I'll work on doing this without adding the option. (Just reread and noticed you had answered what I asked in my previous comment.)

It should be part of the qualifieralignmentfixer, we don't want to move the tokens when someone doesn't have it turned on. My idea would be hardcoded friend as first entry, regardless of the chosen sequence.
But others may have a different opinion on that.

[owenpan]

In D139801#3989812, @HazardyKnusperkeks wrote:

My idea would be hardcoded friend as first entry, regardless of the chosen sequence.
But others may have a different opinion on that.

It would be confusing with QAS_Right and inconsistent with QAS_Custom which allows e.g. inline, static, and volatile to be placed after the type. IMO we should just add friend to QualifierOrder as this patch currently intends to do.

[MyDeveloperDay]

I know I have situations where I like inline and static to be in a certain order to avoid them getting constantly swapped around, they are never going to be after the type but I still want them the same way, I'd be ok with allow friend for the same reason.

I'm just pleased people find this feature useful, despite the original concern raised and the hairiness of the implementation. I also appreciate the concessions made by others to allow clang-format to alter code as this has opened the doors in my view to 1 or 2 other great code modification changes.

[red1bluelost]

In that case, when someone has free time, could you commit on my behalf (name: Micah Weston, email: [e-mail]).

Thank you all for the reviews!

[owenpan]

In D139801#3991108, @MyDeveloperDay wrote:

I also appreciate the concessions made by others to allow clang-format to alter code as this has opened the doors in my view to 1 or 2 other great code modification changes.

+1.

clang/docs/ClangFormatStyleOptions.rst

 
 **QualifierOrder** (``List of Strings``) :versionbadge:`clang-format 14`
   The order in which the qualifiers appear.
   Order is an array that can contain any of the following:
 
     * const
     * inline
     * static
+    * friend
     * constexpr
     * volatile
     * restrict
     * type
 
   Note: it MUST contain 'type'.
   Items to the left of 'type' will be placed to the left of the type and
   aligned in the order supplied. Items to the right of 'type' will be placed

clang/include/clang/Format/Format.h

   QualifierAlignmentStyle QualifierAlignment;
 
   /// The order in which the qualifiers appear.
   /// Order is an array that can contain any of the following:
   ///
   ///   * const
   ///   * inline
   ///   * static
+  ///   * friend
   ///   * constexpr
   ///   * volatile
   ///   * restrict
   ///   * type
   ///
   /// Note: it MUST contain 'type'.
   /// Items to the left of 'type' will be placed to the left of the type and
   /// aligned in the order supplied. Items to the right of 'type' will be placed

clang/lib/Format/QualifierAlignmentFixer.cpp

tok::TokenKind LeftRightQualifierAlignmentFixer::getTokenFromQualifier(
   return llvm::StringSwitch<tok::TokenKind>(Qualifier)
       .Case("type", tok::kw_typeof)
       .Case("const", tok::kw_const)
       .Case("volatile", tok::kw_volatile)
       .Case("static", tok::kw_static)
       .Case("inline", tok::kw_inline)
       .Case("constexpr", tok::kw_constexpr)
       .Case("restrict", tok::kw_restrict)
+      .Case("friend", tok::kw_friend)
       .Default(tok::identifier);
 }
 
 LeftRightQualifierAlignmentFixer::LeftRightQualifierAlignmentFixer(
     const Environment &Env, const FormatStyle &Style,
     const std::string &Qualifier,
     const std::vector<tok::TokenKind> &QualifierTokens, bool RightAlign)
     : TokenAnalyzer(Env, Style), Qualifier(Qualifier), RightAlign(RightAlign),

clang/unittests/Format/QualifierFixerTest.cpp

TEST_F(QualifierFixerTest, RotateTokens) {
   EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("volatile"),
             tok::kw_volatile);
   EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("inline"),
             tok::kw_inline);
   EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("static"),
             tok::kw_static);
   EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("restrict"),
             tok::kw_restrict);
+  EXPECT_EQ(LeftRightQualifierAlignmentFixer::getTokenFromQualifier("friend"),
+            tok::kw_friend);
 }
 
 TEST_F(QualifierFixerTest, FailQualifierInvalidConfiguration) {
   FormatStyle Style = {};
   Style.Language = FormatStyle::LK_Cpp;
   FAIL_PARSE("QualifierAlignment: Custom\n"
              "QualifierOrder: [const, volatile, apples, type]",
              QualifierOrder,
TEST_F(QualifierFixerTest, QualifierRight) {
   Style.Language = FormatStyle::LK_Cpp;
   CHECK_PARSE("QualifierAlignment: Right", QualifierOrder,
               std::vector<std::string>({"type", "const", "volatile"}));
 }
 
 TEST_F(QualifierFixerTest, QualifiersCustomOrder) {
   FormatStyle Style = getLLVMStyle();
   Style.QualifierAlignment = FormatStyle::QAS_Left;
-  Style.QualifierOrder = {"inline", "constexpr", "static",
-                          "const",  "volatile",  "type"};
+  Style.QualifierOrder = {"friend", "inline",   "constexpr", "static",
+                          "const",  "volatile", "type"};
 
   verifyFormat("const volatile int a;", "const volatile int a;", Style);
   verifyFormat("const volatile int a;", "volatile const int a;", Style);
   verifyFormat("const volatile int a;", "int const volatile a;", Style);
   verifyFormat("const volatile int a;", "int volatile const a;", Style);
   verifyFormat("const volatile int a;", "const int volatile a;", Style);
 
   verifyFormat("static const volatile int a;", "const static int volatile a;",
                Style);
   verifyFormat("inline static const volatile int a;",
                "const static inline int volatile a;", Style);
 
   verifyFormat("constexpr static int a;", "static constexpr int a;", Style);
   verifyFormat("constexpr static int A;", "static constexpr int A;", Style);
   verifyFormat("constexpr static int Bar;", "static constexpr int Bar;", Style);
   verifyFormat("constexpr static LPINT Bar;", "static constexpr LPINT Bar;",
                Style);
   verifyFormat("const const int a;", "const int const a;", Style);
+
+  verifyFormat(
+      "friend constexpr auto operator<=>(const foo &, const foo &) = default;",
+      "constexpr friend auto operator<=>(const foo &, const foo &) = default;",
+      Style);
+  verifyFormat(
+      "friend constexpr bool operator==(const foo &, const foo &) = default;",
+      "constexpr bool friend operator==(const foo &, const foo &) = default;",
+      Style);
 }
 
 TEST_F(QualifierFixerTest, LeftRightQualifier) {
   FormatStyle Style = getLLVMStyle();
 
   // keep the const style unaltered
   verifyFormat("const int a;", Style);
   verifyFormat("const int *a;", Style);

 TEST_F(QualifierFixerTest, IsQualifierType) {
 
   std::vector<tok::TokenKind> ConfiguredTokens;
   ConfiguredTokens.push_back(tok::kw_const);
   ConfiguredTokens.push_back(tok::kw_static);
   ConfiguredTokens.push_back(tok::kw_inline);
   ConfiguredTokens.push_back(tok::kw_restrict);
   ConfiguredTokens.push_back(tok::kw_constexpr);
+  ConfiguredTokens.push_back(tok::kw_friend);
 
-  auto Tokens =
-      annotate("const static inline auto restrict int double long constexpr");
+  auto Tokens = annotate(
+      "const static inline auto restrict int double long constexpr friend");
 
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[0], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[1], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[2], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[3], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[4], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[5], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[6], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[7], ConfiguredTokens));
   EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       Tokens[8], ConfiguredTokens));
+  EXPECT_TRUE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
+      Tokens[9], ConfiguredTokens));
 
   auto NotTokens = annotate("for while do Foo Bar ");
 
   EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       NotTokens[0], ConfiguredTokens));
   EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(
       NotTokens[1], ConfiguredTokens));
   EXPECT_FALSE(LeftRightQualifierAlignmentFixer::isQualifierOrType(