[OpenACC] Implement 'copyout' clause parsing.

This is a fairly simple clause that just requires parsing a potential
'zero:' in front of a Clause var-list.  This patch implements/tests
that.

Author: erichkeane

clang/include/clang/Basic/OpenACCKinds.h

@@ -205,6 +205,9 @@ enum class OpenACCClauseKind {
   /// 'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel
   /// loop', and 'serial loop' constructs.
   Private,
+  /// 'copyout' clause, allowed on Compute and Combined constructs, plus 'data',
+  /// 'exit data', and 'declare'.
+  CopyOut,
 
   /// Represents an invalid clause, for the purposes of parsing.
   Invalid,
@@ -288,6 +291,9 @@ inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &Out,
   case OpenACCClauseKind::Private:
     return Out << "private";
 
+  case OpenACCClauseKind::CopyOut:
+    return Out << "copyout";
+
   case OpenACCClauseKind::Invalid:
     return Out << "<invalid>";
   }

clang/lib/Parse/ParseOpenACC.cpp

@@ -92,6 +92,7 @@ OpenACCClauseKind getOpenACCClauseKind(Token Tok) {
       .Case("attach", OpenACCClauseKind::Attach)
       .Case("auto", OpenACCClauseKind::Auto)
       .Case("copy", OpenACCClauseKind::Copy)
+      .Case("copyout", OpenACCClauseKind::CopyOut)
       .Case("default", OpenACCClauseKind::Default)
       .Case("delete", OpenACCClauseKind::Delete)
       .Case("detach", OpenACCClauseKind::Detach)
@@ -146,6 +147,7 @@ enum class OpenACCSpecialTokenKind {
   ReadOnly,
   DevNum,
   Queues,
+  Zero,
 };
 
 bool isOpenACCSpecialToken(OpenACCSpecialTokenKind Kind, Token Tok) {
@@ -159,6 +161,8 @@ bool isOpenACCSpecialToken(OpenACCSpecialTokenKind Kind, Token Tok) {
     return Tok.getIdentifierInfo()->isStr("devnum");
   case OpenACCSpecialTokenKind::Queues:
     return Tok.getIdentifierInfo()->isStr("queues");
+  case OpenACCSpecialTokenKind::Zero:
+    return Tok.getIdentifierInfo()->isStr("zero");
   }
   llvm_unreachable("Unknown 'Kind' Passed");
 }
@@ -395,6 +399,7 @@ ClauseParensKind getClauseParensKind(OpenACCClauseKind Kind) {
   case OpenACCClauseKind::Default:
   case OpenACCClauseKind::If:
   case OpenACCClauseKind::Copy:
+  case OpenACCClauseKind::CopyOut:
   case OpenACCClauseKind::UseDevice:
   case OpenACCClauseKind::NoCreate:
   case OpenACCClauseKind::Present:
@@ -554,6 +559,12 @@ bool Parser::ParseOpenACCClauseParams(OpenACCClauseKind Kind) {
         return true;
       break;
     }
+    case OpenACCClauseKind::CopyOut:
+      tryParseAndConsumeSpecialTokenKind(*this, OpenACCSpecialTokenKind::Zero,
+                                         Kind);
+      if (ParseOpenACCClauseVarList(Kind))
+        return true;
+      break;
     case OpenACCClauseKind::Attach:
     case OpenACCClauseKind::Copy:
     case OpenACCClauseKind::Delete:
@@ -696,7 +707,8 @@ ExprResult Parser::ParseOpenACCIDExpression() {
 /// - a common block name between slashes (fortran only)
 bool Parser::ParseOpenACCVar() {
   OpenACCArraySectionRAII ArraySections(*this);
-  ExprResult Res = ParseAssignmentExpression();
+  ExprResult Res =
+      getActions().CorrectDelayedTyposInExpr(ParseAssignmentExpression());
   return Res.isInvalid();
 }
 

clang/test/ParserOpenACC/parse-clauses.c

@@ -497,6 +497,38 @@ void VarListClauses() {
   // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
 #pragma acc serial device(s.array[s.value : 5], s.value), seq
 
+  // expected-error@+2{{expected ','}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(s.array[s.value] s.array[s.value :5] ), seq
+
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(s.array[s.value : 5], s.value), seq
+
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(zero:s.array[s.value : 5], s.value), seq
+
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(zero : s.array[s.value : 5], s.value), seq
+
+  // expected-error@+2{{use of undeclared identifier 'zero'}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(zero s.array[s.value : 5], s.value), seq
+
+  // expected-error@+2{{invalid tag 'readonly' on 'copyout' clause}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(readonly:s.array[s.value : 5], s.value), seq
+
+  // expected-error@+2{{invalid tag 'invalid' on 'copyout' clause}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
+
+  // expected-error@+2{{invalid tag 'invalid' on 'copyout' clause}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
+
+  // expected-error@+2{{use of undeclared identifier 'invalid'}}
+  // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}
+#pragma acc serial copyout(invalid s.array[s.value : 5], s.value), seq
 }
 
   // expected-warning@+1{{OpenACC directives not yet implemented, pragma ignored}}