From 0972c867e72171f24052d7b6d307020c065f8a66 Mon Sep 17 00:00:00 2001
From: Douglas Gregor <dgregor@apple.com>
Date: Wed, 22 Dec 2010 18:55:49 +0000
Subject: [PATCH] When performing template argument deduction where the
 argument is a dependent template specialization type, the number of template
 arguments need not match precisely. Rather than checking the number of
 arguments eagerly (which does not consider argument packs), let the deduction
 routine for template argument lists cope with too many/too few arguments.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@122425 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/Sema/SemaTemplateDeduction.cpp            | 27 ++++++++++---------
 .../temp/temp.decls/temp.variadic/replace.cpp | 26 ++++++++++++++++++
 2 files changed, 41 insertions(+), 12 deletions(-)
 create mode 100644 test/CXX/temp/temp.decls/temp.variadic/replace.cpp

diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index 108f207510..80ba1a3dd6 100644
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -81,7 +81,7 @@ DeduceTemplateArguments(Sema &S,
                         const TemplateArgument &Param,
                         const TemplateArgument &Arg,
                         TemplateDeductionInfo &Info,
-                    llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced);
+                      llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced);
 
 static Sema::TemplateDeductionResult
 DeduceTemplateArguments(Sema &S,
@@ -89,7 +89,8 @@ DeduceTemplateArguments(Sema &S,
                         const TemplateArgument *Params, unsigned NumParams,
                         const TemplateArgument *Args, unsigned NumArgs,
                         TemplateDeductionInfo &Info,
-                      llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced);
+                        llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+                        bool NumberOfArgumentsMustMatch = true);
 
 /// \brief If the given expression is of a form that permits the deduction
 /// of a non-type template parameter, return the declaration of that
@@ -309,14 +310,13 @@ DeduceTemplateArguments(Sema &S,
 
 
     // Perform template argument deduction on each template
-    // argument.
-    // FIXME: This "min" function isn't going to work in general. We should
-    // probably pass down a flag that allows too few/too many arguments.
-    unsigned NumArgs = std::min(SpecArg->getNumArgs(), Param->getNumArgs());
+    // argument. Ignore any missing/extra arguments, since they could be
+    // filled in by default arguments.
     return DeduceTemplateArguments(S, TemplateParams, 
-                                   Param->getArgs(), NumArgs, 
-                                   SpecArg->getArgs(), NumArgs,
-                                   Info, Deduced);
+                                   Param->getArgs(), Param->getNumArgs(), 
+                                   SpecArg->getArgs(), SpecArg->getNumArgs(),
+                                   Info, Deduced,
+                                   /*NumberOfArgumentsMustMatch=*/false);
   }
 
   // If the argument type is a class template specialization, we
@@ -953,7 +953,8 @@ DeduceTemplateArguments(Sema &S,
                         const TemplateArgument *Params, unsigned NumParams,
                         const TemplateArgument *Args, unsigned NumArgs,
                         TemplateDeductionInfo &Info,
-                    llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+                    llvm::SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+                        bool NumberOfArgumentsMustMatch) {
   unsigned ArgIdx = 0, ParamIdx = 0;
   for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams); 
        ++ParamIdx) {
@@ -962,7 +963,8 @@ DeduceTemplateArguments(Sema &S,
       
       // Check whether we have enough arguments.
       if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
-        return Sema::TDK_TooFewArguments;
+        return NumberOfArgumentsMustMatch? Sema::TDK_TooFewArguments 
+                                         : Sema::TDK_Success;
       
       // Perform deduction for this P/A pair.
       if (Sema::TemplateDeductionResult Result
@@ -985,7 +987,8 @@ DeduceTemplateArguments(Sema &S,
   }
   
   // If there is an argument remaining, then we had too many arguments.
-  if (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
+  if (NumberOfArgumentsMustMatch &&
+      hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
     return Sema::TDK_TooManyArguments;
   
   return Sema::TDK_Success;
diff --git a/test/CXX/temp/temp.decls/temp.variadic/replace.cpp b/test/CXX/temp/temp.decls/temp.variadic/replace.cpp
new file mode 100644
index 0000000000..eb49cd1317
--- /dev/null
+++ b/test/CXX/temp/temp.decls/temp.variadic/replace.cpp
@@ -0,0 +1,26 @@
+// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s
+
+template<typename T, typename U>
+struct is_same {
+  static const bool value = false;
+};
+
+template<typename T>
+struct is_same<T, T> {
+  static const bool value = true;
+};
+
+// Simple metafunction that replaces the template arguments of
+// template template parameters with 'int'.
+template<typename T>
+struct EverythingToInt;
+
+template<template<typename ...> class TT, typename T1, typename T2>
+struct EverythingToInt<TT<T1, T2> > {
+  typedef TT<int, int> type;
+};
+
+template<typename...> struct tuple { };
+
+int check0[is_same<EverythingToInt<tuple<double, float>>::type, 
+                   tuple<int, int>>::value? 1 : -1];
-- 
2.40.0