[clang-format] Add option to align pointers in C style casts differently

[yodaldevoid]

Summary

I personally prefer that pointers are aligned to the right in most cases to avoid problems when multiple variables are declared at once. That said, I prefer left alignment in C style casts to avoid the extra space and because there is no chance of the sorts of problems you see in declarations. This setting supports people with preferences like mine.

Currently this affects the alignment of both pointers and references in C style casts. If someone wanted to affect references separately then a separate setting for that, similar to ReferenceAlignmet, could be added.

[yodaldevoid]

Correct commit email

[HazardyKnusperkeks]

clang/lib/Format/TokenAnnotator.cpp

3045

What are Left and Right in your cases? I don't like the loop here and am not sure what exactly you want to check. Shouldn't Left be the PointerOrReference and Right is a r_paren?

clang/unittests/Format/FormatTest.cpp

15346

I think you should add some tests with simpler casts too.

[curdeius]

Why this option is useful? Why would someone want to have a different alignment in casts than in other places?
As such I'm opposed to introducing one more option. Is there any well established code style that has something like this?

[owenpan]

In D116229#3208507, @curdeius wrote:

Why this option is useful? Why would someone want to have a different alignment in casts than in other places?
As such I'm opposed to introducing one more option. Is there any well established code style that has something like this?

Yes, we should adhere to the policy when adding new options.

[yodaldevoid]

In D116229#3209414, @owenpan wrote:

In D116229#3208507, @curdeius wrote:

Why this option is useful? Why would someone want to have a different alignment in casts than in other places?
As such I'm opposed to introducing one more option. Is there any well established code style that has something like this?

Yes, we should adhere to the policy when adding new options.

Understood. I'll close this out, then, as I don't know of a major project that needs this.

clang/include/clang/Format/Format.h

enum PointerAlignmentStyle : unsigned char {
     /// \endcode
     PAS_Middle
   };
 
   /// Pointer and reference alignment style.
   /// \version 3.7
   PointerAlignmentStyle PointerAlignment;
 
+  /// The ``&``, ``&&`` and ``*`` alignment style when in C style casts.
+  enum PointerAlignmentInCastStyle {
+    /// Align pointers and references like ``PointerAlignment`` for pointers and
+    //  like `'ReferenceAlignment`' for references.
+    PACS_Pointer,
+    /// Align pointer to the left.
+    /// \code
+    ///   (int*) a;
+    /// \endcode
+    PACS_Left,
+    /// Align pointer to the right.
+    /// \code
+    ///   (int *) a;
+    /// \endcode
+    PACS_Right,
+  };
+
+  /// Pointer alignment style in C style casts.
+  /// \version 14
+  PointerAlignmentInCastStyle PointerAlignmentInCast;
+
   /// The number of columns to use for indentation of preprocessor statements.
   /// When set to -1 (default) ``IndentWidth`` is used also for preprocessor
   /// statements.
   /// \code
   ///    PPIndentWidth: 1
   ///
   ///    #ifdef __linux__
   ///    # define FOO

clang/lib/Format/Format.cpp

static void enumeration(IO &IO, FormatStyle::PointerAlignmentStyle &Value) {
 
     // For backward compatibility.
     IO.enumCase(Value, "true", FormatStyle::PAS_Left);
     IO.enumCase(Value, "false", FormatStyle::PAS_Right);
   }
 };
 
 template <>
+struct ScalarEnumerationTraits<FormatStyle::PointerAlignmentInCastStyle> {
+  static void enumeration(IO &IO,
+                          FormatStyle::PointerAlignmentInCastStyle &Value) {
+    IO.enumCase(Value, "Pointer", FormatStyle::PACS_Pointer);
+    IO.enumCase(Value, "Left", FormatStyle::PACS_Left);
+    IO.enumCase(Value, "Right", FormatStyle::PACS_Right);
+  }
+};
+
+template <>
 struct ScalarEnumerationTraits<FormatStyle::SpaceAroundPointerQualifiersStyle> {
   static void
   enumeration(IO &IO, FormatStyle::SpaceAroundPointerQualifiersStyle &Value) {
     IO.enumCase(Value, "Default", FormatStyle::SAPQ_Default);
     IO.enumCase(Value, "Before", FormatStyle::SAPQ_Before);
     IO.enumCase(Value, "After", FormatStyle::SAPQ_After);
     IO.enumCase(Value, "Both", FormatStyle::SAPQ_Both);
   }
static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("PenaltyBreakTemplateDeclaration",
                    Style.PenaltyBreakTemplateDeclaration);
     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
                    Style.PenaltyReturnTypeOnItsOwnLine);
     IO.mapOptional("PenaltyIndentedWhitespace",
                    Style.PenaltyIndentedWhitespace);
     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
