[clang] db4ea21 - [OpenACC] Change 'not implemented' diagnostic to be more specific

[via cfe-commits]

Author: erichkeane
Date: 2024-02-15T12:22:11-08:00
New Revision: db4ea21dfde307f4fc873a6fe56791cd7ae3f0a1

URL: https://github.com/llvm/llvm-project/commit/db4ea21dfde307f4fc873a6fe56791cd7ae3f0a1
DIFF: https://github.com/llvm/llvm-project/commit/db4ea21dfde307f4fc873a6fe56791cd7ae3f0a1.diff

LOG: [OpenACC] Change 'not implemented' diagnostic to be more specific

Currently we just emit a generic 'not implemented' diagnostic for all
OpenACC pragmas. This patch moves the diagnostic to 'Sema' and diagnoses
for a specific clause or construct, in preperation of implementing Sema
for constructs.

Added: 
    

Modified: 
    clang/include/clang/Basic/DiagnosticParseKinds.td
    clang/include/clang/Basic/DiagnosticSemaKinds.td
    clang/lib/Parse/ParseOpenACC.cpp
    clang/lib/Sema/SemaOpenACC.cpp
    clang/test/ParserOpenACC/parse-cache-construct.c
    clang/test/ParserOpenACC/parse-cache-construct.cpp
    clang/test/ParserOpenACC/parse-clauses.c
    clang/test/ParserOpenACC/parse-clauses.cpp
    clang/test/ParserOpenACC/parse-constructs.c
    clang/test/ParserOpenACC/parse-constructs.cpp
    clang/test/ParserOpenACC/parse-wait-clause.c
    clang/test/ParserOpenACC/parse-wait-construct.c
    clang/test/ParserOpenACC/unimplemented.c
    clang/test/ParserOpenACC/unimplemented.cpp

Removed: 
    


################################################################################
diff  --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
index a30ab27566ec3e..11b490a0928e60 100644
--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
@@ -1355,9 +1355,6 @@ def warn_pragma_acc_ignored
       DefaultIgnore;
 def err_acc_unexpected_directive
     : Error<"unexpected OpenACC directive %select{|'#pragma acc %1'}0">;
-def warn_pragma_acc_unimplemented
-    : Warning<"OpenACC directives not yet implemented, pragma ignored">,
-      InGroup<SourceUsesOpenACC>;
 def err_acc_invalid_directive
     : Error<"invalid OpenACC directive %select{%1|'%1 %2'}0">;
 def err_acc_invalid_clause : Error<"invalid OpenACC clause %0">;

diff  --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 935d94e38cc377..ce619d2996f201 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -12186,4 +12186,15 @@ def err_wasm_builtin_arg_must_match_table_element_type : Error <
   "%ordinal0 argument must match the element type of the WebAssembly table in the %ordinal1 argument">;
 def err_wasm_builtin_arg_must_be_integer_type : Error <
   "%ordinal0 argument must be an integer">;
+
+// OpenACC diagnostics.
+def warn_acc_construct_unimplemented
+    : Warning<"OpenACC construct '%0' not yet implemented, pragma ignored">,
+      InGroup<SourceUsesOpenACC>;
+def warn_acc_clause_unimplemented
+    : Warning<"OpenACC clause '%0' not yet implemented, clause ignored">,
+      InGroup<SourceUsesOpenACC>;
+def err_acc_construct_appertainment
+    : Error<"OpenACC construct '%0' cannot be used here; it can only "
+            "be used in a statement context">;
 } // end of sema component.

