Better macro error messages involving initializer lists

[rtrieu]

Summary

When an initializer list is used within a marco argument, each comma is the list is treated as a macro argument separator. When this happens, the only error message is "too many macro arguments provided". This patch changes the handling of function-like macros to give additional notes detailing the problems.

For a macro FOO(vector<int>{1,2,3}, 3), it will suggest parenthesis to preserve the initializer list with the corrected code as FOO((vector<int>{1,2,3}), 3).

For a macro such as FOO( {1,2,3} ), it will provide a different note saying that initializer lists cannot be used as macro arguments. This is because adding parentheses around the braces would make it no longer an initializer list.

[rtrieu]

Ping.

[rsmith]

This looks essentially reasonable (assuming the extra Token copying doesn't cause any measurable slowdown for preprocessor-intensive code -- there are some boost libraries that might be worth checking here).

You need to rebase this patch; it will conflict with the MS ignored commas patch which landed last week.

include/clang/Basic/DiagnosticLexKinds.td

463–464

This is ambiguous, and could be read as "braced lists require that parentheses are recognized inside macros". Maybe "parentheses are required around macro argument containing braced initializer list"?

lib/Lex/PPMacroExpansion.cpp

582

Using an enum for paren/brace instead of bool here would be clearer.

586–598

Have you considered trying to also match angle-brackets if matching braces doesn't work? That would be useful for a number of template cases.

604

Can you make this variable name more descriptive or add a comment? Something which more explicitly says that this tracks whether the current corrected argument includes a braced but unparenthesized comma.

635

Do you need the FoundBrace check here? It looks like FoundComma implies FoundBrace, so you can remove the FoundBrace variable entirely.

638–639

The parens fix-up won't work in any case where the ArgStart is l_brace, no matter what the end token is. It's a shame that we don't recover well in this case; it'd be nice to treat the argument as a single item regardless, but the current factoring of the code makes that very hard.

Have you considered making this code directly produce MacroArgs instead (maybe performing these checks as a fixup after the handling in ProcessFunctionLikeMacroArgTokens), so that you can produce arguments with embedded commas? Alternatively, we now have the Token::IgnoredComma flag that you can use to indicate that a comma is not a macro argument separator; you could use that for recovery.

638–641

This note isn't appropriate if the argument is of the form "{...} stuff {...}". Perhaps you shouldn't give a note at all for that case?

645–648

Reusing MacroTokens.front() and MacroTokens.back() here will give surprising source locations. Perhaps put the ( at the location of the first token, and put the ) past the end of the location of the last token instead (that is, at the locations where you point the fix-its)?

647

The TokenIterator location here should really be the location past the end of the prior token. Imagine we had:

MACRO(
  vector<int>{1, 2, 3}
)

We'd want the ) suggested after the }, not before the ).

[rtrieu]

Refactoring the earlier patch to take into account comments.

• Instead of attempting a correction after every failure, only try after a "too many arguments" failure.
• Rewrite the code that generates a new vector of token arguments to use the old vector of tokens. This cuts back the amount of token copying to only when a correction is attempted.
• Give a note on all arguments started with a brace list instead of only when the brace list is the entire token.

[rtrieu]

include/clang/Basic/DiagnosticLexKinds.td

463–464

Done.

lib/Lex/PPMacroExpansion.cpp

582

Done.

586–598

Scope creep! Maybe in a future patch. Added a TODO for now.

604

Renamed and added comments.

638–639

The new patch intercepts the argument tokens earlier, so only one attempt to generate MacroArgs is attempted.

Arguments starting with an l_brace now produce the "cannot start with a braced list" note.

645–648

Now using the locations of the beginning and end tokens of the argument.

647

Using getLocForEndOfToken() as needed.

[rsmith]

lib/Lex/PPMacroExpansion.cpp

443

This variable seems to be unused.

482

Incomplete comment.

693–696

It looks like DiagnosticBuilder will assert if given more than 10 ranges. Maybe guard this with DB.hasMaxRanges()?

704–709

Likewise w/fixits.

test/Preprocessor/macro_with_initializer_list.cpp

141

This is done, right?

[rtrieu]

Also fixed a problem where the too many arguments error was always pointing to the last argument. It now properly points to the first extra element.

lib/Lex/PPMacroExpansion.cpp

443

Variable removed.

482

Done.

693–696

Done with test case.

704–709

Done with test case.

test/Preprocessor/macro_with_initializer_list.cpp

141

Yes.

[rsmith]

LGTM with a couple of tiny tweaks.

include/clang/Basic/Diagnostic.h

987

Should be "hasMaxFixItHints" presumably?

lib/Lex/PPMacroExpansion.cpp

710–713

For robustness, please check hasMaxFixItHints between adding the two fixits here. The maximum might not always be even.

[rtrieu]

Committed with tiny tweaks at r186971

include/clang/Basic/Diagnostic.h

void AddFixItHint(const FixItHint &Hint) const {
     assert(NumFixits < DiagnosticsEngine::MaxFixItHints &&
            "Too many arguments to diagnostic!");
     DiagObj->DiagFixItHints[NumFixits++] = Hint;
   }
 
   bool hasMaxRanges() const {
     return NumRanges == DiagnosticsEngine::MaxRanges;
   }
+
+  bool hasMaxFixItsHints() const {
+    return NumFixits == DiagnosticsEngine::MaxFixItHints;
+  }
 };
 
 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                            StringRef S) {
   DB.AddString(S);
   return DB;
 }
 

