vendor/clang/clang-release_40-r292732

16 files changed, 132 insertions, 69 deletions

diff --git a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
index 74db2b80e70e..0c58da01be59 100644
--- a/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
+++ b/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p15.cpp
@@ -1,16 +1,16 @@
 // RUN: %clang_cc1 -std=c++11 -verify %s
 
-struct B1 { // expected-note 2{{candidate}}
+struct B1 {
   B1(int); // expected-note {{candidate}}
 };
 
-struct B2 { // expected-note 2{{candidate}}
+struct B2 {
   B2(int); // expected-note {{candidate}}
 };
 
 struct D1 : B1, B2 { // expected-note 2{{candidate}}
-  using B1::B1; // expected-note 3{{inherited here}}
-  using B2::B2; // expected-note 3{{inherited here}}
+  using B1::B1; // expected-note {{inherited here}}
+  using B2::B2; // expected-note {{inherited here}}
 };
 D1 d1(0); // expected-error {{ambiguous}}
 
@@ -35,7 +35,7 @@ namespace default_ctor {
     operator D&&();
   };
 
-  struct A { // expected-note 4{{candidate}}
+  struct A { // expected-note 2{{candidate}}
     A(); // expected-note {{candidate}}
 
     A(C &&); // expected-note {{candidate}}
@@ -47,7 +47,7 @@ namespace default_ctor {
     A(convert_to_D2); // expected-note {{candidate}}
   };
 
-  struct B { // expected-note 4{{candidate}}
+  struct B { // expected-note 2{{candidate}}
     B(); // expected-note {{candidate}}
 
     B(C &&); // expected-note {{candidate}}
@@ -66,9 +66,9 @@ namespace default_ctor {
     using B::operator=;
   };
   struct D : A, B {
-    using A::A; // expected-note 5{{inherited here}}
+    using A::A; // expected-note 3{{inherited here}}
     using A::operator=;
-    using B::B; // expected-note 5{{inherited here}}
+    using B::B; // expected-note 3{{inherited here}}
     using B::operator=;
 
     D(int);
@@ -93,13 +93,13 @@ namespace default_ctor {
   }
 
   struct Y;
-  struct X { // expected-note 2{{candidate}}
+  struct X {
     X();
-    X(volatile Y &); // expected-note {{constructor inherited from base class cannot be used to initialize from an argument of the derived class type}}
+    X(volatile Y &); // expected-note 3{{inherited constructor cannot be used to copy object}}
   } x;
-  struct Y : X { using X::X; } volatile y; // expected-note 2{{candidate}}
-  struct Z : Y { using Y::Y; } volatile z; // expected-note 3{{candidate}} expected-note 5{{inherited here}}
-  Z z1(x); // ok
-  Z z2(y); // ok, Z is not reference-related to type of y
+  struct Y : X { using X::X; } volatile y;
+  struct Z : Y { using Y::Y; } volatile z; // expected-note 4{{no known conversion}} expected-note 2{{would lose volatile}} expected-note 3{{requires 0}} expected-note 3{{inherited here}}
+  Z z1(x); // expected-error {{no match}}
+  Z z2(y); // expected-error {{no match}}
   Z z3(z); // expected-error {{no match}}
 }
diff --git a/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp b/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp
index 7a92e7a13d95..f4f73a5af8ce 100644
--- a/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp
+++ b/test/CXX/dcl.decl/dcl.init/dcl.init.aggr/p1.cpp
@@ -134,13 +134,13 @@ ExplicitDefaultedAggr eda2{};
 
 struct DefaultedBase {
   int n;
-  DefaultedBase() = default; // expected-note 0+ {{candidate}}
-  DefaultedBase(DefaultedBase const&) = default; // expected-note 0+ {{candidate}}
-  DefaultedBase(DefaultedBase &&) = default; // expected-note 0+ {{candidate}}
+  DefaultedBase() = default;
+  DefaultedBase(DefaultedBase const&) = default;
+  DefaultedBase(DefaultedBase &&) = default;
 };
 
 struct InheritingConstructors : DefaultedBase { // expected-note 3 {{candidate}}
-  using DefaultedBase::DefaultedBase; // expected-note 2 {{inherited here}}
+  using DefaultedBase::DefaultedBase;
 };
 InheritingConstructors ic = { 42 }; // expected-error {{no matching constructor}}
 
diff --git a/test/CXX/drs/dr16xx.cpp b/test/CXX/drs/dr16xx.cpp
index c0b7c29e5dd1..c9f084db73a1 100644
--- a/test/CXX/drs/dr16xx.cpp
+++ b/test/CXX/drs/dr16xx.cpp
@@ -71,14 +71,14 @@ namespace dr1638 { // dr1638: yes
 
 namespace dr1645 { // dr1645: 3.9
 #if __cplusplus >= 201103L
-  struct A { // expected-note 2{{candidate}}
+  struct A {
     constexpr A(int, float = 0); // expected-note 2{{candidate}}
     explicit A(int, int = 0); // expected-note 2{{candidate}}
     A(int, int, int = 0) = delete; // expected-note {{candidate}}
   };
 
   struct B : A { // expected-note 2{{candidate}}
-    using A::A; // expected-note 7{{inherited here}}
+    using A::A; // expected-note 5{{inherited here}}
   };
 
   constexpr B a(0); // expected-error {{ambiguous}}
diff --git a/test/CXX/drs/dr19xx.cpp b/test/CXX/drs/dr19xx.cpp
index 15ed30583fd0..e6cf337da0ba 100644
--- a/test/CXX/drs/dr19xx.cpp
+++ b/test/CXX/drs/dr19xx.cpp
@@ -138,18 +138,21 @@ namespace dr1959 { // dr1959: 3.9
   struct c;
   struct a {
     a() = default;
-    a(const a &) = delete; // expected-note 2{{deleted}}
+    a(const a &) = delete; // expected-note {{deleted}}
     a(const b &) = delete; // not inherited
-    a(c &&) = delete;
-    template<typename T> a(T) = delete;
+    a(c &&) = delete; // expected-note {{not viable}}
+    template<typename T> a(T) = delete; // expected-note {{would take its own class type by value}}
   };
 
-  struct b : a { // expected-note {{copy constructor of 'b' is implicitly deleted because base class 'dr1959::a' has a deleted copy constructor}}
-    using a::a;
+  struct b : a { // expected-note {{cannot bind}} expected-note {{deleted because}}
+    using a::a; // expected-note 2{{inherited here}}
   };
 
   a x;
-  b y = x; // expected-error {{deleted}}
+  // FIXME: As a resolution to an open DR against P0136R0, we disallow
+  // use of inherited constructors to construct from a single argument
+  // where the base class is reference-related to the argument type.
+  b y = x; // expected-error {{no viable conversion}}
   b z = z; // expected-error {{deleted}}
 
   struct c : a {
@@ -158,7 +161,7 @@ namespace dr1959 { // dr1959: 3.9
   };
   // FIXME: As a resolution to an open DR against P0136R0, we disallow
   // use of inherited constructors to construct from a single argument
-  // where the derived class is reference-related to its type.
+  // where the base class is reference-related to the argument type.
   c q(static_cast<c&&>(q));
 #endif
 }
diff --git a/test/CXX/special/class.inhctor/p1.cpp b/test/CXX/special/class.inhctor/p1.cpp
index c006abe3506f..45f6049b4598 100644
--- a/test/CXX/special/class.inhctor/p1.cpp
+++ b/test/CXX/special/class.inhctor/p1.cpp
@@ -3,7 +3,7 @@
 // Note: [class.inhctor] was removed by P0136R1. This tests the new behavior
 // for the wording that used to be there.
 
-struct A { // expected-note 8{{candidate is the implicit}}
+struct A { // expected-note 4{{candidate is the implicit}}
   A(...); // expected-note 4{{candidate constructor}} expected-note 4{{candidate inherited constructor}}
   A(int = 0, int = 0, int = 0, int = 0, ...); // expected-note 3{{candidate constructor}} expected-note 3{{candidate inherited constructor}}
   A(int = 0, int = 0, ...); // expected-note 3{{candidate constructor}} expected-note 3{{candidate inherited constructor}}
@@ -15,7 +15,7 @@ struct A { // expected-note 8{{candidate is the implicit}}
 };
 
 struct B : A { // expected-note 4{{candidate is the implicit}}
-  using A::A; // expected-note 19{{inherited here}}
+  using A::A; // expected-note 15{{inherited here}}
   B(void*);
 };
 
diff --git a/test/CXX/special/class.inhctor/p3.cpp b/test/CXX/special/class.inhctor/p3.cpp
index 7f054874e075..19f15ebe0f0b 100644
--- a/test/CXX/special/class.inhctor/p3.cpp
+++ b/test/CXX/special/class.inhctor/p3.cpp
@@ -14,21 +14,21 @@ D1 d1a(1), d1b(1, 1);
 
 D1 fd1() { return 1; }
 
-struct B2 { // expected-note 2{{candidate}}
+struct B2 {
   explicit B2(int, int = 0, int = 0);
 };
 struct D2 : B2 { // expected-note 2{{candidate constructor}}
-  using B2::B2; // expected-note 2{{inherited here}}
+  using B2::B2;
 };
 D2 d2a(1), d2b(1, 1), d2c(1, 1, 1);
 
 D2 fd2() { return 1; } // expected-error {{no viable conversion}}
 
-struct B3 { // expected-note 2{{candidate}}
+struct B3 {
   B3(void*); // expected-note {{candidate}}
 };
 struct D3 : B3 { // expected-note 2{{candidate constructor}}
-  using B3::B3; // expected-note 3{{inherited here}}
+  using B3::B3; // expected-note {{inherited here}}
 };
 D3 fd3() { return 1; } // expected-error {{no viable conversion}}
 
diff --git a/test/CXX/special/class.inhctor/p7.cpp b/test/CXX/special/class.inhctor/p7.cpp
index c22a43a61898..2d7acdcc2ce2 100644
--- a/test/CXX/special/class.inhctor/p7.cpp
+++ b/test/CXX/special/class.inhctor/p7.cpp
@@ -3,15 +3,15 @@
 // Note: [class.inhctor] was removed by P0136R1. This tests the new behavior
 // for the wording that used to be there.
 
-struct B1 { // expected-note 2{{candidate}}
+struct B1 {
   B1(int); // expected-note {{candidate}}
 };
-struct B2 { // expected-note 2{{candidate}}
+struct B2 {
   B2(int); // expected-note {{candidate}}
 };
 struct D1 : B1, B2 { // expected-note 2{{candidate}}
-  using B1::B1; // expected-note 3{{inherited here}}
-  using B2::B2; // expected-note 3{{inherited here}}
+  using B1::B1; // expected-note {{inherited here}}
+  using B2::B2; // expected-note {{inherited here}}
 };
 struct D2 : B1, B2 {
   using B1::B1;
diff --git a/test/CodeCompletion/member-access.cpp b/test/CodeCompletion/member-access.cpp
index 8f772c065279..8195f764fbb6 100644
--- a/test/CodeCompletion/member-access.cpp
+++ b/test/CodeCompletion/member-access.cpp
@@ -27,6 +27,16 @@ public:
 
 void test(const Proxy &p) {
   p->
+}
+
+struct Test1 {
+  Base1 b;
+
+  static void sfunc() {
+    b. // expected-error {{invalid use of member 'b' in static member function}}
+  }
+};
+
   // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:29:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
   // CHECK-CC1: Base1 : Base1::
   // CHECK-CC1: member1 : [#int#][#Base1::#]member1
@@ -39,4 +49,6 @@ void test(const Proxy &p) {
   // CHECK-CC1: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>)
   // CHECK-CC1: memfun2 : [#void#][#Base3::#]memfun2(<#int#>)
   // CHECK-CC1: memfun3 : [#int#]memfun3(<#int#>)
-  
+
+// Make sure this doesn't crash
+// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:36:7 %s -verify
diff --git a/test/Driver/netbsd.c b/test/Driver/netbsd.c
index 5558a80b9860..06b5eadfca85 100644
--- a/test/Driver/netbsd.c
+++ b/test/Driver/netbsd.c
@@ -126,6 +126,8 @@
 // RUN: %clang -no-canonical-prefixes -target powerpc64--netbsd -static \
 // RUN: --sysroot=%S/Inputs/basic_netbsd_tree %s -### 2>&1 \
 // RUN: | FileCheck -check-prefix=S-POWERPC64 %s
+// RUN: %clang -target x86_64--netbsd -pthread -dM -E %s \
+// RUN: | FileCheck -check-prefix=PTHREAD %s
 
 // STATIC: ld{{.*}}" "--eh-frame-hdr"
 // STATIC-NOT: "-pie"
@@ -427,3 +429,7 @@
 // S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crti.o"
 // S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtbegin.o" "{{.*}}.o" "-lc"
 // S-POWERPC64: "{{.*}}/usr/lib{{/|\\\\}}crtend.o" "{{.*}}/usr/lib{{/|\\\\}}crtn.o"
+
+// PTHREAD-NOT: _POSIX_THREADS
+// PTHREAD:     _REENTRANT
+// PTHREAD-NOT: _POSIX_THREADS
diff --git a/test/Preprocessor/dependencies-and-pp.c b/test/Preprocessor/dependencies-and-pp.c
index fb4963804093..8bf32dc0fd65 100644
--- a/test/Preprocessor/dependencies-and-pp.c
+++ b/test/Preprocessor/dependencies-and-pp.c
@@ -32,5 +32,12 @@
 // RUN: FileCheck -check-prefix=TEST5 %s < %t.d
 // TEST5: foo $$(bar) b az qu\ ux \ space:
 
+// Test self dependency, PR31644
+
+// RUN: %clang -E -MD -MP -MF %t.d %s
+// RUN: FileCheck -check-prefix=TEST6 %s < %t.d
+// TEST6: dependencies-and-pp.c
+// TEST6-NOT: dependencies-and-pp.c:
+
 // TODO: Test default target without quoting
 // TODO: Test default target with quoting
diff --git a/test/SemaCXX/cxx11-inheriting-ctors.cpp b/test/SemaCXX/cxx11-inheriting-ctors.cpp
index 5ce8d1aa3e0b..c9e01188fd2e 100644
--- a/test/SemaCXX/cxx11-inheriting-ctors.cpp
+++ b/test/SemaCXX/cxx11-inheriting-ctors.cpp
@@ -56,9 +56,9 @@ namespace InvalidConstruction {
 }
 
 namespace ExplicitConv {
-  struct B {}; // expected-note 2{{candidate}}
+  struct B {};
   struct D : B { // expected-note 3{{candidate}}
-    using B::B; // expected-note 2{{inherited}}
+    using B::B;
   };
   struct X { explicit operator B(); } x;
   struct Y { explicit operator D(); } y;
@@ -68,19 +68,40 @@ namespace ExplicitConv {
 }
 
 namespace NestedListInit {
-  struct B { B(); } b; // expected-note 5{{candidate}}
-  struct D : B { // expected-note 3{{candidate}}
-    using B::B; // expected-note 2{{inherited}}
+  struct B { B(); } b; // expected-note 3{{candidate}}
+  struct D : B { // expected-note 14{{not viable}}
+    using B::B;
   };
   // This is a bit weird. We're allowed one pair of braces for overload
   // resolution, and one more pair of braces due to [over.ics.list]/2.
   B b1 = {b};
   B b2 = {{b}};
   B b3 = {{{b}}}; // expected-error {{no match}}
-  // This is the same, but we get one call to D's version of B::B(const B&)
-  // before the two permitted calls to D::D(D&&).
-  D d1 = {b};
-  D d2 = {{b}};
-  D d3 = {{{b}}};
+  // Per a proposed defect resolution, we don't get to call
+  // D's version of B::B(const B&) here.
+  D d0 = b; // expected-error {{no viable conversion}}
+  D d1 = {b}; // expected-error {{no match}}
+  D d2 = {{b}}; // expected-error {{no match}}
+  D d3 = {{{b}}}; // expected-error {{no match}}
   D d4 = {{{{b}}}}; // expected-error {{no match}}
 }
+
+namespace PR31606 {
+  // PR31606: as part of a proposed defect resolution, do not consider
+  // inherited constructors that would be copy constructors for any class
+  // between the declaring class and the constructed class (inclusive).
+  struct Base {};
+
+  struct A : Base {
+    using Base::Base;
+    bool operator==(A const &) const; // expected-note {{no known conversion from 'PR31606::B' to 'const PR31606::A' for 1st argument}}
+  };
+
+  struct B : Base {
+    using Base::Base;
+  };
+
+  bool a = A{} == A{};
+  // Note, we do *not* allow operator=='s argument to use the inherited A::A(Base&&) constructor to construct from B{}.
+  bool b = A{} == B{}; // expected-error {{invalid operands}}
+}
diff --git a/test/SemaTemplate/class-template-spec.cpp b/test/SemaTemplate/class-template-spec.cpp
index 518ec78e6f7d..00e03ef61eb0 100644
--- a/test/SemaTemplate/class-template-spec.cpp
+++ b/test/SemaTemplate/class-template-spec.cpp
@@ -207,19 +207,19 @@ namespace NTTPTypeVsPartialOrder {
   struct X { typedef int value_type; };
   template<typename T> struct Y { typedef T value_type; };
 
-  template<typename T, typename T::value_type N> struct A; // expected-note {{template}}
+  template<typename T, typename T::value_type N> struct A;
   template<int N> struct A<X, N> {};
-  template<typename T, T N> struct A<Y<T>, N> {}; // expected-error {{not more specialized}} expected-note {{'T' vs 'typename Y<type-parameter-0-0>::value_type'}}
+  template<typename T, T N> struct A<Y<T>, N> {};
   A<X, 0> ax;
   A<Y<int>, 0> ay;
 
 
-  template<int, typename T, typename T::value_type> struct B; // expected-note {{template}}
-  template<typename T, typename T::value_type N> struct B<0, T, N>; // expected-note {{matches}}
+  template<int, typename T, typename T::value_type> struct B;
+  template<typename T, typename T::value_type N> struct B<0, T, N>;
   template<int N> struct B<0, X, N> {};
-  template<typename T, T N> struct B<0, Y<T>, N> {}; // expected-error {{not more specialized}} expected-note {{'T' vs 'typename Y<type-parameter-0-0>::value_type'}} expected-note {{matches}}
+  template<typename T, T N> struct B<0, Y<T>, N> {};
   B<0, X, 0> bx;
-  B<0, Y<int>, 0> by; // expected-error {{ambiguous}}
+  B<0, Y<int>, 0> by;
 }
 
 namespace DefaultArgVsPartialSpec {
diff --git a/test/SemaTemplate/cxx1z-using-declaration.cpp b/test/SemaTemplate/cxx1z-using-declaration.cpp
index 7bef36db1f47..87ca748f8fd5 100644
--- a/test/SemaTemplate/cxx1z-using-declaration.cpp
+++ b/test/SemaTemplate/cxx1z-using-declaration.cpp
@@ -17,7 +17,7 @@ void test_Unexpanded() {
 
 // Test using non-type members from pack of base classes.
 template<typename ...T> struct A : T... { // expected-note 2{{candidate}}
-  using T::T ...; // expected-note 6{{inherited here}}
+  using T::T ...; // expected-note 2{{inherited here}}
   using T::operator() ...;
   using T::operator T* ...;
   using T::h ...;
@@ -29,7 +29,7 @@ template<typename ...T> struct A : T... { // expected-note 2{{candidate}}
 };
 
 namespace test_A {
-  struct X { // expected-note 2{{candidate}}
+  struct X {
     X();
     X(int); // expected-note {{candidate}}
     void operator()(int); // expected-note 2{{candidate}}
@@ -43,7 +43,7 @@ namespace test_A {
     operator Y *();
     void h(int, int); // expected-note {{not viable}}
   };
-  struct Z { // expected-note 2{{candidate}}
+  struct Z {
     Z();
     Z(int); // expected-note {{candidate}}
     void operator()(int); // expected-note 2{{candidate}}
diff --git a/test/SemaTemplate/partial-order.cpp b/test/SemaTemplate/partial-order.cpp
new file mode 100644
index 000000000000..0a151de39023
--- /dev/null
+++ b/test/SemaTemplate/partial-order.cpp
@@ -0,0 +1,14 @@
+// RUN: %clang_cc1 -std=c++1z %s -verify
+
+// expected-no-diagnostics
+
+namespace hana_enable_if_idiom {
+  template<bool> struct A {};
+  template<typename, typename = A<true>> struct B;
+  template<typename T, bool N> struct B<T, A<N>> {};
+  template<typename T> struct B<T, A<T::value>> {};
+  struct C {
+    static const bool value = true;
+  };
+  B<C> b;
+}
diff --git a/test/SemaTemplate/temp_arg_nontype.cpp b/test/SemaTemplate/temp_arg_nontype.cpp
index 27a0a03f84f4..5b72b8c6549a 100644
--- a/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/test/SemaTemplate/temp_arg_nontype.cpp
@@ -370,13 +370,13 @@ namespace PR17696 {
 }
 
 namespace partial_order_different_types {
-  // These are unordered because the type of the final argument doesn't match.
-  template<int, int, typename T, typename, T> struct A; // expected-note {{here}}
-  template<int N, typename T, typename U, T V> struct A<0, N, T, U, V> {}; // expected-note {{matches}}
-  template<typename T, typename U, U V> struct A<0, 0, T, U, V> {}; // expected-note {{matches}}
-  // expected-error@-1 {{not more specialized than the primary}}
-  // expected-note@-2 {{deduced non-type template argument does not have the same type as the corresponding template parameter ('U' vs 'type-parameter-0-0')}}
-  A<0, 0, int, int, 0> a; // expected-error {{ambiguous partial specializations}}
+  template<int, int, typename T, typename, T> struct A;
+  template<int N, typename T, typename U, T V> struct A<0, N, T, U, V>; // expected-note {{matches}}
+  // FIXME: It appears that this partial specialization should be ill-formed as
+  // it is not more specialized than the primary template. V is not deducible
+  // because it does not have the same type as the corresponding parameter.
+  template<int N, typename T, typename U, U V> struct A<0, N, T, U, V> {}; // expected-note {{matches}}
+  A<0, 0, int, int, 0> a; // expected-error {{ambiguous}}
 }
 
 namespace partial_order_references {
@@ -434,7 +434,7 @@ namespace dependent_nested_partial_specialization {
 
   template<typename T> struct E {
     template<typename U, U V> struct F; // expected-note {{template}}
-    template<typename W, T V> struct F<W, V> {}; // expected-error {{not more specialized than the primary}} expected-note {{does not have the same type}}
+    template<typename W, T V> struct F<W, V> {}; // expected-error {{not more specialized than the primary}}
   };
   E<int>::F<int, 0> e1; // expected-note {{instantiation of}}
 }
diff --git a/test/SemaTemplate/temp_arg_template_cxx1z.cpp b/test/SemaTemplate/temp_arg_template_cxx1z.cpp
index aa517c328599..703935dcd5c1 100644
--- a/test/SemaTemplate/temp_arg_template_cxx1z.cpp
+++ b/test/SemaTemplate/temp_arg_template_cxx1z.cpp
@@ -79,13 +79,13 @@ namespace Auto {
 
   TInt<Auto> ia;
   TInt<AutoPtr> iap; // expected-error {{different template parameters}}
-  TInt<DecltypeAuto> ida; // FIXME expected-error {{different template parameters}}
+  TInt<DecltypeAuto> ida;
   TInt<Int> ii;
   TInt<IntPtr> iip; // expected-error {{different template parameters}}
 
   TIntPtr<Auto> ipa;
   TIntPtr<AutoPtr> ipap;
-  TIntPtr<DecltypeAuto> ipda; // FIXME expected-error {{different template parameters}}
+  TIntPtr<DecltypeAuto> ipda;
   TIntPtr<Int> ipi; // expected-error {{different template parameters}}
   TIntPtr<IntPtr> ipip;
 
@@ -114,6 +114,6 @@ namespace Auto {
 
   int n;
   template<auto A, decltype(A) B = &n> struct SubstFailure;
-  TInt<SubstFailure> isf; // expected-error {{different template parameters}}
-  TIntPtr<SubstFailure> ipsf; // expected-error {{different template parameters}}
+  TInt<SubstFailure> isf; // FIXME: this should be ill-formed
+  TIntPtr<SubstFailure> ipsf;
 }