Enhance the diagnostic for negative array sizes to include the

declaration name of the array when present. This ensures that
a poor-man's C++03 static_assert will include the user error message
often embedded in the name.

Update all the tests to reflect the new wording, and add a test for the
name behavior.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@122802 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index ffef24269aad11ce190fdfbe4ddc7cbf709d8c78..bf28070f18577ed4e274355203a85c43b1d778e0 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -2167,6 +2167,8 @@ def err_illegal_message_expr_incomplete_type : Error<
   "objective-c message has incomplete result type %0">;
 def err_illegal_decl_array_of_references : Error<
   "'%0' declared as array of references of type %1">;
+def err_decl_negative_array_size : Error<
+  "'%0' declared as an array with a negative size">;
 def err_array_star_outside_prototype : Error<
   "star modifier used outside of function prototype">;
 def err_illegal_decl_pointer_to_reference : Error<

diff --git a/lib/Sema/SemaType.cpp b/lib/Sema/SemaType.cpp
index c70d5befbbf3f3d9dcfacebc8ea7b3e8a808068b..453531d98d057bbda6c9f331c874204af45c1c82 100644 (file)
--- a/lib/Sema/SemaType.cpp
+++ b/lib/Sema/SemaType.cpp
@@ -711,9 +711,12 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
     // C99 6.7.5.2p1: If the expression is a constant expression, it shall
     // have a value greater than zero.
     if (ConstVal.isSigned() && ConstVal.isNegative()) {
-      Diag(ArraySize->getLocStart(),
-           diag::err_typecheck_negative_array_size)
-        << ArraySize->getSourceRange();
+      if (Entity)
+        Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size)
+          << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange();
+      else
+        Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size)
+          << ArraySize->getSourceRange();
       return QualType();
     }
     if (ConstVal == 0) {

diff --git a/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1.cpp b/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1.cpp
index f032bf9979e29b5594564eb9cc0b53a99d157952..bb4a48eb5b9148a3ecd1192ad8f34d2f06bb6796 100644 (file)
--- a/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1.cpp
+++ b/test/CXX/dcl.decl/dcl.meaning/dcl.array/p1.cpp
@@ -16,7 +16,7 @@ struct Abstract { virtual void fn() = 0; }; // expected-note {{pure virtual}}
 Abstract ar5[10]; // expected-error {{abstract class}}
 
 // If we have a size, it must be greater than zero.
-int ar6[-1]; // expected-error {{array size is negative}}
+int ar6[-1]; // expected-error {{array with a negative size}}
 int ar7[0u]; // expected-warning {{zero size arrays are an extension}}
 
 // An array with unknown bound is incomplete.
@@ -42,3 +42,13 @@ template <typename T> struct S {
   typename T::type x; // expected-error {{has no members}}
 };
 S<int> ar10[10]; // expected-note {{requested here}}
+
+// Ensure that negative array size errors include the name of the declared
+// array as this is often used to simulate static_assert with template
+// instantiations, placing the 'error message' in the declarator name.
+int
+user_error_message
+[-1]; // expected-error {{user_error_message}}
+typedef int
+another_user_error_message
+[-1]; // expected-error {{another_user_error_message}}

diff --git a/test/Sema/array-constraint.c b/test/Sema/array-constraint.c
index fe7fdc71155e8441113f938d7c62cd351c46cc23..bee33c09efbd04a30ff7d5da33478acbf3813ca9 100644 (file)
--- a/test/Sema/array-constraint.c
+++ b/test/Sema/array-constraint.c
@@ -36,7 +36,7 @@ pfunc xx(int f[](void)) { // expected-error {{'f' declared as array of functions
 void check_size() {
   float f;
   int size_not_int[f]; // expected-error {{size of array has non-integer type 'float'}}
-  int negative_size[1-2]; // expected-error{{array size is negative}}
+  int negative_size[1-2]; // expected-error{{array with a negative size}}
   int zero_size[0]; // expected-warning{{zero size arrays are an extension}}
 }
 

diff --git a/test/SemaCXX/virtual-override.cpp b/test/SemaCXX/virtual-override.cpp
index ba2b80dacd0f168e7473d64fbba43ab8d1e3a612..4ea77a3e54df37e5f8c8337b07521ae50cc55353 100644 (file)
--- a/test/SemaCXX/virtual-override.cpp
+++ b/test/SemaCXX/virtual-override.cpp
@@ -121,7 +121,7 @@ namespace T9 {
   struct a { };
   
   template<typename T> struct b : a {
-    int a[sizeof(T) ? -1 : -1]; // expected-error {{array size is negative}}
+    int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}}
   };
   
   class A {

diff --git a/test/SemaTemplate/attributes.cpp b/test/SemaTemplate/attributes.cpp
index f4c1887c25e2c4dc4f8cbb66690b9f7ad24ca633..e208bd2b89908b5189d517eda99a515f3567c6d1 100644 (file)
--- a/test/SemaTemplate/attributes.cpp
+++ b/test/SemaTemplate/attributes.cpp
@@ -7,7 +7,7 @@ namespace attribute_aligned {
   };
 
   template <bool X> struct check {
-    int check_failed[X ? 1 : -1]; // expected-error {{array size is negative}}
+    int check_failed[X ? 1 : -1]; // expected-error {{array with a negative size}}
   };
 
   template <int N> struct check_alignment {

diff --git a/test/SemaTemplate/default-expr-arguments.cpp b/test/SemaTemplate/default-expr-arguments.cpp
index 8d54926b965ce1e9628cd996dad4bae4a09032d6..5d301be2fb13733b2f25dfda804fc56ec792c8ba 100644 (file)
--- a/test/SemaTemplate/default-expr-arguments.cpp
+++ b/test/SemaTemplate/default-expr-arguments.cpp
@@ -151,7 +151,7 @@ namespace pr5301 {
 namespace PR5810 {
   template<typename T>
   struct allocator {
-    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array size is negative}}
+    allocator() { int a[sizeof(T) ? -1 : -1]; } // expected-error2 {{array with a negative size}}
   };
   
   template<typename T>

diff --git a/test/SemaTemplate/friend-template.cpp b/test/SemaTemplate/friend-template.cpp
index 419ae93daab8e0cfaf8d2c55cbf271dbec5d4529..703daea3e63005d363e4a6a9d9f1d5fe96d0d4ef 100644 (file)
--- a/test/SemaTemplate/friend-template.cpp
+++ b/test/SemaTemplate/friend-template.cpp
@@ -93,7 +93,7 @@ namespace test4 {
   };
 
   template<typename T> void f(const A<T>&) {
-    int a[sizeof(T) ? -1 : -1]; // expected-error {{array size is negative}}
+    int a[sizeof(T) ? -1 : -1]; // expected-error {{array with a negative size}}
   }
 
   void f() {

diff --git a/test/SemaTemplate/instantiate-default-assignment-operator.cpp b/test/SemaTemplate/instantiate-default-assignment-operator.cpp
index 8b97f59e87ed36234c627270a66c17af7cbb0c10..31cdef59d9fd1a0470bbb2c795a11e2334780861 100644 (file)
--- a/test/SemaTemplate/instantiate-default-assignment-operator.cpp
+++ b/test/SemaTemplate/instantiate-default-assignment-operator.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 template<typename> struct PassRefPtr { };
 template<typename T> struct RefPtr {
-  RefPtr& operator=(const RefPtr&) { int a[sizeof(T) ? -1 : -1];} // expected-error 2 {{array size is negative}}
+  RefPtr& operator=(const RefPtr&) { int a[sizeof(T) ? -1 : -1];} // expected-error 2 {{array with a negative size}}
   RefPtr& operator=(const PassRefPtr<T>&);
 };
 

diff --git a/test/SemaTemplate/instantiate-expr-4.cpp b/test/SemaTemplate/instantiate-expr-4.cpp
index 11efe5b7f397ba9a55da6280fdf796b777e49f03..d923f2b555cdbb5459469f6558e3b1a30babdd0f 100644 (file)
--- a/test/SemaTemplate/instantiate-expr-4.cpp
+++ b/test/SemaTemplate/instantiate-expr-4.cpp
@@ -46,8 +46,8 @@ template struct Temporaries0<5, 7>;
 // Ensure that both the constructor and the destructor are instantiated by
 // checking for parse errors from each.
 template<int N> struct BadX {
-  BadX() { int a[-N]; } // expected-error {{array size is negative}}
-  ~BadX() { int a[-N]; } // expected-error {{array size is negative}}
+  BadX() { int a[-N]; } // expected-error {{array with a negative size}}
+  ~BadX() { int a[-N]; } // expected-error {{array with a negative size}}
 };
 
 template<int N>

diff --git a/test/SemaTemplate/instantiate-member-expr.cpp b/test/SemaTemplate/instantiate-member-expr.cpp
index 6c0e91bac88f6f0aec14c8c6c7386024f12890ae..a31569a0c3952b7ff008e3cb7a98887e20285b35 100644 (file)
--- a/test/SemaTemplate/instantiate-member-expr.cpp
+++ b/test/SemaTemplate/instantiate-member-expr.cpp
@@ -6,7 +6,7 @@ struct S {
 
 template<typename T>
 struct vector {
-  void push_back(const T&) { int a[sizeof(T) ? -1: -1]; } // expected-error {{array size is negative}}
+  void push_back(const T&) { int a[sizeof(T) ? -1: -1]; } // expected-error {{array with a negative size}}
 };
 
 class ExprEngine {

diff --git a/test/SemaTemplate/instantiate-member-pointers.cpp b/test/SemaTemplate/instantiate-member-pointers.cpp
index dca0f621705496a55a149436519641c5c9af3f2a..0db90e3cbf120d9a73a37dbf14ed8b451537d29f 100644 (file)
--- a/test/SemaTemplate/instantiate-member-pointers.cpp
+++ b/test/SemaTemplate/instantiate-member-pointers.cpp
@@ -61,7 +61,7 @@ namespace ValueDepMemberPointer {
     typedef instantiate_function<&S::instantiate> x; // expected-note{{instantiation}}
   };
   template <typename T> void S<T>::instantiate() {
-    int a[(int)sizeof(T)-42]; // expected-error{{array size is negative}}
+    int a[(int)sizeof(T)-42]; // expected-error{{array with a negative size}}
   }
   S<int> s; 
 }