The declaration of a special member can require overload resolution to be

performed, to determine whether that special member is deleted or constexpr.
That overload resolution process can in turn trigger the instantiation of a
template, which can do anything, including triggering the declaration of that
very same special member function. When this happens, do not try to recursively
declare the special member -- that's impossible. Instead, only try to realise
the truth. There is no special member.

llvm-svn: 168847

1 files changed, 68 insertions, 1 deletions

diff --git a/clang/test/SemaCXX/implicit-member-functions.cpp b/clang/test/SemaCXX/implicit-member-functions.cpp
index 84517393421..b5f7fe1016b 100644
--- a/clang/test/SemaCXX/implicit-member-functions.cpp
+++ b/clang/test/SemaCXX/implicit-member-functions.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 struct A { };
 A::A() { } // expected-error {{definition of implicitly declared default constructor}}
@@ -50,3 +50,70 @@ namespace PR7594 {
   };
   C *C::c = new C();
 }
+
+namespace Recursion {
+  template<typename T> struct InvokeCopyConstructor {
+    static const T &get();
+    typedef decltype(T(get())) type; // expected-error {{no matching conver}}
+  };
+  struct B;
+  struct A {
+    typedef B type;
+    template<typename T,
+             typename = typename InvokeCopyConstructor<typename T::type>::type>
+    // expected-note@-1 {{in instantiation of template class}}
+    A(const T &);
+    // expected-note@-1 {{in instantiation of default argument}}
+    // expected-note@-2 {{while substituting deduced template arguments}}
+  };
+  struct B { // expected-note {{candidate constructor (the implicit move }}
+    B(); // expected-note {{candidate constructor not viable}}
+    A a;
+  };
+  // Triggering the declaration of B's copy constructor causes overload
+  // resolution to occur for A's copying constructor, which instantiates
+  // InvokeCopyConstructor<B>, which triggers the declaration of B's copy
+  // constructor. Notionally, this happens when we get to the end of the
+  // definition of 'struct B', so there is no declared copy constructor yet.
+  //
+  // This behavior is g++-compatible, but isn't exactly right; the class is
+  // supposed to be incomplete when we implicitly declare its special members.
+  B b = B();
+
+
+  // Another case, which isn't ill-formed under our rules. This is inspired by
+  // a problem which occurs when combining CGAL with libstdc++-4.7.
+
+  template<typename T> T &&declval();
+  template<typename T, typename U> struct pair {
+    pair();
+    template<typename V, typename W,
+             typename = decltype(T(declval<const V&>())),
+             typename = decltype(U(declval<const W&>()))>
+    pair(const pair<V,W> &);
+  };
+
+  template<typename K> struct Line;
+
+  template<typename K> struct Vector {
+    Vector(const Line<K> &l);
+  };
+
+  template<typename K> struct Point {
+    Vector<K> v;
+  };
+
+  template<typename K> struct Line {
+    pair<Point<K>, Vector<K>> x;
+  };
+
+  // Trigger declaration of Line copy ctor, which causes substitution into
+  // pair's templated constructor, which triggers instantiation of the
+  // definition of Point's copy constructor, which performs overload resolution
+  // on Vector's constructors, which requires declaring all of Line's
+  // constructors. That should not find a copy constructor (because we've not
+  // declared it yet), but by the time we get all the way back here, we should
+  // find the copy constructor.
+  Line<void> L1;
+  Line<void> L2(L1);
+}