[OpenACC] Implement ignoring of extension clauses

OpenACC 3.4 will permit extension clauses, which are clauses that start
with '__', and contain an optional balanced-paren-token-sequence inside
of parens.

This patch ensures we consume these, and emit a warning instead of an
error for unsupported clauses.

Author: erichkeane

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -1456,6 +1456,9 @@ def err_acc_unexpected_directive
 def err_acc_invalid_directive
     : Error<"invalid OpenACC directive %select{%1|'%1 %2'}0">;
 def err_acc_invalid_clause : Error<"invalid OpenACC clause %0">;
+def warn_acc_unsupported_extension_clause
+    : Warning<"unsupported OpenACC extension clause %0">,
+      InGroup<DiagGroup<"unknown-acc-extension-clause">>;
 def err_acc_missing_directive : Error<"expected OpenACC directive">;
 def err_acc_invalid_open_paren
     : Error<"expected clause-list or newline in OpenACC directive">;

clang/lib/Parse/ParseOpenACC.cpp

@@ -939,6 +939,15 @@ bool Parser::ParseOpenACCGangArgList(
   return false;
 }
 
+namespace {
+bool isUnsupportedExtensionClause(Token Tok) {
+  if (!Tok.is(tok::identifier))
+    return false;
+
+  return Tok.getIdentifierInfo()->getName().starts_with("__");
+}
+} // namespace
+
 Parser::OpenACCClauseParseResult
 Parser::ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
                            OpenACCDirectiveKind DirKind) {
@@ -949,7 +958,21 @@ Parser::ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
 
   OpenACCClauseKind Kind = getOpenACCClauseKind(getCurToken());
 
-  if (Kind == OpenACCClauseKind::Invalid) {
+  if (isUnsupportedExtensionClause(getCurToken())) {
+    Diag(getCurToken(), diag::warn_acc_unsupported_extension_clause)
+        << getCurToken().getIdentifierInfo();
+
+    // Extension methods optionally contain balanced token sequences, so we are
+    // going to parse this.
+    ConsumeToken(); // Consume the clause name.
+    BalancedDelimiterTracker Parens(*this, tok::l_paren,
+                                    tok::annot_pragma_openacc_end);
+    // Consume the optional parens and tokens inside of them.
+    if (!Parens.consumeOpen())
+      Parens.skipToEnd();
+
+    return OpenACCCanContinue();
+  } else if (Kind == OpenACCClauseKind::Invalid) {
     Diag(getCurToken(), diag::err_acc_invalid_clause)
         << getCurToken().getIdentifierInfo();
     return OpenACCCannotContinue();

clang/test/ParserOpenACC/extensions.c

@@ -0,0 +1,66 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+// RUN: not %clang_cc1 %s -fopenacc -ast-dump | FileCheck %s
+
+void foo(int Var) {
+  // expected-warning@+1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning@+1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(stuff) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning@+1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(")") copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning@+1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(()) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning@+2{{unsupported OpenACC extension clause '__extension'}}
+  // expected-error@+1{{expected identifier}}
+#pragma acc parallel copy(Var) __extension()) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // Cannot recover from a bad paren, so we give up here.
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning@+3{{unsupported OpenACC extension clause '__extension'}}
+  // expected-error@+2{{expected ')'}}
+  // expected-note@+1{{to match this '('}}
+#pragma acc parallel copy(Var) __extension(() copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // Cannot recover from a bad paren, so we give up here.
+  // CHECK-NEXT: NullStmt
+
+}