Clean the code, formated and add basic tests for the patch.

[abidmalikwaterloo]

It. should update D122255. It should not create the new one.
--->
I used the following
arc patch D122255
"did something"
git commit -a
arc diff
---->

[abidmalikwaterloo]

I submitted update but it created a new patch D123598.
I marked it abandon and submitting it again.

clang/include/clang/AST/OpenMPClause.h

 //===- OpenMPClause.h - Classes for OpenMP clauses --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
 
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   child_range used_children() {
     return child_range(child_iterator(), child_iterator());
   }
+  
   const_child_range used_children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_bind;
   }
 };
 
-/// This represents 'when' clause in the '#pragma omp ...' directive
-///
-/// \code
-/// #pragma omp metadirective when(user={condition(N<10)} : parallel for) \
-///            when(user={condition(N> 10)}: parallel)\  
-/// \endcode
-/// In this example directive '#pragma omp metadirective' has two 'when'
-/// clauses with user defined conditions.
-
-
-
 
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
 class OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \

 template <typename T> using const_ptr = std::add_pointer_t<std::add_const_t<T>>;
 
 template <class ImplClass, typename RetTy = void>
 class OMPClauseVisitor
     : public OMPClauseVisitorBase<ImplClass, std::add_pointer_t, RetTy> {};
 template<class ImplClass, typename RetTy = void>
 class ConstOMPClauseVisitor :
       public OMPClauseVisitorBase <ImplClass, const_ptr, RetTy> {};
            
-     
-/*
-class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
-  raw_ostream &OS;
-  const PrintingPolicy &Policy;
-
-  /// Process clauses with list of variables.
-  template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
-  /// Process motion clauses.
-  template <typename T> void VisitOMPMotionClause(T *Node);
-
-public:
-  OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
-      : OS(OS), Policy(Policy) {}
-      
- // void VisitOMPWhenClause(OMPWhenClause *Node);
-  
-#define GEN_CLANG_CLAUSE_CLASS
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
-#include "llvm/Frontend/OpenMP/OMP.inc"
-};
-
-*/
-
 struct OMPTraitProperty {
   llvm::omp::TraitProperty Kind = llvm::omp::TraitProperty::invalid;
 
   /// The raw string as we parsed it. This is needed for the `isa` trait set
   /// (which accepts anything) and (later) extensions.
   StringRef RawString;
 };
 struct OMPTraitSelector {

clang/include/clang/AST/StmtOpenMP.h

 //===- StmtOpenMP.h - Classes for OpenMP directives  ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 
 public:
   static OMPMetaDirective *Create(const ASTContext &C, SourceLocation StartLoc,
                                   SourceLocation EndLoc,
                                   ArrayRef<OMPClause *> Clauses,
                                   Stmt *AssociatedStmt, Stmt *IfStmt);
   static OMPMetaDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
                                        EmptyShell);
-                                       
   Stmt *getIfStmt() const { return IfStmt; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPMetaDirectiveClass;
   }
 };
 
 /// This represents '#pragma omp loop' directive.

clang/include/clang/Parse/Parser.h

 //===--- Parser.h - C Language Parser ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
private:
   /// \param AllowScopeSpecifier true, if the variables can have fully
   /// qualified names.
   ///
   bool ParseOpenMPSimpleVarList(
       OpenMPDirectiveKind Kind,
       const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
           Callback,
       bool AllowScopeSpecifier);
+      
   /// Parses declarative or executable directive.
   ///
   /// \param StmtCtx The context in which we're parsing the directive.
+  ///
   StmtResult
   ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx);
   /// Parse clause for metadirective
+  ///
   /// \param Dkind Kind of current directive
   /// \param CKind Kind of current clause
   /// 
   OMPClause *ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
                                             OpenMPClauseKind CKind);
   /// Parses clause of kind \a CKind for directive of a kind \a Kind.
   ///
   /// \param DKind Kind of current directive.

clang/include/clang/Sema/Sema.h

 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