diff  --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index 8157656246873d..10bdd8e9f7448e 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -1182,7 +1182,6 @@ Parser::OpenACCDirectiveParseInfo Parser::ParseOpenACCDirective() {
   // Parses the list of clauses, if present.
   ParseOpenACCClauseList(DirKind);
 
-  Diag(getCurToken(), diag::warn_pragma_acc_unimplemented);
   assert(Tok.is(tok::annot_pragma_openacc_end) &&
          "Didn't parse all OpenACC Clauses");
   SourceLocation EndLoc = ConsumeAnnotationToken();

diff  --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
index dc530845433900..4dc36ce08bd21d 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -11,16 +11,35 @@
 ///
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/OpenACCKinds.h"
 #include "clang/Sema/Sema.h"
 
 using namespace clang;
 bool Sema::ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
                               SourceLocation StartLoc) {
-  return true;
+  if (ClauseKind == OpenACCClauseKind::Invalid)
+    return false;
+  // For now just diagnose that it is unsupported and leave the parsing to do
+  // whatever it can do. This function will eventually need to start returning
+  // some sort of Clause AST type, but for now just return true/false based on
+  // success.
+  return Diag(StartLoc, diag::warn_acc_clause_unimplemented) << ClauseKind;
 }
 void Sema::ActOnOpenACCConstruct(OpenACCDirectiveKind K,
-                                 SourceLocation StartLoc) {}
+                                 SourceLocation StartLoc) {
+  switch (K) {
+  case OpenACCDirectiveKind::Invalid:
+    // Nothing to do here, an invalid kind has nothing we can check here.  We
+    // want to continue parsing clauses as far as we can, so we will just
+    // ensure that we can still work and don't check any construct-specific
+    // rules anywhere.
+    break;
+  default:
+    Diag(StartLoc, diag::warn_acc_construct_unimplemented) << K;
+    break;
+  }
+}
 
 bool Sema::ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
                                           SourceLocation StartLoc) {

diff  --git a/clang/test/ParserOpenACC/parse-cache-construct.c b/clang/test/ParserOpenACC/parse-cache-construct.c
index 093587f37df4fc..fd161c03c09f75 100644
--- a/clang/test/ParserOpenACC/parse-cache-construct.c
+++ b/clang/test/ParserOpenACC/parse-cache-construct.c
@@ -13,32 +13,32 @@ void func() {
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +3{{expected '('}}
     // expected-error at +2{{invalid OpenACC clause 'clause'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache clause list
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache()
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{invalid OpenACC clause 'clause'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache() clause-list
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(
   }
 
@@ -46,25 +46,25 @@ void func() {
     // expected-error at +4{{use of undeclared identifier 'invalid'}}
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(invalid
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(ArrayPtr
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{use of undeclared identifier 'invalid'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(invalid)
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(ArrayPtr)
   }
 
@@ -74,7 +74,7 @@ void func() {
     // expected-note at +4{{to match this '['}}
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(ArrayPtr[
   }
 
@@ -82,7 +82,7 @@ void func() {
     // expected-error at +4{{expected expression}}
     // expected-error at +3{{expected ']'}}
     // expected-note at +2{{to match this '['}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(ArrayPtr[, 5)
   }
 
@@ -90,12 +90,12 @@ void func() {
     // expected-error at +4{{expected expression}}
     // expected-error at +3{{expected ']'}}
     // expected-note at +2{{to match this '['}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Array[)
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Array[*readonly])
   }
 
@@ -105,55 +105,55 @@ void func() {
     // expected-note at +4{{to match this '['}}
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Array[*readonly:
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly)
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{invalid tag 'devnum' on 'cache' directive}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(devnum:ArrayPtr)
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{invalid tag 'invalid' on 'cache' directive}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(invalid:ArrayPtr)
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr)
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected expression}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:])
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:*readonly])
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:*readonly], Array)
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:*readonly], Array[*readonly:3])
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5 + i:*readonly], Array[*readonly + i:3])
   }
 
@@ -161,36 +161,36 @@ void func() {
     // expected-error at +4{{expected expression}}
     // expected-error at +3{{expected ')'}}
     // expected-note at +2{{to match this '('}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:*readonly],
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected expression}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:*readonly],)
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-warning at +2{{left operand of comma operator has no effect}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5,6:*readonly])
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-warning at +2{{left operand of comma operator has no effect}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:ArrayPtr[5:3, *readonly], ArrayPtr[0])
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:s.foo)
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-warning at +2{{left operand of comma operator has no effect}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(readonly:s.Array[1,2])
   }
 }

diff  --git a/clang/test/ParserOpenACC/parse-cache-construct.cpp b/clang/test/ParserOpenACC/parse-cache-construct.cpp
index affe43d4b0f0ba..f0a35824696d8c 100644
--- a/clang/test/ParserOpenACC/parse-cache-construct.cpp
+++ b/clang/test/ParserOpenACC/parse-cache-construct.cpp
@@ -9,34 +9,34 @@ template<typename T, int I>
 void func() {
   char *ArrayPtr = getArrayPtr();
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(ArrayPtr[T::value + I:I + 5], T::array[(i + T::value, 5): 6])
   }
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(NS::NSArray[NS::NSInt])
   }
 
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(NS::NSArray[NS::NSInt : NS::NSInt])
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{use of undeclared identifier 'NSArray'; did you mean 'NS::NSArray'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(NSArray[NS::NSInt : NS::NSInt])
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{use of undeclared identifier 'NSInt'; did you mean 'NS::NSInt'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(NS::NSArray[NSInt : NS::NSInt])
   }
 
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{use of undeclared identifier 'NSInt'; did you mean 'NS::NSInt'}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(NS::NSArray[NS::NSInt : NSInt])
   }
 }
