clang-format: never align after 'return' for Java

[het]

Summary

In Java, alignment after returns is usually disabled: see https://github.com/google/guava/blob/master/guava/src/com/google/common/collect/Maps.java#L548

[djasper]

Hm. If you think this is Java-specific, I might be inclined to gate this based on the Style's Language for now. The problem is that each additional configuration flag has a certain amount of cost, e.g. because:

• Style flags become less discoverable
• Maintenance increases when ensuring that all combinations of flags work as expected

[djasper]

Submitted as r222424.

include/clang/Format/Format.h

struct FormatStyle {
   /// This applies to round brackets (parentheses), angle brackets and square
   /// brackets. This will result in formattings like
   /// \code
   /// someLongFunction(argument1,
   ///                  argument2);
   /// \endcode
   bool AlignAfterOpenBracket;
 
+  /// \brief Different ways to align after 'return'.
+  enum ReturnAlignStyle {
+    /// Never align after return.
+    RA_Never,
+    /// Align after return except for builder-style calls.
+    RA_ExceptBuilder,
+    /// Always align after return
+    RA_Always
+  };
+
+  /// \brief How to align expressions following 'return'.
+  ReturnAlignStyle AlignAfterReturn;
+
   /// \brief If \c true, aligns trailing comments.
   bool AlignTrailingComments;
 
   /// \brief If \c true, aligns escaped newlines as far left as possible.
   /// Otherwise puts them into the right-most column.
   bool AlignEscapedNewlinesLeft;
 
   /// \brief The number of columns to use for indentation.
struct FormatStyle {
   /// \endcode
   ///
   /// For example: BOOST_FOREACH.
   std::vector<std::string> ForEachMacros;
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
+           AlignAfterReturn == R.AlignAfterReturn &&
            AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
            AlignTrailingComments == R.AlignTrailingComments &&
            AllowAllParametersOfDeclarationOnNextLine ==
                R.AllowAllParametersOfDeclarationOnNextLine &&
            AllowShortFunctionsOnASingleLine ==
                R.AllowShortFunctionsOnASingleLine &&
            AllowShortBlocksOnASingleLine == R.AllowShortBlocksOnASingleLine &&
            AllowShortIfStatementsOnASingleLine ==

lib/Format/ContinuationIndenter.cpp

bool SkipFirstExtraIndent =
                     Previous->Type == TT_ObjCMethodExpr));
   for (SmallVectorImpl<prec::Level>::const_reverse_iterator
            I = Current.FakeLParens.rbegin(),
            E = Current.FakeLParens.rend();
        I != E; ++I) {
     ParenState NewParenState = State.Stack.back();
     NewParenState.ContainsLineBreak = false;
 
-    // Indent from 'LastSpace' unless these are fake parentheses encapsulating
-    // a builder type call after 'return' or, if the alignment after opening
-    // brackets is disabled.
-    if (!Current.isTrailingComment() &&
-        (!Previous || Previous->isNot(tok::kw_return) || *I > 0) &&
-        (Style.AlignAfterOpenBracket || *I != prec::Comma ||
-         Current.NestingLevel == 0))
+    // Indent from 'LastSpace' unless alignment after 'return' is disabled or
+    // alignment after opening brackets is disabled.
+    bool ShouldAlign = !Current.isTrailingComment();
+    if (Previous && Previous->is(tok::kw_return)) {
+      if (Style.AlignAfterReturn == FormatStyle::RA_Never)
+        ShouldAlign = false;
+      if (Style.AlignAfterReturn == FormatStyle::RA_ExceptBuilder)
+        ShouldAlign &= *I > 0;
+    }
+    if (!Style.AlignAfterOpenBracket && *I == prec::Comma &&
+        Current.NestingLevel > 0)
+      ShouldAlign = false;
+    if (ShouldAlign)
       NewParenState.Indent =
           std::max(std::max(State.Column, NewParenState.Indent),
                    State.Stack.back().LastSpace);
 
     // Don't allow the RHS of an operator to be split over multiple lines unless
     // there is a line-break right after the operator.
     // Exclude relational operators, as there, it is always more desirable to
     // have the LHS 'left' of the RHS.

lib/Format/Format.cpp

static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
     IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03);
     IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03);
     IO.enumCase(Value, "Cpp11", FormatStyle::LS_Cpp11);
     IO.enumCase(Value, "C++11", FormatStyle::LS_Cpp11);
     IO.enumCase(Value, "Auto", FormatStyle::LS_Auto);
   }
 };
 