public:
   /// \param Clauses List of clauses for the current OpenMP region.
   ///
   /// \returns Statement for finished OpenMP region.
   StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef<OMPClause *> Clauses);
   StmtResult ActOnOpenMPExecutableDirective(
       OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName,
       OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
       Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
-  StmtResult ActOnOpenMPExecutableMetaDirective( // This might be needed later
+  
+  /// Called on '\#pragma omp metadirective' after parsing
+  ///
+  ///
+  /// \returns Statement for metadirective    
+  StmtResult ActOnOpenMPExecutableMetaDirective( 
       OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, 
       OpenMPDirectiveKind CancelRegion, ArrayRef<OMPClause *> Clauses,
       Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
+      
   /// Called on well-formed '\#pragma omp parallel' after parsing
   /// of the  associated statement.
   StmtResult ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                           Stmt *AStmt,
                                           SourceLocation StartLoc,
                                           SourceLocation EndLoc);
   using VarsWithInheritedDSAType =
       llvm::SmallDenseMap<const ValueDecl *, const Expr *, 4>;
public:
 
   OMPClause *ActOnOpenMPSimpleClause(OpenMPClauseKind Kind,
                                      unsigned Argument,
                                      SourceLocation ArgumentLoc,
                                      SourceLocation StartLoc,
                                      SourceLocation LParenLoc,
                                      SourceLocation EndLoc);
   /// Called on well-formed 'when' clause.
-  /// Abid
   OMPClause *ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
               StmtResult Directive,  
               SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation EndLoc);
   /// Called on well-formed 'default' clause.
   OMPClause *ActOnOpenMPDefaultClause(llvm::omp::DefaultKind Kind,
                                       SourceLocation KindLoc,

clang/lib/AST/OpenMPClause.cpp

 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 
 OMPBindClause *OMPBindClause::CreateEmpty(const ASTContext &C) {
   return new (C) OMPBindClause();
 }
 //===----------------------------------------------------------------------===//
 //  OpenMP clauses printing methods
 //===----------------------------------------------------------------------===//
 
-
 void OMPClausePrinter::VisitOMPWhenClause(OMPWhenClause *Node) {
 
   if (Node->getTI().Sets.size() == 0) {
     OS << "default(";
     return;
   }
   OS << "when(";
   int count = 0;
for (const OMPTraitSelector &Selector : Set.Selectors) {
         break;
       }
       case TraitSelector::user_condition: {
         OS << "user={condition(";
         Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy, 0);
         OS << ")}";
         break;
       }
-      
       default:
         break;
       }
     }
   }
   OS << ": ";
 }
 

clang/lib/AST/StmtPrinter.cpp

 //===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //

 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) {
   PrintStmt(Node->getLoopStmt());
 }
 
 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S,
                                               bool ForceNoStmt) {
-   
-        
   OMPClausePrinter Printer(OS, Policy);
   ArrayRef<OMPClause *> Clauses = S->clauses();
-  for (auto *Clause : Clauses){
-    
+  for (auto *Clause : Clauses){ 
     if (Clause && !Clause->isImplicit()) {
       OS << ' ';
-      Printer.Visit(Clause);
-      
+      Printer.Visit(Clause);    
       if (dyn_cast<OMPMetaDirective>(S)){
-     
         OMPWhenClause *c = dyn_cast<OMPWhenClause>(Clause);
         if (c!=NULL){
           if (c->getDKind() != llvm::omp::OMPD_unknown){
             Printer.VisitOMPWhenClause(c);
             OS << llvm::omp::getOpenMPDirectiveName(c->getDKind());
             }
           OS << ")";  
           }
             }
       } 
     }
   OS << NL;
   if (!ForceNoStmt && S->hasAssociatedStmt())
     PrintStmt(S->getRawStmt());
 }
 
-void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {
-  
+void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) {  
   Indent() << "#pragma omp metadirective";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
   Indent() << "#pragma omp parallel";
   PrintOMPExecutableDirective(Node);
 }

clang/lib/Parse/ParseOpenMP.cpp

 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 ///         parallel for' | 'target teams' | 'target teams distribute' | 'target
 ///         teams distribute parallel for' | 'target teams distribute parallel
 ///         for simd' | 'target teams distribute simd' | 'masked' {clause}
 ///         annot_pragma_openmp_end
 ///
 StmtResult
 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
 // need to check about the following
-  static bool ReadDirectiveWithinMetadirective = false; // what is this?
+  static bool ReadDirectiveWithinMetadirective = false;
   if (!ReadDirectiveWithinMetadirective)
     assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&
            "Not an OpenMP directive!");
   ParsingOpenMPDirectiveRAII DirScope(*this);
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<OMPClause *, 5> Clauses;
   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
               llvm::omp::Clause_enumSize + 1>
