Downgrade the "excess elements in initializer" errors to warnings *in

C*. They're required errors in C++.

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

diff --git a/include/clang/Basic/DiagnosticSemaKinds.def b/include/clang/Basic/DiagnosticSemaKinds.def
index 1f67e09a9c478936d953cadd06433efed08abb06..1b9cd916b81328c0642e894743e78c462d574579 100644 (file)
--- a/include/clang/Basic/DiagnosticSemaKinds.def
+++ b/include/clang/Basic/DiagnosticSemaKinds.def
@@ -685,8 +685,12 @@ DIAG(err_array_init_list_required, ERROR,
      "initialization with '{...}' expected for array")
 DIAG(err_excess_initializers, ERROR,
      "excess elements in %select{array|vector|scalar|union|struct}0 initializer")
+DIAG(warn_excess_initializers, WARNING,
+     "excess elements in %select{array|vector|scalar|union|struct}0 initializer")
 DIAG(err_excess_initializers_in_char_array_initializer, ERROR,
     "excess elements in char array initializer")
+DIAG(warn_excess_initializers_in_char_array_initializer, WARNING,
+    "excess elements in char array initializer")
 DIAG(warn_initializer_string_for_char_array_too_long, WARNING,
     "initializer-string for char array is too long")
 DIAG(warn_braces_around_scalar_init, WARNING,

diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index b54a8d674b2477f114c5bba56f88af40fa90f15b..38ab5c520da418f1fcd557f36330ae4f0d3caff4 100644 (file)
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -323,9 +323,11 @@ void InitListChecker::CheckExplicitInitList(InitListExpr *IList, QualType &T,
     // We have leftover initializers
     if (IList->getNumInits() > 0 &&
         SemaRef->IsStringLiteralInit(IList->getInit(Index), T)) {
+      unsigned DK = diag::warn_excess_initializers_in_char_array_initializer;
+      if (SemaRef->getLangOptions().CPlusPlus)
+        DK = diag::err_excess_initializers_in_char_array_initializer;
       // Special-case
-      SemaRef->Diag(IList->getInit(Index)->getLocStart(),
-                    diag::err_excess_initializers_in_char_array_initializer)
+      SemaRef->Diag(IList->getInit(Index)->getLocStart(), DK)
         << IList->getInit(Index)->getSourceRange();
       hadError = true; 
     } else if (!T->isIncompleteType()) {
@@ -338,8 +340,12 @@ void InitListChecker::CheckExplicitInitList(InitListExpr *IList, QualType &T,
         CurrentObjectType->isScalarType()? 2 :
         CurrentObjectType->isUnionType()? 3 :
         4;
-      SemaRef->Diag(IList->getInit(Index)->getLocStart(), 
-                    diag::err_excess_initializers)
+
+      unsigned DK = diag::warn_excess_initializers;
+      if (SemaRef->getLangOptions().CPlusPlus)
+          DK = diag::err_excess_initializers;
+
+      SemaRef->Diag(IList->getInit(Index)->getLocStart(), DK)
         << initKind << IList->getInit(Index)->getSourceRange();
     }
   }

diff --git a/test/Sema/array-init.c b/test/Sema/array-init.c
index 2c835bd54f2e357a9df3aff191e6351197b2cbc5..4ee86181afed890886f64486b848f6c6da003a6e 100644 (file)
--- a/test/Sema/array-init.c
+++ b/test/Sema/array-init.c
@@ -20,7 +20,7 @@ void func() {
 
   int x3[x] = { 1, 2 }; // expected-error{{variable-sized object may not be initialized}}
 
-  int x4 = { 1, 2 }; // expected-warning{{braces around scalar initializer}} expected-error{{excess elements in scalar initializer}}
+  int x4 = { 1, 2 }; // expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in scalar initializer}}
 
   int y[4][3] = { 
     { 1, 3, 5 },
@@ -37,7 +37,7 @@ void func() {
     { 2, 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
-    { 5 }, // expected-error{{excess elements in array initializer}}
+    { 5 }, // expected-warning{{excess elements in array initializer}}
   };
 
   struct threeElements {
@@ -53,17 +53,17 @@ void func() {
 
 void test() {
   int y1[3] = { 
-    { 1, 2, 3 } // expected-warning{{braces around scalar initializer}} expected-error{{excess elements in scalar initializer}}
+    { 1, 2, 3 } // expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in scalar initializer}}
   };
   int y3[4][3] = {  
     { 1, 3, 5 },
     { 2, 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
-    {  }, // expected-warning{{use of GNU empty initializer extension}} expected-error{{excess elements in array initializer}}
+    {  }, // expected-warning{{use of GNU empty initializer extension}} expected-warning{{excess elements in array initializer}}
   };
   int y4[4][3] = {  
-    { 1, 3, 5, 2 }, // expected-error{{excess elements in array initializer}}
+    { 1, 3, 5, 2 }, // expected-warning{{excess elements in array initializer}}
     { 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
@@ -149,7 +149,7 @@ void charArrays()
        static char const test[] = "test";
         int test_sizecheck[(sizeof(test) / sizeof(char)) == 5? 1 : -1];
        static char const test2[] = { "weird stuff" };
-       static char const test3[] = { "test", "excess stuff" }; // expected-error{{excess elements in char array initializer}}
+       static char const test3[] = { "test", "excess stuff" }; // expected-warning{{excess elements in char array initializer}}
 
   char* cp[] = { "Hello" };
 
@@ -157,7 +157,7 @@ void charArrays()
   int l[sizeof(c) == 6 ? 1 : -1];
   
   int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'char [7]', expected 'int'}}
-  char c2[] = { "Hello", "Good bye" }; //expected-error{{excess elements in char array initializer}}
+  char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}}
 
   int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'char [6]', expected 'int'}}
   char c3[5] = { "Hello" };
@@ -178,7 +178,7 @@ float r2[] = {{8}}; //expected-warning{{braces around scalar initializer}}
 char r3[][5] = {1,2,3,4,5,6};
 int r3_sizecheck[(sizeof(r3) / sizeof(char[5])) == 2? 1 : -1];
 char r3_2[sizeof r3 == 10 ? 1 : -1];
-float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-error{{excess elements in array initializer}}
+float r4[1][2] = {1,{2},3,4}; //expected-warning{{braces around scalar initializer}} expected-warning{{excess elements in array initializer}}
 char r5[][5] = {"aa", "bbb", "ccccc"};
 char r6[sizeof r5 == 15 ? 1 : -1];
 const char r7[] = "zxcv";
@@ -207,7 +207,7 @@ union {char a; int b;} t7[] = {1, 2, 3};
 int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1];
 
 struct bittest{int : 31, a, :21, :12, b;};
-struct bittest bittestvar = {1, 2, 3, 4}; //expected-error{{excess elements in struct initializer}}
+struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}}
 
 // Not completely sure what should happen here...
 int u1 = {}; //expected-warning{{use of GNU empty initializer extension}} expected-error{{scalar initializer cannot be empty}}
@@ -242,7 +242,7 @@ struct soft_segment_descriptor gdt_segs[] = {
 };
 
 static void sppp_ipv6cp_up();
-const struct {} ipcp = { sppp_ipv6cp_up }; //expected-warning{{empty struct extension}} expected-error{{excess elements in struct initializer}}
+const struct {} ipcp = { sppp_ipv6cp_up }; //expected-warning{{empty struct extension}} expected-warning{{excess elements in struct initializer}}
 
 struct _Matrix { union { float m[4][4]; }; }; //expected-warning{{anonymous unions are a GNU extension in C}}
 typedef struct _Matrix Matrix;

diff --git a/test/Sema/designated-initializers.c b/test/Sema/designated-initializers.c
index 7c6ddca8ef2e7d3f9feb9c83363398aae07d4190..f604701d1210f16fe22448fc1998e45a038db845 100644 (file)
--- a/test/Sema/designated-initializers.c
+++ b/test/Sema/designated-initializers.c
@@ -185,4 +185,4 @@ const union wibble wobble = { .arr2[0] = 0xffff,
                               .arr2[1] = 0xffff,
                               .arr2[2] = 0xffff };
 
-const union wibble wobble2 = { .arr2 = {4, 5, 6}, 7 }; // expected-error{{excess elements in union initializer}}
+const union wibble wobble2 = { .arr2 = {4, 5, 6}, 7 }; // expected-warning{{excess elements in union initializer}}

diff --git a/test/Sema/flexible-array-init.c b/test/Sema/flexible-array-init.c
index 909b856d171bca761787b66fd1f8220d1798522e..fff5fee2afc28a3acf41fc75d5ef65f040962947 100644 (file)
--- a/test/Sema/flexible-array-init.c
+++ b/test/Sema/flexible-array-init.c
@@ -4,7 +4,7 @@ struct one {
   int values[];
 } x = {5, {1, 2, 3}};
 
-struct one x2 = { 5, 1, 2, 3 }; // expected-error{{excess elements in struct initializer}}
+struct one x2 = { 5, 1, 2, 3 }; // expected-warning{{excess elements in struct initializer}}
 
 void test() {
   struct one x3 = {5, {1, 2, 3}};

diff --git a/test/Sema/init.c b/test/Sema/init.c
index 900749f119e442a8b01c25f5acdb7abffc7f2f78..67a188feb8b2bbc27fdf4eecd1c87c1332e13faf 100644 (file)
--- a/test/Sema/init.c
+++ b/test/Sema/init.c
@@ -108,3 +108,5 @@ struct foo2 {
 struct foo2 bar2[] = {
    { (intptr_t)bbb }
 };
+
+struct foo2 bar3 = { 1, 2 }; // expected-warning{{excess elements in struct initializer}}

diff --git a/test/Sema/vector-init.c b/test/Sema/vector-init.c
index e2a00b1ffb45a0d3407a74e8d4d097233ddbbea3..eb009b9cd59dd4aef4147db9b1b4fc100544dcc0 100644 (file)
--- a/test/Sema/vector-init.c
+++ b/test/Sema/vector-init.c
@@ -1,15 +1,17 @@
 // RUN: clang %s -fsyntax-only -verify
 
-typedef __attribute__(( ext_vector_type(4) ))  float float4;
-//typedef float float4 __attribute__((vector_size(16)));
+//typedef __attribute__(( ext_vector_type(4) ))  float float4;
+typedef float float4 __attribute__((vector_size(16)));
 
 float4 foo = (float4){ 1.0, 2.0, 3.0, 4.0 };
 
+float4 foo2 = (float4){ 1.0, 2.0, 3.0, 4.0 , 5.0 }; // expected-warning{{excess elements in vector initializer}}
+
 float4 array[] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
 int array_sizecheck[(sizeof(array) / sizeof(float4)) == 3? 1 : -1];
 
 float4 array2[2] = { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 
-                     9.0 }; // expected-error {{excess elements in array initializer}}
+                     9.0 }; // expected-warning {{excess elements in array initializer}}
 
 float4 array3[2] = { {1.0, 2.0, 3.0}, 5.0, 6.0, 7.0, 8.0,
-                     9.0 }; // expected-error {{excess elements in array initializer}}
+                     9.0 }; // expected-warning {{excess elements in array initializer}}