include/clang/Basic/DiagnosticLexKinds.td

def err_paste_at_start : Error<
   "'##' cannot appear at start of macro expansion">;
 def err_paste_at_end : Error<"'##' cannot appear at end of macro expansion">;
 def ext_paste_comma : Extension<
   "token pasting of ',' and __VA_ARGS__ is a GNU extension">, InGroup<GNU>;
 def err_unterm_macro_invoc : Error<
   "unterminated function-like macro invocation">;
 def err_too_many_args_in_macro_invoc : Error<
   "too many arguments provided to function-like macro invocation">;
+def note_suggest_parens_for_macro : Note<
+  "parentheses are required around macro argument containing braced "
+  "initializer list">;
+def note_init_list_at_beginning_of_macro_argument : Note<
+  "cannot use initializer list at the beginning of an macro argument">;
 def err_too_few_args_in_macro_invoc : Error<
   "too few arguments provided to function-like macro invocation">;
 def err_pp_bad_paste : Error<
   "pasting formed '%0', an invalid preprocessing token">;
 def err_pp_bad_paste_ms : Warning<
   "pasting formed '%0', an invalid preprocessing token">, DefaultError,
   InGroup<DiagGroup<"invalid-token-paste">>;
 def err_pp_operator_used_as_macro_name : Error<

lib/Lex/PPMacroExpansion.cpp

bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier,
   EnterMacro(Identifier, ExpansionEnd, MI, Args);
 
   // Now that the macro is at the top of the include stack, ask the
   // preprocessor to read the next token from it.
   Lex(Identifier);
   return false;
 }
 