case OMPD_metadirective: {
     // The function will get the score for each clause and sort it 
     // based on the score number
     
     getArrayVariantMatchForContext(VMIs, OMPCtx, A) ;          
                                     
     ParseScope OMPDirectiveScope(this, ScopeFlags); 
     Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);  
     
     while(Tok.isNot(tok::annot_pragma_openmp_end)){
     
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
                                    
       Actions.StartOpenMPClause(CKind);
       OMPClause *Clause = ParseOpenMPMetaDirectiveClause( DKind, CKind);
       
OMPClause *Parser::ParseOpenMPMetaDirectiveClause(OpenMPDirectiveKind DKind,
   // Check if clause is allowed for the given directive.
   if (CKind != OMPC_unknown &&
       !isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
     ErrorFound = true;
     WrongDirective = true;
   }
-
  // Check if clause is not allowed
  if (CKind == OMPC_unknown) {
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << "Unknown clause: Not allowed";
     ErrorFound = true;
     WrongDirective = true;
   }
   
-  
-  if (CKind == OMPC_default || CKind == OMPC_when) {
     SourceLocation Loc = ConsumeToken();
     SourceLocation DelimLoc;
     // Parse '('.
     BalancedDelimiterTracker T(*this, tok::l_paren,
                                tok::annot_pragma_openmp_end);
     if (T.expectAndConsume(diag::err_expected_lparen_after,
                            getOpenMPClauseName(CKind).data()))
       return nullptr;
 
     OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
+ 
     if (CKind == OMPC_when) {
       // parse and get condition expression to pass to the When clause
       parseOMPContextSelectors(Loc, TI);
 
       // Parse ':'
       if (Tok.is(tok::colon))
         ConsumeAnyToken();
       else {
if (Tok.isNot(tok::r_paren)) {
 
       DirKind = parseOpenMPDirectiveKind(*this);
       ConsumeToken();
       ParseScope OMPDirectiveScope(this, ScopeFlags);
       Actions.StartOpenMPDSABlock(DirKind, DirName, Actions.getCurScope(), Loc);
       
       int paren = 0;
       
-      while (Tok.isNot(tok::r_paren) || paren != 0) {
-        if (Tok.is(tok::l_paren))
           paren++;
-        if (Tok.is(tok::r_paren))
           paren--;
   
-        OpenMPClauseKind CKind = Tok.isAnnotation()
                                      ? OMPC_unknown
                                      : getOpenMPClauseKind(PP.getSpelling(Tok));
          
-        if (CKind == OMPC_unknown &&
           !isAllowedClauseForDirective(DirKind, CKind, getLangOpts().OpenMP)) {
         Diag(Tok, diag::err_omp_unexpected_clause)
             << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
         ErrorFound = true;
         WrongDirective = true;
-    }
+       }
         
                                
-        Actions.StartOpenMPClause(CKind);
 
-        OMPClause *Clause = ParseOpenMPClause(
             DirKind, CKind, !FirstClauses[(unsigned)CKind].getInt());
-        FirstClauses[(unsigned)CKind].setInt(true);
-        if (Clause) {
           FirstClauses[(unsigned)CKind].setPointer(Clause);
           Clauses.push_back(Clause);
-        }
-
-        // Skip ',' if any.
-        if (Tok.is(tok::comma))
           ConsumeToken();
-        Actions.EndOpenMPClause();
-        
-        
+      Actions.EndOpenMPClause();  
       }
-  
       Actions.ActOnOpenMPRegionStart(DirKind, getCurScope());
       ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
-
       /* Get Stmt and revert back */
       TentativeParsingAction TPA(*this);
       while (Tok.isNot(tok::annot_pragma_openmp_end)) {
         ConsumeAnyToken();
       }
       
       ConsumeAnnotationToken();
       ParseScope InnerStmtScope(this, Scope::DeclScope,
                                 getLangOpts().C99 || getLangOpts().CPlusPlus,
                                 Tok.is(tok::l_brace));
                                                       
       StmtResult AStmt = ParseStatement();
       InnerStmtScope.Exit();
       TPA.Revert();
       /* End Get Stmt */
 
       AssociatedStmt = (Sema::CompoundScopeRAII(Actions), AStmt);
       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
-  
+      
       Directive = Actions.ActOnOpenMPExecutableDirective(
           DirKind, DirName, OMPD_unknown, llvm::makeArrayRef(Clauses),
           AssociatedStmt.get(), Loc, Tok.getLocation());
-  
-  
+          
       Actions.EndOpenMPDSABlock(Directive.get());
       OMPDirectiveScope.Exit();
- 
     }
-
     // Parse ')'
     T.consumeClose();
 
     if (WrongDirective)
       return nullptr;
 
     Clause = Actions.ActOnOpenMPWhenClause(TI, DirKind, Directive, Loc,
                                            DelimLoc, Tok.getLocation());
   } else {
     ErrorFound = false;
     Diag(Tok, diag::err_omp_unexpected_clause)
         << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);     
   }
-    
+    
   return ErrorFound ? nullptr : Clause;
 }
 
-
-
 /// Parsing of OpenMP clauses.
 ///
 ///    clause:
 ///       if-clause | final-clause | num_threads-clause | safelen-clause |
 ///       default-clause | private-clause | firstprivate-clause | shared-clause
 ///       | linear-clause | aligned-clause | collapse-clause | bind-clause |
 ///       lastprivate-clause | reduction-clause | proc_bind-clause |
 ///       schedule-clause | copyin-clause | copyprivate-clause | untied-clause |

clang/lib/Sema/SemaOpenMP.cpp

 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
if (isOpenMPWorksharingDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_for_for);
   if (isOpenMPSimdDirective(DKind))
     Traits.emplace_back(llvm::omp::TraitProperty::construct_simd_simd);
   Stack->handleConstructTrait(Traits, ScopeEntry);
 }
 
 void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   switch (DKind) {
-  case OMPD_metadirective: // added
+  case OMPD_metadirective:
   case OMPD_parallel:
   case OMPD_parallel_for:
   case OMPD_parallel_for_simd:
   case OMPD_parallel_sections:
   case OMPD_parallel_master:
   case OMPD_teams:
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd: {
void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
   case OMPD_declare_variant:
   case OMPD_begin_declare_variant:
   case OMPD_end_declare_variant:
-  //case OMPD_metadirective:
     //llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
   default:
     llvm_unreachable("Unknown OpenMP directive");
   }
   DSAStack->setContext(CurContext);
   handleDeclareVariantConstructTrait(DSAStack, DKind, /* ScopeEntry */ true);
 }
