From 222e2a7620e6520ffaf4fc4e69d79c18da31542e Mon Sep 17 00:00:00 2001
From: "Zancanaro; Carlo" <czan8762@plang3.cs.usyd.edu.au>
Date: Mon, 24 Sep 2012 09:58:17 +1000
Subject: Add the clang library to the repo (with some of my changes, too).

---
 clang/test/CXX/over/over.built/p1.cpp              |  16 ++
 clang/test/CXX/over/over.built/p23.cpp             |  25 +++
 clang/test/CXX/over/over.built/p25.cpp             |  15 ++
 clang/test/CXX/over/over.load/p2-0x.cpp            |  24 +++
 .../over.best.ics/over.ics.list/p6.cpp             |  15 ++
 .../over.best.ics/over.ics.user/p3-0x.cpp          |  14 ++
 .../over.match.best/over.ics.rank/p3-0x.cpp        |  59 +++++++
 .../CXX/over/over.match/over.match.best/p1.cpp     |  16 ++
 .../over.match.funcs/over.match.copy/p1.cpp        |  37 ++++
 .../CXX/over/over.match/over.match.funcs/p4-0x.cpp |  70 ++++++++
 clang/test/CXX/over/over.oper/over.literal/p2.cpp  |  35 ++++
 clang/test/CXX/over/over.oper/over.literal/p3.cpp  |  40 +++++
 clang/test/CXX/over/over.oper/over.literal/p5.cpp  |  22 +++
 clang/test/CXX/over/over.oper/over.literal/p6.cpp  |  13 ++
 clang/test/CXX/over/over.oper/over.literal/p7.cpp  |  16 ++
 clang/test/CXX/over/over.oper/over.literal/p8.cpp  |  19 ++
 clang/test/CXX/over/over.over/p1.cpp               |  94 ++++++++++
 .../over.over/p2-resolve-single-template-id.cpp    | 191 +++++++++++++++++++++
 clang/test/CXX/over/over.over/p2.cpp               |   9 +
 clang/test/CXX/over/over.over/p4.cpp               |  20 +++
 20 files changed, 750 insertions(+)
 create mode 100644 clang/test/CXX/over/over.built/p1.cpp
 create mode 100644 clang/test/CXX/over/over.built/p23.cpp
 create mode 100644 clang/test/CXX/over/over.built/p25.cpp
 create mode 100644 clang/test/CXX/over/over.load/p2-0x.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.best/p1.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp
 create mode 100644 clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p2.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p3.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p5.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p6.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p7.cpp
 create mode 100644 clang/test/CXX/over/over.oper/over.literal/p8.cpp
 create mode 100644 clang/test/CXX/over/over.over/p1.cpp
 create mode 100644 clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp
 create mode 100644 clang/test/CXX/over/over.over/p2.cpp
 create mode 100644 clang/test/CXX/over/over.over/p4.cpp

(limited to 'clang/test/CXX/over')

