Stop emit incomplete type error for a variable in an omp map clause where should not.

[jyu2]

Summary

Stop emit incomplete type error for a variable in a map clause
where should not.

Currently we are using QTy->isIncompleteType(&ND) to check incomplete
type. But before doing that, need to instantiate for a class template
specialization or a class member of a class template specialization,
or an array with known size of such..., so that we know it is really
incomplete type.

To fix this using RequireCompleteType instead.

The new test is added into "test/OpenMP/target_update_messages.cpp"

The different using RequireCompleteType when emit incomplete type, a
note is also emitted to point to where incomplete type is declared.
Because this change, many tests are needed to be fixed where adding
additional note.

This is to fix https://bugs.llvm.org/show_bug.cgi?id=50508

[ABataev]

LG with a nit.

clang/lib/Sema/SemaOpenMP.cpp

18446

Formatting?

[jyu2]

Fix format problem.

clang/lib/Sema/SemaOpenMP.cpp

OMPClause *Sema::ActOnOpenMPDeviceClause(OpenMPDeviceClauseModifier Modifier,
   return new (Context)
       OMPDeviceClause(Modifier, ValExpr, HelperValStmt, CaptureRegion, StartLoc,
                       LParenLoc, ModifierLoc, EndLoc);
 }
 
 static bool checkTypeMappable(SourceLocation SL, SourceRange SR, Sema &SemaRef,
                               DSAStackTy *Stack, QualType QTy,
                               bool FullCheck = true) {
-  NamedDecl *ND;
-  if (QTy->isIncompleteType(&ND)) {
-    SemaRef.Diag(SL, diag::err_incomplete_type) << QTy << SR;
+  if (SemaRef.RequireCompleteType(SL, QTy, diag::err_incomplete_type))
     return false;
-  }
   if (FullCheck && !SemaRef.CurContext->isDependentContext() &&
       !QTy.isTriviallyCopyableType(SemaRef.Context))
     SemaRef.Diag(SL, diag::warn_omp_non_trivial_type_mapped) << QTy << SR;
   return true;
 }
 
 /// Return true if it can be proven that the provided array expression
 /// (array section or array subscript) does NOT specify the whole size of the

clang/test/OpenMP/distribute_firstprivate_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/distribute_parallel_for_firstprivate_messages.cpp

void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp distribute parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
 extern int omp_default_mem_alloc;
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/distribute_parallel_for_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=45 %s -Wuninitialized
 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=45 %s -Wuninitialized
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 extern int omp_default_mem_alloc;
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/distribute_parallel_for_reduction_messages.cpp

 void foobar(int &ref) {
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for reduction(+:ref)
   for (int i = 0; i < 10; ++i)
     foo();
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/distribute_parallel_for_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/distribute_parallel_for_simd_aligned_messages.cpp

 #pragma omp teams
 #pragma omp distribute parallel for simd aligned(ind2:LEN) // expected-error {{argument to 'aligned' clause must be a strictly positive integer value}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return 0;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a; // expected-note {{'a' declared here}}
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 1 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/distribute_parallel_for_simd_firstprivate_messages.cpp

 
 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp distribute parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/distribute_parallel_for_simd_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/distribute_parallel_for_simd_linear_messages.cpp

template<int LEN> int test_warn() {
   #pragma omp teams
   #pragma omp parallel for simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return ind2;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 2 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/distribute_parallel_for_simd_reduction_messages.cpp

 void foobar(int &ref) {
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd reduction(+:ref)
   for (int i = 0; i < 10; ++i)
     foo();
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/distribute_parallel_for_simd_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
 
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/distribute_simd_aligned_messages.cpp

 #pragma omp teams
 #pragma omp distribute simd aligned(ind2:LEN) // expected-error {{argument to 'aligned' clause must be a strictly positive integer value}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return 0;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a; // expected-note {{'a' declared here}}
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 1 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/distribute_simd_firstprivate_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/distribute_simd_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45  -fopenmp %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp %s -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd %s -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/distribute_simd_linear_messages.cpp

template<int LEN> int test_warn() {
   #pragma omp teams
   #pragma omp parallel for simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return ind2;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 2 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/distribute_simd_reduction_messages.cpp

 void foobar(int &ref) {
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd reduction(+:ref)
   for (int i = 0; i < 10; ++i)
     foo();
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/target_map_messages.cpp

 }
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_parallel_for_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target parallel for map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_parallel_for_simd_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target parallel for simd map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_parallel_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target parallel map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_simd_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target simd map(to: map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_teams_distribute_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target teams distribute map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_teams_distribute_parallel_for_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target teams distribute parallel for map(tofrom: map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_teams_distribute_parallel_for_simd_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target teams distribute parallel for simd map(to: map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_teams_distribute_simd_map_messages.cpp

 
 void xxx(int argc) {
   int map; // expected-note {{initialize the variable 'map' to silence this warning}}
 #pragma omp target teams distribute simd map(map) // expected-warning {{variable 'map' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_teams_map_messages.cpp

 }
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}}  // expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_update_from_messages.cpp

 // RUN: %clang_cc1 -verify=expected,le50 -fopenmp -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,le45 -fopenmp -fopenmp-version=40 -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,le45 -fopenmp -fopenmp-version=45 -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,le50 -fopenmp -fopenmp-version=50 -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,le50 -fopenmp-simd -ferror-limit 100 %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}}  // expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/target_update_messages.cpp

 // lt50-error@+3 {{expected ']'}}
 // lt50-note@+2 {{to match this '['}}
 // lt50-error@+1 {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
 #pragma omp target update from(iarr[0: :2][1:2])
   {}
 
   return tmain(argc, argv);
 }
+
+template<typename _Tp, int _Nm> struct array {
+  _Tp & operator[](int __n) noexcept;
+};
+
+#pragma omp declare target
+extern array<double, 4> arr;
+#pragma omp end declare target
+
+void copy_host_to_device()
+{
+  #pragma omp target update from(arr)  // expected-no-error
+  arr[0] = 0;
+}
+
+struct FOO; // expected-note {{forward declaration of 'FOO'}}
+extern FOO a;
+template <typename T, int I>
+struct bar {
+  void func() {
+    #pragma omp target map(to: a) // expected-error {{incomplete type 'FOO' where a complete type is required}}
+    foo();
+  }
+};

clang/test/OpenMP/target_update_to_messages.cpp

 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}}  // expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
   static float S2s;
   static const float S2sc;

clang/test/OpenMP/teams_distribute_firstprivate_messages.cpp

 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp target
 #pragma omp teams distribute firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/teams_distribute_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/teams_distribute_parallel_for_firstprivate_messages.cpp

 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp target
 #pragma omp teams distribute parallel for firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/teams_distribute_parallel_for_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/teams_distribute_parallel_for_reduction_messages.cpp

 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/teams_distribute_parallel_for_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}}
