For C++11, do more checking of initializer lists up-front, enabling some subset of the final functionality. C just leaves the function early. C++98 runs through the same code path, but has no changed functionality either.

This is a first baby step towards supporting generalized initializer lists. This also removes an aggregate
test case that was just plain wrong, assuming that non-aggregates couldn't be initialized with initializer lists
in C++11 mode.

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

3 files changed, 41 insertions, 71 deletions

diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1-0x.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1-0x.cpp
deleted file mode 100644
index 9b92340fa4..0000000000
--- a/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1-0x.cpp
+++ /dev/null
@@ -1,63 +0,0 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s
-
-// An aggregate is an array or a class...
-struct Aggr {
-private:
-  static const int n;
-  void f();
-protected:
-  struct Inner { int m; };
-public:
-  bool &br;
-};
-bool b;
-Aggr ag = { b };
-
-// with no user-provided constructors, ...
-struct NonAggr1a {
-  NonAggr1a(int, int);
-  int k;
-};
-// In C++03, this is {{non-aggregate type 'NonAggr1a'}}.
-// In C++0x, 'user-provided' is only defined for special member functions, so
-// this type is considered to be an aggregate. This is probably a langauge
-// defect.
-NonAggr1a na1a = { 42 };
-
-struct NonAggr1b {
-  NonAggr1b(const NonAggr1b &);
-  int k;
-};
-NonAggr1b na1b = { 42 }; // expected-error {{non-aggregate type 'NonAggr1b'}}
-
-// no brace-or-equal-initializers for non-static data members, ...
-struct NonAggr2 {
-  int m = { 123 };
-};
-NonAggr2 na2 = { 42 }; // expected-error {{non-aggregate type 'NonAggr2'}}
-
-// no private...
-struct NonAggr3 {
-private:
-  int n;
-};
-NonAggr3 na3 = { 42 }; // expected-error {{non-aggregate type 'NonAggr3'}}
-
-// or protected non-static data members, ...
-struct NonAggr4 {
-protected:
-  int n;
-};
-NonAggr4 na4 = { 42 }; // expected-error {{non-aggregate type 'NonAggr4'}}
-
-// no base classes, ...
-struct NonAggr5 : Aggr {
-};
-NonAggr5 na5 = { b }; // expected-error {{non-aggregate type 'NonAggr5'}}
-
-// and no virtual functions.
-struct NonAggr6 {
-  virtual void f();
-  int n;
-};
-NonAggr6 na6 = { 42 }; // expected-error {{non-aggregate type 'NonAggr6'}}
diff --git a/test/SemaCXX/aggregate-initialization.cpp b/test/SemaCXX/aggregate-initialization.cpp
index b9e69b00b7..d489691898 100644
--- a/test/SemaCXX/aggregate-initialization.cpp
+++ b/test/SemaCXX/aggregate-initialization.cpp
@@ -1,9 +1,7 @@
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x %s 
+// RUN: %clang_cc1 -fsyntax-only -verify %s 
 
 // Verify that we can't initialize non-aggregates with an initializer
 // list.
-// FIXME: Note that due to a (likely) standard bug, this is technically an
-//        aggregate.
 struct NonAggr1 {
   NonAggr1(int) { }
 
@@ -24,7 +22,7 @@ struct NonAggr4 {
   virtual void f();
 };
 
-NonAggr1 na1 = { 17 };
+NonAggr1 na1 = { 17 }; // expected-error{{non-aggregate type 'NonAggr1' cannot be initialized with an initializer list}}
 NonAggr2 na2 = { 17 }; // expected-error{{non-aggregate type 'NonAggr2' cannot be initialized with an initializer list}}
 NonAggr3 na3 = { 17 }; // expected-error{{non-aggregate type 'NonAggr3' cannot be initialized with an initializer list}}
 NonAggr4 na4 = { 17 }; // expected-error{{non-aggregate type 'NonAggr4' cannot be initialized with an initializer list}}
@@ -48,8 +46,9 @@ struct A {
   A();
   A(int);
   ~A();
-  
-  A(const A&) = delete; // expected-note 2 {{function has been explicitly marked deleted here}}
+
+private:
+  A(const A&) {} // expected-note 4 {{declared private here}}
 };
 
 struct B {
@@ -62,10 +61,10 @@ struct C {
 
 void f() {
   A as1[1] = { };
-  A as2[1] = { 1 }; // expected-error {{copying array element of type 'A' invokes deleted constructor}}
+  A as2[1] = { 1 }; // expected-error {{calling a private constructor of class 'A'}} expected-warning {{requires an accessible copy constructor}}
 
   B b1 = { };
-  B b2 = { 1 }; // expected-error {{copying member subobject of type 'A' invokes deleted constructor}}
+  B b2 = { 1 }; // expected-error {{field of type 'A' has private copy constructor}} expected-warning {{requires an accessible copy constructor}}
   
   C c1 = { 1 };
 }
diff --git a/test/SemaCXX/generalized-initializers.cpp b/test/SemaCXX/generalized-initializers.cpp
index 6e2bee7e30..738dc5cf2c 100644
--- a/test/SemaCXX/generalized-initializers.cpp
+++ b/test/SemaCXX/generalized-initializers.cpp
@@ -224,5 +224,39 @@ namespace aggregate {
     S s3{ 1, 2, 3, 4, 5, 6 }; // xpected-error
     S s4{ {1, 2}, {3, 4}, {5, 6}, { {7, 8} } }; // xpected-error
     S s5{ {1, 2}, {3, 4}, { {5}, {6} }, {7, 8} }; // xpected-error
+    // May still omit stuff, though.
+    S s6{ {1}, {}, { {}, {} } };
   }
 }
+
+namespace references {
+  // From [dcl.init.list]p3 bullet 5:
+  struct S {
+    S(std::initializer_list<double>);
+    S(const std::string&);
+  };
+  void test() {
+    const S &r1 = { 1, 2, 3.0 }; // no-error (constructor #1)
+    const S &r2{ "Spinach" }; // no-error (constructor #2)
+    S &r3 = { 1, 2, 3 }; // xpected-error (binding to non-const)
+    const int &i1 = { 1 }; // no-error
+    const int &i2 = { 1.1 }; // xpected-error {{narrowing}}
+    const int (&iar)[2] = { 1, 2 }; // no-error
+
+    // Edge case: the standard says this must create a temporary and thus
+    // fail to bind, but that's almost certainly a defect.
+    int i;
+    int &ri1{ i };
+    int &ri2 = { i };
+    S s{ "Spinach" };
+    S &rs1{ s };
+    S &rs2 = { s };
+  }
+}
+
+namespace incomplete {
+  // Just to make sure it doesn't crash.
+  struct S;
+  S s { 1, 2, 3 }; // expected-error {{incomplete}}
+  S t = { 1, 2, 3 }; // expected-error {{incomplete}}
+}