@@ -59,56 +59,56 @@ void use() {
 
   Members s;
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(s.array[s.value])
   }
   HasMembersArray Arrs;
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3].array[4])
   }
   for (int i = 0; i < 10; ++i) {
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3].array[1:4])
   }
   for (int i = 0; i < 10; ++i) {
     // FIXME: Once we have a new array-section type to represent OpenACC as
     // well, change this error message.
     // expected-error at +2{{OpenMP array section is not allowed here}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3:4].array[1:4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{OpenMP array section is not allowed here}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3:4].array[4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +3{{expected ']'}}
     // expected-note at +2{{to match this '['}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3:4:].array[4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected expression}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[:].array[4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected unqualified-id}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[::].array[4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +4{{expected expression}}
     // expected-error at +3{{expected ']'}}
     // expected-note at +2{{to match this '['}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[: :].array[4])
   }
   for (int i = 0; i < 10; ++i) {
     // expected-error at +2{{expected expression}}
-    // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
     #pragma acc cache(Arrs.MemArr[3:].array[4])
   }
   func<S, 5>();

diff  --git a/clang/test/ParserOpenACC/parse-clauses.c b/clang/test/ParserOpenACC/parse-clauses.c
index 18eb0fc996cceb..3468e160a39cbe 100644
--- a/clang/test/ParserOpenACC/parse-clauses.c
+++ b/clang/test/ParserOpenACC/parse-clauses.c
@@ -4,371 +4,467 @@
 
 void func() {
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data finalize
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data finalize finalize
 
+  // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
   // expected-error at +2{{invalid OpenACC clause 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data finalize invalid
 
+  // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
   // expected-error at +2{{invalid OpenACC clause 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data finalize invalid invalid finalize
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data seq finalize
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
 #pragma acc host_data if_present
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
 #pragma acc host_data if_present, if_present
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop seq independent auto
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop seq, independent auto
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop seq independent, auto
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
 #pragma acc kernels loop seq independent auto
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop seq, independent auto
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
 #pragma acc parallel loop seq independent, auto
+  {}
 
 
   // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop , seq
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop seq,
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse()
   for(;;){}
 
-  // expected-error at +3{{invalid tag 'unknown' on 'collapse' clause}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'unknown' on 'collapse' clause}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(unknown:)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(force:)
   for(;;){}
 
-  // expected-error at +2{{invalid tag 'unknown' on 'collapse' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'unknown' on 'collapse' clause}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(unknown:5)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(force:5)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(5)
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(5, 6)
   for(;;){}
 }
 
 void DefaultClause() {
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop default
   for(;;){}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default seq
   for(;;){}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default, seq
   for(;;){}
 
-  // expected-error at +4{{expected identifier}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected identifier}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(
   for(;;){}
 
-  // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{invalid value for 'default' clause; expected 'present' or 'none'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default( seq
   for(;;){}
 
-  // expected-error at +4{{expected identifier}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected identifier}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(, seq
   for(;;){}
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default)
   for(;;){}
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
-#pragma acc serial default) seq
-  for(;;){}
-
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default), seq
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default()
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected identifier}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default() seq
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected identifier}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(), seq
   for(;;){}
 
-  // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid value for 'default' clause; expected 'present' or 'none'}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(invalid)
   for(;;){}
 
-  // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(auto) seq
   for(;;){}
 
-  // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(invalid), seq
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(none)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial default(present), seq
   for(;;){}
 }
 
 void IfClause() {
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop if
   for(;;){}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if seq
   for(;;){}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if, seq
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(
   for(;;){}
 
-  // expected-error at +4{{use of undeclared identifier 'seq'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{use of undeclared identifier 'seq'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if( seq
   for(;;){}
 
-  // expected-error at +5{{expected expression}}
-  // expected-error at +4{{use of undeclared identifier 'seq'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +6{{expected expression}}
+  // expected-error at +5{{use of undeclared identifier 'seq'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(, seq
   for(;;){}
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if)
   for(;;){}
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if) seq
   for(;;){}
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if), seq
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if()
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if() seq
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(), seq
   for(;;){}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid_expr'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid_expr'}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(invalid_expr)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if() seq
   for(;;){}
 
   int i, j;
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(i > j)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial if(1+5>3), seq
   for(;;){}
 }
 
-void SyncClause() {
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+void SelfClause() {
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self, seq
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self(
   for(;;){}
 
-  // expected-error at +4{{use of undeclared identifier 'seq'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{use of undeclared identifier 'seq'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self( seq
   for(;;){}
 
-  // expected-error at +5{{expected expression}}
-  // expected-error at +4{{use of undeclared identifier 'seq'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +6{{expected expression}}
+  // expected-error at +5{{use of undeclared identifier 'seq'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self(, seq
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self)
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self) seq
   for(;;){}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self), seq
   for(;;){}
 
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self(), seq
   for(;;){}
 
