7 files changed, 83 insertions, 48 deletions
diff --git a/test/CXX/basic/basic.link/p9.cpp b/test/CXX/basic/basic.link/p9.cpp
index bd16b02d7badf..680c93db2e29a 100644
--- a/test/CXX/basic/basic.link/p9.cpp
+++ b/test/CXX/basic/basic.link/p9.cpp
@@ -6,6 +6,5 @@ namespace N { } // expected-note{{here}}
 // First bullet: two names with external linkage that refer to
 // different kinds of entities.
 void f() {
-  int N(); // expected-error{{redefinition}}
+  int N(); // expected-error{{redefinition}} expected-warning{{interpreted as a function declaration}} expected-note {{replace parentheses with an initializer}}
 }
-
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
index cee7c02420333..f5ad68b75bdf1 100644
--- a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
@@ -46,7 +46,7 @@ namespace M {
   int g(N::X); // expected-note{{candidate function}}
 
   void test(N::X x) {
-    g(x); // expected-error{{call to 'g' is ambiguous; candidates are:}}
+    g(x); // expected-error{{call to 'g' is ambiguous}}
     int i = (g)(x);
 
     int g(N::X);
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp
index 15d86b7740c4c..32dd75ad49a87 100644
--- a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp
@@ -44,7 +44,7 @@ namespace Test {
     A::A() + A::A();
     B::B() + B::B();
     C::C() + C::C();
-    D::D() + D::D(); // expected-error {{ invalid operands to binary expression ('D::D' and 'D::D') }}
+    D::D() + D::D(); // expected-error {{invalid operands to binary expression ('D::D' and 'D::D')}}
   }
 }
 
diff --git a/test/CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp b/test/CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp
index c35af1def2085..c20728332704a 100644
--- a/test/CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.classref/p1.cpp
@@ -36,7 +36,7 @@ void resolves_to_different() {
     Value v;
     // The fact that the next line is a warning rather than an error is an
     // extension.
-    v.set<double>(3.2);  // expected-warning{{lookup of 'set' in member access expression is ambiguous; using member of 'Value' [-Wambiguous-member-template]}}
+    v.set<double>(3.2);  // expected-warning{{lookup of 'set' in member access expression is ambiguous; using member of 'Value'}}
   }
   {
     int set;  // Non-template.
@@ -62,3 +62,28 @@ namespace rdar9915664 {
     }
   };
 }
