[OpenMP]Fix parsing of OpenMP directive nested in a metadirective

[mikerice]

Summary

Currently any directives inside the associated statement of the metadirective would be parsed as a metadirective and fail. This change just resets the variable before the associated statement is parsed.

It's not clear to me why ReadDirectiveWithinMetadirective is a static instead of a default parameter to ParseOpenMPDeclarativeOrExecutableDirective. That seems to work too if we like it better.

[ABataev]

Could you try to make it a param, if possible?

[ABataev]

Or at least a static member of a class

[mikerice]

Use a parameter for ReadDirectiveWithinMetadirective.

[ABataev]

LG

clang/include/clang/Parse/Parser.h

private:
   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);
+  /// \param ReadDirectiveWithinMetadirective true if directive is within a
+  /// metadirective and therefore ends on the closing paren.
+  StmtResult ParseOpenMPDeclarativeOrExecutableDirective(
+      ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective = false);
   /// Parses clause of kind \a CKind for directive of a kind \a Kind.
   ///
   /// \param DKind Kind of current directive.
   /// \param CKind Kind of current clause.
   /// \param FirstClause true, if this is the first clause of a kind \a CKind
   /// in current directive.
   ///
   OMPClause *ParseOpenMPClause(OpenMPDirectiveKind DKind,

clang/lib/Parse/ParseOpenMP.cpp

 ///         'distribute paralle for simd' | 'distribute simd' | 'target parallel
 ///         for simd' | 'target simd' | 'teams distribute' | 'teams distribute
 ///         simd' | 'teams distribute parallel for simd' | 'teams distribute
 ///         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) {
-  static bool ReadDirectiveWithinMetadirective = false;
+StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
+    ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective) {
   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>
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
       // If no directive is passed, skip in OpenMP 5.0.
       // TODO: Generate nothing directive from OpenMP 5.1.
       if (Tok.is(tok::r_paren)) {
         SkipUntil(tok::annot_pragma_openmp_end);
         break;
       }
 
       // Parse Directive
-      ReadDirectiveWithinMetadirective = true;
-      Directive = ParseOpenMPDeclarativeOrExecutableDirective(StmtCtx);
-      ReadDirectiveWithinMetadirective = false;
+      Directive = ParseOpenMPDeclarativeOrExecutableDirective(
+          StmtCtx,
+          /*ReadDirectiveWithinMetadirective=*/true);
       break;
     }
     break;
   }
   case OMPD_threadprivate: {
     // FIXME: Should this be permitted in C++?
     if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
         ParsedStmtContext()) {

clang/test/OpenMP/metadirective_ast_print.c

 #pragma omp metadirective when(implementation = {extension(match_any)} \
                                : parallel) default(parallel for)
   for (int i = 0; i < 100; i++)
     ;
 #pragma omp metadirective when(implementation = {extension(match_none)} \
                                : parallel) default(parallel for)
   for (int i = 0; i < 100; i++)
     ;
+
+// Test metadirective with nested OpenMP directive.
+  int array[16];
+  #pragma omp metadirective when(user = {condition(1)} \
+                                 : parallel for)
+  for (int i = 0; i < 16; i++) {
+    #pragma omp simd
+    for (int j = 0; j < 16; j++)
+      array[i] = i;
+  }
 }
 
 // CHECK: void bar();
 // CHECK: void foo()
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: bar()
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: bar()
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: bar()
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: bar()
 // CHECK-NEXT: #pragma omp parallel
 // CHECK-NEXT: bar()
 // CHECK-NEXT: #pragma omp parallel for
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK: #pragma omp parallel
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK: #pragma omp parallel for
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
 // CHECK: #pragma omp parallel
 // CHECK-NEXT: for (int i = 0; i < 100; i++)
+// CHECK: #pragma omp parallel for
+// CHECK-NEXT: for (int i = 0; i < 16; i++) {
+// CHECK-NEXT: #pragma omp simd
+// CHECK-NEXT: for (int j = 0; j < 16; j++)
 
 #endif