-  // expected-error at +3{{expected expression}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self(,), seq
   for(;;){}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid_expr'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'invalid_expr'}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop self(invalid_expr), seq
   for(;;){}
 
   int i, j;
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial self(i > j
   for(;;){}
 
-  // expected-error at +4{{use of undeclared identifier 'seq'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{use of undeclared identifier 'seq'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial self(i > j, seq
   for(;;){}
 
-  // expected-warning at +2{{left operand of comma operator has no effect}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{left operand of comma operator has no effect}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial self(i, j)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial self(i > j)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial self(1+5>3), seq
   for(;;){}
 }
@@ -385,926 +481,1288 @@ struct HasMembersArray {
 void SelfUpdate() {
   struct Members s;
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
 #pragma acc update self
   for(;;){}
 
-  // expected-error at +2{{use of undeclared identifier 'zero'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'zero'}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
 #pragma acc update self(zero : s.array[s.value : 5], s.value), seq
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
 #pragma acc update self(s.array[s.value : 5], s.value), seq
   for(;;){}
 }
 
 void VarListClauses() {
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy, seq
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy)
 
-  // expected-error at +3{{expected '('}}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected '('}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy), seq
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(, seq
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy()
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(), seq
 
   struct Members s;
   struct HasMembersArray HasMem;
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(s.array[s.value]), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(s.array[s.value], s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[3].array[1]), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[3].array[1:4]), seq
 
-  // expected-error at +2{{OpenMP array section is not allowed here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{OpenMP array section is not allowed here}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[1:3].array[1]), seq
 
-  // expected-error at +2{{OpenMP array section is not allowed here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{OpenMP array section is not allowed here}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[1:3].array[1:2]), seq
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[:]), seq
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[::]), seq
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ']'}}
-  // expected-note at +2{{to match this '['}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +6{{expected expression}}
+  // expected-error at +5{{expected ']'}}
+  // expected-note at +4{{to match this '['}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[: :]), seq
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copy(HasMem.MemArr[3:]), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial use_device(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial use_device(s.array[s.value : 5]), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'no_create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial no_create(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'no_create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial no_create(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'present' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial present(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'present' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial present(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'deviceptr' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial deviceptr(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'deviceptr' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial deviceptr(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'attach' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial attach(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'attach' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial attach(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'detach' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial detach(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'detach' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial detach(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'private' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial private(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'private' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial private(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'firstprivate' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial firstprivate(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'firstprivate' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial firstprivate(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'delete' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial delete(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'delete' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial delete(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial use_device(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial use_device(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'device_resident' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial device_resident(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'device_resident' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial device_resident(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'link' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial link(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'link' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial link(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'host' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial host(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'host' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial host(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial device(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'device' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial device(s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(zero:s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(zero : s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'zero'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'zero'}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(zero s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'readonly' on 'copyout' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'readonly' on 'copyout' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(readonly:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'copyout' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'copyout' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyout(invalid s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(zero:s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(zero : s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'zero'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'zero'}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(zero s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'readonly' on 'create' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'readonly' on 'create' clause}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(readonly:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'create' clause}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'create' clause}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial create(invalid s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{expected ','}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ','}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(s.array[s.value] s.array[s.value :5] ), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(readonly:s.array[s.value : 5], s.value), seq
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(readonly : s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'readonly'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'readonly'}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(readonly s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'zero' on 'copyin' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'zero' on 'copyin' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(zero :s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'copyin' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'copyin' clause}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial copyin(invalid s.array[s.value : 5], s.value), seq
 }
 
 void ReductionClauseParsing() {
   char *Begin, *End;
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction
-  // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction()
-  // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(Begin)
-  // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(Begin, End)
-  // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(+:Begin)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(+:Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(*: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(max : Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(min: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(&: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(|: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(^: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial seq, reduction(&&: Begin, End)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial reduction(||: Begin, End), seq
 }
 
 int returns_int();
 
 void IntExprParsing() {
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length
+  {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length()
+  {}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(invalid)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(5, 4)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(5)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(returns_int())
+  {}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs
+  {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs()
+  {}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs(invalid)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs(5, 4)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs(5)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_gangs(returns_int())
+  {}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers
+  {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers()
+  {}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers(invalid)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers(5, 4)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers(5)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel num_workers(returns_int())
+  {}
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num()
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num(invalid)
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num(5, 4)
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num(5)
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init device_num(returns_int())
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async()
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async(invalid)
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async(5, 4)
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async(5)
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set default_async(returns_int())
 
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector()
-  // expected-error at +3{{invalid tag 'invalid' on 'vector' clause}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'vector' clause}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(invalid:)
-  // expected-error at +2{{invalid tag 'invalid' on 'vector' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'invalid' on 'vector' clause}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(invalid:5)
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(length:)
-  // expected-error at +3{{invalid tag 'num' on 'vector' clause}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'num' on 'vector' clause}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(num:)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(5, 4)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(length:6,4)
-  // expected-error at +4{{invalid tag 'num' on 'vector' clause}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{invalid tag 'num' on 'vector' clause}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(num:6,4)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(5)
-  // expected-error at +2{{invalid tag 'num' on 'vector' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'num' on 'vector' clause}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(num:5)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(length:5)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(returns_int())
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop vector(length:returns_int())
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker()
-  // expected-error at +3{{invalid tag 'invalid' on 'worker' clause}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'invalid' on 'worker' clause}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(invalid:)
-  // expected-error at +2{{invalid tag 'invalid' on 'worker' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'invalid' on 'worker' clause}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(invalid:5)
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(num:)
-  // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{invalid tag 'length' on 'worker' clause}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(length:)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(5, 4)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(num:6,4)
-  // expected-error at +4{{invalid tag 'length' on 'worker' clause}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{invalid tag 'length' on 'worker' clause}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(length:6,4)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(5)
-  // expected-error at +2{{invalid tag 'length' on 'worker' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(length:5)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(num:5)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(returns_int())
-  // expected-error at +2{{invalid tag 'length' on 'worker' clause}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
+  // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop worker(length:returns_int())
 }
 
 void device_type() {
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype
+  {}
 
-  // expected-error at +4{{expected identifier}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected identifier}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(
-  // expected-error at +4{{expected identifier}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-error at +5{{expected identifier}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(
+  {}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type()
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype()
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(*
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(*
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident
+  {}
 
-  // expected-error at +4{{expected ','}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected ','}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident ident2
-  // expected-error at +4{{expected ','}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +5{{expected ','}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident ident2
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident, ident2
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident, ident2
+  {}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident, ident2,)
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident, ident2,)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(*,)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(*,)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(*,ident)
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(*,ident)
+  {}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident, *)
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident, *)
+  {}
 
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type("foo", 54)
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-error at +3{{expected identifier}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(31, "bar")
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident, auto, int, float)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  {}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel dtype(ident, auto, int, float)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel device_type(ident, auto, int, float) dtype(ident, auto, int, float)
+  {}
 }
 
 #define acc_async_sync -1
 void AsyncArgument() {
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async
+  {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async()
+  {}
 
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(invalid)
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(4, 3)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(returns_int())
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(5)
+  {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(acc_async_sync)
+  {}
 }
 
 void Tile() {
 
   int* Foo;
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile
   for(;;){}
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(
   for(;;){}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile()
   for(;;){}
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(,
   for(;;){}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(,)
   for(;;){}
-  // expected-error at +2{{use of undeclared identifier 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'invalid'}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(returns_int(), *, invalid, *)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(returns_int() *, Foo, *)
   for(;;){}
 
-  // expected-error at +2{{indirection requires pointer operand ('int' invalid)}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{indirection requires pointer operand ('int' invalid)}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(* returns_int() , *)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(*)
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(*Foo, *Foo)
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(5)
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(*, 5)
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(5, *)
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop tile(5, *, 3, *)
   for(;;){}
 }
 
 void Gang() {
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang
   for(;;){}
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(
   for(;;){}
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang()
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(5, *)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(*)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(5, num:*)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num:5, *)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num:5, num:*)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num:*)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(dim:5)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(dim:5, dim:*)
   for(;;){}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(dim:*)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*, static:5)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*, 5)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:45, 5)
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:45,
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:45
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*,
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(45,
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(45
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num:45,
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num:45
   for(;;){}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(dim:45,
   for(;;){}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(dim:45
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(static:*, dim:returns_int(), 5)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop gang(num: 32, static:*, dim:returns_int(), 5)
   for(;;){}
 
 }
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +5{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +4{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'nohost' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine worker, vector, seq, nohost
 void bar();
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +5{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+  // expected-warning at +4{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+  // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+  // expected-warning at +2{{OpenACC clause 'nohost' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(bar) worker, vector, seq, nohost
 
 
 // Bind Clause Parsing.
 
-  // expected-error at +2{{expected '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected '('}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine bind
 void BCP1();
 
-  // expected-error at +2{{expected identifier or string literal}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected identifier or string literal}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(BCP1) bind()
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine bind("ReductionClauseParsing")
 void BCP2();
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(BCP1) bind(BCP2)
 
-  // expected-error at +2{{use of undeclared identifier 'unknown_thing'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'unknown_thing'}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(BCP1) bind(unknown_thing)

diff  --git a/clang/test/ParserOpenACC/parse-clauses.cpp b/clang/test/ParserOpenACC/parse-clauses.cpp
index 322080c3c35bcc..e524f73d8fdbac 100644
--- a/clang/test/ParserOpenACC/parse-clauses.cpp
+++ b/clang/test/ParserOpenACC/parse-clauses.cpp
@@ -2,27 +2,33 @@
 
 template<unsigned I, typename T>
 void templ() {
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(I)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop collapse(T::value)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(T::value)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel vector_length(I)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(T::value)
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'async' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel async(I)
   for(;;){}
 }
@@ -51,39 +57,51 @@ void function();
 }
 
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::NSFunc)
-  // expected-error at +3{{'RecordTy' does not refer to a value}}
+  // expected-error at +4{{'RecordTy' does not refer to a value}}
   // expected-note@#RecTy{{declared here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::RecordTy)
-  // expected-error at +3{{'Value' is a private member of 'NS::RecordTy'}}
+  // expected-error at +4{{'Value' is a private member of 'NS::RecordTy'}}
   // expected-note@#VAL{{implicitly declared private here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::RecordTy::Value)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::RecordTy::ValuePub)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::TemplTy<int>)
-  // expected-error at +2{{no member named 'unknown' in namespace 'NS'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{no member named 'unknown' in namespace 'NS'}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::unknown<int>)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::function)
-  // expected-error at +3{{'priv_mem_function' is a private member of 'NS::RecordTy'}}
+  // expected-error at +4{{'priv_mem_function' is a private member of 'NS::RecordTy'}}
   // expected-note@#PrivMemFun{{implicitly declared private here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::RecordTy::priv_mem_function)
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(NS::RecordTy::mem_function)
 
-  // expected-error at +2{{string literal with user-defined suffix cannot be used here}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{string literal with user-defined suffix cannot be used here}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind("unknown udl"_UDL)
 
-  // expected-warning at +2{{encoding prefix 'u' on an unevaluated string literal has no effect}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{encoding prefix 'u' on an unevaluated string literal has no effect}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(u"16 bits")
-  // expected-warning at +2{{encoding prefix 'U' on an unevaluated string literal has no effect}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +3{{encoding prefix 'U' on an unevaluated string literal has no effect}}
+  // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(use) bind(U"32 bits")

diff  --git a/clang/test/ParserOpenACC/parse-constructs.c b/clang/test/ParserOpenACC/parse-constructs.c
index 0bb33269bbe98f..213b298df08a82 100644
--- a/clang/test/ParserOpenACC/parse-constructs.c
+++ b/clang/test/ParserOpenACC/parse-constructs.c
@@ -2,194 +2,201 @@
 
 void func() {
 
-  // expected-error at +2{{expected OpenACC directive}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{expected OpenACC directive}}
 #pragma acc
   for(;;){}
 
-  // expected-error at +3{{expected OpenACC directive}}
-  // expected-error at +2{{invalid OpenACC clause 'whatever'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +2{{expected OpenACC directive}}
+  // expected-error at +1{{invalid OpenACC clause 'whatever'}}
 #pragma acc(whatever) routine
 
-  // expected-error at +3{{expected OpenACC directive}}
-  // expected-error at +2{{invalid OpenACC clause 'routine'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +2{{expected OpenACC directive}}
+  // expected-error at +1{{invalid OpenACC clause 'routine'}}
 #pragma acc) routine
 
-  // expected-error at +2{{invalid OpenACC directive 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{invalid OpenACC directive 'invalid'}}
 #pragma acc invalid
   for(;;){}
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel clause list
   for(;;){}
   // expected-error at +3{{expected clause-list or newline in OpenACC directive}}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel() clause list
   for(;;){}
   // expected-error at +4{{expected clause-list or newline in OpenACC directive}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel( clause list
+  for(;;){}
+  // expected-error at +3{{expected clause-list or newline in OpenACC directive}}
+  // expected-error at +2{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial() clause list
+  for(;;){}
+  // expected-error at +4{{expected clause-list or newline in OpenACC directive}}
+  // expected-error at +3{{expected ')'}}
+  // expected-note at +2{{to match this '('}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial( clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
 #pragma acc serial clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'kernels' not yet implemented, pragma ignored}}
 #pragma acc kernels clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'data' not yet implemented, pragma ignored}}
 #pragma acc data clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
 #pragma acc enter data clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'exit data' not yet implemented, pragma ignored}}
 #pragma acc exit data clause list
   for(;;){}
-  // expected-error at +2{{invalid OpenACC directive 'enter invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{invalid OpenACC directive 'enter invalid'}}
 #pragma acc enter invalid
   for(;;){}
-  // expected-error at +2{{invalid OpenACC directive 'exit invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{invalid OpenACC directive 'exit invalid'}}
 #pragma acc exit invalid
   for(;;){}
-  // expected-error at +2{{invalid OpenACC directive 'enter'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{invalid OpenACC directive 'enter'}}
 #pragma acc enter
   for(;;){}
-  // expected-error at +2{{expected identifier}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +1{{expected identifier}}
 #pragma acc exit }
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
 #pragma acc host_data clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
 #pragma acc loop clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'invalid'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
 #pragma acc parallel invalid clause list
+  for(;;){}
+  // expected-error at +2{{invalid OpenACC clause 'invalid'}}
+  // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial invalid clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
 #pragma acc parallel loop clause list
   for(;;){}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
 #pragma acc parallel loop
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop clause list
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
 #pragma acc serial loop
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
 #pragma acc kernels loop clause list
   for(;;){}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
 #pragma acc kernels loop
   for(;;){}
 
   int i = 0, j = 0, k = 0;
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic
   i = j;
   // expected-error at +2{{invalid OpenACC clause 'garbage'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic garbage
   i = j;
   // expected-error at +2{{invalid OpenACC clause 'garbage'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic garbage clause list
   i = j;
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic read
   i = j;
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic write clause list
   i = i + j;
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic update clause list
   i++;
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
 #pragma acc atomic capture clause list
   i = j++;
 
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
 #pragma acc declare clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
 #pragma acc init clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'shutdown' not yet implemented, pragma ignored}}
 #pragma acc shutdown clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
 #pragma acc set clause list
   for(;;){}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
 #pragma acc update clause list
   for(;;){}
 }
 
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine
 void routine_func();
 // expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine clause list
 void routine_func();
 
 // expected-error at +2{{use of undeclared identifier 'func_name'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (func_name)
 // expected-error at +3{{use of undeclared identifier 'func_name'}}
 // expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (func_name) clause list
 
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (routine_func)
 // expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (routine_func) clause list
 
 // expected-error at +3{{expected ')'}}
 // expected-note at +2{{to match this '('}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (routine_func())
 
 // expected-error at +2{{expected identifier}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine()
 
 // expected-error at +2{{expected identifier}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(int)

diff  --git a/clang/test/ParserOpenACC/parse-constructs.cpp b/clang/test/ParserOpenACC/parse-constructs.cpp
index abeddd357619e0..42fd09d6977ddc 100644
--- a/clang/test/ParserOpenACC/parse-constructs.cpp
+++ b/clang/test/ParserOpenACC/parse-constructs.cpp
@@ -14,50 +14,50 @@ namespace NS {
 }
 
 // expected-error at +2{{use of undeclared identifier 'foo'; did you mean 'NS::foo'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(foo)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(NS::foo)
 
 // expected-error at +2{{use of undeclared identifier 'templ'; did you mean 'NS::templ'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(templ)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(NS::templ)
 
 // expected-error at +2{{use of undeclared identifier 'templ'; did you mean 'NS::templ'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(templ<int>)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(NS::templ<int>)
 
 // expected-error at +2{{use of undeclared identifier 'T'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(templ<T>)
 // expected-error at +2{{use of undeclared identifier 'T'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(NS::templ<T>)
 
 // expected-error at +3{{expected ')'}}
 // expected-note at +2{{to match this '('}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (NS::foo())
 
 // expected-error at +2 {{expected unqualified-id}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine()
 
 // expected-error at +2 {{expected unqualified-id}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine(int)
 
 // expected-error at +3{{'C' does not refer to a value}}
 // expected-note@#CDef{{declared here}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (NS::C)
 // expected-error at +3{{'private_mem_func' is a private member of 'NS::C'}}
 // expected-note@#PrivateMemFunc{{implicitly declared private here}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (NS::C::private_mem_func)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
 #pragma acc routine (NS::C::public_mem_func)

diff  --git a/clang/test/ParserOpenACC/parse-wait-clause.c b/clang/test/ParserOpenACC/parse-wait-clause.c
index 7639e6242ea671..a3037905350469 100644
--- a/clang/test/ParserOpenACC/parse-wait-clause.c
+++ b/clang/test/ParserOpenACC/parse-wait-clause.c
@@ -3,155 +3,227 @@
 void func() {
   int i, j;
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait
+  {}
 
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait clause-list
+  {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (
+      {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait ()
+      {}
 
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait () clause-list
+      {}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum:
+    {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum:)
+    {}
 
-  // expected-error at +3{{expected expression}}
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum:) clause-list
+    {}
 
-  // expected-error at +4{{expected ':'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected ':'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j
+    {}
 
-  // expected-error at +2{{expected ':'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected ':'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j)
+    {}
 
-  // expected-error at +3{{expected ':'}}
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ':'}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:
+    {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:)
+    {}
 
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j:queues:
+    {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j:queues:)
+    {}
 
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (devnum: i + j:queues:) clause-list
+    {}
 
-  // expected-error at +4{{use of undeclared identifier 'devnum'}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{use of undeclared identifier 'devnum'}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:devnum: i + j
+    {}
 
-  // expected-error at +2{{use of undeclared identifier 'devnum'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{use of undeclared identifier 'devnum'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:devnum: i + j)
+    {}
 
-  // expected-error at +3{{use of undeclared identifier 'devnum'}}
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{use of undeclared identifier 'devnum'}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait (queues:devnum: i + j) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(i, j, 1+1, 3.3
+    {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(i, j, 1+1, 3.3)
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(i, j, 1+1, 3.3) clause-list
+    {}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(,
+    {}
 
-  // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{expected expression}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(,)
+    {}
 
-  // expected-error at +3{{expected expression}}
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected expression}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(,) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(queues:i, j, 1+1, 3.3
+    {}
 
-  // expected-error at +4{{expected expression}}
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +5{{expected expression}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(queues:i, j, 1+1, 3.3,
+    {}
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(queues:i, j, 1+1, 3.3)
+    {}
 
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(queues:i, j, 1+1, 3.3) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3)
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3) clause-list
+    {}
 
-  // expected-error at +3{{expected ')'}}
-  // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-error at +4{{expected ')'}}
+  // expected-note at +3{{to match this '('}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3)
-  // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+    {}
+  // expected-error at +3{{invalid OpenACC clause 'clause'}}
+  // expected-warning at +2{{OpenACC clause 'wait' not yet implemented, clause ignored}}
+  // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
   #pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3) clause-list
+    {}
 }

diff  --git a/clang/test/ParserOpenACC/parse-wait-construct.c b/clang/test/ParserOpenACC/parse-wait-construct.c
index 8f99f4aa8f67b1..30a9fc8c12a474 100644
--- a/clang/test/ParserOpenACC/parse-wait-construct.c
+++ b/clang/test/ParserOpenACC/parse-wait-construct.c
@@ -3,155 +3,155 @@
 void func() {
   int i, j;
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait ()
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait () clause-list
 
   // expected-error at +4{{expected expression}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum:
 
   // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum:)
 
   // expected-error at +3{{expected expression}}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum:) clause-list
 
   // expected-error at +4{{expected ':'}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j
 
   // expected-error at +2{{expected ':'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j)
 
   // expected-error at +3{{expected ':'}}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:)
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j:queues:
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j:queues:)
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (devnum: i + j:queues:) clause-list
 
   // expected-error at +4{{use of undeclared identifier 'devnum'}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:devnum: i + j
 
   // expected-error at +2{{use of undeclared identifier 'devnum'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:devnum: i + j)
 
   // expected-error at +3{{use of undeclared identifier 'devnum'}}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait (queues:devnum: i + j) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(i, j, 1+1, 3.3
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(i, j, 1+1, 3.3)
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(i, j, 1+1, 3.3) clause-list
 
   // expected-error at +4{{expected expression}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(,
 
   // expected-error at +2{{expected expression}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(,)
 
   // expected-error at +3{{expected expression}}
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(,) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(queues:i, j, 1+1, 3.3
 
   // expected-error at +4{{expected expression}}
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(queues:i, j, 1+1, 3.3,
 
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(queues:i, j, 1+1, 3.3)
 
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(queues:i, j, 1+1, 3.3) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:i, j, 1+1, 3.3
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:i, j, 1+1, 3.3)
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:i, j, 1+1, 3.3) clause-list
 
   // expected-error at +3{{expected ')'}}
   // expected-note at +2{{to match this '('}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3)
   // expected-error at +2{{invalid OpenACC clause 'clause'}}
-  // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+  // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
   #pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3) clause-list
 }

diff  --git a/clang/test/ParserOpenACC/unimplemented.c b/clang/test/ParserOpenACC/unimplemented.c
index be8e62b5811789..7426e028c0252c 100644
--- a/clang/test/ParserOpenACC/unimplemented.c
+++ b/clang/test/ParserOpenACC/unimplemented.c
@@ -1,26 +1,23 @@
 // RUN: %clang_cc1 %s -verify -fopenacc
 
 // Parser::ParseExternalDeclaration
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
 int foo;
 
 struct S {
 // Parser::ParseStructUnionBody
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
   int foo;
 };
 
 void func() {
 // Parser::ParseStmtOrDeclarationAfterAttributes
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
   while(0) {}
 }

diff  --git a/clang/test/ParserOpenACC/unimplemented.cpp b/clang/test/ParserOpenACC/unimplemented.cpp
index 6ffc84a3bc09d3..0acd69a7ae0876 100644
--- a/clang/test/ParserOpenACC/unimplemented.cpp
+++ b/clang/test/ParserOpenACC/unimplemented.cpp
@@ -1,26 +1,23 @@
 // RUN: %clang_cc1 %s -verify -fopenacc
 
 // Parser::ParseExternalDeclaration
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
 int foo;
 
 struct S {
 // Parser::ParseCXXClassMemberDeclarationWithPragmas
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
   int foo;
 };
 
 void func() {
 // Parser::ParseStmtOrDeclarationAfterAttributes
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
 #pragma acc havent implemented
   while(false) {}
 }