Clang-tidy macro parantheses checker, fix false positives for some c++ type usages

[danielmarjamaki]

Summary

This patch fix false positives, that alexfh pointed out, in the recently added clang-tidy macro parentheses checker.

[alexfh]

LG. Thank you!

clang-tools-extra/trunk/clang-tidy/misc/MacroParenthesesCheck.cpp

 /// Is given TokenKind a keyword?
 bool isKeyword(const Token &T) {
   /// \TODO better matching of keywords to avoid false positives
   return T.isOneOf(tok::kw_case, tok::kw_const, tok::kw_struct);
 }
 
 /// Warning is written when one of these operators are not within parentheses.
 bool isWarnOp(const Token &T) {
-   /// \TODO This is an initial list of operators. It can be tweaked later to
-   /// get more positives or perhaps avoid some false positive.
   return T.isOneOf(tok::plus, tok::minus, tok::star, tok::slash, tok::percent,
                    tok::amp, tok::pipe, tok::caret);
 }
 }
 
 void MacroParenthesesPPCallbacks::replacementList(const Token &MacroNameTok,
                                                   const MacroInfo *MI) {
   // Count how deep we are in parentheses/braces/squares.
for (auto TI = MI->tokens_begin(), TE = MI->tokens_end(); TI != TE; ++TI) {
     // Don't warn after hash/hashhash or before hashhash.
     if (Prev.isOneOf(tok::hash, tok::hashhash) || Next.is(tok::hashhash))
       continue;
 
     // Argument is a struct member.
     if (Prev.isOneOf(tok::period, tok::arrow, tok::coloncolon))
       continue;
 
+    // Argument is a namespace or class.
+    if (Next.is(tok::coloncolon))
+      continue;
+
     // String concatenation.
     if (isStringLiteral(Prev.getKind()) || isStringLiteral(Next.getKind()))
       continue;
 
     // Type/Var.
     if (isAnyIdentifier(Prev.getKind()) || isKeyword(Prev) ||
         isAnyIdentifier(Next.getKind()) || isKeyword(Next))
       continue;
 
     // Initialization.
     if (Next.is(tok::l_paren))
       continue;
 
     // Cast.
     if (Prev.is(tok::l_paren) && Next.is(tok::star) &&
         TI + 2 != MI->tokens_end() && (TI + 2)->is(tok::r_paren))
       continue;
 
     // Assignment/return, i.e. '=x;' or 'return x;'.
     if (Prev.isOneOf(tok::equal, tok::kw_return) && Next.is(tok::semi))
       continue;
 
+    // C++ template parameters.
+    if (PP->getLangOpts().CPlusPlus && Prev.isOneOf(tok::comma, tok::less) &&
+        Next.isOneOf(tok::comma, tok::greater))
+      continue;
+
     Check->diag(Tok.getLocation(), "macro argument should be enclosed in "
                                    "parentheses")
         << FixItHint::CreateInsertion(Tok.getLocation(), "(")
         << FixItHint::CreateInsertion(Tok.getLocation().getLocWithOffset(
                                           PP->getSpelling(Tok).length()),
                                       ")");
   }
 }

clang-tools-extra/trunk/test/clang-tidy/misc-macro-parentheses.cpp

 #define GOOD15(x)         ({ int a = x; a+4; })
 #define GOOD16(x)         a_ ## x, b_ ## x = c_ ## x - 1,
 #define GOOD17            case 123: x=4+5; break;
 #define GOOD18(x)         ;x;
 #define GOOD19            ;-2;
 #define GOOD20            void*
 #define GOOD21(a)         case Fred::a:
 #define GOOD22(a)         if (verbose) return a;
+#define GOOD23(type)      (type::Field)
+#define GOOD24(t)         std::set<t> s
+#define GOOD25(t)         std::set<t,t,t> s
 
 // These are allowed for now..
 #define MAYBE1            *12.34
 #define MAYBE2            <<3