+    IO.mapOptional("PointerAlignmentInCast", Style.PointerAlignmentInCast);
     IO.mapOptional("PPIndentWidth", Style.PPIndentWidth);
     IO.mapOptional("RawStringFormats", Style.RawStringFormats);
     IO.mapOptional("ReferenceAlignment", Style.ReferenceAlignment);
     IO.mapOptional("ReflowComments", Style.ReflowComments);
     IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
     IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
   LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
   LLVMStyle.ObjCBlockIndentWidth = 2;
   LLVMStyle.ObjCBreakBeforeNestedBlockParam = true;
   LLVMStyle.ObjCSpaceAfterProperty = false;
   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
+  LLVMStyle.PointerAlignmentInCast = FormatStyle::PACS_Pointer;
   LLVMStyle.ReferenceAlignment = FormatStyle::RAS_Pointer;
   LLVMStyle.ShortNamespaceLines = 1;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Latest;
   LLVMStyle.UseCRLF = false;
   LLVMStyle.UseTab = FormatStyle::UT_Never;
   LLVMStyle.ReflowComments = true;
   LLVMStyle.SpacesInParentheses = false;

clang/lib/Format/TokenAnnotator.h

FormatToken *calculateInitializerColumnList(AnnotatedLine &Line,
                                               FormatToken *CurrentToken,
                                               unsigned Depth);
   FormatStyle::PointerAlignmentStyle
   getTokenReferenceAlignment(const FormatToken &PointerOrReference);
 
   FormatStyle::PointerAlignmentStyle
   getTokenPointerOrReferenceAlignment(const FormatToken &PointerOrReference);
 
+  FormatStyle::PointerAlignmentStyle getTokenPointerOrReferenceAlignmentInCase(
+      const FormatToken &PointerOrReference);
+
   const FormatStyle &Style;
 
   const AdditionalKeywords &Keywords;
 };
 
 } // end namespace format
 } // end namespace clang
 
 #endif

clang/lib/Format/TokenAnnotator.cpp

if ((Style.SpaceAroundPointerQualifiers == FormatStyle::SAPQ_After ||
       return true;
     if (Left.Tok.isLiteral())
       return true;
     // for (auto a = 0, b = 0; const auto & c : {1, 2, 3})
     if (Left.isTypeOrIdentifier() && Right.Next && Right.Next->Next &&
         Right.Next->Next->is(TT_RangeBasedForLoopColon))
       return getTokenPointerOrReferenceAlignment(Right) !=
              FormatStyle::PAS_Left;
+    // To find if we are currently in a C style cast we just have to follow the
+    // linked list until one of three conditions. If we have either reached the
+    // end of the list or find the opening parenthesis of a cast we can assume
+    // we are not currently in a cast. If we instead find the right-most
+    // parenthesis of a cast we know we are in a cast.
+    if (!Left.isOneOf(TT_PointerOrReference, tok::l_paren))
+      for (const FormatToken *Tok = &Right;
+           Tok &&
+           (!Tok->MatchingParen || !Tok->MatchingParen->is(TT_CastRParen));
+           Tok = Tok->Next)
+        if (Tok->Next && Tok->Next->is(TT_CastRParen))
+          return getTokenPointerOrReferenceAlignmentInCase(Right) !=
+                 FormatStyle::PAS_Left;
     return (
         (!Left.isOneOf(TT_PointerOrReference, tok::l_paren) &&
          (getTokenPointerOrReferenceAlignment(Right) != FormatStyle::PAS_Left ||
           (Line.IsMultiVariableDeclStmt &&
            (Left.NestingLevel == 0 ||
             (Left.NestingLevel == 1 && Line.First->is(tok::kw_for)))))));
   }
   if (Right.is(TT_FunctionTypeLParen) && Left.isNot(tok::l_paren) &&
if (PointerOrReference.isOneOf(tok::amp, tok::ampamp)) {
     case FormatStyle::RAS_Middle:
       return FormatStyle::PAS_Middle;
     }
   }
   assert(PointerOrReference.is(tok::star));
   return Style.PointerAlignment;
 }
 
