[Sema] Fix a crash by completing a type before using it

[erik.pilkington]

Summary

Only apply this exception on a type that we're able to check.

Thanks!
Erik

[rjmccall]

Could you include a test that satisfies the exception but requires a template to be instantiated to check that? It's probably already tested elsewhere, but still.

[erik.pilkington]

Add the testcase @rjmccall requested.

[rjmccall]

Thanks, LGTM.

lib/Sema/SemaInit.cpp

if (!ListInit->getNumInits()) {
       // C++ [over.match.class.deduct]:
       //   As an exception, the first phase in [over.match.list] (considering
       //   initializer-list constructors) is omitted if the initializer list
       //   consists of a single expression of type cv U, where U is a
       //   specialization of C or a class derived from a specialization of C.
       Expr *E = ListInit->getInit(0);
       auto *RD = E->getType()->getAsCXXRecordDecl();
       if (!isa<InitListExpr>(E) && RD &&
+          isCompleteType(Kind.getLocation(), E->getType()) &&
           isOrIsDerivedFromSpecializationOf(RD, Template))
         TryListConstructors = false;
     }
 
     if (TryListConstructors)
       Result = tryToResolveOverload(/*OnlyListConstructor*/true);
     // Then unwrap the initializer list and try again considering all
     // constructors.

test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

private: // expected-note {{declared private by intervening access specifier}}
     Protected(int) -> Protected<int>; // expected-error {{different access}}
   public: // expected-note 2{{declared public by intervening access specifier}}
     template<typename T> Public(T) -> Public<T>;
     template<typename T> Protected(T) -> Protected<T>; // expected-error {{different access}}
     template<typename T> Private(T) -> Private<T>; // expected-error {{different access}}
   };
 }
 
+namespace rdar41903969 {
+template <class T> struct A {};
+template <class T> struct B;
+template <class T> struct C {
+  C(A<T>&);
+  C(B<T>&);
+};
+
+void foo(A<int> &a, B<int> &b) {
+  (void)C{b};
+  (void)C{a};
+}
+
+template<typename T> struct X {
+  X(std::initializer_list<T>) = delete;
+  X(const X&);
+};
+
+template <class T> struct D : X<T> {};
+
+void bar(D<int>& d) {
+  (void)X{d};
+}
+}
+
 #else
 
 // expected-no-diagnostics
 namespace undefined_warnings {
   // Make sure we don't get an "undefined but used internal symbol" warning for the deduction guide here.
   namespace {
     template <typename T>
     struct TemplDObj {