+template <> struct ScalarEnumerationTraits<FormatStyle::ReturnAlignStyle> {
+  static void enumeration(IO &IO, FormatStyle::ReturnAlignStyle &Value) {
+    IO.enumCase(Value, "Never", FormatStyle::RA_Never);
+    IO.enumCase(Value, "false", FormatStyle::RA_Never);
+    IO.enumCase(Value, "Always", FormatStyle::RA_Always);
+    IO.enumCase(Value, "true", FormatStyle::RA_Always);
+    IO.enumCase(Value, "ExceptBuilder", FormatStyle::RA_ExceptBuilder);
+  }
+};
+
 template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
   static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
     IO.enumCase(Value, "Never", FormatStyle::UT_Never);
     IO.enumCase(Value, "false", FormatStyle::UT_Never);
     IO.enumCase(Value, "Always", FormatStyle::UT_Always);
     IO.enumCase(Value, "true", FormatStyle::UT_Always);
     IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
   }
if (IO.outputting()) {
           return;
         }
         Style.Language = OldLanguage;
       }
     }
 
     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
+    IO.mapOptional("AlignAfterReturn", Style.AlignAfterReturn);
     IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
     IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
                    Style.AllowAllParametersOfDeclarationOnNextLine);
     IO.mapOptional("AllowShortBlocksOnASingleLine",
                    Style.AllowShortBlocksOnASingleLine);
     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
                    Style.AllowShortCaseLabelsOnASingleLine);

 }
 
 FormatStyle getLLVMStyle() {
   FormatStyle LLVMStyle;
   LLVMStyle.Language = FormatStyle::LK_Cpp;
   LLVMStyle.AccessModifierOffset = -2;
   LLVMStyle.AlignEscapedNewlinesLeft = false;
   LLVMStyle.AlignAfterOpenBracket = true;
+  LLVMStyle.AlignAfterReturn = FormatStyle::RA_ExceptBuilder;
   LLVMStyle.AlignTrailingComments = true;
   LLVMStyle.AllowAllParametersOfDeclarationOnNextLine = true;
   LLVMStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
   LLVMStyle.AllowShortBlocksOnASingleLine = false;
   LLVMStyle.AllowShortCaseLabelsOnASingleLine = false;
   LLVMStyle.AllowShortIfStatementsOnASingleLine = false;
   LLVMStyle.AllowShortLoopsOnASingleLine = false;
   LLVMStyle.AlwaysBreakAfterDefinitionReturnType = false;
FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   GoogleStyle.SpacesBeforeTrailingComments = 2;
   GoogleStyle.Standard = FormatStyle::LS_Auto;
 
   GoogleStyle.PenaltyReturnTypeOnItsOwnLine = 200;
   GoogleStyle.PenaltyBreakBeforeFirstCallParameter = 1;
 
   if (Language == FormatStyle::LK_Java) {
     GoogleStyle.AlignAfterOpenBracket = false;
+    GoogleStyle.AlignAfterReturn = FormatStyle::RA_Never;
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
     GoogleStyle.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
     GoogleStyle.ColumnLimit = 100;
     GoogleStyle.SpaceAfterCStyleCast = true;
     GoogleStyle.SpacesBeforeTrailingComments = 1;
   } else if (Language == FormatStyle::LK_JavaScript) {
     GoogleStyle.BreakBeforeTernaryOperators = false;
     GoogleStyle.MaxEmptyLinesToKeep = 3;

unittests/Format/FormatTest.cpp

 }
 
 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
   verifyFormat("double\n"
                "f();",
                getLLVMStyleWithColumns(8));
 }
 
