13 files changed, 415 insertions, 45 deletions
diff --git a/test/CXX/class/class.mem/p2.cpp b/test/CXX/class/class.mem/p2.cpp
index 0a823f4c1f00..4aa4a5c6f1b7 100644
--- a/test/CXX/class/class.mem/p2.cpp
+++ b/test/CXX/class/class.mem/p2.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s 
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 // C++11 [class.mem]p2:
 //   A class is considered a completely-defined object type (or
diff --git a/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp b/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
index ad4f4064c255..030c90c525c0 100644
--- a/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
+++ b/test/CXX/expr/expr.prim/expr.prim.general/p3-0x.cpp
@@ -91,10 +91,11 @@ namespace Static {
 
 namespace PR12564 {
   struct Base {
-    void bar(Base&) {}
+    void bar(Base&) {} // unexpected-note {{here}}
   };
 
   struct Derived : Base {
-    void foo(Derived& d) noexcept(noexcept(d.bar(d))) {}
+    // FIXME: This should be accepted.
+    void foo(Derived& d) noexcept(noexcept(d.bar(d))) {} // unexpected-error {{cannot bind to a value of unrelated type}}
   };
 }
diff --git a/test/CXX/special/class.copy/implicit-move.cpp b/test/CXX/special/class.copy/implicit-move.cpp
index b1b298e893ff..3e9accfbf6a7 100644
--- a/test/CXX/special/class.copy/implicit-move.cpp
+++ b/test/CXX/special/class.copy/implicit-move.cpp
@@ -198,15 +198,15 @@ namespace DR1402 {
   struct NoMove4 : NonTrivialCopyAssign {}; // expected-note 2{{'const DR1402::NoMove4 &'}}
   struct NoMove5 : virtual NonTrivialCopyCtor {}; // expected-note 2{{'const DR1402::NoMove5 &'}}
   struct NoMove6 : virtual NonTrivialCopyAssign {}; // expected-note 2{{'const DR1402::NoMove6 &'}}
-  struct NoMove7 : NonTrivialCopyCtorVBase {}; // expected-note 2{{'DR1402::NoMove7 &'}}
-  struct NoMove8 : NonTrivialCopyAssignVBase {}; // expected-note 2{{'DR1402::NoMove8 &'}}
+  struct NoMove7 : NonTrivialCopyCtorVBase {}; // expected-note 2{{'const DR1402::NoMove7 &'}}
+  struct NoMove8 : NonTrivialCopyAssignVBase {}; // expected-note 2{{'const DR1402::NoMove8 &'}}
 
   // A non-trivially-move-assignable virtual base class inhibits the declaration
   // of a move assignment (which might move-assign the base class multiple
   // times).
   struct NoMove9 : NonTrivialMoveAssign {};
-  struct NoMove10 : virtual NonTrivialMoveAssign {}; // expected-note {{'DR1402::NoMove10 &'}}
-  struct NoMove11 : NonTrivialMoveAssignVBase {}; // expected-note {{'DR1402::NoMove11 &'}}
+  struct NoMove10 : virtual NonTrivialMoveAssign {}; // expected-note {{'const DR1402::NoMove10 &'}}
+  struct NoMove11 : NonTrivialMoveAssignVBase {}; // expected-note {{'const DR1402::NoMove11 &'}}
 
   struct Test {
     friend NoMove1::NoMove1(NoMove1 &&); // expected-error {{no matching function}}
diff --git a/test/CXX/special/class.copy/p8-cxx11.cpp b/test/CXX/special/class.copy/p8-cxx11.cpp
new file mode 100644
index 000000000000..02e6cd1c9ab6
--- /dev/null
+++ b/test/CXX/special/class.copy/p8-cxx11.cpp
@@ -0,0 +1,48 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+// C++98 [class.copy]p5 / C++11 [class.copy]p8.
+
+// The implicitly-declared copy constructor for a class X will have the form
+//   X::X(const X&)
+// if [every direct subobject] has a copy constructor whose first parameter is
+// of type 'const volatile[opt] T &'. Otherwise, it will have the form
+//   X::X(X&)
+
+struct ConstCopy {
+  ConstCopy(const ConstCopy &);
+};
+
+struct NonConstCopy {
+  NonConstCopy(NonConstCopy &);
+};
+
+struct DeletedConstCopy {
+  DeletedConstCopy(const DeletedConstCopy &) = delete;
+};
+
+struct DeletedNonConstCopy {
+  DeletedNonConstCopy(DeletedNonConstCopy &) = delete;
+};
+
+struct ImplicitlyDeletedConstCopy {
+  ImplicitlyDeletedConstCopy(ImplicitlyDeletedConstCopy &&);
+};
+
+
+struct A : ConstCopy {};
+struct B : NonConstCopy { ConstCopy a; };
+struct C : ConstCopy { NonConstCopy a; };
+struct D : DeletedConstCopy {};
+struct E : DeletedNonConstCopy {};
+struct F { ImplicitlyDeletedConstCopy a; };
+struct G : virtual B {};
+
+struct Test {
+  friend A::A(const A &);
+  friend B::B(B &);
+  friend C::C(C &);
+  friend D::D(const D &);
+  friend E::E(E &);
+  friend F::F(const F &);
+  friend G::G(G &);
+};
diff --git a/test/CodeGenCXX/x86-64-abi-sret-vs-2word-struct-param.cpp b/test/CodeGenCXX/x86-64-abi-sret-vs-2word-struct-param.cpp
deleted file mode 100644
index 1aa80f2d6e6f..000000000000
--- a/test/CodeGenCXX/x86-64-abi-sret-vs-2word-struct-param.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// RUN: %clang_cc1 -emit-llvm %s -o - | FileCheck %s
-// XTARGET: x86
-// PR4242
-// (PR 4242 bug is on 64-bit only, test passes on x86-32 as well)
-
-struct S {
-    void* data[3];
-};
-
-struct T {
-    void* data[2];
-};
-
-// CHECK: %struct.T* byval
-extern "C" S fail(int, int, int, int, T t, void* p) {
-    S s;
-    s.data[0] = t.data[0];
-    s.data[1] = t.data[1];
-    s.data[2] = p;
-    return s;
-}
-
-// CHECK: %struct.T* byval
-extern "C" S* succeed(S* sret, int, int, int, int, T t, void* p) {
-    sret->data[0] = t.data[0];
-    sret->data[1] = t.data[1];
-    sret->data[2] = p;
-    return sret;
-}
diff --git a/test/CodeGenCXX/x86_64-arguments.cpp b/test/CodeGenCXX/x86_64-arguments.cpp
index e1d9dfc1fc30..672180363fca 100644
--- a/test/CodeGenCXX/x86_64-arguments.cpp
+++ b/test/CodeGenCXX/x86_64-arguments.cpp
@@ -56,6 +56,7 @@ namespace PR7742 { // Also rdar://8250764
   
   // CHECK: define <2 x float> @_ZN6PR77423fooEPNS_2c2E(%"struct.PR7742::c2"* %P)
   c2 foo(c2 *P) {
+    return c2();
   }
   
 }
@@ -149,3 +150,34 @@ namespace test8 {
    foo(b);
   }
 }
+
+// PR4242
+namespace test9 {
+  // Large enough to be passed indirectly.
+  struct S { void *data[3]; };
+
+  struct T { void *data[2]; };
+
+  // CHECK: define void @_ZN5test93fooEPNS_1SEPNS_1TE([[S:%.*]]*, [[T:%.*]]*)
+  void foo(S*, T*) {}
+
+  // CHECK: define void @_ZN5test91aEiiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32, i32, i32, i32, [[T]]* byval align 8, i8*)
+  S a(int, int, int, int, T, void*) {
+    return S();
+  }
+
+  // CHECK: define [[S]]* @_ZN5test91bEPNS_1SEiiiiNS_1TEPv([[S]]* {{%.*}}, i32, i32, i32, i32, [[T:%.*]]* byval align 8, i8*)
+  S* b(S* sret, int, int, int, int, T, void*) {
+    return sret;
+  }
+
+  // CHECK: define void @_ZN5test91cEiiiNS_1TEPv([[S]]* noalias sret {{%.*}}, i32, i32, i32, i8* {{%.*}}, i8* {{%.*}}, i8*)
+  S c(int, int, int, T, void*) {
+    return S();
+  }
+
+  // CHECK: define [[S]]* @_ZN5test91dEPNS_1SEiiiNS_1TEPv([[S]]* {{%.*}}, i32, i32, i32, i8* {{%.*}}, i8* {{%.*}}, i8*)
+  S* d(S* sret, int, int, int, T, void*) {
+    return sret;
+  }
+}
diff --git a/test/PCH/cxx11-exception-spec.cpp b/test/PCH/cxx11-exception-spec.cpp
new file mode 100644
index 000000000000..3fca4e48acf8
--- /dev/null
+++ b/test/PCH/cxx11-exception-spec.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -pedantic-errors -std=c++11 -emit-pch %s -o %t
+// RUN: %clang_cc1 -pedantic-errors -std=c++11 -include-pch %t -verify %s
+
+#ifndef HEADER_INCLUDED
+
+#define HEADER_INCLUDED
+
+template<bool b> int f() noexcept(b) {}
+decltype(f<false>()) a;
+decltype(f<true>()) b;
+
+#else
+
+static_assert(!noexcept(f<false>()), "");
+static_assert(noexcept(f<true>()), "");
+
+#endif
diff --git a/test/Parser/recursion-limits.cpp b/test/Parser/recursion-limits.cpp
new file mode 100644
index 000000000000..ea25dea0dacc
--- /dev/null
+++ b/test/Parser/recursion-limits.cpp
@@ -0,0 +1,259 @@
+// RUN: %clang_cc1 -fsyntax-only %s -verify
+class outer {
+  class inner1 { inner1(); };
+  class inner2 { inner2(); };
+  class inner3 { inner3(); };
+  class inner4 { inner4(); };
+  class inner5 { inner5(); };
+  class inner6 { inner6(); };
+  class inner7 { inner7(); };
+  class inner8 { inner8(); };
+  class inner9 { inner9(); };
+  class inner10 { inner10(); };
+  class inner11 { inner11(); };
+  class inner12 { inner12(); };
+  class inner13 { inner13(); };
+  class inner14 { inner14(); };
+  class inner15 { inner15(); };
+  class inner16 { inner16(); };
+  class inner17 { inner17(); };
+  class inner18 { inner18(); };
+  class inner19 { inner19(); };
+  class inner20 { inner20(); };
+  class inner21 { inner21(); };
+  class inner22 { inner22(); };
+  class inner23 { inner23(); };
+  class inner24 { inner24(); };
+  class inner25 { inner25(); };
+  class inner26 { inner26(); };
+  class inner27 { inner27(); };
+  class inner28 { inner28(); };
+  class inner29 { inner29(); };
+  class inner30 { inner30(); };
+  class inner31 { inner31(); };
+  class inner32 { inner32(); };
+  class inner33 { inner33(); };
+  class inner34 { inner34(); };
+  class inner35 { inner35(); };
+  class inner36 { inner36(); };
+  class inner37 { inner37(); };
+  class inner38 { inner38(); };
+  class inner39 { inner39(); };
+  class inner40 { inner40(); };
+  class inner41 { inner41(); };
+  class inner42 { inner42(); };
+  class inner43 { inner43(); };
+  class inner44 { inner44(); };
+  class inner45 { inner45(); };
+  class inner46 { inner46(); };
+  class inner47 { inner47(); };
+  class inner48 { inner48(); };
+  class inner49 { inner49(); };
+  class inner50 { inner50(); };
+  class inner51 { inner51(); };
+  class inner52 { inner52(); };
+  class inner53 { inner53(); };
+  class inner54 { inner54(); };
+  class inner55 { inner55(); };
+  class inner56 { inner56(); };
+  class inner57 { inner57(); };
+  class inner58 { inner58(); };
+  class inner59 { inner59(); };
+  class inner60 { inner60(); };
+  class inner61 { inner61(); };
+  class inner62 { inner62(); };
+  class inner63 { inner63(); };
+  class inner64 { inner64(); };
+  class inner65 { inner65(); };
+  class inner66 { inner66(); };
+  class inner67 { inner67(); };
+  class inner68 { inner68(); };
+  class inner69 { inner69(); };
+  class inner70 { inner70(); };
+  class inner71 { inner71(); };
+  class inner72 { inner72(); };
+  class inner73 { inner73(); };
+  class inner74 { inner74(); };
+  class inner75 { inner75(); };
+  class inner76 { inner76(); };
+  class inner77 { inner77(); };
+  class inner78 { inner78(); };
+  class inner79 { inner79(); };
+  class inner80 { inner80(); };
+  class inner81 { inner81(); };
+  class inner82 { inner82(); };
+  class inner83 { inner83(); };
+  class inner84 { inner84(); };
+  class inner85 { inner85(); };
+  class inner86 { inner86(); };
+  class inner87 { inner87(); };
+  class inner88 { inner88(); };
+  class inner89 { inner89(); };
+  class inner90 { inner90(); };
+  class inner91 { inner91(); };
+  class inner92 { inner92(); };
+  class inner93 { inner93(); };
+  class inner94 { inner94(); };
+  class inner95 { inner95(); };
+  class inner96 { inner96(); };
+  class inner97 { inner97(); };
+  class inner98 { inner98(); };
+  class inner99 { inner99(); };
+  class inner100 { inner100(); };
+  class inner101 { inner101(); };
+  class inner102 { inner102(); };
+  class inner103 { inner103(); };
+  class inner104 { inner104(); };
+  class inner105 { inner105(); };
+  class inner106 { inner106(); };
+  class inner107 { inner107(); };
+  class inner108 { inner108(); };
+  class inner109 { inner109(); };
+  class inner110 { inner110(); };
+  class inner111 { inner111(); };
+  class inner112 { inner112(); };
+  class inner113 { inner113(); };
+  class inner114 { inner114(); };
+  class inner115 { inner115(); };
+  class inner116 { inner116(); };
+  class inner117 { inner117(); };
+  class inner118 { inner118(); };
+  class inner119 { inner119(); };
+  class inner120 { inner120(); };
+  class inner121 { inner121(); };
+  class inner122 { inner122(); };
+  class inner123 { inner123(); };
+  class inner124 { inner124(); };
+  class inner125 { inner125(); };
+  class inner126 { inner126(); };
+  class inner127 { inner127(); };
+  class inner128 { inner128(); };
+  class inner129 { inner129(); };
+  class inner130 { inner130(); };
+  class inner131 { inner131(); };
+  class inner132 { inner132(); };
+  class inner133 { inner133(); };
+  class inner134 { inner134(); };
+  class inner135 { inner135(); };
+  class inner136 { inner136(); };
+  class inner137 { inner137(); };
+  class inner138 { inner138(); };
+  class inner139 { inner139(); };
+  class inner140 { inner140(); };
+  class inner141 { inner141(); };
+  class inner142 { inner142(); };
+  class inner143 { inner143(); };
+  class inner144 { inner144(); };
+  class inner145 { inner145(); };
+  class inner146 { inner146(); };
+  class inner147 { inner147(); };
+  class inner148 { inner148(); };
+  class inner149 { inner149(); };
+  class inner150 { inner150(); };
+  class inner151 { inner151(); };
+  class inner152 { inner152(); };
+  class inner153 { inner153(); };
+  class inner154 { inner154(); };
+  class inner155 { inner155(); };
+  class inner156 { inner156(); };
+  class inner157 { inner157(); };
+  class inner158 { inner158(); };
+  class inner159 { inner159(); };
+  class inner160 { inner160(); };
+  class inner161 { inner161(); };
+  class inner162 { inner162(); };
+  class inner163 { inner163(); };
+  class inner164 { inner164(); };
+  class inner165 { inner165(); };
+  class inner166 { inner166(); };
+  class inner167 { inner167(); };
+  class inner168 { inner168(); };
+  class inner169 { inner169(); };
+  class inner170 { inner170(); };
+  class inner171 { inner171(); };
+  class inner172 { inner172(); };
+  class inner173 { inner173(); };
+  class inner174 { inner174(); };
+  class inner175 { inner175(); };
+  class inner176 { inner176(); };
+  class inner177 { inner177(); };
+  class inner178 { inner178(); };
+  class inner179 { inner179(); };
+  class inner180 { inner180(); };
+  class inner181 { inner181(); };
+  class inner182 { inner182(); };
+  class inner183 { inner183(); };
+  class inner184 { inner184(); };
+  class inner185 { inner185(); };
+  class inner186 { inner186(); };
+  class inner187 { inner187(); };
+  class inner188 { inner188(); };
+  class inner189 { inner189(); };
+  class inner190 { inner190(); };
+  class inner191 { inner191(); };
+  class inner192 { inner192(); };
+  class inner193 { inner193(); };
+  class inner194 { inner194(); };
+  class inner195 { inner195(); };
+  class inner196 { inner196(); };
+  class inner197 { inner197(); };
+  class inner198 { inner198(); };
+  class inner199 { inner199(); };
+  class inner200 { inner200(); };
+  class inner201 { inner201(); };
+  class inner202 { inner202(); };
+  class inner203 { inner203(); };
+  class inner204 { inner204(); };
+  class inner205 { inner205(); };
+  class inner206 { inner206(); };
+  class inner207 { inner207(); };
+  class inner208 { inner208(); };
+  class inner209 { inner209(); };
+  class inner210 { inner210(); };
+  class inner211 { inner211(); };
+  class inner212 { inner212(); };
+  class inner213 { inner213(); };
+  class inner214 { inner214(); };
+  class inner215 { inner215(); };
+  class inner216 { inner216(); };
+  class inner217 { inner217(); };
+  class inner218 { inner218(); };
+  class inner219 { inner219(); };
+  class inner220 { inner220(); };
+  class inner221 { inner221(); };
+  class inner222 { inner222(); };
+  class inner223 { inner223(); };
+  class inner224 { inner224(); };
+  class inner225 { inner225(); };
+  class inner226 { inner226(); };
+  class inner227 { inner227(); };
+  class inner228 { inner228(); };
+  class inner229 { inner229(); };
+  class inner230 { inner230(); };
+  class inner231 { inner231(); };
+  class inner232 { inner232(); };
+  class inner233 { inner233(); };
+  class inner234 { inner234(); };
+  class inner235 { inner235(); };
+  class inner236 { inner236(); };
+  class inner237 { inner237(); };
+  class inner238 { inner238(); };
+  class inner239 { inner239(); };
+  class inner240 { inner240(); };
+  class inner241 { inner241(); };
+  class inner242 { inner242(); };
+  class inner243 { inner243(); };
+  class inner244 { inner244(); };
+  class inner245 { inner245(); };
+  class inner246 { inner246(); };
+  class inner247 { inner247(); };
+  class inner248 { inner248(); };
+  class inner249 { inner249(); };
+  class inner250 { inner250(); };
+  class inner251 { inner251(); };
+  class inner252 { inner252(); };
+  class inner253 { inner253(); };
+  class inner254 { inner254(); };
+  class inner255 { inner255(); };
+  class inner256 { inner256(); };
+};
diff --git a/test/Rewriter/rewrite-modern-extern-c-func-decl.mm b/test/Rewriter/rewrite-modern-extern-c-func-decl.mm
index 10023bbc9f9f..82d5a4d9c34e 100644
--- a/test/Rewriter/rewrite-modern-extern-c-func-decl.mm
+++ b/test/Rewriter/rewrite-modern-extern-c-func-decl.mm
@@ -1,10 +1,7 @@
-// RUN: %clang_cc1 -fms-extensions -rewrite-objc -x objective-c++ -fblocks -o %t-rw.cpp %s
-// RUN: %clang_cc1 -fsyntax-only -Werror -Wno-address-of-temporary -Wno-attributes -D"Class=void*" -D"id=void*" -D"SEL=void*" -D"__declspec(X)=" %t-rw.cpp
+// RUN: %clang_cc1 -fms-extensions -U__declspec -rewrite-objc -x objective-c++ -fblocks -o %t-rw.cpp %s
+// RUN: %clang_cc1 -fsyntax-only -Werror -Wno-address-of-temporary -Wno-attributes -D"Class=void*" -D"id=void*" -D"SEL=void*" -U__declspec -D"__declspec(X)=" %t-rw.cpp
 // rdar://11131490
 
-// XFAIL: mingw
-// FIXME: __declspec(X) is predefined on mingw.
-
 extern "C" __declspec(dllexport) void BreakTheRewriter(void) {
         __block int aBlockVariable = 0;
         void (^aBlock)(void) = ^ {
diff --git a/test/SemaCXX/cxx0x-initializer-references.cpp b/test/SemaCXX/cxx0x-initializer-references.cpp
index d8fdd5a5a07a..c4e9c907a37a 100644
--- a/test/SemaCXX/cxx0x-initializer-references.cpp
+++ b/test/SemaCXX/cxx0x-initializer-references.cpp
@@ -85,3 +85,8 @@ namespace PR12182 {
       f({1, 2});
   }
 }
+
+namespace PR12660 {
+  const int &i { 1 };
+  struct S { S(int); } const &s { 2 };
+}
diff --git a/test/SemaCXX/dependent-noexcept-unevaluated.cpp b/test/SemaCXX/dependent-noexcept-unevaluated.cpp
index fad8d0918d53..0a3a8bb250bc 100644
--- a/test/SemaCXX/dependent-noexcept-unevaluated.cpp
+++ b/test/SemaCXX/dependent-noexcept-unevaluated.cpp
@@ -23,7 +23,7 @@ struct array
 {
     T data[N];
 
-  void swap(array& a) noexcept(noexcept(::swap(declval<T&>(), declval<T&>())));
+    void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
 };
 
 struct DefaultOnly
@@ -38,4 +38,3 @@ int main()
 {
     array<DefaultOnly, 1> a, b;
 }
-
diff --git a/test/SemaCXX/implicit-exception-spec.cpp b/test/SemaCXX/implicit-exception-spec.cpp
index 143d9f7cc877..25316f8d51ee 100644
--- a/test/SemaCXX/implicit-exception-spec.cpp
+++ b/test/SemaCXX/implicit-exception-spec.cpp
@@ -40,9 +40,12 @@ namespace InClassInitializers {
 }
 
 namespace ExceptionSpecification {
-  struct Nested {
+  // A type is permitted to be used in a dynamic exception specification when it
+  // is still being defined, but isn't complete within such an exception
+  // specification.
+  struct Nested { // expected-note {{not complete}}
     struct T {
-      T() noexcept(!noexcept(Nested())); // expected-error{{exception specification is not available until end of class definition}}
+      T() noexcept(!noexcept(Nested())); // expected-error{{incomplete type}}
     } t;
   };
 }
@@ -54,3 +57,33 @@ namespace DefaultArgument {
     } t; // expected-note {{has no default constructor}}
   };
 }
+
+namespace ImplicitDtorExceptionSpec {
+  struct A {
+    virtual ~A();
+
+    struct Inner {
+      ~Inner() throw();
+    };
+    Inner inner;
+  };
+
+  struct B {
+    virtual ~B() {} // expected-note {{here}}
+  };
+
+  struct C : B {
+    virtual ~C() {}
+    A a;
+  };
+
+  struct D : B {
+    ~D(); // expected-error {{more lax than base}}
+    struct E {
+      ~E();
+      struct F {
+        ~F() throw(A);
+      } f;
+    } e;
+  };
+}
diff --git a/test/SemaObjCXX/ivar-construct.mm b/test/SemaObjCXX/ivar-construct.mm
index 535d2a0217ff..a066fca3595a 100644
--- a/test/SemaObjCXX/ivar-construct.mm
+++ b/test/SemaObjCXX/ivar-construct.mm
@@ -27,3 +27,11 @@ struct Z; // expected-note{{forward declaration}}
 
 @implementation B
 @end
+
+// <rdar://problem/11284902>
+template<typename T> struct Incomplete; // expected-note{{declared here}}
+
+@interface C {
+  Incomplete<int> a[4][4][4]; // expected-error{{implicit instantiation of undefined template 'Incomplete<int>'}}
+}
+@end