+enum Bracket {
+  Brace,
+  Paren
+};
+
+/// CheckMatchedBrackets - Returns true if the braces and parentheses in the
+/// token vector are properly nested.
+static bool CheckMatchedBrackets(const SmallVectorImpl<Token> &Tokens) {
+  SmallVector<Bracket, 8> Brackets;
+  for (SmallVectorImpl<Token>::const_iterator I = Tokens.begin(),
+                                              E = Tokens.end();
+       I != E; ++I) {
+    if (I->is(tok::l_paren)) {
+      Brackets.push_back(Paren);
+    } else if (I->is(tok::r_paren)) {
+      if (Brackets.empty() || Brackets.back() == Brace)
+        return false;
+      Brackets.pop_back();
+    } else if (I->is(tok::l_brace)) {
+      Brackets.push_back(Brace);
+    } else if (I->is(tok::r_brace)) {
+      if (Brackets.empty() || Brackets.back() == Paren)
+        return false;
+      Brackets.pop_back();
+    }
+  }
+  if (!Brackets.empty())
+    return false;
+  return true;
+}
+
+/// GenerateNewArgTokens - Returns true if OldTokens can be converted to a new
+/// vector of tokens in NewTokens.  The new number of arguments will be placed
+/// in NumArgs and the ranges which need to surrounded in parentheses will be
+/// in ParenHints.
+/// Returns false if the token stream cannot be changed.  If this is because
+/// of an initializer list starting a macro argument, the range of those
+/// initializer lists will be place in InitLists.
+static bool GenerateNewArgTokens(Preprocessor &PP,
+                                 SmallVectorImpl<Token> &OldTokens,
+                                 SmallVectorImpl<Token> &NewTokens,
+                                 unsigned &NumArgs,
+                                 SmallVectorImpl<SourceRange> &ParenHints,
+                                 SmallVectorImpl<SourceRange> &InitLists) {
+  if (!CheckMatchedBrackets(OldTokens))
+    return false;
+
+  // Once it is known that the brackets are matched, only a simple count of the
+  // braces is needed.
+  unsigned Braces = 0;
+
+  // First token of a new macro argument.
+  SmallVectorImpl<Token>::iterator ArgStartIterator = OldTokens.begin();
+
+  // First closing brace in a new macro argument.  Used to generate
+  // SourceRanges for InitLists.
+  SmallVectorImpl<Token>::iterator ClosingBrace = OldTokens.end();
+  NumArgs = 0;
+  Token TempToken;
+  // Set to true when a macro separator token is found inside a braced list.
+  // If true, the fixed argument spans multiple old arguments and ParenHints
+  // will be updated.
+  bool FoundSeparatorToken = false;
+  for (SmallVectorImpl<Token>::iterator I = OldTokens.begin(),
+                                        E = OldTokens.end();
+       I != E; ++I) {
+    if (I->is(tok::l_brace)) {
+      ++Braces;
+    } else if (I->is(tok::r_brace)) {
+      --Braces;
+      if (Braces == 0 && ClosingBrace == E && FoundSeparatorToken)
+        ClosingBrace = I;
+    } else if (I->is(tok::eof)) {
+      // EOF token is used to separate macro arguments
+      if (Braces != 0) {
+        // Assume comma separator is actually braced list separator and change
+        // it back to a comma.
+        FoundSeparatorToken = true;
+        I->setKind(tok::comma);
+        I->setLength(1);
+      } else { // Braces == 0
+        // Separator token still separates arguments.
+        ++NumArgs;
+
+        // If the argument starts with a brace, it can't be fixed with
+        // parentheses.  A different diagnostic will be given.
+        if (FoundSeparatorToken && ArgStartIterator->is(tok::l_brace)) {
+          InitLists.push_back(
+              SourceRange(ArgStartIterator->getLocation(),
+                          PP.getLocForEndOfToken(ClosingBrace->getLocation())));
+          ClosingBrace = E;
+        }
+
+        // Add left paren
+        if (FoundSeparatorToken) {
+          TempToken.startToken();
+          TempToken.setKind(tok::l_paren);
+          TempToken.setLocation(ArgStartIterator->getLocation());
+          TempToken.setLength(0);
+          NewTokens.push_back(TempToken);
+        }
+
+        // Copy over argument tokens
+        NewTokens.insert(NewTokens.end(), ArgStartIterator, I);
+
+        // Add right paren and store the paren locations in ParenHints
+        if (FoundSeparatorToken) {
+          SourceLocation Loc = PP.getLocForEndOfToken((I - 1)->getLocation());
+          TempToken.startToken();
+          TempToken.setKind(tok::r_paren);
+          TempToken.setLocation(Loc);
+          TempToken.setLength(0);
+          NewTokens.push_back(TempToken);
+          ParenHints.push_back(SourceRange(ArgStartIterator->getLocation(),
+                                           Loc));
+        }
+
+        // Copy separator token
+        NewTokens.push_back(*I);
+
+        // Reset values
+        ArgStartIterator = I + 1;
+        FoundSeparatorToken = false;
+      }
+    }
+  }
+
+  return !ParenHints.empty() && InitLists.empty();
+}
+
 /// ReadFunctionLikeMacroArgs - After reading "MACRO" and knowing that the next
 /// token is the '(' of the macro, this method is invoked to read all of the
 /// actual arguments specified for the macro invocation.  This returns null on
 /// error.
 MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
                                                    MacroInfo *MI,
                                                    SourceLocation &MacroEnd) {
   // The number of fixed arguments to parse.
MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
   assert(Tok.is(tok::l_paren) && "Error computing l-paren-ness?");
 
   // ArgTokens - Build up a list of tokens that make up each argument.  Each
   // argument is separated by an EOF token.  Use a SmallVector so we can avoid
   // heap allocations in the common case.
   SmallVector<Token, 64> ArgTokens;
   bool ContainsCodeCompletionTok = false;
 
+  SourceLocation TooManyArgsLoc;
+
   unsigned NumActuals = 0;
   while (Tok.isNot(tok::r_paren)) {
     if (ContainsCodeCompletionTok && (Tok.is(tok::eof) || Tok.is(tok::eod)))
       break;
 
     assert((Tok.is(tok::l_paren) || Tok.is(tok::comma)) &&
            "only expect argument separators here");
 
while (1) {
             << MacroName.getIdentifierInfo();
           // Do not lose the EOF/EOD.  Return it to the client.
           MacroName = Tok;
           return 0;
         } else {
           // Do not lose the EOF/EOD.
           Token *Toks = new Token[1];
           Toks[0] = Tok;
           EnterTokenStream(Toks, 1, true, true);
           break;
         }
       } else if (Tok.is(tok::r_paren)) {
         // If we found the ) token, the macro arg list is done.
         if (NumParens-- == 0) {
           MacroEnd = Tok.getLocation();
           break;
         }
       } else if (Tok.is(tok::l_paren)) {
         ++NumParens;
       } else if (Tok.is(tok::comma) && NumParens == 0 &&
                  !(Tok.getFlags() & Token::IgnoredComma)) {
         // In Microsoft-compatibility mode, single commas from nested macro
         // expansions should not be considered as argument separators. We test
         // for this with the IgnoredComma token flag above.
 
         // Comma ends this argument if there are more fixed arguments expected.
         // However, if this is a variadic macro, and this is part of the
         // variadic part, then the comma is just an argument token.
         if (!isVariadic) break;
         if (NumFixedArgsLeft > 1)
           break;
       } else if (Tok.is(tok::comment) && !KeepMacroComments) {
         // If this is a comment token in the argument list and we're just in
         // -C mode (not -CC mode), discard the comment.
         continue;
       } else if (Tok.getIdentifierInfo() != 0) {
         // Reading macro arguments can cause macros that we are currently
         // expanding from to be popped off the expansion stack.  Doing so causes
         // them to be reenabled for expansion.  Here we record whether any
while (1) {
       }
 
       ArgTokens.push_back(Tok);
     }
 
     // If this was an empty argument list foo(), don't add this as an empty
     // argument.
     if (ArgTokens.empty() && Tok.getKind() == tok::r_paren)
       break;
 
     // If this is not a variadic macro, and too many args were specified, emit
     // an error.
-    if (!isVariadic && NumFixedArgsLeft == 0) {
+    if (!isVariadic && NumFixedArgsLeft == 0 && TooManyArgsLoc.isInvalid()) {
       if (ArgTokens.size() != ArgTokenStart)
-        ArgStartLoc = ArgTokens[ArgTokenStart].getLocation();
-
-      if (!ContainsCodeCompletionTok) {
-        // Emit the diagnostic at the macro name in case there is a missing ).
-        // Emitting it at the , could be far away from the macro name.
-        Diag(ArgStartLoc, diag::err_too_many_args_in_macro_invoc);
-        Diag(MI->getDefinitionLoc(), diag::note_macro_here)
-          << MacroName.getIdentifierInfo();
-        return 0;
-      }
+        TooManyArgsLoc = ArgTokens[ArgTokenStart].getLocation();
+      else
+        TooManyArgsLoc = ArgStartLoc;
     }
 
-    // Empty arguments are standard in C99 and C++0x, and are supported as an extension in
-    // other modes.
+    // Empty arguments are standard in C99 and C++0x, and are supported as an
+    // extension in other modes.
     if (ArgTokens.size() == ArgTokenStart && !LangOpts.C99)
       Diag(Tok, LangOpts.CPlusPlus11 ?
            diag::warn_cxx98_compat_empty_fnmacro_arg :
            diag::ext_empty_fnmacro_arg);
 
     // Add a marker EOF token to the end of the token list for this argument.
     Token EOFTok;
     EOFTok.startToken();
     EOFTok.setKind(tok::eof);
     EOFTok.setLocation(Tok.getLocation());
     EOFTok.setLength(0);
     ArgTokens.push_back(EOFTok);
     ++NumActuals;
-    if (!ContainsCodeCompletionTok || NumFixedArgsLeft != 0) {
-      assert(NumFixedArgsLeft != 0 && "Too many arguments parsed");
+    if (!ContainsCodeCompletionTok && NumFixedArgsLeft != 0)
       --NumFixedArgsLeft;
-    }
-  }
 
   // Okay, we either found the r_paren.  Check to see if we parsed too few
   // arguments.
   unsigned MinArgsExpected = MI->getNumArgs();
 
+  // If this is not a variadic macro, and too many args were specified, emit
+  // an error.
+  if (!isVariadic && NumActuals > MinArgsExpected &&
+      !ContainsCodeCompletionTok) {
+    // Emit the diagnostic at the macro name in case there is a missing ).
+    // Emitting it at the , could be far away from the macro name.
+    Diag(TooManyArgsLoc, diag::err_too_many_args_in_macro_invoc);
+    Diag(MI->getDefinitionLoc(), diag::note_macro_here)
+      << MacroName.getIdentifierInfo();
+
+    // Commas from braced initializer lists will be treated as argument
+    // separators inside macros.  Attempt to correct for this with parentheses.
+    // TODO: See if this can be generalized to angle brackets for templates
+    // inside macro arguments.
+
+    SmallVector<Token, 64> FixedArgTokens;
+    unsigned FixedNumArgs = 0;
+    SmallVector<SourceRange, 4> ParenHints, InitLists;
+    if (!GenerateNewArgTokens(*this, ArgTokens, FixedArgTokens, FixedNumArgs,
+                              ParenHints, InitLists)) {
+      if (!InitLists.empty()) {
+        DiagnosticBuilder DB =
+            Diag(MacroName,
+                 diag::note_init_list_at_beginning_of_macro_argument);
+        for (SmallVector<SourceRange, 4>::iterator
+                 Range = InitLists.begin(), RangeEnd = InitLists.end();
+                 Range != RangeEnd; ++Range) {
+          if (DB.hasMaxRanges())
+            break;
+          DB << *Range;
+        }
+      }
+      return 0;
+    }
+    if (FixedNumArgs != MinArgsExpected)
+      return 0;
+
+    DiagnosticBuilder DB = Diag(MacroName, diag::note_suggest_parens_for_macro);
+    for (SmallVector<SourceRange, 4>::iterator
+             ParenLocation = ParenHints.begin(), ParenEnd = ParenHints.end();
+         ParenLocation != ParenEnd; ++ParenLocation) {
+      if (DB.hasMaxFixItsHints())
+        break;
+      DB << FixItHint::CreateInsertion(ParenLocation->getBegin(), "(")
+         << FixItHint::CreateInsertion(ParenLocation->getEnd(), ")");
+    }
+    ArgTokens.swap(FixedArgTokens);
+    NumActuals = FixedNumArgs;
+  }
+
   // See MacroArgs instance var for description of this.
   bool isVarargsElided = false;
 
   if (ContainsCodeCompletionTok) {
     // Recover from not-fully-formed macro invocation during code-completion.
     Token EOFTok;
     EOFTok.startToken();
     EOFTok.setKind(tok::eof);

test/Preprocessor/macro_fn.c

 /* RUN: %clang_cc1 %s -Eonly -std=c89 -pedantic -verify
 */
 /* PR3937 */
 #define zero() 0 /* expected-note 2 {{defined here}} */
 #define one(x) 0 /* expected-note 2 {{defined here}} */
 #define two(x, y) 0 /* expected-note 4 {{defined here}} */
 #define zero_dot(...) 0   /* expected-warning {{variadic macros are a C99 feature}} */
 #define one_dot(x, ...) 0 /* expected-warning {{variadic macros are a C99 feature}} expected-note 2{{macro 'one_dot' defined here}} */
 
 zero()
 zero(1);          /* expected-error {{too many arguments provided to function-like macro invocation}} */
 zero(1, 2, 3);    /* expected-error {{too many arguments provided to function-like macro invocation}} */
 
 one()   /* ok */
 one(a)
-one(a,)           /* expected-error {{too many arguments provided to function-like macro invocation}} */
+one(a,)           /* expected-error {{too many arguments provided to function-like macro invocation}} \
+                     expected-warning {{empty macro arguments are a C99 feature}}*/
 one(a, b)         /* expected-error {{too many arguments provided to function-like macro invocation}} */
 
 two()       /* expected-error {{too few arguments provided to function-like macro invocation}} */
 two(a)      /* expected-error {{too few arguments provided to function-like macro invocation}} */
 two(a,b)
 two(a, )    /* expected-warning {{empty macro arguments are a C99 feature}} */
 two(a,b,c)  /* expected-error {{too many arguments provided to function-like macro invocation}} */
 two(
     ,     /* expected-warning {{empty macro arguments are a C99 feature}} */
     ,     /* expected-warning {{empty macro arguments are a C99 feature}}  \
              expected-error {{too many arguments provided to function-like macro invocation}} */
-    )     
+    )     /* expected-warning {{empty macro arguments are a C99 feature}} */
 two(,)      /* expected-warning 2 {{empty macro arguments are a C99 feature}} */
 
 
 
 /* PR4006 & rdar://6807000 */
 #define e(...) __VA_ARGS__  /* expected-warning {{variadic macros are a C99 feature}} */
 e(x)
 e()

test/Preprocessor/macro_with_initializer_list.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s
+namespace std {
+  template <class X>
+  class initializer_list {
+    public:
+    initializer_list();
+  };
+}
+
+class Foo {
+public:
+  Foo();
+  Foo(std::initializer_list<int>);
+  bool operator==(const Foo);
+  Foo operator+(const Foo);
+};
+
+#define EQ(x,y) (void)(x == y)  // expected-note 6{{defined here}}
+void test_EQ() {
+  Foo F;
+  F = Foo{1,2};
+
+  EQ(F,F);
+  EQ(F,Foo());
+  EQ(F,Foo({1,2,3}));
+  EQ(Foo({1,2,3}),F);
+  EQ((Foo{1,2,3}),(Foo{1,2,3}));
+  EQ(F, F + F);
+  EQ(F, Foo({1,2,3}) + Foo({1,2,3}));
+  EQ(F, (Foo{1,2,3} + Foo{1,2,3}));
+
+  EQ(F,Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  EQ(Foo{1,2,3},F);
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  EQ(Foo{1,2,3},Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+
+  EQ(Foo{1,2,3} + Foo{1,2,3}, F);
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  EQ(F, Foo({1,2,3}) + Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  EQ(F, Foo{1,2,3} + Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+}
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{33:8-33:8}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{33:18-33:18}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{36:6-36:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{36:16-36:16}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{39:6-39:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{39:16-39:16}:")"
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{39:17-39:17}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{39:27-39:27}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{43:6-43:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{43:29-43:29}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{46:9-46:9}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{46:34-46:34}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{49:9-49:9}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{49:32-49:32}:")"
+
+#define NE(x,y) (void)(x != y)  // expected-note 6{{defined here}}
+// Operator != isn't defined.  This tests that the corrected macro arguments
+// are used in the macro expansion.
+void test_NE() {
+  Foo F;
+
+  NE(F,F);
+  // expected-error@-1 {{invalid operands}}
+  NE(F,Foo());
+  // expected-error@-1 {{invalid operands}}
+  NE(F,Foo({1,2,3}));
+  // expected-error@-1 {{invalid operands}}
+  NE((Foo{1,2,3}),(Foo{1,2,3}));
+  // expected-error@-1 {{invalid operands}}
+
+  NE(F,Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+  NE(Foo{1,2,3},F);
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+  NE(Foo{1,2,3},Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+
+  NE(Foo{1,2,3} + Foo{1,2,3}, F);
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+  NE(F, Foo({1,2,3}) + Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+  NE(F, Foo{1,2,3} + Foo{1,2,3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+  // expected-error@-3 {{invalid operands}}
+}
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{89:8-89:8}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{89:18-89:18}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{93:6-93:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{93:16-93:16}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{97:6-97:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{97:16-97:16}:")"
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{97:17-97:17}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{97:27-97:27}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{102:6-102:6}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{102:29-102:29}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{106:9-106:9}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{106:34-106:34}:")"
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{110:9-110:9}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{110:32-110:32}:")"
+
+#define INIT(var, init) Foo var = init; // expected-note 3{{defined here}}
+// Can't use an initializer list as a macro argument.  The commas in the list
+// will be interpretted as argument separaters and adding parenthesis will
+// make it no longer an initializer list.
+void test() {
+  INIT(a, Foo());
+  INIT(b, Foo({1, 2, 3}));
+  INIT(c, Foo());
+
+  INIT(d, Foo{1, 2, 3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-note@-2 {{parentheses are required}}
+
+  // Can't be fixed by parentheses.
+  INIT(e, {1, 2, 3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-error@-2 {{use of undeclared identifier}}
+  // expected-note@-3 {{cannot use initializer list at the beginning of an macro argument}}
+
+  // Can't be fixed by parentheses.
+  INIT(e, {1, 2, 3} + {1, 2, 3});
+  // expected-error@-1 {{too many arguments provided}}
+  // expected-error@-2 {{use of undeclared identifier}}
+  // expected-note@-3 {{cannot use initializer list at the beginning of an macro argument}}
+}
+
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{145:11-145:11}:"("
+// CHECK: fix-it:"{{.*}}macro_with_initializer_list.cpp":{145:23-145:23}:")"
+
+#define M(name,a,b,c,d,e,f,g,h,i,j,k,l) \
+  Foo name = a + b + c + d + e + f + g + h + i + j + k + l;
+// expected-note@-2 2{{defined here}}
+void test2() {
+  M(F1, Foo(), Foo(), Foo(), Foo(), Foo(), Foo(),
+        Foo(), Foo(), Foo(), Foo(), Foo(), Foo());
+
+  M(F2, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3},
+        Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3}, Foo{1,2,3});
+  // expected-error@-2 {{too many arguments provided}}
+  // expected-note@-3 {{parentheses are required}}
+
+  M(F3, {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3},
+        {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3}, {1,2,3});
+  // expected-error@-2 {{too many arguments provided}}
+  // expected-error@-3 {{use of undeclared identifier}}
+  // expected-note@-4 {{cannot use initializer list at the beginning of an macro argument}}
+}