17 files changed, 551 insertions, 9 deletions
diff --git a/test/CXX/expr/expr.cast/p4-0x.cpp b/test/CXX/expr/expr.cast/p4-0x.cpp
new file mode 100644
index 0000000..5824cd2
--- /dev/null
+++ b/test/CXX/expr/expr.cast/p4-0x.cpp
@@ -0,0 +1,11 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+struct X { };
+struct Y : X { };
+
+void test_lvalue_to_rvalue_drop_cvquals(const X &x, const Y &y, const int &i) {
+  (void)(X&&)x;
+  (void)(int&&)i;
+  (void)(X&&)y;
+  (void)(Y&&)x;
+}
diff --git a/test/CXX/expr/expr.cast/p4.cpp b/test/CXX/expr/expr.cast/p4.cpp
new file mode 100644
index 0000000..907e008
--- /dev/null
+++ b/test/CXX/expr/expr.cast/p4.cpp
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -ast-dump %s | FileCheck %s
+
+struct A { int x; };
+struct B { int y; };
+struct C : A, B { };
+
+// CHECK: casting_away_constness
+void casting_away_constness(const B &b, const C &c, const B *bp, const C *cp) {
+  // CHECK: DerivedToBase (B)
+  // CHECK: DeclRefExpr {{.*}} ParmVar {{.*}} 'c'
+  (void)(B&)c;
+  // CHECK: BaseToDerived (B)
+  // CHECK: DeclRefExpr {{.*}} ParmVar {{.*}} 'b'
+  (void)(C&)b;
+  // CHECK: DerivedToBase (B)
+  // CHECK: DeclRefExpr {{.*}} ParmVar {{.*}} 'cp'
+  (void)(B*)cp;
+  // CHECK: BaseToDerived (B)
+  // CHECK: DeclRefExpr {{.*}} ParmVar {{.*}} 'bp'
+  (void)(C*)bp;
+  // CHECK: ReturnStmt
+  return;
+}
diff --git a/test/CXX/expr/expr.mptr.oper/p5.cpp b/test/CXX/expr/expr.mptr.oper/p5.cpp
new file mode 100644
index 0000000..7380b5d
--- /dev/null
+++ b/test/CXX/expr/expr.mptr.oper/p5.cpp
@@ -0,0 +1,61 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+struct X0 {
+  void f0();
+  void f1() const;
+  void f2() volatile;
+  void f3() const volatile;
+};
+
+void test_object_cvquals(void (X0::*pm)(),
+                         void (X0::*pmc)() const,
+                         void (X0::*pmv)() volatile,
+                         void (X0::*pmcv)() const volatile,
+                         X0 *p,
+                         const X0 *pc,
+                         volatile X0 *pv,
+                         const volatile X0 *pcv,
+                         X0 &o,
+                         const X0 &oc,
+                         volatile X0 &ov,
+                         const volatile X0 &ocv) {
+  (p->*pm)();
+  (p->*pmc)();
+  (p->*pmv)();
+  (p->*pmcv)();
+
+  (pc->*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'const' qualifier}}
+  (pc->*pmc)();
+  (pc->*pmv)(); // expected-error{{call to pointer to member function of type 'void () volatile' drops 'const' qualifier}}
+  (pc->*pmcv)();
+
+  (pv->*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'volatile' qualifier}}
+  (pv->*pmc)(); // expected-error{{call to pointer to member function of type 'void () const' drops 'volatile' qualifier}}
+  (pv->*pmv)();
+  (pv->*pmcv)();
+
+  (pcv->*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'const volatile' qualifiers}}
+  (pcv->*pmc)(); // expected-error{{call to pointer to member function of type 'void () const' drops 'volatile' qualifier}}
+  (pcv->*pmv)(); // expected-error{{call to pointer to member function of type 'void () volatile' drops 'const' qualifier}}
+  (pcv->*pmcv)();
+
+  (o.*pm)();
+  (o.*pmc)();
+  (o.*pmv)();
+  (o.*pmcv)();
+
+  (oc.*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'const' qualifier}}
+  (oc.*pmc)();
+  (oc.*pmv)(); // expected-error{{call to pointer to member function of type 'void () volatile' drops 'const' qualifier}}
+  (oc.*pmcv)();
+
+  (ov.*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'volatile' qualifier}}
+  (ov.*pmc)(); // expected-error{{call to pointer to member function of type 'void () const' drops 'volatile' qualifier}}
+  (ov.*pmv)();
+  (ov.*pmcv)();
+
+  (ocv.*pm)(); // expected-error{{call to pointer to member function of type 'void ()' drops 'const volatile' qualifiers}}
+  (ocv.*pmc)(); // expected-error{{call to pointer to member function of type 'void () const' drops 'volatile' qualifier}}
+  (ocv.*pmv)(); // expected-error{{call to pointer to member function of type 'void () volatile' drops 'const' qualifier}}
+  (ocv.*pmcv)();
+}
diff --git a/test/CXX/expr/expr.mptr.oper/p6-0x.cpp b/test/CXX/expr/expr.mptr.oper/p6-0x.cpp
new file mode 100644
index 0000000..d5dc7d2
--- /dev/null
+++ b/test/CXX/expr/expr.mptr.oper/p6-0x.cpp
@@ -0,0 +1,34 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+struct X { };
+
+template<typename T> T& lvalue();
+template<typename T> T&& xvalue();
+template<typename T> T prvalue();
+
+// In a .* expression whose object expression is an rvalue, the
+// program is ill-formed if the second operand is a pointer to member
+// function with ref-qualifier &. In a ->* expression or in a .*
+// expression whose object expression is an lvalue, the program is
+// ill-formed if the second operand is a pointer to member function
+// with ref-qualifier &&.
+void test(X *xp, int (X::*pmf)(int), int (X::*l_pmf)(int) &, 
+          int (X::*r_pmf)(int) &&) {
+  // No ref-qualifier.
+  (lvalue<X>().*pmf)(17);
+  (xvalue<X>().*pmf)(17);
+  (prvalue<X>().*pmf)(17);
+  (xp->*pmf)(17);
+
+  // Lvalue ref-qualifier.
+  (lvalue<X>().*l_pmf)(17);
+  (xvalue<X>().*l_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int) &' can only be called on an lvalue}}
+  (prvalue<X>().*l_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int) &' can only be called on an lvalue}}
+  (xp->*l_pmf)(17);
+
+  // Rvalue ref-qualifier.
+  (lvalue<X>().*r_pmf)(17); // expected-error{{pointer-to-member function type 'int (X::*)(int) &&' can only be called on an rvalue}}
+  (xvalue<X>().*r_pmf)(17);
+  (prvalue<X>().*r_pmf)(17);
+  (xp->*r_pmf)(17);  // expected-error{{pointer-to-member function type 'int (X::*)(int) &&' can only be called on an rvalue}}
+}
diff --git a/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp b/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp
new file mode 100644
index 0000000..d464881
--- /dev/null
+++ b/test/CXX/expr/expr.post/expr.const.cast/p1-0x.cpp
@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+// The result of the expression const_cast<T>(v) is of type T. If T is
+// an lvalue reference to object type, the result is an lvalue; if T
+// is an rvalue reference to object type, the result is an xvalue;.
+
+unsigned int f(int);
+
+template<typename T> T& lvalue();
+template<typename T> T&& xvalue();
+template<typename T> T prvalue();
+
+void test_classification(const int *ptr) {
+  int *ptr0 = const_cast<int *&&>(ptr);
+  int *ptr1 = const_cast<int *&&>(xvalue<const int*>());
+  int *ptr2 = const_cast<int *&&>(prvalue<const int*>());
+}
diff --git a/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp b/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp
new file mode 100644
index 0000000..3b448a8
--- /dev/null
+++ b/test/CXX/expr/expr.post/expr.dynamic.cast/p3-0x.cpp
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+struct X { virtual ~X(); };
+struct Y : public X { };
+struct Z; // expected-note{{forward declaration of 'Z'}}
+
+void test(X &x, Y &y, Z &z) {
+  // If T is an rvalue reference type, v shall be an expression having
+  // a complete class type, and the result is an xvalue of the type
+  // referred to by T.
+  Y &&yr0 = dynamic_cast<Y&&>(x);
+  Y &&yr1 = dynamic_cast<Y&&>(static_cast<X&&>(x));
+  Y &&yr2 = dynamic_cast<Y&&>(z); // expected-error{{'Z' is an incomplete type}}
+}
diff --git a/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp b/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp
new file mode 100644
index 0000000..e80082a
--- /dev/null
+++ b/test/CXX/expr/expr.post/expr.reinterpret.cast/p1-0x.cpp
@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+// If T is an lvalue reference type or an rvalue reference to function
+// type, the result is an lvalue; if T is an rvalue reference to
+// object type, the result is an xvalue;
+
+unsigned int f(int);
+
+template<typename T> T&& xvalue();
+void test_classification(char *ptr) {
+  int (&fr0)(int) = reinterpret_cast<int (&&)(int)>(f);
+  int &&ir0 = reinterpret_cast<int &&>(*ptr);
+  int &&ir1 = reinterpret_cast<int &&>(0);
+  int &&ir2 = reinterpret_cast<int &&>('a');
+  int &&ir3 = reinterpret_cast<int &&>(xvalue<char>());
+}
diff --git a/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp b/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp
new file mode 100644
index 0000000..c103351
--- /dev/null
+++ b/test/CXX/expr/expr.post/expr.static.cast/p3-0x.cpp
@@ -0,0 +1,24 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+// A glvalue of type "cv1 T1" can be cast to type "rvalue reference to
+// cv2 T2" if "cv2 T2" is reference-compatible with "cv1 T1" (8.5.3).
+struct A { };
+struct B : A { };
+
+template<typename T> T& lvalue();
+template<typename T> T&& xvalue();
+
+void test(A &a, B &b) {
+  A &&ar0 = static_cast<A&&>(a);
+  A &&ar1 = static_cast<A&&>(b);
+  A &&ar2 = static_cast<A&&>(lvalue<A>());
+  A &&ar3 = static_cast<A&&>(lvalue<B>());
+  A &&ar4 = static_cast<A&&>(xvalue<A>());
+  A &&ar5 = static_cast<A&&>(xvalue<B>());
+  const A &&ar6 = static_cast<const A&&>(a);
+  const A &&ar7 = static_cast<const A&&>(b);
+  const A &&ar8 = static_cast<const A&&>(lvalue<A>());
+  const A &&ar9 = static_cast<const A&&>(lvalue<B>());
+  const A &&ar10 = static_cast<const A&&>(xvalue<A>());
+  const A &&ar11 = static_cast<const A&&>(xvalue<B>());
+}
diff --git a/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp b/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp
new file mode 100644
index 0000000..4acafb8
--- /dev/null
+++ b/test/CXX/expr/expr.post/expr.static.cast/p9-0x.cpp
@@ -0,0 +1,29 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+enum class EC { ec1 };
+
+void test0(EC ec) {
+  (void)static_cast<bool>(ec);
+  (void)static_cast<bool>(EC::ec1);
+  (void)static_cast<char>(ec);
+  (void)static_cast<char>(EC::ec1);
+  (void)static_cast<int>(ec);
+  (void)static_cast<int>(EC::ec1);
+  (void)static_cast<unsigned long>(ec);
+  (void)static_cast<unsigned long>(EC::ec1);
+  (void)static_cast<float>(ec);
+  (void)static_cast<float>(EC::ec1);
+  (void)static_cast<double>(ec);
+  (void)static_cast<double>(EC::ec1);
+}
+
+namespace PR9107 {
+  enum E {};
+  template <class _Tp> inline _Tp* addressof(_Tp& __x) {
+    return (_Tp*)&(char&)__x;
+  }
+  void test() {
+    E a;
+    addressof(a);
+  }
+}
diff --git a/test/CXX/expr/expr.unary/expr.delete/p5.cpp b/test/CXX/expr/expr.unary/expr.delete/p5.cpp
index 2fa30e5..ecb2918 100644
--- a/test/CXX/expr/expr.unary/expr.delete/p5.cpp
+++ b/test/CXX/expr/expr.unary/expr.delete/p5.cpp
@@ -24,11 +24,23 @@ void f0(T2_A *a) { T2_C x; x.f0(a); }
 class T2_A { };
 
 // An alternate version of the same.
