[clang-format] Add ability to align Objective-C property declarations

[matto1990]

Summary

In Objective-C some style guides use a style where property declarations are aligned, to help with code readability. I've added an option which enable this functionality. It is disabled by default.

The option will align code so

@property(nonatomic, weak) NSNumber *text;
@property(nonatomic) BOOL trueOrFalse;

becomes

@property(nonatomic, weak) NSNumber *text;
@property(nonatomic)       BOOL     trueOrFalse;

[djasper]

Generally, you need to assign a reviewer (me for clang-format changes). Otherwise, these might just get lost on the list.

lib/Format/WhitespaceManager.cpp

32

Manuel, what was the original reason why we don't just store a pointer to the token?

239

"all of the changed"?

324–344

I am actually quite strongly against this. This essentially introduce some additional (mini-)parser in WhitespaceManager. We have so many steps doing parsing already that I think we really should be doing some of this there.

(This might actually also be the right thing to do for assignments, although "parsing" those is much simple).

I think we should extend TokenAnnotator. I just looked at it and it already has the LineType ObjCProperty. I think we should probably just re-use that in some fashion. So the question is how do we carry information about (unwrapped) lines to the WhitespaceManager.

Not quite sure yet how to do that. I'll take a look next week if you don't beat me to it.

Also, if we preserved more of the token information, we would already know, where the name of the property starts (I think).

docs/ClangFormatStyleOptions.rst

**NamespaceIndentation** (``NamespaceIndentationKind``)
   * ``NI_None`` (in configuration: ``None``)
     Don't indent in namespaces.
   * ``NI_Inner`` (in configuration: ``Inner``)
     Indent only in inner namespaces (nested in other namespaces).
   * ``NI_All`` (in configuration: ``All``)
     Indent in all namespaces.
 
 
+**ObjCAlignPropertyDeclaration** (``bool``)
+  If ``true``, aligns Objective-C property declaration to increase
+  readability.
+
+  This will align the Objective-C property declaration that are on
+  consecutive lines. This will result in formattings like
+  \code
+  @property (nonatomic, strong)           NSMutableString \*text;
+  @property (nonatomic, strong, readonly) NSString        \*readonly;
+  @property (nonatomic, weak)             NSNumber        \*text;
+  @property (nonatomic)                   BOOL            trueOrFalse;
+  \endcode
+
 **ObjCBlockIndentWidth** (``unsigned``)
   The number of characters to use for indentation of ObjC blocks.
 
 **ObjCSpaceAfterProperty** (``bool``)
   Add a space after ``@property`` in Objective-C, i.e. use
   ``\@property (readonly)`` instead of ``\@property(readonly)``.
 
 **ObjCSpaceBeforeProtocolList** (``bool``)

include/clang/Format/Format.h

struct FormatStyle {
   /// int ccc  = 23;
   /// \endcode
   bool AlignConsecutiveAssignments;
 
   /// \brief If \c true, aligns escaped newlines as far left as possible.
   /// Otherwise puts them into the right-most column.
   bool AlignEscapedNewlinesLeft;
 
+  /// \brief If \c true, aligns Objective-C property declaration to increase
+  /// readability.
+  ///
+  /// This will align the Objective-C property declaration that are on
+  /// consecutive lines. This will result in formattings like
+  /// \code
+  /// @property (nonatomic, strong)           NSMutableString *text;
+  /// @property (nonatomic, strong, readonly) NSString        *readonly;
+  /// @property (nonatomic, weak)             NSNumber        *text;
+  /// @property (nonatomic)                   BOOL            trueOrFalse;
+  /// \endcode
+  bool ObjCAlignPropertyDeclaration;
+
   /// \brief The number of columns to use for indentation.
   unsigned IndentWidth;
 
   /// \brief The number of columns used for tab stops.
   unsigned TabWidth;
 