if (Ordered && Order) {
     S.Diag(Ordered->getBeginLoc(), diag::note_omp_ordered_param)
         << 0 << SourceRange(Ordered->getBeginLoc(), Ordered->getEndLoc());
     return true;
   }
   return false;
 }
 
 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
-                                      ArrayRef<OMPClause *> Clauses) {
-                                                                        
+                                      ArrayRef<OMPClause *> Clauses) {                                                        
   handleDeclareVariantConstructTrait(DSAStack, DSAStack->getCurrentDirective(),
                                      /* ScopeEntry */ false);
   if (DSAStack->getCurrentDirective() == OMPD_atomic ||
       DSAStack->getCurrentDirective() == OMPD_critical ||
       DSAStack->getCurrentDirective() == OMPD_section ||
       DSAStack->getCurrentDirective() == OMPD_master ||
       DSAStack->getCurrentDirective() == OMPD_masked)
     return S;
if (AStmt && !CurContext->isDependentContext() && Kind != OMPD_atomic &&
     // mappers.
     if (LangOpts.OpenMP >= 50)
       processImplicitMapsWithDefaultMappers(*this, DSAStack,
                                             ClausesWithImplicit);
   }
 
   llvm::SmallVector<OpenMPDirectiveKind, 4> AllowedNameModifiers;
   switch (Kind) {
-
   case OMPD_metadirective:
     Res = ActOnOpenMPMetaDirective(ClausesWithImplicit, AStmt, StartLoc, 
               EndLoc);
     AllowedNameModifiers.push_back(OMPD_metadirective); 
     break;
   case OMPD_parallel:
     Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt, StartLoc,
                                        EndLoc);
auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit(
       Context, VariantRef, &TI, const_cast<Expr **>(AdjustArgsNothing.data()),
       AdjustArgsNothing.size(),
       const_cast<Expr **>(AdjustArgsNeedDevicePtr.data()),
       AdjustArgsNeedDevicePtr.size(),
       const_cast<OMPDeclareVariantAttr::InteropType *>(AppendArgs.data()),
       AppendArgs.size(), SR);
   FD->addAttr(NewAttr);
 }