+TEST_F(FormatTest, ConfigurableAlignmentAfterReturn) {
+  FormatStyle Style = getLLVMStyleWithColumns(40);
+  Style.AlignAfterReturn = FormatStyle::RA_Always;
+  verifyFormat("return SomeLongObject\n"
+               "           .someVeryLongFunction()\n"
+               "           .someLongFunction();",
+               Style);
+
+  Style.AlignAfterReturn = FormatStyle::RA_ExceptBuilder;
+  verifyFormat("return SomeLongObject\n"
+               "    .someVeryLongFunction()\n"
+               "    .someLongFunction();",
+               Style);
+  verifyFormat("return SomeLongObject +\n"
+               "       SomethingVeryLongVarName +\n"
+               "       SomethingElse;",
+               Style);
+
+  Style.AlignAfterReturn = FormatStyle::RA_Never;
+  verifyFormat("return SomeLongObject\n"
+               "    .someVeryLongFunction()\n"
+               "    .someLongFunction();",
+               Style);
+  verifyFormat("return SomeLongObject +\n"
+               "    SomethingVeryLongVarName +\n"
+               "    SomethingElse;",
+               Style);
+}
+
 TEST_F(FormatTest, ConfigurableUseOfTab) {
   FormatStyle Tab = getLLVMStyleWithColumns(42);
   Tab.IndentWidth = 8;
   Tab.UseTab = FormatStyle::UT_Always;
   Tab.AlignEscapedNewlinesLeft = true;
 
   EXPECT_EQ("if (aaaaaaaa && // q\n"
             "    bb)\t\t// w\n"
TEST_F(FormatTest, ParsesConfiguration) {
   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
               FormatStyle::BOS_All);
   // For backward compatibility:
   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
               FormatStyle::BOS_None);
   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
               FormatStyle::BOS_All);
 
+  Style.AlignAfterReturn = FormatStyle::RA_ExceptBuilder;
+  CHECK_PARSE("AlignAfterReturn: Never", AlignAfterReturn,
+              FormatStyle::RA_Never);
+  CHECK_PARSE("AlignAfterReturn: ExceptBuilder", AlignAfterReturn,
+              FormatStyle::RA_ExceptBuilder);
+  CHECK_PARSE("AlignAfterReturn: Always", AlignAfterReturn,
+              FormatStyle::RA_Always);
+  // For backward compatibility:
+  CHECK_PARSE("AlignAfterReturn: false", AlignAfterReturn,
+              FormatStyle::RA_Never);
+  CHECK_PARSE("AlignAfterReturn: true", AlignAfterReturn,
+              FormatStyle::RA_Always);
+
   Style.UseTab = FormatStyle::UT_ForIndentation;
   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
   // For backward compatibility:
   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
 

unittests/Format/FormatTestJava.cpp

 }
 
 TEST_F(FormatTestJava, CppKeywords) {
   verifyFormat("public void union(Type a, Type b);");
   verifyFormat("public void struct(Object o);");
   verifyFormat("public void delete(Object o);");
 }
 
+TEST_F(FormatTestJava, NeverAlignReturns) {
+  verifyFormat("return aaaaaaaaaaaaaaaaaaa\n"
+               "    && bbbbbbbbbbbbbbbbbbb\n"
+               "    && ccccccccccccccccccc",
+               getStyleWithColumns(40));
+  verifyFormat("return (result == null)\n"
+               "    ? aaaaaaaaaaaaaaaaa\n"
+               "    : bbbbbbbbbbbbbbbbb",
+               getStyleWithColumns(40));
+}
+
 } // end namespace tooling
 } // end namespace clang