   /// \brief The number of characters to use for indentation of constructor
   /// initializer lists.

lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     }
 
     IO.mapOptional("AccessModifierOffset", Style.AccessModifierOffset);
     IO.mapOptional("AlignAfterOpenBracket", Style.AlignAfterOpenBracket);
     IO.mapOptional("AlignEscapedNewlinesLeft", Style.AlignEscapedNewlinesLeft);
     IO.mapOptional("AlignOperands", Style.AlignOperands);
     IO.mapOptional("AlignTrailingComments", Style.AlignTrailingComments);
     IO.mapOptional("AlignConsecutiveAssignments", Style.AlignConsecutiveAssignments);
+    IO.mapOptional("ObjCAlignPropertyDeclaration", Style.ObjCAlignPropertyDeclaration);
     IO.mapOptional("AllowAllParametersOfDeclarationOnNextLine",
                    Style.AllowAllParametersOfDeclarationOnNextLine);
     IO.mapOptional("AllowShortBlocksOnASingleLine",
                    Style.AllowShortBlocksOnASingleLine);
     IO.mapOptional("AllowShortCaseLabelsOnASingleLine",
                    Style.AllowShortCaseLabelsOnASingleLine);
     IO.mapOptional("AllowShortIfStatementsOnASingleLine",
                    Style.AllowShortIfStatementsOnASingleLine);
FormatStyle getLLVMStyle() {
   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
   LLVMStyle.IndentCaseLabels = false;
   LLVMStyle.IndentWrappedFunctionNames = false;
   LLVMStyle.IndentWidth = 2;
   LLVMStyle.TabWidth = 8;
   LLVMStyle.MaxEmptyLinesToKeep = 1;
   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
+  LLVMStyle.ObjCAlignPropertyDeclaration = false;
   LLVMStyle.ObjCBlockIndentWidth = 2;
   LLVMStyle.ObjCSpaceAfterProperty = false;
   LLVMStyle.ObjCSpaceBeforeProtocolList = true;
   LLVMStyle.PointerAlignment = FormatStyle::PAS_Right;
   LLVMStyle.SpacesBeforeTrailingComments = 1;
   LLVMStyle.Standard = FormatStyle::LS_Cpp11;
   LLVMStyle.UseTab = FormatStyle::UT_Never;
   LLVMStyle.SpacesInParentheses = false;

lib/Format/WhitespaceManager.h

struct Change {
     /// and \p CurrentLinePrefix.
     ///
     /// \p StartOfTokenColumn and \p InPPDirective will be used to lay out
     /// trailing comments and escaped newlines.
     Change(bool CreateReplacement, const SourceRange &OriginalWhitespaceRange,
            unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn,
            unsigned NewlinesBefore, StringRef PreviousLinePostfix,
            StringRef CurrentLinePrefix, tok::TokenKind Kind,
-           bool ContinuesPPDirective);
+           tok::ObjCKeywordKind ObjCKind, bool ContinuesPPDirective);
 
     bool CreateReplacement;
     // Changes might be in the middle of a token, so we cannot just keep the
     // FormatToken around to query its information.
     SourceRange OriginalWhitespaceRange;
     unsigned StartOfTokenColumn;
     unsigned NewlinesBefore;
     std::string PreviousLinePostfix;
     std::string CurrentLinePrefix;
     // The kind of the token whose whitespace this change replaces, or in which
     // this change inserts whitespace.
     // FIXME: Currently this is not set correctly for breaks inside comments, as
     // the \c BreakableToken is still doing its own alignment.
     tok::TokenKind Kind;
+    tok::ObjCKeywordKind ObjCKind;
     bool ContinuesPPDirective;
 
     // The number of nested blocks the token is in. This is used to add tabs
     // only for the indentation, and not for alignment, when
     // UseTab = US_ForIndentation.
     unsigned IndentLevel;
 
     // The number of spaces in front of the token or broken part of the token.
private:
 
   /// \brief Align consecutive assignments over all \c Changes.
   void alignConsecutiveAssignments();
 
   /// \brief Align consecutive assignments from change \p Start to change \p End at
   /// the specified \p Column.
   void alignConsecutiveAssignments(unsigned Start, unsigned End, unsigned Column);
 
+  /// \brief Aligns Objective-C property declarations over all \c Changes.
+  void alignObjCPropertyDeclarations();
+
+  /// \brief Aligns the type declaration part of Objective-C property
+  /// declarations from change \p Start to change \p End at the specified
+  /// \p Column.
+  void alignObjCPropertyTypeDeclarations(unsigned Start, unsigned End, unsigned Column);
+
+  /// \brief Aligns the variable name part of Objective-C property declarations
+  /// from change \p Start to change \p End at the specified \p Column.
+  void alignObjCPropertyVariableDeclarations(unsigned Start, unsigned End, unsigned Column);
+
   /// \brief Align trailing comments over all \c Changes.
   void alignTrailingComments();
 
   /// \brief Align trailing comments from change \p Start to change \p End at
   /// the specified \p Column.
   void alignTrailingComments(unsigned Start, unsigned End, unsigned Column);
 
   /// \brief Align escaped newlines over all \c Changes.

lib/Format/WhitespaceManager.cpp

return SourceMgr.isBeforeInTranslationUnit(
       C1.OriginalWhitespaceRange.getBegin(),
       C2.OriginalWhitespaceRange.getBegin());
 }
 
 WhitespaceManager::Change::Change(
     bool CreateReplacement, const SourceRange &OriginalWhitespaceRange,
     unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn,
     unsigned NewlinesBefore, StringRef PreviousLinePostfix,
-    StringRef CurrentLinePrefix, tok::TokenKind Kind, bool ContinuesPPDirective)
+    StringRef CurrentLinePrefix, tok::TokenKind Kind,
+    tok::ObjCKeywordKind ObjCKind, bool ContinuesPPDirective)
     : CreateReplacement(CreateReplacement),
       OriginalWhitespaceRange(OriginalWhitespaceRange),
       StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore),
       PreviousLinePostfix(PreviousLinePostfix),