-//
-// FIXME: Revisit this case when we have access control.
 class T3_A;
 template<typename T>
-struct T3_B { void f0(T *a) { delete a; } };
-struct T3_C { T3_B<T3_A> x; void f0(T3_A *a) { x.f0(a); } };
+struct T3_B { 
+  void f0(T *a) { 
+    delete a; // expected-error{{calling a private destructor of class 'T3_A'}}
+  } 
+};
+
+struct T3_C { 
+  T3_B<T3_A> x; 
+  void f0(T3_A *a) { 
+    x.f0(a); // expected-note{{in instantiation of member function 'T3_B<T3_A>::f0' requested here}}
+  } 
+};
+
 void f0(T3_A *a) { T3_C x; x.f0(a); }
-class T3_A { private: ~T3_A(); };
+class T3_A { 
+private: 
+  ~T3_A(); // expected-note{{declared private here}}
+};
diff --git a/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp b/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp
new file mode 100644
index 0000000..c9a8887
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp
@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++0x
+
+template<typename T>
+struct only {
+  only(T);
+  template<typename U> only(U) = delete;
+};
+
+void f() {
+  only<const int*> p = new const auto (0);
+  only<double*> q = new (auto) (0.0);
+
+  new auto; // expected-error{{new expression for type 'auto' requires a constructor argument}}
+  new (const auto)(); // expected-error{{new expression for type 'auto const' requires a constructor argument}}
+  new (auto) (1,2,3); // expected-error{{new expression for type 'auto' contains multiple constructor arguments}}
+}
+
+void p2example() {
+  only<int*> r = new auto(1);
+  auto x = new auto('a');
+
+  only<char*> testX = x;
+}
diff --git a/test/CXX/expr/expr.unary/expr.sizeof/p5-0x.cpp b/test/CXX/expr/expr.unary/expr.sizeof/p5-0x.cpp
new file mode 100644
index 0000000..3824615
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.sizeof/p5-0x.cpp
@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+// Test parsing + semantic analysis
+template<typename ...Types> struct count_types {
+  static const unsigned value = sizeof...(Types);
+};
+
+template<int ...Values> struct count_ints {
+  static const unsigned value = sizeof...(Values);
+};
+
+// Test instantiation
+int check_types[count_types<short, int, long>::value == 3? 1 : -1];
+int check_ints[count_ints<1, 2, 3, 4, 5>::value == 5? 1 : -1];
+
+// Test instantiation involving function parameter packs.
+struct any {
+  template<typename T> any(T);
+};
+
+template<typename ...Inits>
+void init_me(Inits ...inits) {
+  any array[sizeof...(inits)] = { inits... };
+}
+
+template void init_me<int, float, double*>(int, float, double*);
+
+// Test parser and semantic recovery.
+template<int Value> struct count_ints_2 {
+  static const unsigned value = sizeof...(Value); // expected-error{{'Value' does not refer to the name of a parameter pack}}
+};
+
+template<typename ...Types> // expected-note{{parameter pack 'Types' declared here}}
+struct count_types_2 {
+  static const unsigned value = sizeof... Type; // expected-error{{missing parentheses around the size of parameter pack 'Type'}} \
+  // expected-error{{Type' does not refer to the name of a parameter pack; did you mean 'Types'?}}
+};
+
diff --git a/test/CXX/expr/expr.unary/expr.unary.noexcept/cg.cpp b/test/CXX/expr/expr.unary/expr.unary.noexcept/cg.cpp
new file mode 100644
index 0000000..6aec3a2
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.unary.noexcept/cg.cpp
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -fexceptions -triple x86_64-apple-darwin10 -S -emit-llvm -std=c++0x -include %S/ser.h %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fexceptions -triple x86_64-apple-darwin10 -emit-pch -o %t-ser.pch -std=c++0x -x c++ %S/ser.h
+// RUN: %clang_cc1 -fexceptions -triple x86_64-apple-darwin10 -S -emit-llvm -std=c++0x -include-pch %t-ser.pch %s -o - | FileCheck %s
+
+struct D {
+  ~D() throw();
+};
+struct E {
+  ~E() throw();
+};
+
+void test() {
+  bool b;
+  // CHECK: store i8 1
+  b = noexcept(0);
+  // CHECK: store i8 0
+  b = noexcept(throw 0);
+  b = f1();
+  b = f2();
+
+  // CHECK-NOT: call void @_ZN1ED1Ev
+  // CHECK: call void @_ZN1DD1Ev
+  D(), noexcept(E());
+}
+// CHECK: ret i1 true
+// CHECK: ret i1 false
diff --git a/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp b/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp
new file mode 100644
index 0000000..98c6f4e
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.unary.noexcept/sema.cpp
@@ -0,0 +1,172 @@
+// RUN: %clang_cc1 -fexceptions -fsyntax-only -verify -std=c++0x -fms-extensions %s
+
+#define P(e) static_assert(noexcept(e), "expected nothrow")
+#define N(e) static_assert(!noexcept(e), "expected throw")
+#define B(b, e) static_assert(b == noexcept(e), "expectation failed")
+
+void simple() {
+  P(0);
+  P(0 + 0);
+  int i;
+  P(i);
+  P(sizeof(0));
+  P(static_cast<int>(0));
+  N(throw 0);
+  N((throw 0, 0));
+}
+
+void nospec();
+void allspec() throw(...);
+void intspec() throw(int);
+void emptyspec() throw();
+void nothrowattr() __attribute__((nothrow));
+
+void call() {
+  N(nospec());
+  N(allspec());
+  N(intspec());
+  P(emptyspec());
+  P(nothrowattr());
+}
+
+void (*pnospec)();
+void (*pallspec)() throw(...);
+void (*pintspec)() throw(int);
+void (*pemptyspec)() throw();
+
+void callptr() {
+  N(pnospec());
+  N((*pnospec)());
+  N(pallspec());
+  N((*pallspec)());
+  N(pintspec());
+  N((*pintspec)());
+  P(pemptyspec());
+  P((*pemptyspec)());
+}
+
+struct S1 {
+  void nospec();
+  void allspec() throw(...);
+  void intspec() throw(int);
+  void emptyspec() throw();
+};
+
+void callmem() {
+  S1 s;
+  N(s.nospec());
+  N(s.allspec());
+  N(s.intspec());
+  P(s.emptyspec());
+}
+
+void (S1::*mpnospec)();
+void (S1::*mpallspec)() throw(...);
+void (S1::*mpintspec)() throw(int);
+void (S1::*mpemptyspec)() throw();
+
+void callmemptr() {
+  S1 s;
+  N((s.*mpnospec)());
+  N((s.*mpallspec)());
+  N((s.*mpintspec)());
+  P((s.*mpemptyspec)());
+}
+
+struct S2 {
+  S2();
+  S2(int, int) throw();
+  void operator +();
+  void operator -() throw();
+  void operator +(int);
+  void operator -(int) throw();
+  operator int();
+  operator float() throw();
+};
+
+void *operator new(__typeof__(sizeof(int)) sz, int) throw();
+
+struct Bad1 {
+  ~Bad1() throw(int);
+};
+struct Bad2 {
+  void operator delete(void*) throw(int);
+};
+
+void implicits() {
+  N(new int);
+  P(new (0) int);
+  P(delete (int*)0);
+  N(delete (Bad1*)0);
+  N(delete (Bad2*)0);
+  N(S2());
+  P(S2(0, 0));
+  S2 s;
+  N(+s);
+  P(-s);
+  N(s + 0);
+  P(s - 0);
+  N(static_cast<int>(s));
+  P(static_cast<float>(s));
+  N(Bad1());
+}
+
+struct V {
+  virtual ~V() throw();
+};
+struct D : V {};
+
+void dyncast() {
+  V *pv = 0;
+  D *pd = 0;
+  P(dynamic_cast<V&>(*pd));
+  P(dynamic_cast<V*>(pd));
+  N(dynamic_cast<D&>(*pv));
+  P(dynamic_cast<D*>(pv));
+}
+
+namespace std {
+  struct type_info {};
+}
+
+void idtype() {
+  P(typeid(V));
+  P(typeid((V*)0));
+  P(typeid(*(S1*)0));
+  N(typeid(*(V*)0));
+}
+
+void uneval() {
+  P(sizeof(typeid(*(V*)0)));
+  P(typeid(typeid(*(V*)0)));
+}
+
+struct G1 {};
+struct G2 { int i; };
+struct G3 { S2 s; };
+
+void gencon() {
+  P(G1());
+  P(G2());
+  N(G3());
+}
+
+template <typename T, bool b>
+void late() {
+  B(b, typeid(*(T*)0));
+  B(b, T(1));
+  B(b, static_cast<T>(S2(0, 0)));
+  B(b, S1() + T());
+}
+struct S3 {
+  virtual ~S3() throw();
+  S3() throw();
+  explicit S3(int);
+  S3(const S2&);
+};
+void operator +(const S1&, float) throw();
+void operator +(const S1&, const S3&);
+void tlate() {
+  late<float, true>();
+  late<S3, false>();
+}
diff --git a/test/CXX/expr/expr.unary/expr.unary.noexcept/ser.h b/test/CXX/expr/expr.unary/expr.unary.noexcept/ser.h
new file mode 100644
index 0000000..e6e7b79
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.unary.noexcept/ser.h
@@ -0,0 +1,8 @@
+// Serialization testing helper for noexcept, included by cg.cpp.
+
+inline bool f1() {
+  return noexcept(0);
+}
+inline bool f2() {
+  return noexcept(throw 0);
+}
diff --git a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
index 170c734..06cc610 100644
--- a/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
+++ b/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
@@ -7,8 +7,7 @@ namespace test0 {
     template<typename T> void g(T);
 
     void test() {
-      // FIXME: this diagnostic is terrible
-      foo(&g<int>); // expected-error {{cannot initialize a parameter of type 'void (test0::A::*)(int)' with an rvalue of type '<overloaded function type>'}}
+      foo(&g<int>); // expected-error {{can't form member pointer of type 'void (test0::A::*)(int)' without '&' and class name}}
     }
   };
 }
