Accept elided commas in macro function arguments for MS compatibility

[• ehsan]

Summary

This fixes PR25875. When the trailing comma in a macro argument list is
elided, we need to treat it similarly to the case where a variadic macro
misses one actual argument.

[rnk]

Seems reasonable to me, but we should check with Richard.

[• ehsan]

Richard: ping?

[rnk]

Let's go ahead and land this. It doesn't seem high risk. Richard will be back on Monday, he's been skiing.

[• ehsan]

Sure. I'd be happy to address any comments post-landing.

Thanks!

cfe/trunk/include/clang/Lex/Token.h

enum TokenFlags {
     DisableExpand = 0x04,  // This identifier may never be macro expanded.
     NeedsCleaning = 0x08,  // Contained an escaped newline or trigraph.
     LeadingEmptyMacro = 0x10, // Empty macro exists before this token.
     HasUDSuffix = 0x20,    // This string or character literal has a ud-suffix.
     HasUCN = 0x40,         // This identifier contains a UCN.
     IgnoredComma = 0x80,   // This comma is not a macro argument separator (MS).
     StringifiedInMacro = 0x100, // This string or character literal is formed by
                                 // macro stringizing or charizing operator.
+    CommaAfterElided = 0x200, // The comma following this token was elided (MS).
   };
 
   tok::TokenKind getKind() const { return Kind; }
   void setKind(tok::TokenKind K) { Kind = K; }
 
   /// is/isNot - Predicates to check if this token is a specific kind, as in
   /// "if (Tok.is(tok::l_brace)) {...}".
   bool is(tok::TokenKind K) const { return Kind == K; }
public:
   /// Returns true if this token contains a universal character name.
   bool hasUCN() const { return (Flags & HasUCN) ? true : false; }
 
   /// Returns true if this token is formed by macro by stringizing or charizing
   /// operator.
   bool stringifiedInMacro() const {
     return (Flags & StringifiedInMacro) ? true : false;
   }
+
+  /// Returns true if the comma after this token was elided.
+  bool commaAfterElided() const {
+    return (Flags & CommaAfterElided) ? true : false;
+  }
 };
 
 /// \brief Information about the conditional stack (\#if directives)
 /// currently active.
 struct PPConditionalInfo {
   /// \brief Location where the conditional started.
   SourceLocation IfLoc;
 

cfe/trunk/lib/Lex/PPMacroExpansion.cpp

MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
   LexUnexpandedToken(Tok);
   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;
+  bool FoundElidedComma = false;
 
   SourceLocation TooManyArgsLoc;
 
   unsigned NumActuals = 0;
   while (Tok.isNot(tok::r_paren)) {
     if (ContainsCodeCompletionTok && Tok.isOneOf(tok::eof, tok::eod))
       break;
 
while (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();
+          if (!ArgTokens.empty() &&
+              ArgTokens.back().commaAfterElided()) {
+            FoundElidedComma = true;
+          }
           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
if (NumActuals < MinArgsExpected) {
     // There are several cases where too few arguments is ok, handle them now.
     if (NumActuals == 0 && MinArgsExpected == 1) {
       // #define A(X)  or  #define A(...)   ---> A()
 
       // If there is exactly one argument, and that argument is missing,
       // then we have an empty "()" argument empty list.  This is fine, even if
       // the macro expects one argument (the argument is just empty).
       isVarargsElided = MI->isVariadic();
-    } else if (MI->isVariadic() &&
+    } else if ((FoundElidedComma || MI->isVariadic()) &&
                (NumActuals+1 == MinArgsExpected ||  // A(x, ...) -> A(X)
                 (NumActuals == 0 && MinArgsExpected == 2))) {// A(x,...) -> A()
       // Varargs where the named vararg parameter is missing: OK as extension.
       //   #define A(x, ...)
       //   A("blah")
       //
       // If the macro contains the comma pasting extension, the diagnostic
       // is suppressed; we know we'll get another diagnostic later.

cfe/trunk/lib/Lex/TokenLexer.cpp

bool TokenLexer::MaybeRemoveCommaBeforeVaArgs(
 
   // Issue an extension diagnostic for the paste operator.
   if (HasPasteOperator)
     PP.Diag(ResultToks.back().getLocation(), diag::ext_paste_comma);
 
   // Remove the comma.
   ResultToks.pop_back();
 
+  if (!ResultToks.empty()) {
     // If the comma was right after another paste (e.g. "X##,##__VA_ARGS__"),
     // then removal of the comma should produce a placemarker token (in C99
     // terms) which we model by popping off the previous ##, giving us a plain
     // "X" when __VA_ARGS__ is empty.
-  if (!ResultToks.empty() && ResultToks.back().is(tok::hashhash))
+    if (ResultToks.back().is(tok::hashhash))
       ResultToks.pop_back();
 
+    // Remember that this comma was elided.
+    ResultToks.back().setFlag(Token::CommaAfterElided);
+  }
+
   // Never add a space, even if the comma, ##, or arg had a space.
   NextTokGetsSpace = false;
   return true;
 }
 
 /// Expand the arguments of a function-like macro so that we can quickly
 /// return preexpanded tokens from Tokens.
 void TokenLexer::ExpandFunctionArguments() {

cfe/trunk/test/Preprocessor/microsoft-ext.c

 
 #define MAKER(_arg1, _comma, _arg2)                                            \
   void func(_arg1 _comma _arg2) {}
 #define MAKE_FUNC(_makerP1, _makerP2, _arg1, _comma, _arg2)                    \
   _makerP1##_makerP2(_arg1, _comma, _arg2)
 
 MAKE_FUNC(MAK, ER, int a, _COMMA, int b);
 // CHECK: void func(int a , int b) {}
+
+#define macro(a, b) (a - b)
+void function(int a);
+#define COMMA_ELIDER(...) \
+  macro(x, __VA_ARGS__); \
+  function(x, __VA_ARGS__);
+COMMA_ELIDER();
+// CHECK: (x - );
+// CHECK: function(x);