-      CurrentLinePrefix(CurrentLinePrefix), Kind(Kind),
+      CurrentLinePrefix(CurrentLinePrefix), Kind(Kind), ObjCKind(ObjCKind),
       ContinuesPPDirective(ContinuesPPDirective), IndentLevel(IndentLevel),
       Spaces(Spaces), IsTrailingComment(false), TokenLength(0),
       PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0),
       StartOfBlockComment(nullptr), IndentationOffset(0) {}
 
 void WhitespaceManager::reset() {
   Changes.clear();
   Replaces.clear();
 }
 
 void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines,
                                           unsigned IndentLevel, unsigned Spaces,
                                           unsigned StartOfTokenColumn,
                                           bool InPPDirective) {
   if (Tok.Finalized)
     return;
   Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue;
   Changes.push_back(Change(true, Tok.WhitespaceRange, IndentLevel, Spaces,
                            StartOfTokenColumn, Newlines, "", "",
-                           Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst));
+                           Tok.Tok.getKind(), Tok.Tok.getObjCKeywordID(),
+                           InPPDirective && !Tok.IsFirst));
 }
 
 void WhitespaceManager::addUntouchableToken(const FormatToken &Tok,
                                             bool InPPDirective) {
   if (Tok.Finalized)
     return;
   Changes.push_back(Change(false, Tok.WhitespaceRange, /*IndentLevel=*/0,
                            /*Spaces=*/0, Tok.OriginalColumn, Tok.NewlinesBefore,
                            "", "", Tok.Tok.getKind(),
+                           Tok.Tok.getObjCKeywordID(),
                            InPPDirective && !Tok.IsFirst));
 }
 
 void WhitespaceManager::replaceWhitespaceInToken(
     const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars,
     StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective,
     unsigned Newlines, unsigned IndentLevel, int Spaces) {
   if (Tok.Finalized)
     return;
   SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset);
   Changes.push_back(Change(
       true, SourceRange(Start, Start.getLocWithOffset(ReplaceChars)),
       IndentLevel, Spaces, std::max(0, Spaces), Newlines, PreviousPostfix,
       CurrentPrefix,
       // If we don't add a newline this change doesn't start a comment. Thus,
       // when we align line comments, we don't need to treat this change as one.
       // FIXME: We still need to take this change in account to properly
       // calculate the new length of the comment and to calculate the changes
       // for which to do the alignment when aligning comments.
       Tok.is(TT_LineComment) && Newlines > 0 ? tok::comment : tok::unknown,
-      InPPDirective && !Tok.IsFirst));
+      Tok.Tok.getObjCKeywordID(), InPPDirective && !Tok.IsFirst));
 }
 
 const tooling::Replacements &WhitespaceManager::generateReplacements() {
   if (Changes.empty())
     return Replaces;
 
   std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr));
   calculateLineBreakInformation();
   alignConsecutiveAssignments();
