[Sema] Fix assert on valid during template argument deduction

[erik.pilkington]

Summary

This patch fixes an assert that fired when diagnosing a failed template argument deduction attempt. The problem is that when deducing template arguments for a template specialization, if there are insufficient template arguments, we return Sema::TDK_TooFewArguments, which is meant to be used with call arguments, not template arguments and therefore confuses the diagnostic handling. This patch fixes the assert by instead returning Sema::TDK_MiscellaneousDeductionFailure.

This fixes a regression introduced in r274077, recorded by PR31043. Thanks!

[erik.pilkington]

@rsmith fixed this in r291064.

[rsmith]

Sorry I missed this =( Thanks for the fix!

lib/Sema/SemaTemplateDeduction.cpp

   unsigned ArgIdx = 0, ParamIdx = 0;
   for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
        ++ParamIdx) {
     if (!Params[ParamIdx].isPackExpansion()) {
       // The simple case: deduce template arguments by matching Pi and Ai.
 
       // Check whether we have enough arguments.
       if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
-        return NumberOfArgumentsMustMatch ? Sema::TDK_TooFewArguments
-                                          : Sema::TDK_Success;
+        return NumberOfArgumentsMustMatch
+                   ? Sema::TDK_MiscellaneousDeductionFailure
+                   : Sema::TDK_Success;
 
       if (Args[ArgIdx].isPackExpansion()) {
         // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
         // but applied to pack expansions that are template arguments.
         return Sema::TDK_MiscellaneousDeductionFailure;
       }
 
       // Perform deduction for this Pi/Ai pair.

test/SemaTemplate/deduction.cpp

 
 namespace nullptr_deduction {
   template<typename T, T v> struct X {};
   template<typename T, T v> void f(X<T, v>) {
     static_assert(!v, "");
   }
   void g() { f(X<int*, nullptr>()); }
 }
+
+namespace PR31043 {
+template <class... Ts>
+struct tuple {};
+
+template <class T>
+int foo(tuple<T>); // expected-note{{candidate template ignored: failed template argument deduction}}
+
+int z = foo(tuple<>{}); // expected-error{{no matching function call to 'foo'}}
+}