-///
 
 StmtResult Sema::ActOnOpenMPMetaDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
-                                              SourceLocation EndLoc) {
-                                              
+                                              SourceLocation EndLoc) {                                           
  if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
-  // 
   CS->getCapturedDecl()->setNothrow();
 
   StmtResult IfStmt = StmtError();
   Stmt *ElseStmt = NULL;
 
   for (auto i = Clauses.rbegin(); i < Clauses.rend(); i++) {
     OMPWhenClause *WhenClause = dyn_cast<OMPWhenClause>(*i);
     Expr *WhenCondExpr = NULL;
for (const OMPTraitSet &Set : WhenClause->getTI().Sets) {
         }
         case TraitSelector::device_isa:
         case TraitSelector::device_kind:
         case TraitSelector::implementation_extension:
         default:
           break;
         }
       }
-    } ////
+    } 
 
     if (WhenCondExpr == NULL) {
       if (ElseStmt != NULL) {
         Diag(WhenClause->getBeginLoc(), diag::err_omp_misplaced_default_clause);
         return StmtError();
       }
       if (DKind == OMPD_unknown)
         ElseStmt = CompoundStmt::Create(Context, {CS->getCapturedStmt()},
IfStmt =
         ActOnIfStmt(SourceLocation(), /*false*/ IfStatementKind::Ordinary, SourceLocation(), NULL,
                     ActOnCondition(getCurScope(), SourceLocation(),
                                    WhenCondExpr, Sema::ConditionKind::Boolean),
                     SourceLocation(), ThenStmt, SourceLocation(), ElseStmt);
     ElseStmt = IfStmt.get();
   }
 
   return OMPMetaDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
-                                  IfStmt.get());
-                                              
+                                  IfStmt.get());                                         
 }
 
-
-///
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
                                               SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
for (unsigned I = First; I < Last; ++I) {
     if (I + Skipped + 2 == Last)
       Out << " or ";
     else if (I + Skipped + 1 != Last)
       Out << ", ";
   }
   return std::string(Out.str());
 }
 
-/// ActOnOpenMPWheClause --- Abid
-
 OMPClause *
 Sema::ActOnOpenMPWhenClause(OMPTraitInfo &TI, OpenMPDirectiveKind DKind,
                             StmtResult Directive, SourceLocation StartLoc,
                             SourceLocation LParenLoc, SourceLocation EndLoc) {
   return new (Context)
       OMPWhenClause(TI, DKind, Directive.get(), StartLoc, LParenLoc, EndLoc);
 }
 
