[clang] fix -Wparentheses in ParseDecl.cpp after D60934

[Tyker]

Summary

this is a follow-up to https://reviews.llvm.org/D60934

Changes:

• the isAlreadyConsumed and RangeEnd have been reworked into ConsumedEnd.
• the state that was previously checked with an assert now cannot occur. so the assert have been removed

[Tyker]

commited by https://reviews.llvm.org/rGba24f352f4fa47d6caabac3764b8d896d40fb934

clang/lib/Parse/ParseDecl.cpp

bool EnteringContext = (DSContext == DeclSpecContext::DSC_class ||
                           DSContext == DeclSpecContext::DSC_top_level);
   bool AttrsLastTime = false;
   ParsedAttributesWithRange attrs(AttrFactory);
   // We use Sema's policy to get bool macros right.
   PrintingPolicy Policy = Actions.getPrintingPolicy();
   while (1) {
     bool isInvalid = false;
     bool isStorageClass = false;
-    bool isAlreadyConsumed = false;
     const char *PrevSpec = nullptr;
     unsigned DiagID = 0;
 
-    // This value need to be set when isAlreadyConsumed is set to true.
-    SourceLocation RangeEnd;
+    // This value need to be set to the location of the last token if the last
+    // token of the specifier is already consumed.
+    SourceLocation ConsumedEnd;
 
     // HACK: MSVC doesn't consider _Atomic to be a keyword and its STL
     // implementation for VS2013 uses _Atomic as an identifier for one of the
     // classes in <atomic>.
     //
     // A typedef declaration containing _Atomic<...> is among the places where
     // the class is used.  If we are currently parsing such a declaration, treat
     // the token as an identifier.
case tok::kw_virtual:
       else {
         isInvalid = DS.setFunctionSpecVirtual(Loc, PrevSpec, DiagID);
       }
       break;
     case tok::kw_explicit: {
       SourceLocation ExplicitLoc = Loc;
       SourceLocation CloseParenLoc;
       ExplicitSpecifier ExplicitSpec(nullptr, ExplicitSpecKind::ResolvedTrue);
-      isAlreadyConsumed = true;
-      RangeEnd = ExplicitLoc;
+      ConsumedEnd = ExplicitLoc;
       ConsumeToken(); // kw_explicit
       if (Tok.is(tok::l_paren)) {
         if (getLangOpts().CPlusPlus2a) {
           ExprResult ExplicitExpr(static_cast<Expr *>(nullptr));
           BalancedDelimiterTracker Tracker(*this, tok::l_paren);
           Tracker.consumeOpen();
           ExplicitExpr = ParseConstantExpression();
-          RangeEnd = Tok.getLocation();
+          ConsumedEnd = Tok.getLocation();
           if (ExplicitExpr.isUsable()) {
             CloseParenLoc = Tok.getLocation();
             Tracker.consumeClose();
             ExplicitSpec =
                 Actions.ActOnExplicitBoolSpecifier(ExplicitExpr.get());
           } else
             Tracker.skipToEnd();
         } else
case tok::less:
         DS.SetTypeSpecError();
       }
 
       // Need to support trailing type qualifiers (e.g. "id<p> const").
       // If a type specifier follows, it will be diagnosed elsewhere.
       continue;
     }
 
-    assert(!isAlreadyConsumed || RangeEnd != SourceLocation() &&
-                                     "both or neither of isAlreadyConsumed and "
-                                     "RangeEnd needs to be set");
-    DS.SetRangeEnd(isAlreadyConsumed ? RangeEnd : Tok.getLocation());
+    DS.SetRangeEnd(ConsumedEnd.isValid() ? ConsumedEnd : Tok.getLocation());
 
     // If the specifier wasn't legal, issue a diagnostic.
     if (isInvalid) {
       assert(PrevSpec && "Method did not return previous specifier!");
       assert(DiagID);
 
       if (DiagID == diag::ext_duplicate_declspec ||
           DiagID == diag::ext_warn_duplicate_declspec ||
           DiagID == diag::err_duplicate_declspec)
         Diag(Loc, DiagID) << PrevSpec
                           << FixItHint::CreateRemoval(
                                  SourceRange(Loc, DS.getEndLoc()));
       else if (DiagID == diag::err_opencl_unknown_type_specifier) {
         Diag(Loc, DiagID) << getLangOpts().OpenCLCPlusPlus
                           << getLangOpts().getOpenCLVersionTuple().getAsString()
                           << PrevSpec << isStorageClass;
       } else
         Diag(Loc, DiagID) << PrevSpec;
     }
 
-    if (DiagID != diag::err_bool_redeclaration && !isAlreadyConsumed)
+    if (DiagID != diag::err_bool_redeclaration && ConsumedEnd.isInvalid())
       // After an error the next token can be an annotation token.
       ConsumeAnyToken();
 
     AttrsLastTime = false;
   }
 }
 
 /// ParseStructDeclaration - Parse a struct declaration without the terminating