[OpenMP] remove redundant MapTypeModifierSpecified flag in ParseOpenMP.cpp (NFC)

[saghir]

Summary

In the below statement in ParseOpenMP.cpp:

bool IsComma =
1942 (Kind != OMPC_reduction && Kind != OMPC_task_reduction &&
1943 Kind != OMPC_in_reduction && Kind != OMPC_depend && Kind != OMPC_map) ||
1944 (Kind == OMPC_reduction && !InvalidReductionId) ||
1945 (Kind == OMPC_map && Data.MapType != OMPC_MAP_unknown &&
1946 (!MapTypeModifierSpecified ||
1947 Data.MapTypeModifier == OMPC_MAP_always)) ||
1948 (Kind == OMPC_depend && Data.DepKind != OMPC_DEPEND_unknown);

Whenever a map type modifier is specified, the flag MapTypeModifierSpecified is set to true.

In the above statement,

1. when there is no map type modifier specified, !MapTypeModifierSpecified portion evaluates to true.
2. when the map type modifier is specified, Data.MapTypeModifier == OMPC_MAP_always is set to true.

So whether a modifier is specified or not, the condition (highlighted in bold) always evaluates to true.

Check for this condition is redundant. Consequently, declaration and all uses of MapTypeModifierSpecified should be removed.

[ABataev]

LG, add NFC to the title.

cfe/trunk/lib/Parse/ParseOpenMP.cpp

 
 /// Parses clauses with list.
 bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind,
                                 OpenMPClauseKind Kind,
                                 SmallVectorImpl<Expr *> &Vars,
                                 OpenMPVarListDataTy &Data) {
   UnqualifiedId UnqualifiedReductionId;
   bool InvalidReductionId = false;
-  bool MapTypeModifierSpecified = false;
 
   // Parse '('.
   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
                          getOpenMPClauseName(Kind)))
     return true;
 
   bool NeedRParenForLinear = false;
if (IsMapClauseModifierToken(Tok)) {
         ConsumeToken();
       } else if (PP.LookAhead(0).is(tok::comma)) {
         if (IsMapClauseModifierToken(PP.LookAhead(1)) &&
             PP.LookAhead(2).is(tok::colon)) {
           Data.MapTypeModifier = Data.MapType;
           if (Data.MapTypeModifier != OMPC_MAP_always) {
             Diag(Tok, diag::err_omp_unknown_map_type_modifier);
             Data.MapTypeModifier = OMPC_MAP_unknown;
-          } else {
-            MapTypeModifierSpecified = true;
           }
 
           ConsumeToken();
           ConsumeToken();
 
           Data.MapType =
               IsMapClauseModifierToken(Tok)
                   ? static_cast<OpenMPMapClauseKind>(
                         getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok)))
                   : OMPC_MAP_unknown;
           if (Data.MapType == OMPC_MAP_unknown ||
               Data.MapType == OMPC_MAP_always)
             Diag(Tok, diag::err_omp_unknown_map_type);
           ConsumeToken();
         } else {
           Data.MapType = OMPC_MAP_tofrom;
           Data.IsMapTypeImplicit = true;
         }
       } else if (IsMapClauseModifierToken(PP.LookAhead(0))) {
         if (PP.LookAhead(1).is(tok::colon)) {
           Data.MapTypeModifier = Data.MapType;
           if (Data.MapTypeModifier != OMPC_MAP_always) {
             Diag(Tok, diag::err_omp_unknown_map_type_modifier);
             Data.MapTypeModifier = OMPC_MAP_unknown;
-          } else {
-            MapTypeModifierSpecified = true;
           }
 
           ConsumeToken();
 
           Data.MapType =
               IsMapClauseModifierToken(Tok)
                   ? static_cast<OpenMPMapClauseKind>(
                         getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok)))
// Handle dependency type for depend clause.
     else if (ColonExpected)
       Diag(Tok, diag::warn_pragma_expected_colon) << "map type";
   }
 
   bool IsComma =
       (Kind != OMPC_reduction && Kind != OMPC_task_reduction &&
        Kind != OMPC_in_reduction && Kind != OMPC_depend && Kind != OMPC_map) ||
       (Kind == OMPC_reduction && !InvalidReductionId) ||
-      (Kind == OMPC_map && Data.MapType != OMPC_MAP_unknown &&
-       (!MapTypeModifierSpecified ||
-        Data.MapTypeModifier == OMPC_MAP_always)) ||
+      (Kind == OMPC_map && Data.MapType != OMPC_MAP_unknown) ||
       (Kind == OMPC_depend && Data.DepKind != OMPC_DEPEND_unknown);
   const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);
   while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) &&
                      Tok.isNot(tok::annot_pragma_openmp_end))) {
     ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail);
     // Parse variable
     ExprResult VarExpr =
         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());