+FormatStyle::PointerAlignmentStyle
+TokenAnnotator::getTokenPointerOrReferenceAlignmentInCase(
+    const FormatToken &PointerOrReference) {
+  switch (Style.PointerAlignmentInCast) {
+  case FormatStyle::PACS_Pointer:
+    return getTokenPointerOrReferenceAlignment(PointerOrReference);
+  case FormatStyle::PACS_Left:
+    return FormatStyle::PAS_Left;
+  case FormatStyle::PACS_Right:
+    return FormatStyle::PAS_Right;
+  }
+  assert(0); //"Unhandled value of PointerAlignmentInCast"
+  return Style.PointerAlignment;
+}
+
 } // namespace format
 } // namespace clang

clang/unittests/Format/FormatTest.cpp

EXPECT_EQ("#define a    3\n"
                    " * block comment */\n"
                    "\n"
                    "\n"
                    "#define bbbb 4\n"
                    "#define ccc       (5)",
                    Style));
 }
 
+TEST_F(FormatTest, AlignPointersInCasts) {
+  FormatStyle Style = getLLVMStyle();
+  Style.PointerAlignment = FormatStyle::PAS_Right;
+  verifyFormat("(const int (*(*foo)(const void *))[3]) a", Style);
+  Style.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("(const int (*(*foo)(const void*))[3]) a", Style);
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Right;
+  verifyFormat("(const int (*(*foo)(const void *))[3]) a", Style);
+  Style.PointerAlignment = FormatStyle::PAS_Right;
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Left;
+  verifyFormat("(const int (*(*foo)(const void*))[3]) a", Style);
+
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Pointer;
+  Style.ReferenceAlignment = FormatStyle::RAS_Pointer;
+  verifyFormat("(const int (*(*foo)(const void &))[3]) a", Style);
+  Style.ReferenceAlignment = FormatStyle::RAS_Left;
+  verifyFormat("(const int (*(*foo)(const void&))[3]) a", Style);
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Right;
+  verifyFormat("(const int (*(*foo)(const void &))[3]) a", Style);
+  Style.ReferenceAlignment = FormatStyle::RAS_Right;
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Left;
+  verifyFormat("(const int (*(*foo)(const void&))[3]) a", Style);
+}
+
 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {
   FormatStyle Alignment = getLLVMStyle();
   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossEmptyLines;
 
   Alignment.MaxEmptyLinesToKeep = 10;
   /* Test alignment across empty lines */
   EXPECT_EQ("int a           = 5;\n"
TEST_F(FormatTest, ParsesConfiguration) {
 
   Style.PointerAlignment = FormatStyle::PAS_Middle;
   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
               FormatStyle::PAS_Left);
   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
               FormatStyle::PAS_Right);
   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
               FormatStyle::PAS_Middle);
+  Style.PointerAlignmentInCast = FormatStyle::PACS_Left;
+  CHECK_PARSE("PointerAlignmentInCast: Pointer", PointerAlignmentInCast,
+              FormatStyle::PACS_Pointer);
+  CHECK_PARSE("PointerAlignmentInCast: Left", PointerAlignmentInCast,
+              FormatStyle::PACS_Left);
+  CHECK_PARSE("PointerAlignmentInCast: Right", PointerAlignmentInCast,
+              FormatStyle::PACS_Right);
   Style.ReferenceAlignment = FormatStyle::RAS_Middle;
   CHECK_PARSE("ReferenceAlignment: Pointer", ReferenceAlignment,
               FormatStyle::RAS_Pointer);
   CHECK_PARSE("ReferenceAlignment: Left", ReferenceAlignment,
               FormatStyle::RAS_Left);
   CHECK_PARSE("ReferenceAlignment: Right", ReferenceAlignment,
               FormatStyle::RAS_Right);
   CHECK_PARSE("ReferenceAlignment: Middle", ReferenceAlignment,