Consolidate and unify initializer list deduction

[hubert.reinterpretcast]

Summary

This patch reduces duplication in the template argument deduction code
for handling deduction from initializer lists in a function call. This
extends the fix for PR12119 to also apply to the case where the
corresponding parameter is a trailing parameter pack.

[rsmith]

lib/Sema/SemaTemplateDeduction.cpp

3201

Maybe just make this return the TemplateDeductionResult? You -- almost, see below -- always treat a return of false from here and a return of true with Result == TDK_Success the same (which makes sense, because they mean the same thing -- deduction succeeded).

3432–3433

Is this really right? It seems to cause an accepts-invalid on this:

#include <initializer_list>
#include <tuple>
template<typename ...T> void f(std::tuple<T...> a, T ...b);
void g() { f(std::make_tuple(1, 2), {}, 3.0); }

Should this instead be ignoring this P/A pair and carrying on to the next, as we do if deduction succeeds? (This is a pre-existing bug, but it's the only barrier to the cleanup I suggested above.)

[hubert.reinterpretcast]

The additional bug appears to affect more than just the part being changed here. I think it would make sense to leave that change for a separate commit (and get the clean up done there).

lib/Sema/SemaTemplateDeduction.cpp

3432–3433

This seems to be a larger issue having to do with undeduced contexts and trailing parameter packs.

#include <initializer_list>
#include <tuple>
void f();
void f(bool);

typedef void (*fptype)();
struct Func { operator fptype(); } func;

template<typename ...T> void f(std::tuple<T...> a, T ...b);
void g() { f(std::make_tuple(fptype(), fptype()), f, func); } // Clang and GCC accept
void g1() { f(std::make_tuple(fptype(), fptype()), func, f); } // GCC accepts, Clang rejects

[rsmith]

OK, separating the two fixes sounds fine to me.

lib/Sema/SemaTemplateDeduction.cpp

static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
 
   return false;
 }
 
 static bool
 hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate,
                                QualType T);
 
+static Sema::TemplateDeductionResult DeduceTemplateArgumentByListElement(
+    Sema &S, TemplateParameterList *TemplateParams, QualType ParamType,
+    Expr *Arg, TemplateDeductionInfo &Info,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF);
+
+/// \brief Attempt template argument deduction from an initializer list
+///        deemed to be an argument in a function call.
+static bool
+DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams,
+                          QualType AdjustedParamType, InitListExpr *ILE,
+                          TemplateDeductionInfo &Info,
+                          SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+                          unsigned TDF, Sema::TemplateDeductionResult &Result) {
+  // If the argument is an initializer list then the parameter is an undeduced
+  // context, unless the parameter type is (reference to cv)
+  // std::initializer_list<P'>, in which case deduction is done for each element
+  // of the initializer list as-if it were an argument in a function call, and
+  // the result is the deduced type if it's the same for all elements.
+  QualType X;
+  if (!S.isStdInitializerList(AdjustedParamType, &X))
+    return false;
+
+  Result = Sema::TDK_Success;
+
+  // Recurse down into the init list.
+  for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
+    if ((Result = DeduceTemplateArgumentByListElement(
+             S, TemplateParams, X, ILE->getInit(i), Info, Deduced, TDF)))
+      return true;
+  }
+
+  return true;
+}
+
 /// \brief Perform template argument deduction by matching a parameter type
 ///        against a single expression, where the expression is an element of
 ///        an initializer list that was originally matched against a parameter
 ///        of type \c initializer_list\<ParamType\>.
 static Sema::TemplateDeductionResult
 DeduceTemplateArgumentByListElement(Sema &S,
                                     TemplateParameterList *TemplateParams,
                                     QualType ParamType, Expr *Arg,
                                     TemplateDeductionInfo &Info,
                               SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                                     unsigned TDF) {
   // Handle the case where an init list contains another init list as the
   // element.
   if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
-    QualType X;
-    if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X))
+    Sema::TemplateDeductionResult Result;
+    if (!DeduceFromInitializerList(S, TemplateParams,
+                                   ParamType.getNonReferenceType(), ILE, Info,
+                                   Deduced, TDF, Result))
       return Sema::TDK_Success; // Just ignore this expression.
 
-    // Recurse down into the init list.
-    for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
-      if (Sema::TemplateDeductionResult Result =
-            DeduceTemplateArgumentByListElement(S, TemplateParams, X,
-                                                 ILE->getInit(i),
-                                                 Info, Deduced, TDF))
-        return Result;
-    }
-    return Sema::TDK_Success;
-  }
 
   // For all other cases, just match by type.
   QualType ArgType = Arg->getType();
   if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType, 
                                                 ArgType, Arg, TDF)) {
     Info.Expression = Arg;
     return Sema::TDK_FailedOverloadResolution;
   }
if (!ParamExpansion) {
         continue;
 
       // If we have nothing to deduce, we're done.
       if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
         continue;
 
       // If the argument is an initializer list ...
       if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
-        // ... then the parameter is an undeduced context, unless the parameter
-        // type is (reference to cv) std::initializer_list<P'>, in which case
-        // deduction is done for each element of the initializer list, and the
-        // result is the deduced type if it's the same for all elements.
-        QualType X;
+        TemplateDeductionResult Result;
         // Removing references was already done.
-        if (!isStdInitializerList(ParamType, &X))
+        if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE,
+                                       Info, Deduced, TDF, Result))
           continue;
 
-        for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
-          if (TemplateDeductionResult Result =
-                DeduceTemplateArgumentByListElement(*this, TemplateParams, X,
-                                                     ILE->getInit(i),
-                                                     Info, Deduced, TDF))
-            return Result;
-        }
+        if (Result)
         // Don't track the argument type, since an initializer list has none.
         continue;
       }
 
       // Keep track of the argument type and corresponding parameter index,
       // so we can check for compatibility between the deduced A and A.
       OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1, 
                                                  ArgType));
for (; ArgIdx < Args.size(); ++ArgIdx) {
         // We can't actually perform any deduction for this argument, so stop
         // deduction at this point.
         ++ArgIdx;
         break;
       }
 
       // As above, initializer lists need special handling.
       if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
-        QualType X;
-        if (!isStdInitializerList(ParamType, &X)) {
+        TemplateDeductionResult Result;
+        if (!DeduceFromInitializerList(*this, TemplateParams, ParamType, ILE,
+                                       Info, Deduced, TDF, Result)) {
           ++ArgIdx;
           break;
         }
 
-        for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
-          if (TemplateDeductionResult Result =
-                DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X,
-                                                   ILE->getInit(i)->getType(),
-                                                   Info, Deduced, TDF))
-            return Result;
-        }
+        if (Result)
       } else {
 
         // Keep track of the argument type and corresponding argument index,
         // so we can check for compatibility between the deduced A and A.
         if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
           OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx, 
                                                      ArgType));
 

test/SemaCXX/cxx0x-initializer-stdinitializerlist.cpp

namespace TemporaryInitListSourceRange_PR22367 {
   constexpr int k = f( // expected-error {{must be initialized by a constant expression}}
       // The point of this test is to check that the caret points to
       // 'std::initializer_list', not to '{0}'.
       std::initializer_list // expected-note {{constructor}}
       <int>
       {0}
       );
 }
+
+namespace ParameterPackNestedInitializerLists_PR23904c3 {
+  template <typename ...T>
+  void f(std::initializer_list<std::initializer_list<T>> ...tt);
+
+  void foo() { f({{0}}, {{'\0'}}); }
+}