@@ -39,7 +38,6 @@ namespace test2 {
   };
 
   void A::test() {
-    // FIXME: This diagnostic is terrible.
-    int (A::*ptr)(int) = &(A::foo); // expected-error {{cannot initialize a variable of type 'int (test2::A::*)(int)' with an rvalue of type '<overloaded function type>'}}
+    int (A::*ptr)(int) = &(A::foo); // expected-error {{can't form member pointer of type 'int (test2::A::*)(int)' without '&' and class name}}
   }
 }
diff --git a/test/CXX/expr/expr.unary/expr.unary.op/p6.cpp b/test/CXX/expr/expr.unary/expr.unary.op/p6.cpp
new file mode 100644
index 0000000..543a86d
--- /dev/null
+++ b/test/CXX/expr/expr.unary/expr.unary.op/p6.cpp
@@ -0,0 +1,36 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// -- prvalue of arithmetic
+
+bool b = !0;
+
+bool b2 = !1.2;
+
+bool b3 = !4;
+
+// -- unscoped enumeration
+enum { E, F };
+
+bool b4 = !E;
+bool b5 = !F;
+
+// --  pointer, 
+bool b6 = !&b4;
+void f();
+bool b61 = !&f;
+
+// -- or pointer to member type can be converted to a prvalue of type bool.
+struct S { void f() { } };
+
+bool b7 = !&S::f;
+
+
+bool b8 = !S(); //expected-error {{invalid argument type 'S'}}
+
+namespace PR8181
+{
+  void f() { }
+  void f(char) { }
+  bool b = !&f;  //expected-error {{cannot resolve overloaded function from context}}
+
+}