+  alignObjCPropertyDeclarations();
   alignTrailingComments();
   alignEscapedNewlines();
   generateChanges();
 
   return Replaces;
 }
 
 void WhitespaceManager::calculateLineBreakInformation() {
for (unsigned i = Start; i != End; ++i) {
     if (AlignedAssignment) {
       Changes[i].StartOfTokenColumn += PreviousShift;
       if (i + 1 != Changes.size())
         Changes[i + 1].PreviousEndOfTokenColumn += PreviousShift;
     }
   }
 }
 
+// Walk through all of the changed and find the property declarations to align.
+// We do so in two passes. The first will find consecutive lines which begin
+// with a property token and then find the start of the type declaration,
+// the first token after the right parenthesis. These are then aligned. In the
+// second pass we detect the same property tokens but look for the ending
+// semi-colon. We then align on either the variable name (if there is no
+// pointer or the pointer is not right aligned) or the pointer symbol.
+void WhitespaceManager::alignObjCPropertyDeclarations() {
+  if (!Style.ObjCAlignPropertyDeclaration)
+    return;
+
+  unsigned StartOfSequence = 0;
+  unsigned EndOfSequence = 0;
+  bool FoundPropertyOnLine = false;
+  bool FoundRightParenOnLine = false;
+  bool FoundSemiColonOnLine = false;
+  unsigned MinTypeColumn = 0;
+  unsigned MinVariableColumn = 0;
+
+  auto AlignSequence = [&] {
+    if (MinTypeColumn > 0) {
+      alignObjCPropertyTypeDeclarations(StartOfSequence, EndOfSequence,
+                                        MinTypeColumn);
+    } else if (MinVariableColumn > 0) {
+      alignObjCPropertyVariableDeclarations(StartOfSequence, EndOfSequence,
+                                            MinVariableColumn);
+    }
+    StartOfSequence = 0;
+    EndOfSequence = 0;
+    MinTypeColumn = 0;
+    MinVariableColumn = 0;
+  };
+
+  auto BeginNewline = [&](unsigned i) {
+    if (StartOfSequence > 0 &&
+        (Changes[i].NewlinesBefore > 1 || !FoundPropertyOnLine ||
+         (FoundPropertyOnLine &&
+          (!FoundRightParenOnLine || !FoundSemiColonOnLine)))) {
+      EndOfSequence = i - 1;
+      AlignSequence();
+    }
+    FoundPropertyOnLine = false;
+    FoundRightParenOnLine = false;
+    FoundSemiColonOnLine = false;
+  };
+
+  for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
+    if (Changes[i].NewlinesBefore != 0)
+      BeginNewline(i);
+
+    if (Changes[i].ObjCKind == tok::objc_property) {
+      FoundPropertyOnLine = true;
+      if (StartOfSequence == 0)
+        StartOfSequence = i;
+    } else if (FoundPropertyOnLine && Changes[i].Kind == tok::r_paren &&
+               !FoundRightParenOnLine) {
+      FoundRightParenOnLine = true;
+      if (i + 1 != Changes.size()) {
+        unsigned ChangeTypeColumn = Changes[i + 1].StartOfTokenColumn;
+        MinTypeColumn = std::max(MinTypeColumn, ChangeTypeColumn);
+      }
+    } else if (Changes[i].Kind == tok::semi && !FoundSemiColonOnLine) {
+      FoundSemiColonOnLine = true;
+    }
+  }
+
+  if (StartOfSequence > 0) {
+    EndOfSequence = Changes.size();
+    AlignSequence();
+  }
+
+  StartOfSequence = 0;
+  EndOfSequence = 0;
+  FoundPropertyOnLine = false;
+  FoundRightParenOnLine = false;
+  FoundSemiColonOnLine = false;
+  MinTypeColumn = 0;
+  MinVariableColumn = 0;
+
+  for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
+    // Check if we started a newline and if a sequence ended. Align it if we
+    // did.
+    if (Changes[i].NewlinesBefore != 0)
+      BeginNewline(i);
+
+    if (Changes[i].ObjCKind == tok::objc_property) {
+      FoundPropertyOnLine = true;
+      if (StartOfSequence == 0)
+        StartOfSequence = i;
+    } else if (FoundPropertyOnLine && Changes[i].Kind == tok::r_paren &&
+               !FoundRightParenOnLine) {
+      FoundRightParenOnLine = true;
+    } else if (FoundRightParenOnLine && Changes[i].Kind == tok::semi &&
+               !FoundSemiColonOnLine) {
+      FoundSemiColonOnLine = true;
+      if (Changes[i - 1].Kind == tok::identifier) {
+        unsigned VariableChangeIndex = i - 1;
+        if (Style.PointerAlignment == FormatStyle::PAS_Right &&
+            Changes[i - 2].Kind == tok::star)
+          VariableChangeIndex = i - 2;
+        unsigned ChangeVariableColumn =
+            Changes[VariableChangeIndex].StartOfTokenColumn;
+        MinVariableColumn = std::max(MinVariableColumn, ChangeVariableColumn);
+      }
+    }
+  }
+
+  if (StartOfSequence > 0) {
+    EndOfSequence = Changes.size();
+    AlignSequence();
+  }
+}
+
+void WhitespaceManager::alignObjCPropertyTypeDeclarations(unsigned Start,
+                                                          unsigned End,
+                                                          unsigned Column) {
+  bool FoundRightParenOnLine = false;
+  unsigned PreviousShift = 0;
+  for (unsigned i = Start; i != End; ++i) {
+    int Shift = 0;
+    if (Changes[i].NewlinesBefore > 0) {
+      FoundRightParenOnLine = false;
+      PreviousShift = 0;
+    }
+
+    if (Changes[i].Kind == tok::r_paren && !FoundRightParenOnLine) {
+      FoundRightParenOnLine = true;
+      if (i + 1 != Changes.size()) {
+        Shift = Column - Changes[i + 1].StartOfTokenColumn;
+        assert(Shift >= 0);
+        Changes[i + 1].Spaces += Shift;
+        if (i + 2 != Changes.size())
+          Changes[i + 2].PreviousEndOfTokenColumn += Shift;
+        Changes[i + 1].StartOfTokenColumn += Shift;
+        PreviousShift = Shift;
+      }
+    }
+
+    if (FoundRightParenOnLine) {
+      Changes[i].StartOfTokenColumn += PreviousShift;
+      if (i + 1 != Changes.size())
+        Changes[i + 1].PreviousEndOfTokenColumn += PreviousShift;
+    }
+  }
+}
+
+void WhitespaceManager::alignObjCPropertyVariableDeclarations(unsigned Start,
+                                                              unsigned End,
+                                                              unsigned Column) {
+  bool FoundSemiColonOnLine = false;
+  unsigned PreviousShift = 0;
+  for (unsigned i = Start; i != End; ++i) {
+    int Shift = 0;
+    if (Changes[i].NewlinesBefore > 0) {
+      FoundSemiColonOnLine = false;
+      PreviousShift = 0;
+    }
+
+    if (Changes[i].Kind == tok::semi && !FoundSemiColonOnLine) {
+      FoundSemiColonOnLine = true;
+      if (Changes[i - 1].Kind == tok::identifier) {
+        unsigned VariableChangeIndex = i - 1;
+        if (Style.PointerAlignment == FormatStyle::PAS_Right &&
+            Changes[i - 2].Kind == tok::star)
+          VariableChangeIndex = i - 2;
+        Shift = Column - Changes[VariableChangeIndex].StartOfTokenColumn;
+        assert(Shift >= 0);
+        Changes[VariableChangeIndex].Spaces += Shift;
+        if (VariableChangeIndex + 1 != Changes.size())
+          Changes[VariableChangeIndex + 1].PreviousEndOfTokenColumn += Shift;
+        Changes[VariableChangeIndex + 1].StartOfTokenColumn += Shift;
+        PreviousShift = Shift;
+      }
+    }
+
+    if (FoundSemiColonOnLine) {
+      Changes[i].StartOfTokenColumn += PreviousShift;
+      if (i + 1 != Changes.size())
+        Changes[i + 1].PreviousEndOfTokenColumn += PreviousShift;
+    }
+  }
+}
+
 void WhitespaceManager::alignTrailingComments() {
   unsigned MinColumn = 0;
   unsigned MaxColumn = UINT_MAX;
   unsigned StartOfSequence = 0;
   bool BreakBeforeNext = false;
   unsigned Newlines = 0;
   for (unsigned i = 0, e = Changes.size(); i != e; ++i) {
     if (Changes[i].StartOfBlockComment)

unittests/Format/FormatTest.cpp

TEST_F(FormatTest, AlignConsecutiveAssignments) {
   verifyFormat(
       "int i      = 1;\n"
       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
       "                          loooooooooooooooooooooongParameterB);\n"
       "int j = 2;",
       Alignment);
 }
 
+TEST_F(FormatTest, ObjCAlignPropertyDeclaration) {
+  FormatStyle PropertyAlignment = getLLVMStyle();
+  PropertyAlignment.ObjCAlignPropertyDeclaration = false;
+  verifyFormat("@property(nonatomic, strong) NSMutableString *text;\n"
+               "@property(nonatomic, strong, readonly) NSString *readonly;\n"
+               "@property(nonatomic, weak) NSNumber *text;\n"
+               "@property(nonatomic) BOOL trueOrFalse;",
+               PropertyAlignment);
+
+  PropertyAlignment.ObjCAlignPropertyDeclaration = true;
+  verifyFormat("@property(nonatomic, strong)           NSMutableString *text;\n"
+               "@property(nonatomic, strong, readonly) NSString        *readonly;\n"
+               "@property(nonatomic, weak)             NSNumber        *text;\n"
+               "@property(nonatomic)                   BOOL            trueOrFalse;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong)           NSMutableString *text;\n"
+               "@property(nonatomic, strong, readonly) NSString        *readonly;\n"
+               "// Nothing here\n"
+               "@property(nonatomic, weak) NSNumber *text;\n"
+               "@property(nonatomic)       BOOL     trueOrFalse;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong, readonly) NSString        *readonly;\n"
+               "@property(nonatomic, strong)           NSMutableString *text;\n"
+               "// Nothing here\n"
+               "@property(nonatomic)       BOOL     trueOrFalse;\n"
+               "@property(nonatomic, weak) NSNumber *text;\n",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong, getter=iNeedText) NSMutableString *text;\n"
+               "@property(nonatomic, strong, readonly)         NSString        *readonly;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong)           NSArray /* NSString */ *text;\n"
+               "@property(nonatomic, strong, readonly) NSString               *readonly;",
+               PropertyAlignment);
+
+  verifyFormat("@property(nonatomic) BOOL trueOrFalse;\n"
+               "@property(nonatomic, strong)\n"
+               "    NSLooooooooooooooonnnnnnngggggggTyyyyyppppppeeee *loooooooooonnnnngVariable;\n"
+               "@property(nonatomic, weak)           NSNumber *text;\n"
+               "@property(nonatomic, weak, readonly) NSArray  *array;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong)\n"
+               "    NSLooooooooooooooonnnnnnngggggggTyyyyyppppppeeee *loooooooooonnnnngVariable;\n"
+               "@property(nonatomic, weak)           NSNumber *text;\n"
+               "@property(nonatomic, weak, readonly) NSArray  *array;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, weak)   NSNumberThingy *text;\n"
+               "@property(nonatomic, strong) NSArray        *array;\n"
+               "@property(nonatomic, strong)\n"
+               "    NSLooooooooooooooonnnnnnngggggggTyyyyyppppppeeee *loooooooooonnnnngVariable;\n"
+               "@property(nonatomic, weak)           NSNumber *text;\n"
+               "@property(nonatomic, weak, readonly) NSArray  *array;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, weak)           NSNumber *text;\n"
+               "@property(nonatomic, weak, readonly) NSArray  *array;\n"
+               "@property(nonatomic, strong)\n"
+               "    NSLooooooooooooooonnnnnnngggggggTyyyyyppppppeeee *loooooooooonnnnngVariable;",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong)           NSMutableString *text;\n"
+               "@property(nonatomic, strong, readonly) NSString *\n"
+               "    loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooongVariableName;\n"
+               "@property(nonatomic, weak) NSNumber *text;\n"
+               "@property(nonatomic)       BOOL     trueOrFalse;",
+               PropertyAlignment);
+
+  PropertyAlignment.AlignTrailingComments = false;
+  verifyFormat("@property(nonatomic, strong)           NSMutableString *text; // Comment\n"
+               "@property(nonatomic, strong, readonly) NSString        *readonly; // Comment",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong, readonly) NSString        *readonly; // Comment\n"
+               "@property(nonatomic, strong)           NSMutableString *text; // Comment",
+               PropertyAlignment);
+  PropertyAlignment.AlignTrailingComments = true;
+  verifyFormat("@property(nonatomic, strong)           NSMutableString *text;     // Comment\n"
+               "@property(nonatomic, strong, readonly) NSString        *readonly; // Comment",
+               PropertyAlignment);
+  verifyFormat("@property(nonatomic, strong, readonly) NSString        *readonly; // Comment\n"
+               "@property(nonatomic, strong)           NSMutableString *text;     // Comment",
+               PropertyAlignment);
+
+  PropertyAlignment.ObjCSpaceAfterProperty = true;
+  verifyFormat("@property (nonatomic, strong)           NSMutableString *text;\n"
+               "@property (nonatomic, strong, readonly) NSString        *readonly;\n"
+               "@property (nonatomic, weak)             NSNumber        *text;\n"
+               "@property (nonatomic)                   BOOL            trueOrFalse;",
+               PropertyAlignment);
+  PropertyAlignment.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("@property (nonatomic, strong)           NSMutableString* text;\n"
+               "@property (nonatomic, strong, readonly) NSString*        readonly;",
+               PropertyAlignment);
+  PropertyAlignment.PointerAlignment = FormatStyle::PAS_Middle;
+  verifyFormat("@property (nonatomic, strong)           NSMutableString * text;\n"
+               "@property (nonatomic, strong, readonly) NSString *        readonly;",
+               PropertyAlignment);
+  PropertyAlignment.ObjCSpaceAfterProperty = false;
+  PropertyAlignment.PointerAlignment = FormatStyle::PAS_Left;
+  verifyFormat("@property(nonatomic, strong)           NSMutableString* text;\n"
+               "@property(nonatomic, strong, readonly) NSString*        readonly;",
+               PropertyAlignment);
+  PropertyAlignment.PointerAlignment = FormatStyle::PAS_Middle;
+  verifyFormat("@property(nonatomic, strong)           NSMutableString * text;\n"
+               "@property(nonatomic, strong, readonly) NSString *        readonly;",
+               PropertyAlignment);
+}
+
 TEST_F(FormatTest, LinuxBraceBreaking) {
   FormatStyle LinuxBraceStyle = getLLVMStyle();
   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
   verifyFormat("namespace a\n"
                "{\n"
                "class A\n"
                "{\n"
                "  void f()\n"