+struct S1; // expected-note {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/teams_distribute_parallel_for_simd_aligned_messages.cpp

 #pragma omp target
 #pragma omp teams distribute parallel for simd aligned(ind2:LEN) // expected-error {{argument to 'aligned' clause must be a strictly positive integer value}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return 0;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a; // expected-note {{'a' declared here}}
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 1 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/teams_distribute_parallel_for_simd_firstprivate_messages.cpp

 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp target
 #pragma omp teams distribute parallel for simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/teams_distribute_parallel_for_simd_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/teams_distribute_parallel_for_simd_linear_messages.cpp

// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target
   #pragma omp teams distribute parallel for simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return ind2;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 2 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/teams_distribute_parallel_for_simd_reduction_messages.cpp

 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/teams_distribute_parallel_for_simd_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}}
+struct S1; // expected-note {{declared here}} expected-note {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/teams_distribute_reduction_messages.cpp

 }
 
 void foobar(int &ref) {
 #pragma omp target
 #pragma omp teams distribute reduction(+:ref)
   for (int j=0; j<100; j++) foo();
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/teams_distribute_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}}
+struct S1; // expected-note {{declared here}}  // expected-note {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/teams_distribute_simd_aligned_messages.cpp

 #pragma omp target
 #pragma omp teams distribute simd aligned(ind2:LEN) // expected-error {{argument to 'aligned' clause must be a strictly positive integer value}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return 0;
 }
 
-struct S1; // expected-note 2 {{declared here}}
+struct S1; // expected-note 2 {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a; // expected-note {{'a' declared here}}
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 1 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/teams_distribute_simd_firstprivate_messages.cpp

 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp target
 #pragma omp teams distribute simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/teams_distribute_simd_lastprivate_messages.cpp

 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 // RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-version=50 -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 extern int omp_default_mem_alloc;
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}
   const S2 &operator =(const S2&) const;

clang/test/OpenMP/teams_distribute_simd_linear_messages.cpp

// expected-error@+2 {{only loop iteration variables are allowed in 'linear' clause in distribute directives}}
   #pragma omp target
   #pragma omp teams distribute simd linear(ind2:LEN) // expected-warning {{zero linear step (ind2 should probably be const)}}
   for (int i = 0; i < 100; i++) {
     ind2 += LEN;
   }
   return ind2;
 }
 
-struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
+struct S1; // expected-note 2 {{declared here}} expected-note 3 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
 };
 const S2 b; // expected-note 2 {{'b' defined here}}
 const S2 ba[5];

clang/test/OpenMP/teams_distribute_simd_reduction_messages.cpp

 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/teams_distribute_simd_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
 
-struct S1; // expected-note {{declared here}}
+struct S1; // expected-note {{declared here}} // expected-note {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;

clang/test/OpenMP/teams_firstprivate_messages.cpp

 void xxx(int argc) {
   int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
 #pragma omp target
 #pragma omp teams firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
   for (int i = 0; i < 10; ++i)
     ;
 }
 
-struct S1; // expected-note {{declared here}} expected-note{{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 
 public:
   S2() : a(0) {}
   S2(const S2 &s2) : a(s2.a) {}
   static float S2s;

clang/test/OpenMP/teams_reduction_messages.cpp

 }
 
 void foobar(int &ref) {
 #pragma omp target
 #pragma omp teams reduction(+:ref)
   foo();
 }
 
-struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
+struct S1; // expected-note {{declared here}} expected-note 6 {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
   S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
 
 public:
   S2() : a(0) {}
   S2(S2 &s2) : a(s2.a) {}

clang/test/OpenMP/teams_shared_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp %s -Wno-openmp-mapping -Wuninitialized
 
 // RUN: %clang_cc1 -verify -fopenmp-simd %s -Wno-openmp-mapping -Wuninitialized
 
 void foo() {
 }
 
 bool foobool(int argc) {
   return argc;
 }
-
-struct S1; // expected-note {{declared here}}
+struct S1; // expected-note {{declared here}}  // expected-note {{forward declaration of 'S1'}}
 extern S1 a;
 class S2 {
   mutable int a;
 public:
   S2():a(0) { }
   S2(S2 &s2):a(s2.a) { }
 };
 const S2 b;