-
-
-
 OMPClause *Sema::ActOnOpenMPDefaultClause(DefaultKind Kind,
                                           SourceLocation KindKwLoc,
                                           SourceLocation StartLoc,
                                           SourceLocation LParenLoc,
                                           SourceLocation EndLoc) {
   if (Kind == OMP_DEFAULT_unknown) {
     Diag(KindKwLoc, diag::err_omp_unexpected_clause_value)
         << getListOfPossibleValues(OMPC_default, /*First=*/0,

clang/lib/Sema/SemaStmt.cpp

 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
StmtResult Sema::ActOnCapturedRegionEnd(Stmt *S) {
   CapturedDecl *CD = RSI->TheCapturedDecl;
   RecordDecl *RD = RSI->TheRecordDecl;
 
   CapturedStmt *Res = CapturedStmt::Create(
       getASTContext(), S, static_cast<CapturedRegionKind>(RSI->CapRegionKind),
       Captures, CaptureInits, CD, RD);
       
   CD->setBody(Res->getCapturedStmt());
-    
   RD->completeDefinition();
 
   return Res;
 }

llvm/include/llvm/Frontend/OpenMP/OMPContext.h

 //===- OpenMP/OMPContext.h ----- OpenMP context helper functions  - C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file

 /// Sort array \p A of clause index  with score
 /// This will be used to produce AST clauses
 /// in a sorted order with the clause with the highiest order
 /// on the top and default clause at the bottom
 void getArrayVariantMatchForContext(
     const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx,
     SmallVector<std::pair<unsigned, APInt>> &A);
 
-// new--
 } // namespace omp
 
 template <> struct DenseMapInfo<omp::TraitProperty> {
   static inline omp::TraitProperty getEmptyKey() {
     return omp::TraitProperty(-1);
   }
   static inline omp::TraitProperty getTombstoneKey() {
     return omp::TraitProperty(-2);

llvm/lib/Frontend/OpenMP/OMPContext.cpp

 //===- OMPContext.cpp ------ Collection of helpers for OpenMP contexts ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements helper functions and classes to deal with OpenMP
 /// contexts as used by `[begin/end] declare variant` and `metadirective`.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Frontend/OpenMP/OMPContext.h"
 #include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
-
 #include <map>
 #define DEBUG_TYPE "openmp-ir-builder"
 
 using namespace llvm;
 using namespace omp;
 
 OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple) {
   // Add the appropriate device kind trait based on the triple and the
for (TraitProperty Property : VMI.ConstructTraits) {
     Score += (1ULL << ConstructMatches[ConstructIdx++]);
   }
 
   LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of " << Score
                     << "\n");
   return Score;
 }
 
-/// 
 /// Takes \p VMI and \p Ctx and sort the 
 /// scores using \p A
 void llvm::omp::getArrayVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs,
                                     const OMPContext &Ctx, SmallVector<std::pair<unsigned, APInt>> &A){
-  
-  //APInt BestScore(64, 0);
-  APInt Score (64, 0);
-  llvm::DenseMap<unsigned, llvm::APInt> m;
+   APInt Score (64, 0);
+   llvm::DenseMap<unsigned, llvm::APInt> m;
       
-  /*for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
-    const VariantMatchInfo &VMI = VMIs[u];
-    SmallVector<unsigned, 8> ConstructMatches;
-          APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
-          m.insert({u, Score}); 
-  }
-
-  */
-  
-  for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
-        const VariantMatchInfo &VMI = VMIs[u];
+   for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
+      const VariantMatchInfo &VMI = VMIs[u];
 
-        SmallVector<unsigned, 8> ConstructMatches;
-        // If the variant is not applicable its not the best.
-        if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
+      SmallVector<unsigned, 8> ConstructMatches;
+      // If the variant is not applicable its not the best.
+    if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
                                             /* DeviceSetOnly */ false)){
-                       Score = 0;
-                       m.insert({u, Score});                    
-            continue;
-          }
+      continue;}
           
-      // Check if its clearly not the best.
-        Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
+      // Check if its clearly not the best.
+    Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
     m.insert({u, Score}); 
-  }
+   }
       
-  for (auto& it : m) 
-    A.push_back(it);
+   for (auto& it : m)   A.push_back(it);
   
-  std::sort(A.begin(), A.end(), [] (std::pair<unsigned, APInt>&a,
+   std::sort(A.begin(), A.end(), [] (std::pair<unsigned, APInt>&a,
            std::pair<unsigned, APInt>&b){  
-      return a.second.ugt(b.second);
-    }); 
+      return a.second.ugt(b.second);});  
 }
  
-
-
 int llvm::omp::getBestVariantMatchForContext(
     const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
 
   APInt BestScore(64, 0);
   int BestVMIIdx = -1;
   const VariantMatchInfo *BestVMI = nullptr;
 
   for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {