clang-format: better handle statement macros

[Typz]

Summary

Some macros are used in the body of function, and actually contain the trailing semicolon: they should thus be automatically followed by a new line, and not get merged with the next line. This is for example the case with Qt's Q_UNUSED macro:

  
void foo(int a, int b) {
  Q_UNUSED(a)
  return b;
}

This patch deals with these cases by introducing a new option to specify list of statement macros. This re-uses the system already in place for foreach macros, to ensure there is no impact on performance.

[djasper]

clang-format already has logic to detect semicolon-less macro invocations an in fact this already does behave as I would expect. What are you fixing?

[Typz]

Without this patch, macros with no trailing semicolon _in the body of a function_ are not handled properly, so I get:

int foo(int a, int b) {
  Q_UNUSED(a) return b;
}

class Foo {
  void bar(int a, int b) { Q_UNUSED(a) Q_UNUSED(b) }
}

[djasper]

I don't. Only if they start out to be on the same line. As long as I start with:

class C {
  void foo(int a, int b) {
    Q_UNUSED(a)
    Q_UNUSED(a)
    return b;
  }
};

clang-format leaves this alone. That's good enough I think and we don't want to add more special handling for macro-DSLs than strictly necessary.

[Typz]

Digging back, it seem the issue was that I had this code:

void foo(......) { Q_UNUSED(a) Q_UNUSED(b) }

which got wrapped because the line was too long:

void foo(......) {
  Q_UNUSED(a) Q_UNUSED(b)
}

I definitely understand your concern about introduceing special handling for some specific/hard-coded macro-DSLs, but would it be acceptable to add a configuration option to specify a list of such macros? e.g. a StatementMacros option, similar to the ForEachMacros option?

That would allow:

• Systematically reformatting the first example
• If such a code is reformatted, ensure the 2 macros are not on the same line

[djasper]

I generally would not be opposed to such a patch. However, note that this might be hard to get right. We had significant performance problems in the past with ForEachMacros as we used to match every single identifier against the regex stored in there. For for loops you can somewhat get out of that and you might be able to do the same thing here, but I am not entirely sure. In contrast, the added value is actually not very large. clang-format is merely not able to automatically fix something to your liking and it's very easy to make the code right and have clang-format keep it that way.

[Typz]

Complete refactor to make the processing much more generic

[Typz]

Fix typo

[Typz]

ping?

[Typz]

ping?

[Typz]

ping?

[djasper]

So, there are two things in this patch: Statement macros and namespace macros. Lets break this out and handle them individually. They really aren't related that much.

Statement macros:
I think clang-format's handling here is good enough. clang-format does not insert the line break, but it also doesn't remove it. I am not 100% sure here, so I an be convinced. But I want to understand the use cases better. Do you expect people to run into this frequently? I am essentially trying to understand whether the cost of an extra option is worth the benefit it is giving.

Namespace macros:
How important are the automatic closing comments to you? I'd say that we should punt on that and leave it to the user to fix comments of these. And then, we could try to make the things we already have in MacroBlockBegin detect whether it ends with an opening brace and not need an extra list here. What do you think?

unittests/Format/FormatTest.cpp

1483 ↗

(On Diff #103937)

What's the difference here?

[Typz]

t>>! In D33440#812645, @djasper wrote:

So, there are two things in this patch: Statement macros and namespace macros. Lets break this out and handle them individually. They really aren't related that much.

Indeed, the only "relation" is the implementation, which now uses the exact same list (internally) to match all macros. Phabricator makes it very difficult to work with related changes pushed as multiple reviews, so I ended up merging the two features.

Statement macros:
I think clang-format's handling here is good enough. clang-format does not insert the line break, but it also doesn't remove it. I am not 100% sure here, so I an be convinced. But I want to understand the use cases better. Do you expect people to run into this frequently? I am essentially trying to understand whether the cost of an extra option is worth the benefit it is giving.

This happens relatively often, for example when fixing "unused parameter warning" on an inlined function: `int f(int a) { return 0; } often gets fixed to int f(int a) { Q_UNUSED(a) return 0; }` and clang-format does not fix the formatting...

Namespace macros:
How important are the automatic closing comments to you? I'd say that we should punt on that and leave it to the user to fix comments of these. And then, we could try to make the things we already have in MacroBlockBegin detect whether it ends with an opening brace and not need an extra list here. What do you think?

This is not just about automatic closing comments, there are may differences: indentation of namespaces, 'compacting' of namespaces when CompactNamespaces is used, detection of inline functions (for putting on a single line with SFS_Inline), handling of empty blocks (i.e. use BraceWrappingFlags.SplitEmptyNamespace)...

[Typz]

ping?

[Typz]

Rebase to master to fix merge issue

[djasper]

I'd still prefer individual patches for each of these changes. If the code review system or VCS make it hard for you to deal with two adjacent changes this way, do them in sequence.

Adding Manuel as a reviewer who has a longer term idea on how to handle macros.

[krasimir]

Patch looks good, but I also would like to see it splited. I would suggest to first get the statement macro part in, which requires less code. Then we can put the namespace macros on top of that. I really like the generality of this approach and would want to also add support for class macros eventually.

lib/Format/FormatTokenLexer.cpp

641 ↗

(On Diff #114783)

Please move this inside the following if statement, so that we only perform the search when we see a tok::pp_define.

lib/Format/NamespaceEndCommentsFixer.cpp

56 ↗

(On Diff #114783)

I don't understand why you have a Tok ? ... after you assert(Tok && ...)?

82 ↗

(On Diff #114783)

What does this comment refer to? If it's about the line above, consider moving it up.

100 ↗

(On Diff #114783)

nit: end comment with .

105 ↗

(On Diff #114783)

nit: end comment with .

155 ↗

(On Diff #114783)

What happened to the old // Detect "(inline)? namespace" in the beginning of a line.

unittests/Format/FormatTest.cpp

1588 ↗

(On Diff #114783)

Hm, what would happen if you have a namespace macro with two or more parameters?

[Typz]

lib/Format/NamespaceEndCommentsFixer.cpp

155 ↗

(On Diff #114783)

Moved to FormatToken::getNamespaceToken()

unittests/Format/FormatTest.cpp

1588 ↗

(On Diff #114783)

only the first argument is used, as seen in previous test case.

[Typz]

Fix review comments, before splitting the commit.

[Typz]

Split diff: handle only statements in here, namespace macros will be moved to another one.

[krasimir]

unittests/Format/FormatTest.cpp

2407 ↗

(On Diff #115057)

Please add tests where:

• the macro occurs inside a function body, thus having nontrivial indentation
• there are two macros one after another
• there is some code before the macro (on the same line + on a previous line with the same level)

[djasper]

lib/Format/FormatTokenLexer.cpp

642 ↗

(On Diff #115057)

This does a binary search. Why aren't you implementing it with a hashtable?

lib/Format/FormatTokenLexer.h

101 ↗

(On Diff #115057)

What does this class do and why do we need it? Describe it's purpose in a comment.

102 ↗

(On Diff #115057)

nullptr

109 ↗

(On Diff #115057)

Are all of these used?

[Typz]

Add tests.
Replace sorted list with hashtable.

lib/Format/FormatTokenLexer.cpp

642 ↗

(On Diff #115057)

It was already done this way, so I did not change it to avoid any impact on performance.
But I can change it if you prefer.

[Typz]

rebase

[Typz]

ping?

[djasper]

Out of curiosity, will this be able to fix the two situations that you get for python extension?
There, you usually have a PyObject_HEAD with out semicolon in a struct and than a PyObject_HEAD_INIT(..) in a braced init list. More info:
http://starship.python.net/crew/mwh/toext/node20.html

lib/Format/FormatTokenLexer.cpp

642 ↗

(On Diff #115057)

Thanks. This is much better than it was before.

630 ↗

(On Diff #120084)

Just do:

auto it = Macros.find(FormatTok->Tok.getIdentifierInfo());
..

I know that this means that we might do the hash look up when we wouldn't need to (when we are actually in a #define), but I think clarity here is more important than the tiny performance benefit.

lib/Format/FormatTokenLexer.h

25 ↗

(On Diff #120084)

Use ".

lib/Format/UnwrappedLineParser.cpp

1254 ↗

(On Diff #120084)

This contains the exact same code (I think). Can you pull it out into a function?

[Typz]

In D33440#920205, @djasper wrote:

Out of curiosity, will this be able to fix the two situations that you get for python extension?
There, you usually have a PyObject_HEAD with out semicolon in a struct and than a PyObject_HEAD_INIT(..) in a braced init list. More info:
http://starship.python.net/crew/mwh/toext/node20.html

PyObject_HEAD is defined (by defaut) as:

Py_ssize_t ob_refcnt;
PyTypeObject *ob_type;

so declaring it as a statement macro should allow clang-format to process it correctly. (though this is a variable-like macro, so I need to check if this case is supported)

PyObject_HEAD_INIT ends with a comma, which is not supported yet. We would need to add another kind of macro to support that case.

[Typz]

Address review comments

[Typz]

ping?

[Typz]

ping?

[Typz]

Use StatementMacro detection to improve brace type detection heuristics (in UnwrappedLineParser::calculateBraceTypes).

[alexfh]

lib/Format/Format.cpp

647–648 ↗

(On Diff #132837)

What's the reason to have these in the LLVM style? The macros aren't used in LLVM code.

unittests/Format/FormatTest.cpp

2424 ↗

(On Diff #132837)

nit: Add a trailing period.

[Typz]

Rebase on latest master

[alexfh]

There are still outstanding comments.

[Typz]

Address review comments

[Typz]

lib/Format/Format.cpp

647–648 ↗

(On Diff #132837)

This is similar to the default foreach macros (foreach, Q_FOREACH and BOOST_FOREACH) : the macros are added here so that they are the default values for any style, since LLVM style is also both the default style and the base style for any style.

[Typz]

Regenerate documentation

[sylvestre.ledru]

@Typz
I think this should be part of the release notes for v8.
This is changing the output on some code base and this is a new feature.

By the way, an example in the doc would be great (including with the configuration)

merci!

cfe/trunk/docs/ClangFormatStyleOptions.rst

* ``LS_Cpp11`` (in configuration: ``Cpp11``)
     Use features of C++11, C++14 and C++1z (e.g. ``A<A<int>>`` instead of
     ``A<A<int> >``).
 
   * ``LS_Auto`` (in configuration: ``Auto``)
     Automatic detection based on the input.
 
 
 
+**StatementMacros** (``std::vector<std::string>``)
+  A vector of macros that should be interpreted as complete statements.
+
+  Typical macros are expressions, and require a semi-colon to be
+  added; sometimes this is not the case, and this allows to make
+  clang-format aware of such cases.
+
+  For example: Q_UNUSED
+
 **TabWidth** (``unsigned``)
   The number of columns used for tab stops.
 
 **UseTab** (``UseTabStyle``)
   The way to use tab characters in the resulting file.
 
   Possible values:
 

cfe/trunk/include/clang/Format/Format.h

struct FormatStyle {
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   ForEachMacros: ['RANGES_FOR', 'FOREACH']
   /// \endcode
   ///
   /// For example: BOOST_FOREACH.
   std::vector<std::string> ForEachMacros;
 
+  /// A vector of macros that should be interpreted as complete
+  /// statements.
+  ///
+  /// Typical macros are expressions, and require a semi-colon to be
+  /// added; sometimes this is not the case, and this allows to make
+  /// clang-format aware of such cases.
+  ///
+  /// For example: Q_UNUSED
+  std::vector<std::string> StatementMacros;
+
   tooling::IncludeStyle IncludeStyle;
 
   /// Indent case labels one level from the switch statement.
   ///
   /// When ``false``, use the same indentation level as for the switch statement.
   /// Switch statement body is always indented one level more than case labels.
   /// \code
   ///    false:                                 true:
return AccessModifierOffset == R.AccessModifierOffset &&
            SpaceInEmptyParentheses == R.SpaceInEmptyParentheses &&
            SpacesBeforeTrailingComments == R.SpacesBeforeTrailingComments &&
            SpacesInAngles == R.SpacesInAngles &&
            SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
            SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
            SpacesInParentheses == R.SpacesInParentheses &&
            SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
            Standard == R.Standard && TabWidth == R.TabWidth &&
-           UseTab == R.UseTab;
+           StatementMacros == R.StatementMacros && UseTab == R.UseTab;
   }
 
   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
   // StyleSet set to a copy of the originating StyleSet, effectively keeping the
   // internal representation of that StyleSet alive.

cfe/trunk/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("SpacesInAngles", Style.SpacesInAngles);
     IO.mapOptional("SpacesInContainerLiterals",
                    Style.SpacesInContainerLiterals);
     IO.mapOptional("SpacesInCStyleCastParentheses",
                    Style.SpacesInCStyleCastParentheses);
     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
     IO.mapOptional("Standard", Style.Standard);
+    IO.mapOptional("StatementMacros", Style.StatementMacros);
     IO.mapOptional("TabWidth", Style.TabWidth);
     IO.mapOptional("UseTab", Style.UseTab);
   }
 };
 
 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
     IO.mapOptional("AfterClass", Wrapping.AfterClass);
FormatStyle getLLVMStyle() {
   LLVMStyle.PenaltyExcessCharacter = 1000000;
   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
   LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
 
   LLVMStyle.DisableFormat = false;
   LLVMStyle.SortIncludes = true;
   LLVMStyle.SortUsingDeclarations = true;
+  LLVMStyle.StatementMacros.push_back("Q_UNUSED");
+  LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");
 
   return LLVMStyle;
 }
 
 FormatStyle getGoogleStyle(FormatStyle::LanguageKind Language) {
   if (Language == FormatStyle::LK_TextProto) {
     FormatStyle GoogleStyle = getGoogleStyle(FormatStyle::LK_Proto);
     GoogleStyle.Language = FormatStyle::LK_TextProto;

cfe/trunk/lib/Format/FormatToken.h

#define LIST_TOKEN_TYPES                                                       \
   TYPE(OverloadedOperator)                                                     \
   TYPE(OverloadedOperatorLParen)                                               \
   TYPE(PointerOrReference)                                                     \
   TYPE(PureVirtualSpecifier)                                                   \
   TYPE(RangeBasedForLoopColon)                                                 \
   TYPE(RegexLiteral)                                                           \
   TYPE(SelectorName)                                                           \
   TYPE(StartOfName)                                                            \
+  TYPE(StatementMacro)                                                         \
   TYPE(StructuredBindingLSquare)                                               \
   TYPE(TemplateCloser)                                                         \
   TYPE(TemplateOpener)                                                         \
   TYPE(TemplateString)                                                         \
   TYPE(ProtoExtensionLSquare)                                                  \
   TYPE(TrailingAnnotation)                                                     \
   TYPE(TrailingReturnArrow)                                                    \
   TYPE(TrailingUnaryOperator)                                                  \

cfe/trunk/lib/Format/FormatTokenLexer.h

 #define LLVM_CLANG_LIB_FORMAT_FORMATTOKENLEXER_H
 
 #include "Encoding.h"
 #include "FormatToken.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "llvm/Support/Regex.h"
+#include "llvm/ADT/MapVector.h"
 
 #include <stack>
 
 namespace clang {
 namespace format {
 
 enum LexerState {
   NORMAL,
private:
   const FormatStyle &Style;
   IdentifierTable IdentTable;
   AdditionalKeywords Keywords;
   encoding::Encoding Encoding;
   llvm::SpecificBumpPtrAllocator<FormatToken> Allocator;
   // Index (in 'Tokens') of the last token that starts a new line.
   unsigned FirstInLineIndex;
   SmallVector<FormatToken *, 16> Tokens;
-  SmallVector<IdentifierInfo *, 8> ForEachMacros;
+
+  llvm::SmallMapVector<IdentifierInfo *, TokenType, 8> Macros;
 
   bool FormattingDisabled;
 
   llvm::Regex MacroBlockBeginRegex;
   llvm::Regex MacroBlockEndRegex;
 
   void readRawToken(FormatToken &Tok);
 
   void resetLexer(unsigned Offset);
 };
 
 } // namespace format
 } // namespace clang
 
 #endif

cfe/trunk/lib/Format/FormatTokenLexer.cpp

: FormatTok(nullptr), IsFirstToken(true), StateStack({LexerState::NORMAL}),
       Keywords(IdentTable), Encoding(Encoding), FirstInLineIndex(0),
       FormattingDisabled(false), MacroBlockBeginRegex(Style.MacroBlockBegin),
       MacroBlockEndRegex(Style.MacroBlockEnd) {
   Lex.reset(new Lexer(ID, SourceMgr.getBuffer(ID), SourceMgr,
                       getFormattingLangOpts(Style)));
   Lex->SetKeepWhitespaceMode(true);
 
   for (const std::string &ForEachMacro : Style.ForEachMacros)
-    ForEachMacros.push_back(&IdentTable.get(ForEachMacro));
-  llvm::sort(ForEachMacros);
+    Macros.insert({&IdentTable.get(ForEachMacro), TT_ForEachMacro});
+  for (const std::string &StatementMacro : Style.StatementMacros)
+    Macros.insert({&IdentTable.get(StatementMacro), TT_StatementMacro});
 }
 
 ArrayRef<FormatToken *> FormatTokenLexer::lex() {
   assert(Tokens.empty());
   assert(FirstInLineIndex == 0);
   do {
     Tokens.push_back(getNextToken());
     if (Style.Language == FormatStyle::LK_JavaScript) {
if (FirstNewlinePos == StringRef::npos) {
     // The last line of the token always starts in column 0.
     // Thus, the length can be precomputed even in the presence of tabs.
     FormatTok->LastLineColumnWidth = encoding::columnWidthWithTabs(
         Text.substr(Text.find_last_of('\n') + 1), 0, Style.TabWidth, Encoding);
     Column = FormatTok->LastLineColumnWidth;
   }
 
   if (Style.isCpp()) {
+    auto it = Macros.find(FormatTok->Tok.getIdentifierInfo());
     if (!(Tokens.size() > 0 && Tokens.back()->Tok.getIdentifierInfo() &&
           Tokens.back()->Tok.getIdentifierInfo()->getPPKeywordID() ==
               tok::pp_define) &&
-        std::find(ForEachMacros.begin(), ForEachMacros.end(),
-                  FormatTok->Tok.getIdentifierInfo()) != ForEachMacros.end()) {
-      FormatTok->Type = TT_ForEachMacro;
+        it != Macros.end()) {
+      FormatTok->Type = it->second;
     } else if (FormatTok->is(tok::identifier)) {
       if (MacroBlockBeginRegex.match(Text)) {
         FormatTok->Type = TT_MacroBlockBegin;
       } else if (MacroBlockEndRegex.match(Text)) {
         FormatTok->Type = TT_MacroBlockEnd;
       }
     }
   }

cfe/trunk/lib/Format/UnwrappedLineParser.h

private:
   // expression.
   void parseRecord(bool ParseAsExpr = false);
   void parseObjCMethod();
   void parseObjCProtocolList();
   void parseObjCUntilAtEnd();
   void parseObjCInterfaceOrImplementation();
   bool parseObjCProtocol();
   void parseJavaScriptEs6ImportExport();
+  void parseStatementMacro();
   bool tryToParseLambda();
   bool tryToParseLambdaIntroducer();
   void tryToParseJSFunction();
   void addUnwrappedLine();
   bool eof() const;
   // LevelDifference is the difference of levels after and before the current
   // token. For example:
   // - if the token is '{' and opens a block, LevelDifference is 1.

cfe/trunk/lib/Format/UnwrappedLineParser.cpp

case tok::r_brace:
           LBraceStack.back()->BlockKind = BK_BracedInit;
         } else {
           Tok->BlockKind = BK_Block;
           LBraceStack.back()->BlockKind = BK_Block;
         }
       }
       LBraceStack.pop_back();
       break;
+    case tok::identifier:
+      if (!Tok->is(TT_StatementMacro))
+          break;
+      LLVM_FALLTHROUGH;
     case tok::at:
     case tok::semi:
     case tok::kw_if:
     case tok::kw_while:
     case tok::kw_for:
     case tok::kw_switch:
     case tok::kw_try:
     case tok::kw___try:
if (Style.isCpp() &&
                            Keywords.kw_slots, Keywords.kw_qslots)) {
       nextToken();
       if (FormatTok->is(tok::colon)) {
         nextToken();
         addUnwrappedLine();
         return;
       }
     }
+    if (Style.isCpp() && FormatTok->is(TT_StatementMacro)) {
+      parseStatementMacro();
+      return;
+    }
     // In all other cases, parse the declaration.
     break;
   default:
     break;
   }
   do {
     const FormatToken *Previous = FormatTok->Previous;
     switch (FormatTok->Tok.getKind()) {
case tok::identifier: {
             break;
           }
         }
         parseRecord();
         addUnwrappedLine();
         return;
       }
 
+      if (Style.isCpp() && FormatTok->is(TT_StatementMacro)) {
+        parseStatementMacro();
+        return;
+      }
+
       // See if the following token should start a new unwrapped line.
       StringRef Text = FormatTok->TokenText;
       nextToken();
       if (Line->Tokens.size() == 1 &&
           // JS doesn't have macros, and within classes colons indicate fields,
           // not labels.
           Style.Language != FormatStyle::LK_JavaScript) {
         if (FormatTok->Tok.is(tok::colon) && !Line->MustBeDeclaration) {
if (FormatTok->is(tok::l_brace)) {
       nextToken();
       parseBracedList();
     } else {
       nextToken();
     }
   }
 }
 
+void UnwrappedLineParser::parseStatementMacro()
+{
+  nextToken();
+  if (FormatTok->is(tok::l_paren))
+    parseParens();
+  if (FormatTok->is(tok::semi))
+    nextToken();
+  addUnwrappedLine();
+}
+
 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
                                                  StringRef Prefix = "") {
   llvm::dbgs() << Prefix << "Line(" << Line.Level
                << ", FSC=" << Line.FirstStartColumn << ")"
                << (Line.InPPDirective ? " MACRO" : "") << ": ";
   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
                                                     E = Line.Tokens.end();
        I != E; ++I) {

cfe/trunk/unittests/Format/FormatTest.cpp

EXPECT_EQ("class SomeClass {\n"
             format("class SomeClass {\n"
                    "public:\n"
                    "  SomeClass()\n"
                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
                    "};",
                    getLLVMStyleWithColumns(40)));
 
   verifyFormat("MACRO(>)");
+
+  // Some macros contain an implicit semicolon.
+  Style = getLLVMStyle();
+  Style.StatementMacros.push_back("FOO");
+  verifyFormat("FOO(a) int b = 0;");
+  verifyFormat("FOO(a)\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("FOO(a);\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("FOO()\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("FOO\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("void f() {\n"
+               "  FOO(a)\n"
+               "  return a;\n"
+               "}",
+               Style);
+  verifyFormat("FOO(a)\n"
+               "FOO(b)",
+               Style);
+  verifyFormat("int a = 0;\n"
+               "FOO(b)\n"
+               "int c = 0;",
+               Style);
+  verifyFormat("int a = 0;\n"
+               "int x = FOO(a)\n"
+               "int b = 0;",
+               Style);
+  verifyFormat("void foo(int a) { FOO(a) }\n"
+               "uint32_t bar() {}",
+               Style);
 }
 
 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
   verifyFormat("#define A \\\n"
                "  f({     \\\n"
                "    g();  \\\n"
                "  });",
                getLLVMStyleWithColumns(11));
TEST_F(FormatTest, ParsesConfiguration) {
   BoostForeach.push_back("BOOST_FOREACH");
   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
   std::vector<std::string> BoostAndQForeach;
   BoostAndQForeach.push_back("BOOST_FOREACH");
   BoostAndQForeach.push_back("Q_FOREACH");
   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
               BoostAndQForeach);
 
+  Style.StatementMacros.clear();
+  CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
+              std::vector<std::string>{"QUNUSED"});
+  CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
+              std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
+
   Style.IncludeStyle.IncludeCategories.clear();
   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
       {"abc/.*", 2}, {".*", 1}};
   CHECK_PARSE("IncludeCategories:\n"
               "  - Regex: abc/.*\n"
               "    Priority: 2\n"
               "  - Regex: .*\n"
               "    Priority: 1",