diff --git a/clang/test/CXX/over/over.built/p1.cpp b/clang/test/CXX/over/over.built/p1.cpp
new file mode 100644
index 0000000..6000f5b
--- /dev/null
+++ b/clang/test/CXX/over/over.built/p1.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+enum E1 { one };
+enum E2 { two };
+
+bool operator >= (E1, E1) {
+  return false;
+}
+
+bool operator >= (E1, const E2) {
+  return false;
+}
+
+bool test(E1 a, E1 b, E2 c) {
+  return a >= b || a >= c;
+}
diff --git a/clang/test/CXX/over/over.built/p23.cpp b/clang/test/CXX/over/over.built/p23.cpp
new file mode 100644
index 0000000..4125521
--- /dev/null
+++ b/clang/test/CXX/over/over.built/p23.cpp
@@ -0,0 +1,25 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+
+struct Variant {
+  template <typename T> operator T();
+};
+
+Variant getValue();
+
+void testVariant() {
+  bool ret1 = getValue() || getValue(); 
+  bool ret2 = getValue() && getValue(); 
+  bool ret3 = !getValue();
+}
+
+struct ExplicitVariant {
+  template <typename T> explicit operator T();
+};
+
+ExplicitVariant getExplicitValue();
+
+void testExplicitVariant() {
+  bool ret1 = getExplicitValue() || getExplicitValue(); 
+  bool ret2 = getExplicitValue() && getExplicitValue(); 
+  bool ret3 = !getExplicitValue();
+}
diff --git a/clang/test/CXX/over/over.built/p25.cpp b/clang/test/CXX/over/over.built/p25.cpp
new file mode 100644
index 0000000..aea3854
--- /dev/null
+++ b/clang/test/CXX/over/over.built/p25.cpp
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+enum class Color { Red, Green, Blue };
+
+struct ConvertsToColorA {
+  operator Color();
+};
+
+struct ConvertsToColorB {
+  operator Color();
+};
+
+Color foo(bool cond, ConvertsToColorA ca, ConvertsToColorB cb) {
+  return cond? ca : cb;
+}
diff --git a/clang/test/CXX/over/over.load/p2-0x.cpp b/clang/test/CXX/over/over.load/p2-0x.cpp
new file mode 100644
index 0000000..cf38741
--- /dev/null
+++ b/clang/test/CXX/over/over.load/p2-0x.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+// Member function declarations with the same name and the same
+// parameter-type-list as well as mem- ber function template
+// declarations with the same name, the same parameter-type-list, and
+// the same template parameter lists cannot be overloaded if any of
+// them, but not all, have a ref-qualifier (8.3.5).
+
+class Y { 
+  void h() &; 
+  void h() const &; 
+  void h() &&; 
+  void i() &; // expected-note{{previous declaration}}
+  void i() const; // expected-error{{cannot overload a member function without a ref-qualifier with a member function with ref-qualifier '&'}}
+
+  template<typename T> void f(T*) &;
+  template<typename T> void f(T*) &&;
+
+  template<typename T> void g(T*) &; // expected-note{{previous declaration}}
+  template<typename T> void g(T*); // expected-error{{cannot overload a member function without a ref-qualifier with a member function with ref-qualifier '&'}}
+
+  void k(); // expected-note{{previous declaration}}
+  void k() &&; // expected-error{{cannot overload a member function with ref-qualifier '&&' with a member function without a ref-qualifier}}
+};
diff --git a/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp
new file mode 100644
index 0000000..ea059ce
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.list/p6.cpp
@@ -0,0 +1,15 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+// rdar://problem/11120365
+namespace test0 {
+  template <class T> struct A {
+    static void foo(const T &t) {}
+    static void foo(T &&t) {
+      t.foo(); // expected-error {{member reference base type 'int' is not a structure or union}}
+    }
+  }; 
+
+  void test() {
+    A<int>::foo({}); // expected-note {{requested here}}
+  }
+}
diff --git a/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp
new file mode 100644
index 0000000..1c71468
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.best/over.best.ics/over.ics.user/p3-0x.cpp
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
+
+namespace PR6285 {
+  template<typename T> struct identity 
+  { typedef T type; };
+
+  struct D { 
+    template<typename T = short> 
+    operator typename identity<T>::type(); // expected-note{{candidate}}
+  }; 
+
+  int f() { return D(); } // expected-error{{no viable conversion}}
+}
+
diff --git a/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp b/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp
new file mode 100644
index 0000000..3971acc
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.best/over.ics.rank/p3-0x.cpp
@@ -0,0 +1,59 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+namespace std_example {
+  int i; 
+  int f1(); 
+  int&& f2(); 
+  int &g(const int &);
+  float &g(const int &&);
+  int &j = g(i); 
+  float &k = g(f1());
+  float &l = g(f2());
+
+  int &g2(const int &);
+  float &g2(int &&);
+  int &j2 = g2(i); 
+  float &k2 = g2(f1());
+  float &l2 = g2(f2());
+
+  // FIXME: We don't support ref-qualifiers yet.
+#if 0
+  struct A { 
+    A& operator<<(int); 
+    void p() &; 
+    void p() &&;
+  };
+
+  A& operator<<(A&&, char); 
+  A() << 1; 
+  A() << 'c'; 
+  A a; 
+  a << 1; 
+  a << 'c'; 
+  A().p(); 
+  a.p();
+#endif
+}
+
+template<typename T>
+struct remove_reference {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+
+template<typename T>
+struct remove_reference<T&&> {
+  typedef T type;
+};
+
+namespace FunctionReferencesOverloading {
+  template<typename T> int &f(typename remove_reference<T>::type&);
+  template<typename T> float &f(typename remove_reference<T>::type&&);
+
+  void test_f(int (&func_ref)(int)) {
+    int &ir = f<int (&)(int)>(func_ref);
+  }
+}
diff --git a/clang/test/CXX/over/over.match/over.match.best/p1.cpp b/clang/test/CXX/over/over.match/over.match.best/p1.cpp
new file mode 100644
index 0000000..5c315a7
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.best/p1.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> int &f0(T*, int);
+float &f0(void*, int);
+
+void test_f0(int* ip, void *vp) {
+  // One argument is better...
+  int &ir = f0(ip, 0);
+  
+  // Prefer non-templates to templates
+  float &fr = f0(vp, 0);
+}
+
+// Partial ordering of function template specializations will be tested 
+// elsewhere
+// FIXME: Initialization by user-defined conversion is tested elsewhere
diff --git a/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp b/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp
new file mode 100644
index 0000000..31a679f
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.funcs/over.match.copy/p1.cpp
@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only %s -verify
+
+namespace ExplicitConv {
+  struct X { }; // expected-note 2{{candidate constructor}}
+
+  struct Y {
+    explicit operator X() const;
+  };
+
+  void test(const Y& y) {
+    X x(static_cast<X>(y));
+    X x2((X)y);
+    X x3 = y; // expected-error{{no viable conversion from 'const ExplicitConv::Y' to 'ExplicitConv::X'}}
+  }
+}
+
+namespace DR899 {
+  struct C { }; // expected-note 2 {{candidate constructor}}
+
+  struct A {
+    explicit operator int() const;
+    explicit operator C() const;
+  };
+
+  struct B {
+    int i;
+    B(const A& a): i(a) { }
+  };
+
+  int main() {
+    A a;
+    int i = a; // expected-error{{no viable conversion}}
+    int j(a);
+    C c = a; // expected-error{{no viable conversion}}
+    C c2(a);
+  }
+}
diff --git a/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp b/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp
new file mode 100644
index 0000000..3845af0
--- /dev/null
+++ b/clang/test/CXX/over/over.match/over.match.funcs/p4-0x.cpp
@@ -0,0 +1,70 @@
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
+
+template<typename T> T &lvalue();
+template<typename T> T &&xvalue();
+template<typename T> T prvalue();
+
+struct X0 {
+  int &f() &;
+  float &f() &&;
+
+  template<typename T> int &ft(T) &;
+  template<typename T> float &ft(T) &&;
+
+  typedef int &(*func_int_ref)();
+  typedef float &(*func_float_ref)();
+
+  operator func_int_ref() &;
+  operator func_float_ref() &&;
+
+  void g();
+
+  int &operator+(const X0&) &;
+  float &operator+(const X0&) &&;
+
+  template<typename T> int &operator+(const T&) &;
+  template<typename T> float &operator+(const T&) &&;
+
+  int &h() const&;
+  float &h() &&;
+  int &h2() const&;
+  float &h2() const&&;
+};
+
+void X0::g() {
+  int &ir1 = f();
+  int &ir2 = X0::f();
+}
+
+void test_ref_qualifier_binding() {
+  int &ir1 = lvalue<X0>().f();
+  float &fr1 = xvalue<X0>().f();
+  float &fr2 = prvalue<X0>().f();
+  int &ir2 = lvalue<X0>().ft(1);
+  float &fr3 = xvalue<X0>().ft(2);
+  float &fr4 = prvalue<X0>().ft(3);
+}
+
+void test_ref_qualifier_binding_with_surrogates() {
+  int &ir1 = lvalue<X0>()();
+  float &fr1 = xvalue<X0>()();
+  float &fr2 = prvalue<X0>()();
+}
+
+void test_ref_qualifier_binding_operators() {
+  int &ir1 = lvalue<X0>() + prvalue<X0>();
+  float &fr1 = xvalue<X0>() + prvalue<X0>();
+  float &fr2 = prvalue<X0>() + prvalue<X0>();
+  int &ir2 = lvalue<X0>() + 1;
+  float &fr3 = xvalue<X0>() + 2;
+  float &fr4 = prvalue<X0>() + 3;
+}
+
+void test_ref_qualifier_overloading() {
+  int &ir1 = lvalue<X0>().h();
+  float &fr1 = xvalue<X0>().h();
+  float &fr2 = prvalue<X0>().h();
+  int &ir2 = lvalue<X0>().h2();
+  float &fr3 = xvalue<X0>().h2();
+  float &fr4 = prvalue<X0>().h2();
+}
diff --git a/clang/test/CXX/over/over.oper/over.literal/p2.cpp b/clang/test/CXX/over/over.oper/over.literal/p2.cpp
new file mode 100644
index 0000000..c012104
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p2.cpp
@@ -0,0 +1,35 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+void operator "" _a(const char *);
+
+namespace N {
+  using ::operator "" _a;
+
+  void operator "" _b(const char *);
+}
+
+using N::operator "" _b;
+
+class C {
+  void operator "" _c(const char *); // expected-error {{must be in a namespace or global scope}}
+
+  static void operator "" _c(unsigned long long); // expected-error {{must be in a namespace or global scope}}
+
+  friend void operator "" _d(const char *);
+};
+
+int operator "" _e; // expected-error {{cannot be the name of a variable}}
+
+void f() {
+  int operator "" _f; // expected-error {{cannot be the name of a variable}}
+}
+
+extern "C++" {
+  void operator "" _g(const char *);
+}
+
+template<char...> void operator "" _h() {}
+
+template<> void operator "" _h<'a', 'b', 'c'>() {}
+
+template void operator "" _h<'a', 'b', 'c', 'd'>();
diff --git a/clang/test/CXX/over/over.oper/over.literal/p3.cpp b/clang/test/CXX/over/over.oper/over.literal/p3.cpp
new file mode 100644
index 0000000..674ace9
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p3.cpp
@@ -0,0 +1,40 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+using size_t = decltype(sizeof(int));
+
+// Acceptable parameter declarations
+char operator "" _a(const char *);
+char operator "" _a(const char []);
+char operator "" _a(unsigned long long);
+char operator "" _a(long double);
+char operator "" _a(char);
+char operator "" _a(const volatile char);
+char operator "" _a(wchar_t);
+char operator "" _a(char16_t);
+char operator "" _a(char32_t);
+char operator "" _a(const char *, size_t);
+char operator "" _a(const wchar_t *, size_t);
+char operator "" _a(const char16_t *, size_t);
+char operator "" _a(const char32_t *, size_t);
+char operator "" _a(const char [32], size_t);
+
+// Unacceptable parameter declarations
+char operator "" _b(); // expected-error {{parameter}}
+char operator "" _b(const wchar_t *); // expected-error {{parameter}}
+char operator "" _b(long long); // expected-error {{parameter}}
+char operator "" _b(double); // expected-error {{parameter}}
+char operator "" _b(short); // expected-error {{parameter}}
+char operator "" _a(char, int = 0); // expected-error {{parameter}}
+char operator "" _b(unsigned short); // expected-error {{parameter}}
+char operator "" _b(signed char); // expected-error {{parameter}}
+char operator "" _b(unsigned char); // expected-error {{parameter}}
+char operator "" _b(const short *, size_t); // expected-error {{parameter}}
+char operator "" _b(const unsigned short *, size_t); // expected-error {{parameter}}
+char operator "" _b(const signed char *, size_t); // expected-error {{parameter}}
+char operator "" _b(const unsigned char *, size_t); // expected-error {{parameter}}
+char operator "" _a(const volatile char *, size_t); // expected-error {{parameter}}
+char operator "" _a(volatile wchar_t *, size_t); // expected-error {{parameter}}
+char operator "" _a(char16_t *, size_t); // expected-error {{parameter}}
+char operator "" _a(const char32_t *, size_t, bool = false); // expected-error {{parameter}}
+char operator "" _a(const char *, signed long); // expected-error {{parameter}}
+char operator "" _a(const char *, size_t = 0); // expected-error {{default argument}}
diff --git a/clang/test/CXX/over/over.oper/over.literal/p5.cpp b/clang/test/CXX/over/over.oper/over.literal/p5.cpp
new file mode 100644
index 0000000..66f3f97
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p5.cpp
@@ -0,0 +1,22 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+using size_t = decltype(sizeof(int));
+template<char...> struct S {};
+
+template<char...> void operator "" _a();
+template<char... C> S<C...> operator "" _a();
+
+template<typename T> struct U {
+  friend int operator "" _a(const char *, size_t);
+  // FIXME: It's not entirely clear whether this is intended to be legal.
+  friend U operator "" _a(const T *, size_t); // expected-error {{parameter}}
+};
+template<char...> struct V {
+  friend void operator "" _b(); // expected-error {{parameter}}
+};
+
+template<char... C, int N = 0> void operator "" _b(); // expected-error {{parameter}}
+template<char... C> void operator "" _b(int N = 0); // expected-error {{parameter}}
+template<char, char...> void operator "" _b(); // expected-error {{parameter}}
+template<typename T> T operator "" _b(const char *); // expected-error {{parameter}}
+template<typename T> int operator "" _b(const T *, size_t); // expected-error {{parameter}}
diff --git a/clang/test/CXX/over/over.oper/over.literal/p6.cpp b/clang/test/CXX/over/over.oper/over.literal/p6.cpp
new file mode 100644
index 0000000..6bfb856
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p6.cpp
@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+extern "C" void operator "" _a(const char *); // expected-error {{must have C++ linkage}}
+extern "C" template<char...> void operator "" _b(); // expected-error {{must have C++ linkage}}
+
+extern "C" {
+  void operator "" _c(const char *); // expected-error {{must have C++ linkage}}
+  template<char...> void operator "" _d(); // expected-error {{must have C++ linkage}}
+  namespace N {
+    void operator "" _e(const char *); // expected-error {{must have C++ linkage}}
+    template<char...> void operator "" _f(); // expected-error {{must have C++ linkage}}
+  }
+}
diff --git a/clang/test/CXX/over/over.oper/over.literal/p7.cpp b/clang/test/CXX/over/over.oper/over.literal/p7.cpp
new file mode 100644
index 0000000..72411b9
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p7.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+constexpr int operator "" _a(const char *c) {
+  return c[0];
+}
+
+static_assert(operator "" _a("foo") == 'f', "");
+
+void puts(const char *);
+static inline void operator "" _puts(const char *c) {
+  puts(c);
+}
+void f() {
+  operator "" _puts("foo");
+  operator "" _puts("bar");
+}
diff --git a/clang/test/CXX/over/over.oper/over.literal/p8.cpp b/clang/test/CXX/over/over.oper/over.literal/p8.cpp
new file mode 100644
index 0000000..3f76082
--- /dev/null
+++ b/clang/test/CXX/over/over.oper/over.literal/p8.cpp
@@ -0,0 +1,19 @@
+// RUN: %clang_cc1 -std=c++11 %s -verify
+
+struct string;
+namespace std {
+  using size_t = decltype(sizeof(int));
+}
+
+void operator "" _km(long double); // ok
+string operator "" _i18n(const char*, std::size_t); // ok
+// FIXME: This should be accepted once we support UCNs
+template<char...> int operator "" \u03C0(); // ok, UCN for lowercase pi // expected-error {{expected identifier}}
+float operator ""E(const char *); // expected-error {{C++11 requires a space between literal and identifier}} expected-warning {{reserved}}
+float operator " " B(const char *); // expected-error {{must be '""'}} expected-warning {{reserved}}
+string operator "" 5X(const char *, std::size_t); // expected-error {{expected identifier}}
+double operator "" _miles(double); // expected-error {{parameter}}
+template<char...> int operator "" j(const char*); // expected-error {{parameter}}
+
+// FIXME: Accept this as an extension, with a fix-it to add the space
+float operator ""_E(const char *); // expected-error {{C++11 requires a space between the "" and the user-defined suffix in a literal operator}}
diff --git a/clang/test/CXX/over/over.over/p1.cpp b/clang/test/CXX/over/over.over/p1.cpp
new file mode 100644
index 0000000..10c60da
--- /dev/null
+++ b/clang/test/CXX/over/over.over/p1.cpp
@@ -0,0 +1,94 @@
+// RUN: %clang_cc1 -fsyntax-only %s
+
+template<typename T> T f0(T);
+int f0(int);
+
+// -- an object or reference being initialized 
+struct S {
+  int (*f0)(int);
+  float (*f1)(float);
+};
+
+void test_init_f0() {
+  int (*f0a)(int) = f0;
+  int (*f0b)(int) = &f0;
+  int (*f0c)(int) = (f0);
+  float (*f0d)(float) = f0;
+  float (*f0e)(float) = &f0;
+  float (*f0f)(float) = (f0);
+  int (&f0g)(int) = f0;
+  int (&f0h)(int) = (f0);
+  float (&f0i)(float) = f0;
+  float (&f0j)(float) = (f0);
+  S s = { f0, f0 };
+}
+
+// -- the left side of an assignment (5.17),
+void test_assign_f0() {
+  int (*f0a)(int) = 0;
+  float (*f0b)(float) = 0;
+  
+  f0a = f0;
+  f0a = &f0;
+  f0a = (f0);
+  f0b = f0;
+  f0b = &f0;
+  f0b = (f0);  
+}
+
+// -- a parameter of a function (5.2.2),
+void eat_f0(int a(int), float (*b)(float), int (&c)(int), float (&d)(float));
+
+void test_pass_f0() {
+  eat_f0(f0, f0, f0, f0);
+  eat_f0(&f0, &f0, (f0), (f0));
+}
+
+// -- a parameter of a user-defined operator (13.5),
+struct X { };
+void operator+(X, int(int));
+void operator-(X, float(*)(float));
+void operator*(X, int (&)(int));
+void operator/(X, float (&)(float));
+
+void test_operator_pass_f0(X x) {
+  x + f0;
+  x + &f0;
+  x - f0;
+  x - &f0;
+  x * f0;
+  x * (f0);
+  x / f0;
+  x / (f0);
+}
+
+// -- the return value of a function, operator function, or conversion (6.6.3),
+int (*test_return_f0_a())(int) { return f0; }
+int (*test_return_f0_b())(int) { return &f0; }
+int (*test_return_f0_c())(int) { return (f0); }
+float (*test_return_f0_d())(float) { return f0; }
+float (*test_return_f0_e())(float) { return &f0; }
+float (*test_return_f0_f())(float) { return (f0); }
+
+// -- an explicit type conversion (5.2.3, 5.2.9, 5.4), or
+void test_convert_f0() {
+  (void)((int (*)(int))f0);
+  (void)((int (*)(int))&f0);
+  (void)((int (*)(int))(f0));
+  (void)((float (*)(float))f0);
+  (void)((float (*)(float))&f0);
+  (void)((float (*)(float))(f0));
+}
+
+// -- a non-type template-parameter(14.3.2).
+template<int(int)> struct Y0 { };
+template<float(float)> struct Y1 { };
+template<int (&)(int)> struct Y2 { };
+template<float (&)(float)> struct Y3 { };
+
+Y0<f0> y0;
+Y0<&f0> y0a;
+Y1<f0> y1;
+Y1<&f0> y1a;
+Y2<f0> y2;
+Y3<f0> y3;
diff --git a/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp b/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp
new file mode 100644
index 0000000..e021711
--- /dev/null
+++ b/clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp
@@ -0,0 +1,191 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wno-bool-conversion %s
+
+typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
+
+namespace DontResolveTooEarly_WaitForOverloadResolution
+{
+  template <class T> T* f(int);	// #1 
+  template <class T, class U> T& f(U); // #2 
+  
+  void g() {
+    int *ip = f<int>(1);	// calls #1
+  }
+
+  template <class T> 
+    T* f2(int); 
+  template <class T, class U> 
+    T& f2(U); 
+
+  void g2() {
+    int*ip = (f2<int>)(1); // ok
+  }
+
+} // End namespace
+
+namespace DontAllowUnresolvedOverloadedExpressionInAnUnusedExpression
+{
+  void one() { }
+  template<class T> void oneT() { }
+
+  void two() { } // expected-note 2 {{possible target for call}}
+  void two(int) { } // expected-note 2 {{possible target for call}}
+  template<class T> void twoT() { }  // expected-note 2 {{possible target for call}}
+  template<class T> void twoT(T) { }  // expected-note 2 {{possible target for call}}
+
+  void check()
+  {
+    one; // expected-warning {{expression result unused}}
+    two; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
+    oneT<int>; // expected-warning {{expression result unused}}
+    twoT<int>; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+  }
+
+  // check the template function case
+  template<class T> void check()
+  {
+    one; // expected-warning {{expression result unused}}
+    two; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
+    oneT<int>; // expected-warning {{expression result unused}}
+    twoT<int>; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+ 
+  }
+
+}
+
+  template<typename T>
+    void twoT() { }
+  template<typename T, typename U>
+    void twoT(T) { }
+  
+
+  void two() { }; //expected-note 5{{candidate}}
+  void two(int) { }; //expected-note 5{{candidate}}
+ 
+
+
+  void one() { }
+  template<class T> 
+    void oneT() { }
+
+  template<class T>
+  void cant_resolve() { } //expected-note 3{{candidate}}
+ 
+  template<class T> void cant_resolve(T) { }//expected-note 3{{candidate}}
+ 
+
+int main()
+{
+  
+  { static_cast<void>(one); }
+  { (void)(one); }
+  { static_cast<void>(oneT<int>); }
+  { (void)(oneT<int>); }
+
+  { static_cast<void>(two); } // expected-error {{address of overloaded function 'two' cannot be static_cast to type 'void'}}
+  { (void)(two); } // expected-error {{address of overloaded function 'two' cannot be cast to type 'void'}}
+  { static_cast<void>(twoT<int>); } 
+  { (void)(twoT<int>); } 
+
+
+  { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(oneT<int>); } 
+  { (void) reinterpret_cast<int (*)(char, double)>(oneT<int>); } 
+  { (void) reinterpret_cast<ptrdiff_t>(one); }
+  { (void) reinterpret_cast<int (*)(char, double)>(one); }
+
+  { ptrdiff_t x = reinterpret_cast<ptrdiff_t>(twoT<int>); }  
+  { (void) reinterpret_cast<int (*)(char, double)>(twoT<int>); } 
+  { (void) reinterpret_cast<void (*)(int)>(two); } //expected-error {{reinterpret_cast}}
+  { (void) static_cast<void (*)(int)>(two); } //ok
+
+  { (void) reinterpret_cast<int>(two); } //expected-error {{reinterpret_cast}}
+  { (void) reinterpret_cast<int (*)(char, double)>(two); } //expected-error {{reinterpret_cast}}
+
+  { bool b = (twoT<int>); } 
+  { bool b = (twoT<int, int>); } 
+
+  { bool b = &twoT<int>; //&foo<int>; }
+    b = &(twoT<int>); }
+
+  { ptrdiff_t x = (ptrdiff_t) &twoT<int>;
+      x = (ptrdiff_t) &twoT<int>; }
+
+  { ptrdiff_t x = (ptrdiff_t) twoT<int>;
+      x = (ptrdiff_t) twoT<int>; }
+
+  
+  { ptrdiff_t x = (ptrdiff_t) &twoT<int,int>;
+  x = (ptrdiff_t) &twoT<int>; }
+
+  { oneT<int>;   &oneT<int>; } //expected-warning 2{{expression result unused}}
+  { static_cast<void>(cant_resolve<int>); } // expected-error {{address of overload}}
+  { bool b = cant_resolve<int>; } // expected-error {{address of overload}}
+  { (void) cant_resolve<int>; } // expected-error {{address of overload}}
+
+}
+
+namespace member_pointers {
+  struct S {
+    template <typename T> bool f(T) { return false; }
+    template <typename T> static bool g(T) { return false; }
+
+    template <typename T> bool h(T) { return false; }  // expected-note 3 {{possible target for call}}
+    template <int N> static bool h(int) { return false; } // expected-note 3 {{possible target for call}}
+  };
+
+  void test(S s) {
+    if (S::f<char>) return; // expected-error {{call to non-static member function without an object argument}}
+    if (S::f<int>) return; // expected-error {{call to non-static member function without an object argument}}
+    if (&S::f<char>) return;
+    if (&S::f<int>) return;
+    if (s.f<char>) return; // expected-error {{reference to non-static member function must be called}}
+    if (s.f<int>) return; // expected-error {{reference to non-static member function must be called}}
+    if (&s.f<char>) return; // expected-error {{cannot create a non-constant pointer to member function}}
+    if (&s.f<int>) return; // expected-error {{cannot create a non-constant pointer to member function}}
+
+    if (S::g<char>) return;
+    if (S::g<int>) return;
+    if (&S::g<char>) return;
+    if (&S::g<int>) return;
+    if (s.g<char>) return;
+    if (s.g<int>) return;
+    if (&s.g<char>) return;
+    if (&s.g<int>) return;
+
+    if (S::h<42>) return;
+    if (S::h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+    if (&S::h<42>) return;
+    if (&S::h<int>) return;
+    if (s.h<42>) return;
+    if (s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+    if (&s.h<42>) return;
+    if (&s.h<int>) return; // expected-error {{reference to overloaded function could not be resolved; did you mean to call it?}}
+
+    { bool b = S::f<char>; } // expected-error {{call to non-static member function without an object argument}}
+    { bool b = S::f<int>; } // expected-error {{call to non-static member function without an object argument}}
+    { bool b = &S::f<char>; }
+    { bool b = &S::f<int>; }
+    // These next two errors are terrible.
+    { bool b = s.f<char>; } // expected-error {{reference to non-static member function must be called}}
+    { bool b = s.f<int>; } // expected-error {{reference to non-static member function must be called}}
+    { bool b = &s.f<char>; } // expected-error {{cannot create a non-constant pointer to member function}}
+    { bool b = &s.f<int>; } // expected-error {{cannot create a non-constant pointer to member function}}
+
+    { bool b = S::g<char>; }
+    { bool b = S::g<int>; }
+    { bool b = &S::g<char>; }
+    { bool b = &S::g<int>; }
+    { bool b = s.g<char>; }
+    { bool b = s.g<int>; }
+    { bool b = &s.g<char>; }
+    { bool b = &s.g<int>; }
+
+    { bool b = S::h<42>; }
+    { bool b = S::h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
+    { bool b = &S::h<42>; }
+    { bool b = &S::h<int>; }
+    { bool b = s.h<42>; }
+    { bool b = s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
+    { bool b = &s.h<42>; }
+    { bool b = &s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}}
+  }
+}
diff --git a/clang/test/CXX/over/over.over/p2.cpp b/clang/test/CXX/over/over.over/p2.cpp
new file mode 100644
index 0000000..3e8d0f1
--- /dev/null
+++ b/clang/test/CXX/over/over.over/p2.cpp
@@ -0,0 +1,9 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> T f0(T, T); //expected-note{{candidate}}
+
+void test_f0() {
+  int (*f0a)(int, int) = f0;
+  int (*f0b)(int, int) = &f0;
+  int (*f0c)(int, float) = f0; // expected-error{{address of overloaded function 'f0' does not match required type 'int (int, float)'}}
+}
diff --git a/clang/test/CXX/over/over.over/p4.cpp b/clang/test/CXX/over/over.over/p4.cpp
new file mode 100644
index 0000000..27d070e
--- /dev/null
+++ b/clang/test/CXX/over/over.over/p4.cpp
@@ -0,0 +1,20 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+template<typename T> T f0(T); // expected-note{{candidate function}}
+int f0(int); // expected-note{{candidate function}}
+
+void test_f0() {
+  int (*fp0)(int) = f0;
+  int (*fp1)(int) = &f0;
+  float (*fp2)(float) = &f0;
+}
+
+namespace N {
+  int f0(int); // expected-note{{candidate function}}
+}
+
+void test_f0_2() {
+  using namespace N;
+  int (*fp0)(int) = f0; // expected-error{{address of overloaded function 'f0' is ambiguous}}
+  float (*fp1)(float) = f0;
+}
-- 
cgit v1.2.3