5 files changed, 166 insertions, 31 deletions
diff --git a/test/CXX/basic/basic.link/p6.cpp b/test/CXX/basic/basic.link/p6.cpp
index 8faec76..ac6dc2f 100644
--- a/test/CXX/basic/basic.link/p6.cpp
+++ b/test/CXX/basic/basic.link/p6.cpp
@@ -1,4 +1,6 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1y %s
+
+// expected-no-diagnostics
 
 // C++11 [basic.link]p6:
 //   The name of a function declared in block scope and the name
@@ -9,35 +11,34 @@
 //   block scope declaration declares that same entity and
 //   receives the linkage of the previous declaration.
 
-// rdar://13535367
-namespace test0 {
-  extern "C" int test0_array[];
-  void declare() { extern int test0_array[100]; }
-  extern "C" int test0_array[];
-  int value = sizeof(test0_array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}}
-}
-
-namespace test1 {
-  extern "C" int test1_array[];
-  void test() {
-    { extern int test1_array[100]; }
-    extern int test1_array[];
-    int x = sizeof(test1_array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}}
+extern int same_entity;
+constexpr int *get1() {
+  int same_entity = 0; // not the same entity
+  {
+    extern int same_entity;
+    return &same_entity;
   }
 }
+static_assert(get1() == &same_entity, "failed to find previous decl");
 
-namespace test2 {
-  void declare() { extern int test2_array[100]; }
-  extern int test2_array[];
-  int value = sizeof(test2_array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}}
+static int same_entity_2[3];
+constexpr int *get2() {
+  // This is a redeclaration of the same entity, even though it doesn't
+  // inherit the type of the prior declaration.
+  extern int same_entity_2[];
+  return same_entity_2;
 }
+static_assert(get2() == same_entity_2, "failed to find previous decl");
 
-namespace test3 {
-  void test() {
-    { extern int test3_array[100]; }
-    extern int test3_array[];
-    int x = sizeof(test3_array); // expected-error {{invalid application of 'sizeof' to an incomplete type 'int []'}}
+static int different_entities;
+constexpr int *get3() {
+  int different_entities = 0;
+  {
+    // FIXME: This is not a redeclaration of the prior entity, because
+    // it is not visible here. Under DR426, this is ill-formed, and without
+    // it, the static_assert below should fail.
+    extern int different_entities;
+    return &different_entities;
   }
 }
-
-
+static_assert(get3() == &different_entities, "failed to find previous decl");
diff --git a/test/CXX/basic/basic.link/p7.cpp b/test/CXX/basic/basic.link/p7.cpp
new file mode 100644
index 0000000..9a85eac
--- /dev/null
+++ b/test/CXX/basic/basic.link/p7.cpp
@@ -0,0 +1,73 @@
+// RUN: %clang_cc1 -verify -std=c++1y %s
+
+// Example from the standard.
+namespace X {
+  void p() {
+    q(); // expected-error {{undeclared}}
+    extern void q();
+  }
+  void middle() {
+    q(); // expected-error {{undeclared}}
+  }
+  void q() { /*...*/ }
+  void bottom() {
+    q();
+  }
+}
+int q();
+
+namespace Test1 {
+  void f() {
+    extern int a; // expected-note {{previous}}
+    int g(void); // expected-note {{previous}}
+  }
+  double a; // expected-error {{different type: 'double' vs 'int'}}
+  double g(); // expected-error {{differ only in their return type}}
+}
+
+namespace Test2 {
+  void f() {
+    extern int a; // expected-note {{previous}}
+    int g(void); // expected-note {{previous}}
+  }
+  void h() {
+    extern double a; // expected-error {{different type: 'double' vs 'int'}}
+    double g(void); // expected-error {{differ only in their return type}}
+  }
+}
+
+namespace Test3 {
+  constexpr void (*f())() {
+    void h();
+    return &h;
+  }
+  constexpr void (*g())() {
+    void h();
+    return &h;
+  }
+  static_assert(f() == g(), "");
+}
+
+namespace Test4 {
+  template<typename T>
+  constexpr void (*f())() {
+    void h();
+    return &h;
+  }
+  static_assert(f<int>() == f<char>(), "");
+  void h();
+  static_assert(f<int>() == &h, "");
+}
+
+namespace Test5 {
+  constexpr auto f() -> void (*)() {
+    void g();
+    struct X {
+      friend void g();
+      static constexpr auto h() -> void (*)() { return g; }
+    };
+    return X::h();
+  }
+  void g();
+  static_assert(f() == g, "");
+}
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 df9a2cd..e352bbe 100644
--- a/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
+++ b/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp
@@ -5,7 +5,7 @@ namespace N {
   
   X operator+(X, X);
 
-  void f(X);
+  void f(X); // expected-note 2 {{'N::f' declared here}}
   void g(X); // expected-note{{candidate function}}
 
   void test_multiadd(X x) {
@@ -17,7 +17,7 @@ namespace M {
   struct Y : N::X { };
 }
 
-void f(); // expected-note 2 {{'f' declared here}}
+void f();
 
 void test_operator_adl(N::X x, M::Y y) {
   (void)(x + x);
@@ -27,8 +27,8 @@ void test_operator_adl(N::X x, M::Y y) {
 void test_func_adl(N::X x, M::Y y) {
   f(x);
   f(y);
-  (f)(x); // expected-error{{too many arguments to function call}}
-  ::f(x); // expected-error{{too many arguments to function call}}
+  (f)(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
+  ::f(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
 }
 
 namespace N {
@@ -72,7 +72,7 @@ namespace O {
 }
 
 extern "C" {
-  struct L { };
+  struct L { int x; };
 }
 
 void h(L); // expected-note{{candidate function}}
diff --git a/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp b/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp
index 911df98..1d2b525d 100644
--- a/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp
+++ b/test/CXX/basic/basic.scope/basic.scope.hiding/p2.cpp
@@ -22,3 +22,48 @@ void f() {
   Y(1); // okay
 }
 
+namespace PR17731 {
+  void f() {
+    struct S { S() {} };
+    int S(void);
+    int a = S();
+    struct S b;
+    {
+      int S(void);
+      int a = S();
+      struct S c = b;
+    }
+    {
+      struct S { S() {} }; // expected-note {{candidate}}
+      int a = S(); // expected-error {{no viable conversion from 'S'}}
+      struct S c = b; // expected-error {{no viable conversion from 'struct S'}}
+    }
+  }
+  void g() {
+    int S(void);
+    struct S { S() {} };
+    int a = S();
+    struct S b;
+    {
+      int S(void);
+      int a = S();
+      struct S c = b;
+    }
+    {
+      struct S { S() {} }; // expected-note {{candidate}}
+      int a = S(); // expected-error {{no viable conversion from 'S'}}
+      struct S c = b; // expected-error {{no viable conversion from 'struct S'}}
+    }
+  }
+
+  struct A {
+    struct B;
+    void f();
+    int B;
+  };
+  struct A::B {};
+  void A::f() {
+    B = 123;
+    struct B b;
+  }
+}
diff --git a/test/CXX/basic/basic.start/basic.start.main/p2.cpp b/test/CXX/basic/basic.start/basic.start.main/p2.cpp
index a5386f1..5c7d60c 100644
--- a/test/CXX/basic/basic.start/basic.start.main/p2.cpp
+++ b/test/CXX/basic/basic.start/basic.start.main/p2.cpp
@@ -15,6 +15,8 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST10
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST11
 // RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST12
+// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST13
+// RUN: %clang_cc1 -fsyntax-only -verify %s -DTEST14
 
 #if TEST1
 
@@ -94,6 +96,20 @@ int main(int, charT* const *) {}
 typedef char charT;
 int main(int, const charT* const *) {}
 
+#elif TEST13
+
+int main(void) {}
+
+template <typename T>
+int main(void); // expected-error{{'main' cannot be a template}}
+
+#elif TEST14
+
+template <typename T>
+int main(void); // expected-error{{'main' cannot be a template}}
+
+int main(void) {}
+
 #else
 
 #error Unknown test mode