+
+namespace PR11856 {
+  template<typename T> T end(T);
+
+  template <typename T>
+  void Foo() {
+    T it1;
+    if (it1->end < it1->end) {
+    }
+  }
+
+  template<typename T> T *end(T*);
+
+  class X { };
+  template <typename T>
+  void Foo2() {
+    T it1;
+    if (it1->end < it1->end) {
+    }
+
+    X *x;
+    if (x->end < 7) {  // expected-error{{no member named 'end' in 'PR11856::X'}}
+    }
+  }
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2f.cpp b/test/CXX/basic/basic.start/basic.start.main/p2f.cpp
index a3d6a79a4fa0a..ea5a752a191cd 100644
--- a/test/CXX/basic/basic.start/basic.start.main/p2f.cpp
+++ b/test/CXX/basic/basic.start/basic.start.main/p2f.cpp
@@ -1,7 +1,7 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s 
 
-void  // expected-error {{error: 'main' must return 'int'}}
-main( // expected-error {{error: first parameter of 'main' (argument count) must be of type 'int'}}
+void  // expected-error {{'main' must return 'int'}}
+main( // expected-error {{first parameter of 'main' (argument count) must be of type 'int'}}
      float a
 ) {
 }
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2i.cpp b/test/CXX/basic/basic.start/basic.start.main/p2i.cpp
new file mode 100644
index 0000000000000..db8da3c4e7c03
--- /dev/null
+++ b/test/CXX/basic/basic.start/basic.start.main/p2i.cpp
@@ -0,0 +1,6 @@
+// RUN: cp %s %t
+// RUN: %clang_cc1 -x c++ %s -std=c++11 -fsyntax-only -verify
+// RUN: not %clang_cc1 -x c++ %t -std=c++11 -fixit
+// RUN: %clang_cc1 -x c++ %t -std=c++11 -fsyntax-only
+
+constexpr int main() { } // expected-error{{'main' is not allowed to be declared constexpr}}
diff --git a/test/CXX/basic/basic.types/p10.cpp b/test/CXX/basic/basic.types/p10.cpp
index 3b438d15f28bf..83b910b60640d 100644
--- a/test/CXX/basic/basic.types/p10.cpp
+++ b/test/CXX/basic/basic.types/p10.cpp
@@ -5,21 +5,40 @@ struct NonLiteral { NonLiteral(); };
 // A type is a literal type if it is:
 
 // - a scalar type
-constexpr int f1(double);
+constexpr int f1(double) { return 0; }
 
 // - a reference type
 struct S { S(); };
-constexpr int f2(S &);
+constexpr int f2(S &) { return 0; }
+
+// FIXME: I'm not entirely sure whether the following is legal or not...
+struct BeingDefined;
+extern BeingDefined beingdefined;
+struct BeingDefined { 
+  static constexpr BeingDefined& t = beingdefined;
+};
 
 // - a class type that has all of the following properties:
 
+// (implied) - it is complete
+
+struct Incomplete;
+template<class T> struct ClassTemp {};
+
+constexpr Incomplete incomplete = {}; // expected-error {{constexpr variable cannot have non-literal type 'const Incomplete'}}
+constexpr Incomplete incomplete2[] = {}; // expected-error {{constexpr variable cannot have non-literal type 'Incomplete const[]'}}
+constexpr ClassTemp<int> classtemplate = {};
+constexpr ClassTemp<int> classtemplate2[] = {};
+
 //  - it has a trivial destructor
 struct UserProvDtor {
-  constexpr UserProvDtor(); // expected-error {{non-literal type 'UserProvDtor' cannot have constexpr members}}
+  constexpr int f(); // expected-error {{non-literal type 'UserProvDtor' cannot have constexpr members}}
   ~UserProvDtor(); // expected-note {{has a user-provided destructor}}
 };
+
 struct NonTrivDtor {
-  constexpr NonTrivDtor(); // expected-error {{non-literal type 'NonTrivDtor' cannot have constexpr members}}
+  constexpr NonTrivDtor();
+  constexpr int f(); // expected-error {{non-literal type 'NonTrivDtor' cannot have constexpr members}}
   virtual ~NonTrivDtor() = default; // expected-note {{has a non-trivial destructor}}
 };
 struct NonTrivDtorBase {
@@ -29,17 +48,16 @@ template<typename T>
 struct DerivedFromNonTrivDtor : T { // expected-note {{'DerivedFromNonTrivDtor<NonTrivDtorBase>' is not literal because it has base class 'NonTrivDtorBase' of non-literal type}}
   constexpr DerivedFromNonTrivDtor();
 };
-constexpr int f(DerivedFromNonTrivDtor<NonTrivDtorBase>); // expected-error {{constexpr function's 1st parameter type 'DerivedFromNonTrivDtor<NonTrivDtorBase>' is not a literal type}}
+constexpr int f(DerivedFromNonTrivDtor<NonTrivDtorBase>) { return 0; } // expected-error {{constexpr function's 1st parameter type 'DerivedFromNonTrivDtor<NonTrivDtorBase>' is not a literal type}}
 struct TrivDtor {
   constexpr TrivDtor();
 };
-// FIXME: when building DefinitionData we look at 'isUserProvided' before it's set up!
-#if 0
+constexpr int f(TrivDtor) { return 0; }
 struct TrivDefaultedDtor {
   constexpr TrivDefaultedDtor();
   ~TrivDefaultedDtor() = default;
 };
-#endif
+constexpr int f(TrivDefaultedDtor) { return 0; }
 
 //  - it is an aggregate type or has at least one constexpr constructor or
 //    constexpr constructor template that is not a copy or move constructor
@@ -52,36 +70,41 @@ struct CtorTemplate {
   template<typename T> constexpr CtorTemplate(T);
 };
 struct CopyCtorOnly { // expected-note {{'CopyCtorOnly' is not literal because it is not an aggregate and has no constexpr constructors other than copy or move constructors}}
-  constexpr CopyCtorOnly(CopyCtorOnly&); // expected-error {{non-literal type 'CopyCtorOnly' cannot have constexpr members}}
+  constexpr CopyCtorOnly(CopyCtorOnly&);
+  constexpr int f(); // expected-error {{non-literal type 'CopyCtorOnly' cannot have constexpr members}}
 };
 struct MoveCtorOnly { // expected-note {{no constexpr constructors other than copy or move constructors}}
-  constexpr MoveCtorOnly(MoveCtorOnly&&); // expected-error {{non-literal type 'MoveCtorOnly' cannot have constexpr members}}
+  constexpr MoveCtorOnly(MoveCtorOnly&&);
+  constexpr int f(); // expected-error {{non-literal type 'MoveCtorOnly' cannot have constexpr members}}
 };
 template<typename T>
-struct CtorArg { // expected-note {{no constexpr constructors other than copy or move constructors}}
-  constexpr CtorArg(T); // expected-note {{constructor template instantiation is not constexpr because 1st parameter type 'NonLiteral' is not a literal type}}
+struct CtorArg {
+  constexpr CtorArg(T);
 };
-constexpr int f(CtorArg<int>);
-constexpr int f(CtorArg<NonLiteral>); // expected-error {{not a literal type}}
+constexpr int f(CtorArg<int>) { return 0; } // ok
+constexpr int f(CtorArg<NonLiteral>) { return 0; } // ok, ctor is still constexpr
 // We have a special-case diagnostic for classes with virtual base classes.
 struct VBase {};
 struct HasVBase : virtual VBase {}; // expected-note 2{{virtual base class declared here}}
 struct Derived : HasVBase {
-  constexpr Derived(); // expected-error {{constexpr constructor not allowed in struct with virtual base class}}
+  constexpr Derived() {} // expected-error {{constexpr constructor not allowed in struct with virtual base class}}
 };
 template<typename T> struct DerivedFromVBase : T { // expected-note {{struct with virtual base class is not a literal type}}
   constexpr DerivedFromVBase();
 };
-constexpr int f(DerivedFromVBase<HasVBase>); // expected-error {{constexpr function's 1st parameter type 'DerivedFromVBase<HasVBase>' is not a literal type}}
+constexpr int f(DerivedFromVBase<HasVBase>) {} // expected-error {{constexpr function's 1st parameter type 'DerivedFromVBase<HasVBase>' is not a literal type}}
+template<typename T> constexpr DerivedFromVBase<T>::DerivedFromVBase() : T() {}
+constexpr int nVBase = (DerivedFromVBase<HasVBase>(), 0); // expected-error {{constant expression}} expected-note {{cannot construct object of type 'DerivedFromVBase<HasVBase>' with virtual base class in a constant expression}}
 
 //  - it has all non-static data members and base classes of literal types
 struct NonLitMember {
   S s; // expected-note {{has data member 's' of non-literal type 'S'}}
 };
-constexpr int f(NonLitMember); // expected-error {{1st parameter type 'NonLitMember' is not a literal type}}
+constexpr int f(NonLitMember) {} // expected-error {{1st parameter type 'NonLitMember' is not a literal type}}
 struct NonLitBase :
   S { // expected-note {{base class 'S' of non-literal type}}
-  constexpr NonLitBase(); // expected-error {{non-literal type 'NonLitBase' cannot have constexpr members}}
+  constexpr NonLitBase();
+  constexpr int f() { return 0; } // expected-error {{non-literal type 'NonLitBase' cannot have constexpr members}}
 };
 struct LitMemBase : Agg {
   Agg agg;
@@ -91,37 +114,19 @@ struct MemberType {
   T t; // expected-note {{'MemberType<NonLiteral>' is not literal because it has data member 't' of non-literal type 'NonLiteral'}}
   constexpr MemberType();
 };
-constexpr int f(MemberType<int>);
-constexpr int f(MemberType<NonLiteral>); // expected-error {{not a literal type}}
+constexpr int f(MemberType<int>) { return 0; }
+constexpr int f(MemberType<NonLiteral>) { return 0; } // expected-error {{not a literal type}}
 
 // - an array of literal type
 struct ArrGood {
   Agg agg[24];
   double d[12];
   TrivDtor td[3];
+  TrivDefaultedDtor tdd[3];
 };
-constexpr int f(ArrGood);
+constexpr int f(ArrGood) { return 0; }
 
 struct ArrBad {
   S s[3]; // expected-note {{data member 's' of non-literal type 'S [3]'}}
 };
-constexpr int f(ArrBad); // expected-error {{1st parameter type 'ArrBad' is not a literal type}}
-
-
-// As a non-conforming tweak to the standard, we do not allow a literal type to
-// have any mutable data members.
-namespace MutableMembers {
-  struct MM {
-    mutable int n; // expected-note {{'MM' is not literal because it has a mutable data member}}
-  };
-  constexpr int f(MM); // expected-error {{not a literal type}}
-
-  // Here's one reason why allowing this would be a disaster...
-  template<int n> struct Id { int k = n; };
-  int f() {
-    // FIXME: correctly check whether the initializer is a constant expression.
-    constexpr MM m = { 0 }; // desired-error {{must be a constant expression}}
-    ++m.n;
-    return Id<m.n>().k; // expected-error {{not an integral constant expression}}
-  }
-}
+constexpr int f(ArrBad) { return 0; } // expected-error {{1st parameter type 'ArrBad' is not a literal type}}