blob: 28f489a43beed6aa380a6b2114921a13dbc2cbde [file] [log] [blame]
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001//===------- SemaTemplateDeduction.cpp - Template Argument Deduction ------===/
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//===----------------------------------------------------------------------===/
8//
9// This file implements C++ template argument deduction.
10//
11//===----------------------------------------------------------------------===/
12
Douglas Gregore737f502010-08-12 20:07:10 +000013#include "clang/Sema/Sema.h"
John McCall19510852010-08-20 18:27:03 +000014#include "clang/Sema/DeclSpec.h"
John McCall7cd088e2010-08-24 07:21:54 +000015#include "clang/Sema/Template.h"
John McCall2a7fb272010-08-25 05:32:35 +000016#include "clang/Sema/TemplateDeduction.h"
Douglas Gregor0b9247f2009-06-04 00:03:07 +000017#include "clang/AST/ASTContext.h"
John McCall7cd088e2010-08-24 07:21:54 +000018#include "clang/AST/DeclObjC.h"
Douglas Gregor0b9247f2009-06-04 00:03:07 +000019#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/StmtVisitor.h"
21#include "clang/AST/Expr.h"
22#include "clang/AST/ExprCXX.h"
Douglas Gregore02e2622010-12-22 21:19:48 +000023#include "llvm/ADT/BitVector.h"
Richard Smith34b41d92011-02-20 03:19:35 +000024#include "TreeTransform.h"
Douglas Gregor8a514912009-09-14 18:39:43 +000025#include <algorithm>
Douglas Gregor508f1c82009-06-26 23:10:12 +000026
27namespace clang {
John McCall2a7fb272010-08-25 05:32:35 +000028 using namespace sema;
29
Douglas Gregor508f1c82009-06-26 23:10:12 +000030 /// \brief Various flags that control template argument deduction.
31 ///
32 /// These flags can be bitwise-OR'd together.
33 enum TemplateDeductionFlags {
34 /// \brief No template argument deduction flags, which indicates the
35 /// strictest results for template argument deduction (as used for, e.g.,
36 /// matching class template partial specializations).
37 TDF_None = 0,
38 /// \brief Within template argument deduction from a function call, we are
39 /// matching with a parameter type for which the original parameter was
40 /// a reference.
41 TDF_ParamWithReferenceType = 0x1,
42 /// \brief Within template argument deduction from a function call, we
43 /// are matching in a case where we ignore cv-qualifiers.
44 TDF_IgnoreQualifiers = 0x02,
45 /// \brief Within template argument deduction from a function call,
46 /// we are matching in a case where we can perform template argument
Douglas Gregor41128772009-06-26 23:27:24 +000047 /// deduction from a template-id of a derived class of the argument type.
Douglas Gregor12820292009-09-14 20:00:47 +000048 TDF_DerivedClass = 0x04,
49 /// \brief Allow non-dependent types to differ, e.g., when performing
50 /// template argument deduction from a function call where conversions
51 /// may apply.
Douglas Gregor73b3cf62011-01-25 17:19:08 +000052 TDF_SkipNonDependent = 0x08,
53 /// \brief Whether we are performing template argument deduction for
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000054 /// parameters and arguments in a top-level template argument
Douglas Gregor73b3cf62011-01-25 17:19:08 +000055 TDF_TopLevelParameterTypeList = 0x10
Douglas Gregor508f1c82009-06-26 23:10:12 +000056 };
57}
58
Douglas Gregor0b9247f2009-06-04 00:03:07 +000059using namespace clang;
60
Douglas Gregor9d0e4412010-03-26 05:50:28 +000061/// \brief Compare two APSInts, extending and switching the sign as
62/// necessary to compare their values regardless of underlying type.
63static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) {
64 if (Y.getBitWidth() > X.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +000065 X = X.extend(Y.getBitWidth());
Douglas Gregor9d0e4412010-03-26 05:50:28 +000066 else if (Y.getBitWidth() < X.getBitWidth())
Jay Foad9f71a8f2010-12-07 08:25:34 +000067 Y = Y.extend(X.getBitWidth());
Douglas Gregor9d0e4412010-03-26 05:50:28 +000068
69 // If there is a signedness mismatch, correct it.
70 if (X.isSigned() != Y.isSigned()) {
71 // If the signed value is negative, then the values cannot be the same.
72 if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative()))
73 return false;
74
75 Y.setIsSigned(true);
76 X.setIsSigned(true);
77 }
78
79 return X == Y;
80}
81
Douglas Gregorf67875d2009-06-12 18:26:56 +000082static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +000083DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +000084 TemplateParameterList *TemplateParams,
85 const TemplateArgument &Param,
Douglas Gregor77d6bb92011-01-11 22:21:24 +000086 TemplateArgument Arg,
John McCall2a7fb272010-08-25 05:32:35 +000087 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +000088 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
Douglas Gregord708c722009-06-09 16:35:58 +000089
Douglas Gregorb939a192011-01-21 17:29:42 +000090/// \brief Whether template argument deduction for two reference parameters
91/// resulted in the argument type, parameter type, or neither type being more
92/// qualified than the other.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +000093enum DeductionQualifierComparison {
94 NeitherMoreQualified = 0,
95 ParamMoreQualified,
96 ArgMoreQualified
Douglas Gregor5c7bf422011-01-11 17:34:58 +000097};
98
Douglas Gregorb939a192011-01-21 17:29:42 +000099/// \brief Stores the result of comparing two reference parameters while
100/// performing template argument deduction for partial ordering of function
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000101/// templates.
Douglas Gregorb939a192011-01-21 17:29:42 +0000102struct RefParamPartialOrderingComparison {
103 /// \brief Whether the parameter type is an rvalue reference type.
104 bool ParamIsRvalueRef;
105 /// \brief Whether the argument type is an rvalue reference type.
106 bool ArgIsRvalueRef;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000107
Douglas Gregorb939a192011-01-21 17:29:42 +0000108 /// \brief Whether the parameter or argument (or neither) is more qualified.
109 DeductionQualifierComparison Qualifiers;
110};
111
112
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000113
Douglas Gregor20a55e22010-12-22 18:17:10 +0000114static Sema::TemplateDeductionResult
115DeduceTemplateArguments(Sema &S,
116 TemplateParameterList *TemplateParams,
Douglas Gregor603cfb42011-01-05 23:12:31 +0000117 QualType Param,
118 QualType Arg,
119 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000120 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000121 unsigned TDF,
122 bool PartialOrdering = false,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000123 SmallVectorImpl<RefParamPartialOrderingComparison> *
Douglas Gregorb939a192011-01-21 17:29:42 +0000124 RefParamComparisons = 0);
Douglas Gregor603cfb42011-01-05 23:12:31 +0000125
126static Sema::TemplateDeductionResult
127DeduceTemplateArguments(Sema &S,
128 TemplateParameterList *TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +0000129 const TemplateArgument *Params, unsigned NumParams,
130 const TemplateArgument *Args, unsigned NumArgs,
131 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000132 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor0972c862010-12-22 18:55:49 +0000133 bool NumberOfArgumentsMustMatch = true);
Douglas Gregor20a55e22010-12-22 18:17:10 +0000134
Douglas Gregor199d9912009-06-05 00:53:49 +0000135/// \brief If the given expression is of a form that permits the deduction
136/// of a non-type template parameter, return the declaration of that
137/// non-type template parameter.
138static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
139 if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
140 E = IC->getSubExpr();
Mike Stump1eb44332009-09-09 15:08:12 +0000141
Douglas Gregor199d9912009-06-05 00:53:49 +0000142 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
143 return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000144
Douglas Gregor199d9912009-06-05 00:53:49 +0000145 return 0;
146}
147
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000148/// \brief Determine whether two declaration pointers refer to the same
149/// declaration.
150static bool isSameDeclaration(Decl *X, Decl *Y) {
151 if (!X || !Y)
152 return !X && !Y;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000153
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000154 if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
155 X = NX->getUnderlyingDecl();
156 if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
157 Y = NY->getUnderlyingDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000158
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000159 return X->getCanonicalDecl() == Y->getCanonicalDecl();
160}
161
162/// \brief Verify that the given, deduced template arguments are compatible.
163///
164/// \returns The deduced template argument, or a NULL template argument if
165/// the deduced template arguments were incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000166static DeducedTemplateArgument
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000167checkDeducedTemplateArguments(ASTContext &Context,
168 const DeducedTemplateArgument &X,
169 const DeducedTemplateArgument &Y) {
170 // We have no deduction for one or both of the arguments; they're compatible.
171 if (X.isNull())
172 return Y;
173 if (Y.isNull())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000174 return X;
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000175
176 switch (X.getKind()) {
177 case TemplateArgument::Null:
178 llvm_unreachable("Non-deduced template arguments handled above");
179
180 case TemplateArgument::Type:
181 // If two template type arguments have the same type, they're compatible.
182 if (Y.getKind() == TemplateArgument::Type &&
183 Context.hasSameType(X.getAsType(), Y.getAsType()))
184 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000185
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000186 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000187
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000188 case TemplateArgument::Integral:
189 // If we deduced a constant in one case and either a dependent expression or
190 // declaration in another case, keep the integral constant.
191 // If both are integral constants with the same value, keep that value.
192 if (Y.getKind() == TemplateArgument::Expression ||
193 Y.getKind() == TemplateArgument::Declaration ||
194 (Y.getKind() == TemplateArgument::Integral &&
195 hasSameExtendedValue(*X.getAsIntegral(), *Y.getAsIntegral())))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000196 return DeducedTemplateArgument(X,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000197 X.wasDeducedFromArrayBound() &&
198 Y.wasDeducedFromArrayBound());
199
200 // All other combinations are incompatible.
201 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000202
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000203 case TemplateArgument::Template:
204 if (Y.getKind() == TemplateArgument::Template &&
205 Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
206 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000207
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000208 // All other combinations are incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000209 return DeducedTemplateArgument();
Douglas Gregora7fc9012011-01-05 18:58:31 +0000210
211 case TemplateArgument::TemplateExpansion:
212 if (Y.getKind() == TemplateArgument::TemplateExpansion &&
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000213 Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
Douglas Gregora7fc9012011-01-05 18:58:31 +0000214 Y.getAsTemplateOrTemplatePattern()))
215 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000216
Douglas Gregora7fc9012011-01-05 18:58:31 +0000217 // All other combinations are incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000218 return DeducedTemplateArgument();
Douglas Gregora7fc9012011-01-05 18:58:31 +0000219
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000220 case TemplateArgument::Expression:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000221 // If we deduced a dependent expression in one case and either an integral
222 // constant or a declaration in another case, keep the integral constant
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000223 // or declaration.
224 if (Y.getKind() == TemplateArgument::Integral ||
225 Y.getKind() == TemplateArgument::Declaration)
226 return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
227 Y.wasDeducedFromArrayBound());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000228
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000229 if (Y.getKind() == TemplateArgument::Expression) {
230 // Compare the expressions for equality
231 llvm::FoldingSetNodeID ID1, ID2;
232 X.getAsExpr()->Profile(ID1, Context, true);
233 Y.getAsExpr()->Profile(ID2, Context, true);
234 if (ID1 == ID2)
235 return X;
236 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000237
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000238 // All other combinations are incompatible.
239 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000240
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000241 case TemplateArgument::Declaration:
242 // If we deduced a declaration and a dependent expression, keep the
243 // declaration.
244 if (Y.getKind() == TemplateArgument::Expression)
245 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000246
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000247 // If we deduced a declaration and an integral constant, keep the
248 // integral constant.
249 if (Y.getKind() == TemplateArgument::Integral)
250 return Y;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000251
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000252 // If we deduced two declarations, make sure they they refer to the
253 // same declaration.
254 if (Y.getKind() == TemplateArgument::Declaration &&
255 isSameDeclaration(X.getAsDecl(), Y.getAsDecl()))
256 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000257
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000258 // All other combinations are incompatible.
259 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000260
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000261 case TemplateArgument::Pack:
262 if (Y.getKind() != TemplateArgument::Pack ||
263 X.pack_size() != Y.pack_size())
264 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000265
266 for (TemplateArgument::pack_iterator XA = X.pack_begin(),
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000267 XAEnd = X.pack_end(),
268 YA = Y.pack_begin();
269 XA != XAEnd; ++XA, ++YA) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000270 if (checkDeducedTemplateArguments(Context,
271 DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
Douglas Gregor135ffa72011-01-05 21:00:53 +0000272 DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
273 .isNull())
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000274 return DeducedTemplateArgument();
275 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000276
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000277 return X;
278 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000279
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000280 return DeducedTemplateArgument();
281}
282
Mike Stump1eb44332009-09-09 15:08:12 +0000283/// \brief Deduce the value of the given non-type template parameter
Douglas Gregor199d9912009-06-05 00:53:49 +0000284/// from the given constant.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000285static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000286DeduceNonTypeTemplateArgument(Sema &S,
Mike Stump1eb44332009-09-09 15:08:12 +0000287 NonTypeTemplateParmDecl *NTTP,
Douglas Gregor9d0e4412010-03-26 05:50:28 +0000288 llvm::APSInt Value, QualType ValueType,
Douglas Gregor02024a92010-03-28 02:42:43 +0000289 bool DeducedFromArrayBound,
John McCall2a7fb272010-08-25 05:32:35 +0000290 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000291 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Mike Stump1eb44332009-09-09 15:08:12 +0000292 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +0000293 "Cannot deduce non-type template argument with depth > 0");
Mike Stump1eb44332009-09-09 15:08:12 +0000294
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000295 DeducedTemplateArgument NewDeduced(Value, ValueType, DeducedFromArrayBound);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000296 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000297 Deduced[NTTP->getIndex()],
298 NewDeduced);
299 if (Result.isNull()) {
Douglas Gregorf67875d2009-06-12 18:26:56 +0000300 Info.Param = NTTP;
301 Info.FirstArg = Deduced[NTTP->getIndex()];
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000302 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000303 return Sema::TDK_Inconsistent;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000304 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000305
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000306 Deduced[NTTP->getIndex()] = Result;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000307 return Sema::TDK_Success;
Douglas Gregor199d9912009-06-05 00:53:49 +0000308}
309
Mike Stump1eb44332009-09-09 15:08:12 +0000310/// \brief Deduce the value of the given non-type template parameter
Douglas Gregor199d9912009-06-05 00:53:49 +0000311/// from the given type- or value-dependent expression.
312///
313/// \returns true if deduction succeeded, false otherwise.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000314static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000315DeduceNonTypeTemplateArgument(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +0000316 NonTypeTemplateParmDecl *NTTP,
317 Expr *Value,
John McCall2a7fb272010-08-25 05:32:35 +0000318 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000319 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Mike Stump1eb44332009-09-09 15:08:12 +0000320 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +0000321 "Cannot deduce non-type template argument with depth > 0");
322 assert((Value->isTypeDependent() || Value->isValueDependent()) &&
323 "Expression template argument must be type- or value-dependent.");
Mike Stump1eb44332009-09-09 15:08:12 +0000324
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000325 DeducedTemplateArgument NewDeduced(Value);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000326 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
327 Deduced[NTTP->getIndex()],
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000328 NewDeduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000329
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000330 if (Result.isNull()) {
331 Info.Param = NTTP;
332 Info.FirstArg = Deduced[NTTP->getIndex()];
333 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000334 return Sema::TDK_Inconsistent;
Douglas Gregor199d9912009-06-05 00:53:49 +0000335 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000336
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000337 Deduced[NTTP->getIndex()] = Result;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000338 return Sema::TDK_Success;
Douglas Gregor199d9912009-06-05 00:53:49 +0000339}
340
Douglas Gregor15755cb2009-11-13 23:45:44 +0000341/// \brief Deduce the value of the given non-type template parameter
342/// from the given declaration.
343///
344/// \returns true if deduction succeeded, false otherwise.
345static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000346DeduceNonTypeTemplateArgument(Sema &S,
Douglas Gregor15755cb2009-11-13 23:45:44 +0000347 NonTypeTemplateParmDecl *NTTP,
348 Decl *D,
John McCall2a7fb272010-08-25 05:32:35 +0000349 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000350 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregor15755cb2009-11-13 23:45:44 +0000351 assert(NTTP->getDepth() == 0 &&
352 "Cannot deduce non-type template argument with depth > 0");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000353
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000354 DeducedTemplateArgument NewDeduced(D? D->getCanonicalDecl() : 0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000355 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000356 Deduced[NTTP->getIndex()],
357 NewDeduced);
358 if (Result.isNull()) {
359 Info.Param = NTTP;
360 Info.FirstArg = Deduced[NTTP->getIndex()];
361 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000362 return Sema::TDK_Inconsistent;
Douglas Gregor15755cb2009-11-13 23:45:44 +0000363 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000364
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000365 Deduced[NTTP->getIndex()] = Result;
Douglas Gregor15755cb2009-11-13 23:45:44 +0000366 return Sema::TDK_Success;
367}
368
Douglas Gregorf67875d2009-06-12 18:26:56 +0000369static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000370DeduceTemplateArguments(Sema &S,
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000371 TemplateParameterList *TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +0000372 TemplateName Param,
373 TemplateName Arg,
John McCall2a7fb272010-08-25 05:32:35 +0000374 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000375 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregord708c722009-06-09 16:35:58 +0000376 TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000377 if (!ParamDecl) {
378 // The parameter type is dependent and is not a template template parameter,
379 // so there is nothing that we can deduce.
380 return Sema::TDK_Success;
381 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000382
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000383 if (TemplateTemplateParmDecl *TempParam
384 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000385 DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000386 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000387 Deduced[TempParam->getIndex()],
388 NewDeduced);
389 if (Result.isNull()) {
390 Info.Param = TempParam;
391 Info.FirstArg = Deduced[TempParam->getIndex()];
392 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000393 return Sema::TDK_Inconsistent;
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000394 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000395
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000396 Deduced[TempParam->getIndex()] = Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000397 return Sema::TDK_Success;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000398 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000399
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000400 // Verify that the two template names are equivalent.
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000401 if (S.Context.hasSameTemplateName(Param, Arg))
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000402 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000403
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000404 // Mismatch of non-dependent template parameter to argument.
405 Info.FirstArg = TemplateArgument(Param);
406 Info.SecondArg = TemplateArgument(Arg);
407 return Sema::TDK_NonDeducedMismatch;
Douglas Gregord708c722009-06-09 16:35:58 +0000408}
409
Mike Stump1eb44332009-09-09 15:08:12 +0000410/// \brief Deduce the template arguments by comparing the template parameter
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000411/// type (which is a template-id) with the template argument type.
412///
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000413/// \param S the Sema
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000414///
415/// \param TemplateParams the template parameters that we are deducing
416///
417/// \param Param the parameter type
418///
419/// \param Arg the argument type
420///
421/// \param Info information about the template argument deduction itself
422///
423/// \param Deduced the deduced template arguments
424///
425/// \returns the result of template argument deduction so far. Note that a
426/// "success" result means that template argument deduction has not yet failed,
427/// but it may still fail, later, for other reasons.
428static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000429DeduceTemplateArguments(Sema &S,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000430 TemplateParameterList *TemplateParams,
431 const TemplateSpecializationType *Param,
432 QualType Arg,
John McCall2a7fb272010-08-25 05:32:35 +0000433 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000434 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
John McCall467b27b2009-10-22 20:10:53 +0000435 assert(Arg.isCanonical() && "Argument type must be canonical");
Mike Stump1eb44332009-09-09 15:08:12 +0000436
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000437 // Check whether the template argument is a dependent template-id.
Mike Stump1eb44332009-09-09 15:08:12 +0000438 if (const TemplateSpecializationType *SpecArg
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000439 = dyn_cast<TemplateSpecializationType>(Arg)) {
440 // Perform template argument deduction for the template name.
441 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000442 = DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000443 Param->getTemplateName(),
444 SpecArg->getTemplateName(),
445 Info, Deduced))
446 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +0000447
Mike Stump1eb44332009-09-09 15:08:12 +0000448
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000449 // Perform template argument deduction on each template
Douglas Gregor0972c862010-12-22 18:55:49 +0000450 // argument. Ignore any missing/extra arguments, since they could be
451 // filled in by default arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000452 return DeduceTemplateArguments(S, TemplateParams,
453 Param->getArgs(), Param->getNumArgs(),
Douglas Gregor0972c862010-12-22 18:55:49 +0000454 SpecArg->getArgs(), SpecArg->getNumArgs(),
455 Info, Deduced,
456 /*NumberOfArgumentsMustMatch=*/false);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000457 }
Mike Stump1eb44332009-09-09 15:08:12 +0000458
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000459 // If the argument type is a class template specialization, we
460 // perform template argument deduction using its template
461 // arguments.
462 const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
463 if (!RecordArg)
464 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +0000465
466 ClassTemplateSpecializationDecl *SpecArg
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000467 = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
468 if (!SpecArg)
469 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +0000470
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000471 // Perform template argument deduction for the template name.
472 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000473 = DeduceTemplateArguments(S,
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000474 TemplateParams,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000475 Param->getTemplateName(),
476 TemplateName(SpecArg->getSpecializedTemplate()),
477 Info, Deduced))
478 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +0000479
Douglas Gregor20a55e22010-12-22 18:17:10 +0000480 // Perform template argument deduction for the template arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000481 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +0000482 Param->getArgs(), Param->getNumArgs(),
483 SpecArg->getTemplateArgs().data(),
484 SpecArg->getTemplateArgs().size(),
485 Info, Deduced);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000486}
487
John McCallcd05e812010-08-28 22:14:41 +0000488/// \brief Determines whether the given type is an opaque type that
489/// might be more qualified when instantiated.
490static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
491 switch (T->getTypeClass()) {
492 case Type::TypeOfExpr:
493 case Type::TypeOf:
494 case Type::DependentName:
495 case Type::Decltype:
496 case Type::UnresolvedUsing:
John McCall62c28c82011-01-18 07:41:22 +0000497 case Type::TemplateTypeParm:
John McCallcd05e812010-08-28 22:14:41 +0000498 return true;
499
500 case Type::ConstantArray:
501 case Type::IncompleteArray:
502 case Type::VariableArray:
503 case Type::DependentSizedArray:
504 return IsPossiblyOpaquelyQualifiedType(
505 cast<ArrayType>(T)->getElementType());
506
507 default:
508 return false;
509 }
510}
511
Douglas Gregord3731192011-01-10 07:32:04 +0000512/// \brief Retrieve the depth and index of a template parameter.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000513static std::pair<unsigned, unsigned>
Douglas Gregord3731192011-01-10 07:32:04 +0000514getDepthAndIndex(NamedDecl *ND) {
Douglas Gregor603cfb42011-01-05 23:12:31 +0000515 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
516 return std::make_pair(TTP->getDepth(), TTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000517
Douglas Gregor603cfb42011-01-05 23:12:31 +0000518 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
519 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000520
Douglas Gregor603cfb42011-01-05 23:12:31 +0000521 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
522 return std::make_pair(TTP->getDepth(), TTP->getIndex());
523}
524
Douglas Gregord3731192011-01-10 07:32:04 +0000525/// \brief Retrieve the depth and index of an unexpanded parameter pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000526static std::pair<unsigned, unsigned>
Douglas Gregord3731192011-01-10 07:32:04 +0000527getDepthAndIndex(UnexpandedParameterPack UPP) {
528 if (const TemplateTypeParmType *TTP
529 = UPP.first.dyn_cast<const TemplateTypeParmType *>())
530 return std::make_pair(TTP->getDepth(), TTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000531
Douglas Gregord3731192011-01-10 07:32:04 +0000532 return getDepthAndIndex(UPP.first.get<NamedDecl *>());
533}
534
Douglas Gregor603cfb42011-01-05 23:12:31 +0000535/// \brief Helper function to build a TemplateParameter when we don't
536/// know its type statically.
537static TemplateParameter makeTemplateParameter(Decl *D) {
538 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
539 return TemplateParameter(TTP);
540 else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
541 return TemplateParameter(NTTP);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000542
Douglas Gregor603cfb42011-01-05 23:12:31 +0000543 return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
544}
545
Douglas Gregor54293852011-01-10 17:35:05 +0000546/// \brief Prepare to perform template argument deduction for all of the
547/// arguments in a set of argument packs.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000548static void PrepareArgumentPackDeduction(Sema &S,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000549 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
550 const SmallVectorImpl<unsigned> &PackIndices,
551 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
552 SmallVectorImpl<
553 SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) {
Douglas Gregor54293852011-01-10 17:35:05 +0000554 // Save the deduced template arguments for each parameter pack expanded
555 // by this pack expansion, then clear out the deduction.
556 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
557 // Save the previously-deduced argument pack, then clear it out so that we
558 // can deduce a new argument pack.
559 SavedPacks[I] = Deduced[PackIndices[I]];
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000560 Deduced[PackIndices[I]] = TemplateArgument();
561
Douglas Gregor54293852011-01-10 17:35:05 +0000562 // If the template arugment pack was explicitly specified, add that to
563 // the set of deduced arguments.
564 const TemplateArgument *ExplicitArgs;
565 unsigned NumExplicitArgs;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000566 if (NamedDecl *PartiallySubstitutedPack
Douglas Gregor54293852011-01-10 17:35:05 +0000567 = S.CurrentInstantiationScope->getPartiallySubstitutedPack(
568 &ExplicitArgs,
569 &NumExplicitArgs)) {
570 if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I])
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000571 NewlyDeducedPacks[I].append(ExplicitArgs,
Douglas Gregor54293852011-01-10 17:35:05 +0000572 ExplicitArgs + NumExplicitArgs);
573 }
574 }
575}
576
Douglas Gregor0216f812011-01-10 17:53:52 +0000577/// \brief Finish template argument deduction for a set of argument packs,
578/// producing the argument packs and checking for consistency with prior
579/// deductions.
580static Sema::TemplateDeductionResult
581FinishArgumentPackDeduction(Sema &S,
582 TemplateParameterList *TemplateParams,
583 bool HasAnyArguments,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000584 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
585 const SmallVectorImpl<unsigned> &PackIndices,
586 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
587 SmallVectorImpl<
588 SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks,
Douglas Gregor0216f812011-01-10 17:53:52 +0000589 TemplateDeductionInfo &Info) {
590 // Build argument packs for each of the parameter packs expanded by this
591 // pack expansion.
592 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
593 if (HasAnyArguments && NewlyDeducedPacks[I].empty()) {
594 // We were not able to deduce anything for this parameter pack,
595 // so just restore the saved argument pack.
596 Deduced[PackIndices[I]] = SavedPacks[I];
597 continue;
598 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000599
Douglas Gregor0216f812011-01-10 17:53:52 +0000600 DeducedTemplateArgument NewPack;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000601
Douglas Gregor0216f812011-01-10 17:53:52 +0000602 if (NewlyDeducedPacks[I].empty()) {
603 // If we deduced an empty argument pack, create it now.
604 NewPack = DeducedTemplateArgument(TemplateArgument(0, 0));
605 } else {
606 TemplateArgument *ArgumentPack
Douglas Gregor203e6a32011-01-11 23:09:57 +0000607 = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()];
Douglas Gregor0216f812011-01-10 17:53:52 +0000608 std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(),
609 ArgumentPack);
610 NewPack
Douglas Gregor203e6a32011-01-11 23:09:57 +0000611 = DeducedTemplateArgument(TemplateArgument(ArgumentPack,
612 NewlyDeducedPacks[I].size()),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000613 NewlyDeducedPacks[I][0].wasDeducedFromArrayBound());
Douglas Gregor0216f812011-01-10 17:53:52 +0000614 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000615
Douglas Gregor0216f812011-01-10 17:53:52 +0000616 DeducedTemplateArgument Result
617 = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack);
618 if (Result.isNull()) {
619 Info.Param
620 = makeTemplateParameter(TemplateParams->getParam(PackIndices[I]));
621 Info.FirstArg = SavedPacks[I];
622 Info.SecondArg = NewPack;
623 return Sema::TDK_Inconsistent;
624 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000625
Douglas Gregor0216f812011-01-10 17:53:52 +0000626 Deduced[PackIndices[I]] = Result;
627 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000628
Douglas Gregor0216f812011-01-10 17:53:52 +0000629 return Sema::TDK_Success;
630}
631
Douglas Gregor603cfb42011-01-05 23:12:31 +0000632/// \brief Deduce the template arguments by comparing the list of parameter
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000633/// types to the list of argument types, as in the parameter-type-lists of
634/// function types (C++ [temp.deduct.type]p10).
Douglas Gregor603cfb42011-01-05 23:12:31 +0000635///
636/// \param S The semantic analysis object within which we are deducing
637///
638/// \param TemplateParams The template parameters that we are deducing
639///
640/// \param Params The list of parameter types
641///
642/// \param NumParams The number of types in \c Params
643///
644/// \param Args The list of argument types
645///
646/// \param NumArgs The number of types in \c Args
647///
648/// \param Info information about the template argument deduction itself
649///
650/// \param Deduced the deduced template arguments
651///
652/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
653/// how template argument deduction is performed.
654///
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000655/// \param PartialOrdering If true, we are performing template argument
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000656/// deduction for during partial ordering for a call
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000657/// (C++0x [temp.deduct.partial]).
658///
Douglas Gregorb939a192011-01-21 17:29:42 +0000659/// \param RefParamComparisons If we're performing template argument deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000660/// in the context of partial ordering, the set of qualifier comparisons.
661///
Douglas Gregor603cfb42011-01-05 23:12:31 +0000662/// \returns the result of template argument deduction so far. Note that a
663/// "success" result means that template argument deduction has not yet failed,
664/// but it may still fail, later, for other reasons.
665static Sema::TemplateDeductionResult
666DeduceTemplateArguments(Sema &S,
667 TemplateParameterList *TemplateParams,
668 const QualType *Params, unsigned NumParams,
669 const QualType *Args, unsigned NumArgs,
670 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000671 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000672 unsigned TDF,
673 bool PartialOrdering = false,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000674 SmallVectorImpl<RefParamPartialOrderingComparison> *
Douglas Gregorb939a192011-01-21 17:29:42 +0000675 RefParamComparisons = 0) {
Douglas Gregor0bbacf82011-01-05 23:23:17 +0000676 // Fast-path check to see if we have too many/too few arguments.
677 if (NumParams != NumArgs &&
678 !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) &&
679 !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1])))
Douglas Gregor3cae5c92011-01-10 20:53:55 +0000680 return Sema::TDK_NonDeducedMismatch;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000681
Douglas Gregor603cfb42011-01-05 23:12:31 +0000682 // C++0x [temp.deduct.type]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000683 // Similarly, if P has a form that contains (T), then each parameter type
684 // Pi of the respective parameter-type- list of P is compared with the
685 // corresponding parameter type Ai of the corresponding parameter-type-list
686 // of A. [...]
Douglas Gregor603cfb42011-01-05 23:12:31 +0000687 unsigned ArgIdx = 0, ParamIdx = 0;
688 for (; ParamIdx != NumParams; ++ParamIdx) {
689 // Check argument types.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000690 const PackExpansionType *Expansion
Douglas Gregor603cfb42011-01-05 23:12:31 +0000691 = dyn_cast<PackExpansionType>(Params[ParamIdx]);
692 if (!Expansion) {
693 // Simple case: compare the parameter and argument types at this point.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000694
Douglas Gregor603cfb42011-01-05 23:12:31 +0000695 // Make sure we have an argument.
696 if (ArgIdx >= NumArgs)
Douglas Gregor3cae5c92011-01-10 20:53:55 +0000697 return Sema::TDK_NonDeducedMismatch;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000698
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000699 if (isa<PackExpansionType>(Args[ArgIdx])) {
700 // C++0x [temp.deduct.type]p22:
701 // If the original function parameter associated with A is a function
702 // parameter pack and the function parameter associated with P is not
703 // a function parameter pack, then template argument deduction fails.
704 return Sema::TDK_NonDeducedMismatch;
705 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000706
Douglas Gregor603cfb42011-01-05 23:12:31 +0000707 if (Sema::TemplateDeductionResult Result
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000708 = DeduceTemplateArguments(S, TemplateParams,
709 Params[ParamIdx],
710 Args[ArgIdx],
711 Info, Deduced, TDF,
712 PartialOrdering,
Douglas Gregorb939a192011-01-21 17:29:42 +0000713 RefParamComparisons))
Douglas Gregor603cfb42011-01-05 23:12:31 +0000714 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000715
Douglas Gregor603cfb42011-01-05 23:12:31 +0000716 ++ArgIdx;
717 continue;
718 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000719
Douglas Gregor7d5c0c12011-01-11 01:52:23 +0000720 // C++0x [temp.deduct.type]p5:
721 // The non-deduced contexts are:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000722 // - A function parameter pack that does not occur at the end of the
Douglas Gregor7d5c0c12011-01-11 01:52:23 +0000723 // parameter-declaration-clause.
724 if (ParamIdx + 1 < NumParams)
725 return Sema::TDK_Success;
726
Douglas Gregor603cfb42011-01-05 23:12:31 +0000727 // C++0x [temp.deduct.type]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000728 // If the parameter-declaration corresponding to Pi is a function
Douglas Gregor603cfb42011-01-05 23:12:31 +0000729 // parameter pack, then the type of its declarator- id is compared with
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000730 // each remaining parameter type in the parameter-type-list of A. Each
Douglas Gregor603cfb42011-01-05 23:12:31 +0000731 // comparison deduces template arguments for subsequent positions in the
732 // template parameter packs expanded by the function parameter pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000733
Douglas Gregor603cfb42011-01-05 23:12:31 +0000734 // Compute the set of template parameter indices that correspond to
735 // parameter packs expanded by the pack expansion.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000736 SmallVector<unsigned, 2> PackIndices;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000737 QualType Pattern = Expansion->getPattern();
738 {
739 llvm::BitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000740 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000741 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
742 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
743 unsigned Depth, Index;
744 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
745 if (Depth == 0 && !SawIndices[Index]) {
746 SawIndices[Index] = true;
747 PackIndices.push_back(Index);
748 }
749 }
750 }
751 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
752
Douglas Gregord3731192011-01-10 07:32:04 +0000753 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000754 // expanded by this pack expansion (the outer index) and for each
Douglas Gregord3731192011-01-10 07:32:04 +0000755 // template argument (the inner SmallVectors).
Chris Lattner5f9e2722011-07-23 10:55:15 +0000756 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregord3731192011-01-10 07:32:04 +0000757 NewlyDeducedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000758 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregor54293852011-01-10 17:35:05 +0000759 SavedPacks(PackIndices.size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000760 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Douglas Gregor54293852011-01-10 17:35:05 +0000761 NewlyDeducedPacks);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000762
Douglas Gregor603cfb42011-01-05 23:12:31 +0000763 bool HasAnyArguments = false;
764 for (; ArgIdx < NumArgs; ++ArgIdx) {
765 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000766
Douglas Gregor603cfb42011-01-05 23:12:31 +0000767 // Deduce template arguments from the pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000768 if (Sema::TemplateDeductionResult Result
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000769 = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
770 Info, Deduced, TDF, PartialOrdering,
771 RefParamComparisons))
Douglas Gregor603cfb42011-01-05 23:12:31 +0000772 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000773
Douglas Gregor603cfb42011-01-05 23:12:31 +0000774 // Capture the deduced template arguments for each parameter pack expanded
775 // by this pack expansion, add them to the list of arguments we've deduced
776 // for that pack, then clear out the deduced argument.
777 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
778 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
779 if (!DeducedArg.isNull()) {
780 NewlyDeducedPacks[I].push_back(DeducedArg);
781 DeducedArg = DeducedTemplateArgument();
782 }
783 }
784 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000785
Douglas Gregor603cfb42011-01-05 23:12:31 +0000786 // Build argument packs for each of the parameter packs expanded by this
787 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +0000788 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000789 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +0000790 Deduced, PackIndices, SavedPacks,
791 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000792 return Result;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000793 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000794
Douglas Gregor603cfb42011-01-05 23:12:31 +0000795 // Make sure we don't have any extra arguments.
796 if (ArgIdx < NumArgs)
Douglas Gregor3cae5c92011-01-10 20:53:55 +0000797 return Sema::TDK_NonDeducedMismatch;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000798
Douglas Gregor603cfb42011-01-05 23:12:31 +0000799 return Sema::TDK_Success;
800}
801
Douglas Gregor61d0b6b2011-04-28 00:56:09 +0000802/// \brief Determine whether the parameter has qualifiers that are either
803/// inconsistent with or a superset of the argument's qualifiers.
804static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
805 QualType ArgType) {
806 Qualifiers ParamQs = ParamType.getQualifiers();
807 Qualifiers ArgQs = ArgType.getQualifiers();
808
809 if (ParamQs == ArgQs)
810 return false;
811
812 // Mismatched (but not missing) Objective-C GC attributes.
813 if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
814 ParamQs.hasObjCGCAttr())
815 return true;
816
817 // Mismatched (but not missing) address spaces.
818 if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
819 ParamQs.hasAddressSpace())
820 return true;
821
John McCallf85e1932011-06-15 23:02:42 +0000822 // Mismatched (but not missing) Objective-C lifetime qualifiers.
823 if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
824 ParamQs.hasObjCLifetime())
825 return true;
826
Douglas Gregor61d0b6b2011-04-28 00:56:09 +0000827 // CVR qualifier superset.
828 return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
829 ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
830 == ParamQs.getCVRQualifiers());
831}
832
Douglas Gregor500d3312009-06-26 18:27:22 +0000833/// \brief Deduce the template arguments by comparing the parameter type and
834/// the argument type (C++ [temp.deduct.type]).
835///
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000836/// \param S the semantic analysis object within which we are deducing
Douglas Gregor500d3312009-06-26 18:27:22 +0000837///
838/// \param TemplateParams the template parameters that we are deducing
839///
840/// \param ParamIn the parameter type
841///
842/// \param ArgIn the argument type
843///
844/// \param Info information about the template argument deduction itself
845///
846/// \param Deduced the deduced template arguments
847///
Douglas Gregor508f1c82009-06-26 23:10:12 +0000848/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
Mike Stump1eb44332009-09-09 15:08:12 +0000849/// how template argument deduction is performed.
Douglas Gregor500d3312009-06-26 18:27:22 +0000850///
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000851/// \param PartialOrdering Whether we're performing template argument deduction
852/// in the context of partial ordering (C++0x [temp.deduct.partial]).
853///
Douglas Gregorb939a192011-01-21 17:29:42 +0000854/// \param RefParamComparisons If we're performing template argument deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000855/// in the context of partial ordering, the set of qualifier comparisons.
856///
Douglas Gregor500d3312009-06-26 18:27:22 +0000857/// \returns the result of template argument deduction so far. Note that a
858/// "success" result means that template argument deduction has not yet failed,
859/// but it may still fail, later, for other reasons.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000860static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000861DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +0000862 TemplateParameterList *TemplateParams,
863 QualType ParamIn, QualType ArgIn,
John McCall2a7fb272010-08-25 05:32:35 +0000864 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000865 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000866 unsigned TDF,
867 bool PartialOrdering,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000868 SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000869 // We only want to look at the canonical types, since typedefs and
870 // sugar are not part of template argument deduction.
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000871 QualType Param = S.Context.getCanonicalType(ParamIn);
872 QualType Arg = S.Context.getCanonicalType(ArgIn);
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000873
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000874 // If the argument type is a pack expansion, look at its pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000875 // This isn't explicitly called out
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000876 if (const PackExpansionType *ArgExpansion
877 = dyn_cast<PackExpansionType>(Arg))
878 Arg = ArgExpansion->getPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000879
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000880 if (PartialOrdering) {
881 // C++0x [temp.deduct.partial]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000882 // Before the partial ordering is done, certain transformations are
883 // performed on the types used for partial ordering:
884 // - If P is a reference type, P is replaced by the type referred to.
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000885 const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
886 if (ParamRef)
887 Param = ParamRef->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000888
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000889 // - If A is a reference type, A is replaced by the type referred to.
890 const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
891 if (ArgRef)
892 Arg = ArgRef->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000893
Douglas Gregorb939a192011-01-21 17:29:42 +0000894 if (RefParamComparisons && ParamRef && ArgRef) {
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000895 // C++0x [temp.deduct.partial]p6:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000896 // If both P and A were reference types (before being replaced with the
897 // type referred to above), determine which of the two types (if any) is
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000898 // more cv-qualified than the other; otherwise the types are considered
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000899 // to be equally cv-qualified for partial ordering purposes. The result
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000900 // of this determination will be used below.
901 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000902 // We save this information for later, using it only when deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000903 // succeeds in both directions.
Douglas Gregorb939a192011-01-21 17:29:42 +0000904 RefParamPartialOrderingComparison Comparison;
905 Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>();
906 Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>();
907 Comparison.Qualifiers = NeitherMoreQualified;
Douglas Gregor769d0cc2011-04-30 17:07:52 +0000908
909 Qualifiers ParamQuals = Param.getQualifiers();
910 Qualifiers ArgQuals = Arg.getQualifiers();
911 if (ParamQuals.isStrictSupersetOf(ArgQuals))
Douglas Gregorb939a192011-01-21 17:29:42 +0000912 Comparison.Qualifiers = ParamMoreQualified;
Douglas Gregor769d0cc2011-04-30 17:07:52 +0000913 else if (ArgQuals.isStrictSupersetOf(ParamQuals))
Douglas Gregorb939a192011-01-21 17:29:42 +0000914 Comparison.Qualifiers = ArgMoreQualified;
915 RefParamComparisons->push_back(Comparison);
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000916 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000917
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000918 // C++0x [temp.deduct.partial]p7:
919 // Remove any top-level cv-qualifiers:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000920 // - If P is a cv-qualified type, P is replaced by the cv-unqualified
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000921 // version of P.
922 Param = Param.getUnqualifiedType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000923 // - If A is a cv-qualified type, A is replaced by the cv-unqualified
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000924 // version of A.
925 Arg = Arg.getUnqualifiedType();
926 } else {
927 // C++0x [temp.deduct.call]p4 bullet 1:
928 // - If the original P is a reference type, the deduced A (i.e., the type
929 // referred to by the reference) can be more cv-qualified than the
930 // transformed A.
931 if (TDF & TDF_ParamWithReferenceType) {
932 Qualifiers Quals;
933 QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
934 Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
John McCall62c28c82011-01-18 07:41:22 +0000935 Arg.getCVRQualifiers());
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000936 Param = S.Context.getQualifiedType(UnqualParam, Quals);
937 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000938
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000939 if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
940 // C++0x [temp.deduct.type]p10:
941 // If P and A are function types that originated from deduction when
942 // taking the address of a function template (14.8.2.2) or when deducing
943 // template arguments from a function declaration (14.8.2.6) and Pi and
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000944 // Ai are parameters of the top-level parameter-type-list of P and A,
945 // respectively, Pi is adjusted if it is an rvalue reference to a
946 // cv-unqualified template parameter and Ai is an lvalue reference, in
947 // which case the type of Pi is changed to be the template parameter
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000948 // type (i.e., T&& is changed to simply T). [ Note: As a result, when
949 // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
NAKAMURA Takumi00995302011-01-27 07:09:49 +0000950 // deduced as X&. - end note ]
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000951 TDF &= ~TDF_TopLevelParameterTypeList;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000952
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000953 if (const RValueReferenceType *ParamRef
954 = Param->getAs<RValueReferenceType>()) {
955 if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
956 !ParamRef->getPointeeType().getQualifiers())
957 if (Arg->isLValueReferenceType())
958 Param = ParamRef->getPointeeType();
959 }
960 }
Douglas Gregor500d3312009-06-26 18:27:22 +0000961 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000962
Douglas Gregorf670c8c2009-06-26 20:57:09 +0000963 // If the parameter type is not dependent, there is nothing to deduce.
Douglas Gregor12820292009-09-14 20:00:47 +0000964 if (!Param->isDependentType()) {
Douglas Gregor3cae5c92011-01-10 20:53:55 +0000965 if (!(TDF & TDF_SkipNonDependent) && Param != Arg)
Douglas Gregor12820292009-09-14 20:00:47 +0000966 return Sema::TDK_NonDeducedMismatch;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000967
Douglas Gregorf670c8c2009-06-26 20:57:09 +0000968 return Sema::TDK_Success;
Douglas Gregor12820292009-09-14 20:00:47 +0000969 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000970
Douglas Gregor199d9912009-06-05 00:53:49 +0000971 // C++ [temp.deduct.type]p9:
Mike Stump1eb44332009-09-09 15:08:12 +0000972 // A template type argument T, a template template argument TT or a
973 // template non-type argument i can be deduced if P and A have one of
Douglas Gregor199d9912009-06-05 00:53:49 +0000974 // the following forms:
975 //
976 // T
977 // cv-list T
Mike Stump1eb44332009-09-09 15:08:12 +0000978 if (const TemplateTypeParmType *TemplateTypeParm
John McCall183700f2009-09-21 23:43:11 +0000979 = Param->getAs<TemplateTypeParmType>()) {
Douglas Gregoraf1308232011-09-22 15:57:07 +0000980 // Just skip any attempts to deduce from a placeholder type.
981 if (Arg->isPlaceholderType())
982 return Sema::TDK_Success;
983
Douglas Gregorf67875d2009-06-12 18:26:56 +0000984 unsigned Index = TemplateTypeParm->getIndex();
Douglas Gregorf290e0d2009-07-22 21:30:48 +0000985 bool RecanonicalizeArg = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000986
Douglas Gregor9e9fae42009-07-22 20:02:25 +0000987 // If the argument type is an array type, move the qualifiers up to the
988 // top level, so they can be matched with the qualifiers on the parameter.
Douglas Gregorf290e0d2009-07-22 21:30:48 +0000989 if (isa<ArrayType>(Arg)) {
John McCall0953e762009-09-24 19:53:00 +0000990 Qualifiers Quals;
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000991 Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
John McCall0953e762009-09-24 19:53:00 +0000992 if (Quals) {
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000993 Arg = S.Context.getQualifiedType(Arg, Quals);
Douglas Gregorf290e0d2009-07-22 21:30:48 +0000994 RecanonicalizeArg = true;
995 }
996 }
Mike Stump1eb44332009-09-09 15:08:12 +0000997
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000998 // The argument type can not be less qualified than the parameter
999 // type.
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001000 if (!(TDF & TDF_IgnoreQualifiers) &&
1001 hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
Douglas Gregorf67875d2009-06-12 18:26:56 +00001002 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
John McCall57e97782010-08-05 09:05:08 +00001003 Info.FirstArg = TemplateArgument(Param);
John McCall833ca992009-10-29 08:12:44 +00001004 Info.SecondArg = TemplateArgument(Arg);
John McCall57e97782010-08-05 09:05:08 +00001005 return Sema::TDK_Underqualified;
Douglas Gregorf67875d2009-06-12 18:26:56 +00001006 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001007
1008 assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001009 assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
John McCall0953e762009-09-24 19:53:00 +00001010 QualType DeducedType = Arg;
John McCall49f4e1c2010-12-10 11:01:00 +00001011
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001012 // Remove any qualifiers on the parameter from the deduced type.
1013 // We checked the qualifiers for consistency above.
1014 Qualifiers DeducedQs = DeducedType.getQualifiers();
1015 Qualifiers ParamQs = Param.getQualifiers();
1016 DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
1017 if (ParamQs.hasObjCGCAttr())
1018 DeducedQs.removeObjCGCAttr();
1019 if (ParamQs.hasAddressSpace())
1020 DeducedQs.removeAddressSpace();
John McCallf85e1932011-06-15 23:02:42 +00001021 if (ParamQs.hasObjCLifetime())
1022 DeducedQs.removeObjCLifetime();
Douglas Gregore559ca12011-06-17 22:11:49 +00001023
1024 // Objective-C ARC:
Douglas Gregorda8b2492011-07-26 14:53:44 +00001025 // If template deduction would produce a lifetime qualifier on a type
1026 // that is not a lifetime type, template argument deduction fails.
1027 if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
1028 !DeducedType->isDependentType()) {
1029 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1030 Info.FirstArg = TemplateArgument(Param);
1031 Info.SecondArg = TemplateArgument(Arg);
1032 return Sema::TDK_Underqualified;
1033 }
1034
1035 // Objective-C ARC:
Douglas Gregore559ca12011-06-17 22:11:49 +00001036 // If template deduction would produce an argument type with lifetime type
1037 // but no lifetime qualifier, the __strong lifetime qualifier is inferred.
1038 if (S.getLangOptions().ObjCAutoRefCount &&
1039 DeducedType->isObjCLifetimeType() &&
1040 !DeducedQs.hasObjCLifetime())
1041 DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
1042
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001043 DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
1044 DeducedQs);
1045
Douglas Gregorf290e0d2009-07-22 21:30:48 +00001046 if (RecanonicalizeArg)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001047 DeducedType = S.Context.getCanonicalType(DeducedType);
Mike Stump1eb44332009-09-09 15:08:12 +00001048
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001049 DeducedTemplateArgument NewDeduced(DeducedType);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001050 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001051 Deduced[Index],
1052 NewDeduced);
1053 if (Result.isNull()) {
1054 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1055 Info.FirstArg = Deduced[Index];
1056 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001057 return Sema::TDK_Inconsistent;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001058 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001059
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001060 Deduced[Index] = Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001061 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001062 }
1063
Douglas Gregorf67875d2009-06-12 18:26:56 +00001064 // Set up the template argument deduction information for a failure.
John McCall833ca992009-10-29 08:12:44 +00001065 Info.FirstArg = TemplateArgument(ParamIn);
1066 Info.SecondArg = TemplateArgument(ArgIn);
Douglas Gregorf67875d2009-06-12 18:26:56 +00001067
Douglas Gregor0bc15d92011-01-14 05:11:40 +00001068 // If the parameter is an already-substituted template parameter
1069 // pack, do nothing: we don't know which of its arguments to look
1070 // at, so we have to wait until all of the parameter packs in this
1071 // expansion have arguments.
1072 if (isa<SubstTemplateTypeParmPackType>(Param))
1073 return Sema::TDK_Success;
1074
Douglas Gregor508f1c82009-06-26 23:10:12 +00001075 // Check the cv-qualifiers on the parameter and argument types.
1076 if (!(TDF & TDF_IgnoreQualifiers)) {
1077 if (TDF & TDF_ParamWithReferenceType) {
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001078 if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
Douglas Gregor508f1c82009-06-26 23:10:12 +00001079 return Sema::TDK_NonDeducedMismatch;
John McCallcd05e812010-08-28 22:14:41 +00001080 } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
Douglas Gregor508f1c82009-06-26 23:10:12 +00001081 if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
Mike Stump1eb44332009-09-09 15:08:12 +00001082 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor508f1c82009-06-26 23:10:12 +00001083 }
1084 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001085
Douglas Gregord560d502009-06-04 00:21:18 +00001086 switch (Param->getTypeClass()) {
Douglas Gregor4ac01402011-06-15 16:02:29 +00001087 // Non-canonical types cannot appear here.
1088#define NON_CANONICAL_TYPE(Class, Base) \
1089 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1090#define TYPE(Class, Base)
1091#include "clang/AST/TypeNodes.def"
1092
1093 case Type::TemplateTypeParm:
1094 case Type::SubstTemplateTypeParmPack:
1095 llvm_unreachable("Type nodes handled above");
1096
1097 // These types cannot be used in templates or cannot be dependent, so
1098 // deduction always fails.
Douglas Gregor199d9912009-06-05 00:53:49 +00001099 case Type::Builtin:
Douglas Gregor4ac01402011-06-15 16:02:29 +00001100 case Type::VariableArray:
1101 case Type::Vector:
1102 case Type::FunctionNoProto:
1103 case Type::Record:
1104 case Type::Enum:
1105 case Type::ObjCObject:
1106 case Type::ObjCInterface:
1107 case Type::ObjCObjectPointer:
Douglas Gregorf67875d2009-06-12 18:26:56 +00001108 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001109
Douglas Gregor4ac01402011-06-15 16:02:29 +00001110 // _Complex T [placeholder extension]
1111 case Type::Complex:
1112 if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
1113 return DeduceTemplateArguments(S, TemplateParams,
1114 cast<ComplexType>(Param)->getElementType(),
1115 ComplexArg->getElementType(),
1116 Info, Deduced, TDF);
1117
1118 return Sema::TDK_NonDeducedMismatch;
Eli Friedmanb001de72011-10-06 23:00:33 +00001119
1120 // _Atomic T [extension]
1121 case Type::Atomic:
1122 if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
1123 return DeduceTemplateArguments(S, TemplateParams,
1124 cast<AtomicType>(Param)->getValueType(),
1125 AtomicArg->getValueType(),
1126 Info, Deduced, TDF);
1127
1128 return Sema::TDK_NonDeducedMismatch;
1129
Douglas Gregor199d9912009-06-05 00:53:49 +00001130 // T *
Douglas Gregord560d502009-06-04 00:21:18 +00001131 case Type::Pointer: {
John McCallc0008342010-05-13 07:48:05 +00001132 QualType PointeeType;
1133 if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
1134 PointeeType = PointerArg->getPointeeType();
1135 } else if (const ObjCObjectPointerType *PointerArg
1136 = Arg->getAs<ObjCObjectPointerType>()) {
1137 PointeeType = PointerArg->getPointeeType();
1138 } else {
Douglas Gregorf67875d2009-06-12 18:26:56 +00001139 return Sema::TDK_NonDeducedMismatch;
John McCallc0008342010-05-13 07:48:05 +00001140 }
Mike Stump1eb44332009-09-09 15:08:12 +00001141
Douglas Gregor41128772009-06-26 23:27:24 +00001142 unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001143 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregord560d502009-06-04 00:21:18 +00001144 cast<PointerType>(Param)->getPointeeType(),
John McCallc0008342010-05-13 07:48:05 +00001145 PointeeType,
Douglas Gregor41128772009-06-26 23:27:24 +00001146 Info, Deduced, SubTDF);
Douglas Gregord560d502009-06-04 00:21:18 +00001147 }
Mike Stump1eb44332009-09-09 15:08:12 +00001148
Douglas Gregor199d9912009-06-05 00:53:49 +00001149 // T &
Douglas Gregord560d502009-06-04 00:21:18 +00001150 case Type::LValueReference: {
Ted Kremenek6217b802009-07-29 21:53:49 +00001151 const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
Douglas Gregord560d502009-06-04 00:21:18 +00001152 if (!ReferenceArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001153 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001154
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001155 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregord560d502009-06-04 00:21:18 +00001156 cast<LValueReferenceType>(Param)->getPointeeType(),
1157 ReferenceArg->getPointeeType(),
Douglas Gregor508f1c82009-06-26 23:10:12 +00001158 Info, Deduced, 0);
Douglas Gregord560d502009-06-04 00:21:18 +00001159 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001160
Douglas Gregor199d9912009-06-05 00:53:49 +00001161 // T && [C++0x]
Douglas Gregord560d502009-06-04 00:21:18 +00001162 case Type::RValueReference: {
Ted Kremenek6217b802009-07-29 21:53:49 +00001163 const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
Douglas Gregord560d502009-06-04 00:21:18 +00001164 if (!ReferenceArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001165 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001166
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001167 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregord560d502009-06-04 00:21:18 +00001168 cast<RValueReferenceType>(Param)->getPointeeType(),
1169 ReferenceArg->getPointeeType(),
Douglas Gregor508f1c82009-06-26 23:10:12 +00001170 Info, Deduced, 0);
Douglas Gregord560d502009-06-04 00:21:18 +00001171 }
Mike Stump1eb44332009-09-09 15:08:12 +00001172
Douglas Gregor199d9912009-06-05 00:53:49 +00001173 // T [] (implied, but not stated explicitly)
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001174 case Type::IncompleteArray: {
Mike Stump1eb44332009-09-09 15:08:12 +00001175 const IncompleteArrayType *IncompleteArrayArg =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001176 S.Context.getAsIncompleteArrayType(Arg);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001177 if (!IncompleteArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001178 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001179
John McCalle4f26e52010-08-19 00:20:19 +00001180 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001181 return DeduceTemplateArguments(S, TemplateParams,
1182 S.Context.getAsIncompleteArrayType(Param)->getElementType(),
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001183 IncompleteArrayArg->getElementType(),
John McCalle4f26e52010-08-19 00:20:19 +00001184 Info, Deduced, SubTDF);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001185 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001186
1187 // T [integer-constant]
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001188 case Type::ConstantArray: {
Mike Stump1eb44332009-09-09 15:08:12 +00001189 const ConstantArrayType *ConstantArrayArg =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001190 S.Context.getAsConstantArrayType(Arg);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001191 if (!ConstantArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001192 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001193
1194 const ConstantArrayType *ConstantArrayParm =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001195 S.Context.getAsConstantArrayType(Param);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001196 if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
Douglas Gregorf67875d2009-06-12 18:26:56 +00001197 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001198
John McCalle4f26e52010-08-19 00:20:19 +00001199 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001200 return DeduceTemplateArguments(S, TemplateParams,
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001201 ConstantArrayParm->getElementType(),
1202 ConstantArrayArg->getElementType(),
John McCalle4f26e52010-08-19 00:20:19 +00001203 Info, Deduced, SubTDF);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001204 }
1205
Douglas Gregor199d9912009-06-05 00:53:49 +00001206 // type [i]
1207 case Type::DependentSizedArray: {
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001208 const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
Douglas Gregor199d9912009-06-05 00:53:49 +00001209 if (!ArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001210 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001211
John McCalle4f26e52010-08-19 00:20:19 +00001212 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1213
Douglas Gregor199d9912009-06-05 00:53:49 +00001214 // Check the element type of the arrays
1215 const DependentSizedArrayType *DependentArrayParm
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001216 = S.Context.getAsDependentSizedArrayType(Param);
Douglas Gregorf67875d2009-06-12 18:26:56 +00001217 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001218 = DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001219 DependentArrayParm->getElementType(),
1220 ArrayArg->getElementType(),
John McCalle4f26e52010-08-19 00:20:19 +00001221 Info, Deduced, SubTDF))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001222 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001223
Douglas Gregor199d9912009-06-05 00:53:49 +00001224 // Determine the array bound is something we can deduce.
Mike Stump1eb44332009-09-09 15:08:12 +00001225 NonTypeTemplateParmDecl *NTTP
Douglas Gregor199d9912009-06-05 00:53:49 +00001226 = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
1227 if (!NTTP)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001228 return Sema::TDK_Success;
Mike Stump1eb44332009-09-09 15:08:12 +00001229
1230 // We can perform template argument deduction for the given non-type
Douglas Gregor199d9912009-06-05 00:53:49 +00001231 // template parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001232 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +00001233 "Cannot deduce non-type template argument at depth > 0");
Mike Stump1eb44332009-09-09 15:08:12 +00001234 if (const ConstantArrayType *ConstantArrayArg
Anders Carlsson335e24a2009-06-16 22:44:31 +00001235 = dyn_cast<ConstantArrayType>(ArrayArg)) {
1236 llvm::APSInt Size(ConstantArrayArg->getSize());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001237 return DeduceNonTypeTemplateArgument(S, NTTP, Size,
Douglas Gregor9d0e4412010-03-26 05:50:28 +00001238 S.Context.getSizeType(),
Douglas Gregor02024a92010-03-28 02:42:43 +00001239 /*ArrayBound=*/true,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001240 Info, Deduced);
Anders Carlsson335e24a2009-06-16 22:44:31 +00001241 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001242 if (const DependentSizedArrayType *DependentArrayArg
1243 = dyn_cast<DependentSizedArrayType>(ArrayArg))
Douglas Gregor34c2f8c2010-12-22 23:15:38 +00001244 if (DependentArrayArg->getSizeExpr())
1245 return DeduceNonTypeTemplateArgument(S, NTTP,
1246 DependentArrayArg->getSizeExpr(),
1247 Info, Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001248
Douglas Gregor199d9912009-06-05 00:53:49 +00001249 // Incomplete type does not match a dependently-sized array type
Douglas Gregorf67875d2009-06-12 18:26:56 +00001250 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001251 }
Mike Stump1eb44332009-09-09 15:08:12 +00001252
1253 // type(*)(T)
1254 // T(*)()
1255 // T(*)(T)
Anders Carlssona27fad52009-06-08 15:19:08 +00001256 case Type::FunctionProto: {
Douglas Gregor73b3cf62011-01-25 17:19:08 +00001257 unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
Mike Stump1eb44332009-09-09 15:08:12 +00001258 const FunctionProtoType *FunctionProtoArg =
Anders Carlssona27fad52009-06-08 15:19:08 +00001259 dyn_cast<FunctionProtoType>(Arg);
1260 if (!FunctionProtoArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001261 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001262
1263 const FunctionProtoType *FunctionProtoParam =
Anders Carlssona27fad52009-06-08 15:19:08 +00001264 cast<FunctionProtoType>(Param);
Anders Carlsson994b6cb2009-06-08 19:22:23 +00001265
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001266 if (FunctionProtoParam->getTypeQuals()
Douglas Gregore3c7a7c2011-01-26 16:50:54 +00001267 != FunctionProtoArg->getTypeQuals() ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001268 FunctionProtoParam->getRefQualifier()
Douglas Gregore3c7a7c2011-01-26 16:50:54 +00001269 != FunctionProtoArg->getRefQualifier() ||
1270 FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
Douglas Gregorf67875d2009-06-12 18:26:56 +00001271 return Sema::TDK_NonDeducedMismatch;
Anders Carlsson994b6cb2009-06-08 19:22:23 +00001272
Anders Carlssona27fad52009-06-08 15:19:08 +00001273 // Check return types.
Douglas Gregorf67875d2009-06-12 18:26:56 +00001274 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001275 = DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001276 FunctionProtoParam->getResultType(),
1277 FunctionProtoArg->getResultType(),
Douglas Gregor508f1c82009-06-26 23:10:12 +00001278 Info, Deduced, 0))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001279 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001280
Douglas Gregor603cfb42011-01-05 23:12:31 +00001281 return DeduceTemplateArguments(S, TemplateParams,
1282 FunctionProtoParam->arg_type_begin(),
1283 FunctionProtoParam->getNumArgs(),
1284 FunctionProtoArg->arg_type_begin(),
1285 FunctionProtoArg->getNumArgs(),
Douglas Gregor73b3cf62011-01-25 17:19:08 +00001286 Info, Deduced, SubTDF);
Anders Carlssona27fad52009-06-08 15:19:08 +00001287 }
Mike Stump1eb44332009-09-09 15:08:12 +00001288
John McCall3cb0ebd2010-03-10 03:28:59 +00001289 case Type::InjectedClassName: {
1290 // Treat a template's injected-class-name as if the template
1291 // specialization type had been used.
John McCall31f17ec2010-04-27 00:57:59 +00001292 Param = cast<InjectedClassNameType>(Param)
1293 ->getInjectedSpecializationType();
John McCall3cb0ebd2010-03-10 03:28:59 +00001294 assert(isa<TemplateSpecializationType>(Param) &&
1295 "injected class name is not a template specialization type");
1296 // fall through
1297 }
1298
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001299 // template-name<T> (where template-name refers to a class template)
Douglas Gregord708c722009-06-09 16:35:58 +00001300 // template-name<i>
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001301 // TT<T>
1302 // TT<i>
1303 // TT<>
Douglas Gregord708c722009-06-09 16:35:58 +00001304 case Type::TemplateSpecialization: {
1305 const TemplateSpecializationType *SpecParam
1306 = cast<TemplateSpecializationType>(Param);
Mike Stump1eb44332009-09-09 15:08:12 +00001307
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001308 // Try to deduce template arguments from the template-id.
1309 Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001310 = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001311 Info, Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001312
Douglas Gregor4a5c15f2009-09-30 22:13:51 +00001313 if (Result && (TDF & TDF_DerivedClass)) {
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001314 // C++ [temp.deduct.call]p3b3:
1315 // If P is a class, and P has the form template-id, then A can be a
1316 // derived class of the deduced A. Likewise, if P is a pointer to a
Mike Stump1eb44332009-09-09 15:08:12 +00001317 // class of the form template-id, A can be a pointer to a derived
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001318 // class pointed to by the deduced A.
1319 //
1320 // More importantly:
Mike Stump1eb44332009-09-09 15:08:12 +00001321 // These alternatives are considered only if type deduction would
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001322 // otherwise fail.
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001323 if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
1324 // We cannot inspect base classes as part of deduction when the type
1325 // is incomplete, so either instantiate any templates necessary to
1326 // complete the type, or skip over it if it cannot be completed.
John McCall5769d612010-02-08 23:07:23 +00001327 if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001328 return Result;
1329
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001330 // Use data recursion to crawl through the list of base classes.
Mike Stump1eb44332009-09-09 15:08:12 +00001331 // Visited contains the set of nodes we have already visited, while
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001332 // ToVisit is our stack of records that we still need to visit.
1333 llvm::SmallPtrSet<const RecordType *, 8> Visited;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001334 SmallVector<const RecordType *, 8> ToVisit;
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001335 ToVisit.push_back(RecordT);
1336 bool Successful = false;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001337 SmallVectorImpl<DeducedTemplateArgument> DeducedOrig(0);
Douglas Gregor053105d2010-11-02 00:02:34 +00001338 DeducedOrig = Deduced;
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001339 while (!ToVisit.empty()) {
1340 // Retrieve the next class in the inheritance hierarchy.
1341 const RecordType *NextT = ToVisit.back();
1342 ToVisit.pop_back();
Mike Stump1eb44332009-09-09 15:08:12 +00001343
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001344 // If we have already seen this type, skip it.
1345 if (!Visited.insert(NextT))
1346 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001347
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001348 // If this is a base class, try to perform template argument
1349 // deduction from it.
1350 if (NextT != RecordT) {
1351 Sema::TemplateDeductionResult BaseResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001352 = DeduceTemplateArguments(S, TemplateParams, SpecParam,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001353 QualType(NextT, 0), Info, Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001354
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001355 // If template argument deduction for this base was successful,
Douglas Gregor053105d2010-11-02 00:02:34 +00001356 // note that we had some success. Otherwise, ignore any deductions
1357 // from this base class.
1358 if (BaseResult == Sema::TDK_Success) {
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001359 Successful = true;
Douglas Gregor053105d2010-11-02 00:02:34 +00001360 DeducedOrig = Deduced;
1361 }
1362 else
1363 Deduced = DeducedOrig;
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001364 }
Mike Stump1eb44332009-09-09 15:08:12 +00001365
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001366 // Visit base classes
1367 CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
1368 for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
1369 BaseEnd = Next->bases_end();
Sebastian Redl9994a342009-10-25 17:03:50 +00001370 Base != BaseEnd; ++Base) {
Mike Stump1eb44332009-09-09 15:08:12 +00001371 assert(Base->getType()->isRecordType() &&
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001372 "Base class that isn't a record?");
Ted Kremenek6217b802009-07-29 21:53:49 +00001373 ToVisit.push_back(Base->getType()->getAs<RecordType>());
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001374 }
1375 }
Mike Stump1eb44332009-09-09 15:08:12 +00001376
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001377 if (Successful)
1378 return Sema::TDK_Success;
1379 }
Mike Stump1eb44332009-09-09 15:08:12 +00001380
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001381 }
Mike Stump1eb44332009-09-09 15:08:12 +00001382
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001383 return Result;
Douglas Gregord708c722009-06-09 16:35:58 +00001384 }
1385
Douglas Gregor637a4092009-06-10 23:47:09 +00001386 // T type::*
1387 // T T::*
1388 // T (type::*)()
1389 // type (T::*)()
1390 // type (type::*)(T)
1391 // type (T::*)(T)
1392 // T (type::*)(T)
1393 // T (T::*)()
1394 // T (T::*)(T)
1395 case Type::MemberPointer: {
1396 const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
1397 const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
1398 if (!MemPtrArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001399 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor637a4092009-06-10 23:47:09 +00001400
Douglas Gregorf67875d2009-06-12 18:26:56 +00001401 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001402 = DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001403 MemPtrParam->getPointeeType(),
1404 MemPtrArg->getPointeeType(),
Douglas Gregor508f1c82009-06-26 23:10:12 +00001405 Info, Deduced,
1406 TDF & TDF_IgnoreQualifiers))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001407 return Result;
1408
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001409 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001410 QualType(MemPtrParam->getClass(), 0),
1411 QualType(MemPtrArg->getClass(), 0),
Douglas Gregor508f1c82009-06-26 23:10:12 +00001412 Info, Deduced, 0);
Douglas Gregor637a4092009-06-10 23:47:09 +00001413 }
1414
Anders Carlsson9a917e42009-06-12 22:56:54 +00001415 // (clang extension)
1416 //
Mike Stump1eb44332009-09-09 15:08:12 +00001417 // type(^)(T)
1418 // T(^)()
1419 // T(^)(T)
Anders Carlsson859ba502009-06-12 16:23:10 +00001420 case Type::BlockPointer: {
1421 const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
1422 const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +00001423
Anders Carlsson859ba502009-06-12 16:23:10 +00001424 if (!BlockPtrArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001425 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001426
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001427 return DeduceTemplateArguments(S, TemplateParams,
Anders Carlsson859ba502009-06-12 16:23:10 +00001428 BlockPtrParam->getPointeeType(),
Douglas Gregorf67875d2009-06-12 18:26:56 +00001429 BlockPtrArg->getPointeeType(), Info,
Douglas Gregor508f1c82009-06-26 23:10:12 +00001430 Deduced, 0);
Anders Carlsson859ba502009-06-12 16:23:10 +00001431 }
1432
Douglas Gregor4ac01402011-06-15 16:02:29 +00001433 // (clang extension)
1434 //
1435 // T __attribute__(((ext_vector_type(<integral constant>))))
1436 case Type::ExtVector: {
1437 const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
1438 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1439 // Make sure that the vectors have the same number of elements.
1440 if (VectorParam->getNumElements() != VectorArg->getNumElements())
1441 return Sema::TDK_NonDeducedMismatch;
1442
1443 // Perform deduction on the element types.
1444 return DeduceTemplateArguments(S, TemplateParams,
1445 VectorParam->getElementType(),
1446 VectorArg->getElementType(),
1447 Info, Deduced,
1448 TDF);
1449 }
1450
1451 if (const DependentSizedExtVectorType *VectorArg
1452 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1453 // We can't check the number of elements, since the argument has a
1454 // dependent number of elements. This can only occur during partial
1455 // ordering.
1456
1457 // Perform deduction on the element types.
1458 return DeduceTemplateArguments(S, TemplateParams,
1459 VectorParam->getElementType(),
1460 VectorArg->getElementType(),
1461 Info, Deduced,
1462 TDF);
1463 }
1464
1465 return Sema::TDK_NonDeducedMismatch;
1466 }
1467
1468 // (clang extension)
1469 //
1470 // T __attribute__(((ext_vector_type(N))))
1471 case Type::DependentSizedExtVector: {
1472 const DependentSizedExtVectorType *VectorParam
1473 = cast<DependentSizedExtVectorType>(Param);
1474
1475 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1476 // Perform deduction on the element types.
1477 if (Sema::TemplateDeductionResult Result
1478 = DeduceTemplateArguments(S, TemplateParams,
1479 VectorParam->getElementType(),
1480 VectorArg->getElementType(),
1481 Info, Deduced,
1482 TDF))
1483 return Result;
1484
1485 // Perform deduction on the vector size, if we can.
1486 NonTypeTemplateParmDecl *NTTP
1487 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1488 if (!NTTP)
1489 return Sema::TDK_Success;
1490
1491 llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
1492 ArgSize = VectorArg->getNumElements();
1493 return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy,
1494 false, Info, Deduced);
1495 }
1496
1497 if (const DependentSizedExtVectorType *VectorArg
1498 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1499 // Perform deduction on the element types.
1500 if (Sema::TemplateDeductionResult Result
1501 = DeduceTemplateArguments(S, TemplateParams,
1502 VectorParam->getElementType(),
1503 VectorArg->getElementType(),
1504 Info, Deduced,
1505 TDF))
1506 return Result;
1507
1508 // Perform deduction on the vector size, if we can.
1509 NonTypeTemplateParmDecl *NTTP
1510 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1511 if (!NTTP)
1512 return Sema::TDK_Success;
1513
1514 return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(),
1515 Info, Deduced);
1516 }
1517
1518 return Sema::TDK_NonDeducedMismatch;
1519 }
1520
Douglas Gregor637a4092009-06-10 23:47:09 +00001521 case Type::TypeOfExpr:
1522 case Type::TypeOf:
Douglas Gregor4714c122010-03-31 17:34:00 +00001523 case Type::DependentName:
Douglas Gregor4ac01402011-06-15 16:02:29 +00001524 case Type::UnresolvedUsing:
1525 case Type::Decltype:
1526 case Type::UnaryTransform:
1527 case Type::Auto:
1528 case Type::DependentTemplateSpecialization:
1529 case Type::PackExpansion:
Douglas Gregor637a4092009-06-10 23:47:09 +00001530 // No template argument deduction for these types
Douglas Gregorf67875d2009-06-12 18:26:56 +00001531 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001532 }
1533
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001534 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001535}
1536
Douglas Gregorf67875d2009-06-12 18:26:56 +00001537static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001538DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001539 TemplateParameterList *TemplateParams,
1540 const TemplateArgument &Param,
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001541 TemplateArgument Arg,
John McCall2a7fb272010-08-25 05:32:35 +00001542 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001543 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001544 // If the template argument is a pack expansion, perform template argument
1545 // deduction against the pattern of that expansion. This only occurs during
1546 // partial ordering.
1547 if (Arg.isPackExpansion())
1548 Arg = Arg.getPackExpansionPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001549
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001550 switch (Param.getKind()) {
Douglas Gregor199d9912009-06-05 00:53:49 +00001551 case TemplateArgument::Null:
David Blaikieb219cfc2011-09-23 05:06:16 +00001552 llvm_unreachable("Null template argument in parameter list");
Mike Stump1eb44332009-09-09 15:08:12 +00001553
1554 case TemplateArgument::Type:
Douglas Gregor788cd062009-11-11 01:00:40 +00001555 if (Arg.getKind() == TemplateArgument::Type)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001556 return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(),
Douglas Gregor788cd062009-11-11 01:00:40 +00001557 Arg.getAsType(), Info, Deduced, 0);
1558 Info.FirstArg = Param;
1559 Info.SecondArg = Arg;
1560 return Sema::TDK_NonDeducedMismatch;
Douglas Gregora7fc9012011-01-05 18:58:31 +00001561
Douglas Gregor788cd062009-11-11 01:00:40 +00001562 case TemplateArgument::Template:
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001563 if (Arg.getKind() == TemplateArgument::Template)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001564 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor788cd062009-11-11 01:00:40 +00001565 Param.getAsTemplate(),
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001566 Arg.getAsTemplate(), Info, Deduced);
Douglas Gregor788cd062009-11-11 01:00:40 +00001567 Info.FirstArg = Param;
1568 Info.SecondArg = Arg;
1569 return Sema::TDK_NonDeducedMismatch;
Douglas Gregora7fc9012011-01-05 18:58:31 +00001570
1571 case TemplateArgument::TemplateExpansion:
1572 llvm_unreachable("caller should handle pack expansions");
1573 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001574
Douglas Gregor199d9912009-06-05 00:53:49 +00001575 case TemplateArgument::Declaration:
Douglas Gregor788cd062009-11-11 01:00:40 +00001576 if (Arg.getKind() == TemplateArgument::Declaration &&
1577 Param.getAsDecl()->getCanonicalDecl() ==
1578 Arg.getAsDecl()->getCanonicalDecl())
1579 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001580
Douglas Gregorf67875d2009-06-12 18:26:56 +00001581 Info.FirstArg = Param;
1582 Info.SecondArg = Arg;
1583 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001584
Douglas Gregor199d9912009-06-05 00:53:49 +00001585 case TemplateArgument::Integral:
1586 if (Arg.getKind() == TemplateArgument::Integral) {
Douglas Gregor9d0e4412010-03-26 05:50:28 +00001587 if (hasSameExtendedValue(*Param.getAsIntegral(), *Arg.getAsIntegral()))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001588 return Sema::TDK_Success;
1589
1590 Info.FirstArg = Param;
1591 Info.SecondArg = Arg;
1592 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001593 }
Douglas Gregorf67875d2009-06-12 18:26:56 +00001594
1595 if (Arg.getKind() == TemplateArgument::Expression) {
1596 Info.FirstArg = Param;
1597 Info.SecondArg = Arg;
1598 return Sema::TDK_NonDeducedMismatch;
1599 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001600
Douglas Gregorf67875d2009-06-12 18:26:56 +00001601 Info.FirstArg = Param;
1602 Info.SecondArg = Arg;
1603 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001604
Douglas Gregor199d9912009-06-05 00:53:49 +00001605 case TemplateArgument::Expression: {
Mike Stump1eb44332009-09-09 15:08:12 +00001606 if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor199d9912009-06-05 00:53:49 +00001607 = getDeducedParameterFromExpr(Param.getAsExpr())) {
1608 if (Arg.getKind() == TemplateArgument::Integral)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001609 return DeduceNonTypeTemplateArgument(S, NTTP,
Mike Stump1eb44332009-09-09 15:08:12 +00001610 *Arg.getAsIntegral(),
Douglas Gregor9d0e4412010-03-26 05:50:28 +00001611 Arg.getIntegralType(),
Douglas Gregor02024a92010-03-28 02:42:43 +00001612 /*ArrayBound=*/false,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001613 Info, Deduced);
Douglas Gregor199d9912009-06-05 00:53:49 +00001614 if (Arg.getKind() == TemplateArgument::Expression)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001615 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
Douglas Gregorf67875d2009-06-12 18:26:56 +00001616 Info, Deduced);
Douglas Gregor15755cb2009-11-13 23:45:44 +00001617 if (Arg.getKind() == TemplateArgument::Declaration)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001618 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
Douglas Gregor15755cb2009-11-13 23:45:44 +00001619 Info, Deduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001620
Douglas Gregorf67875d2009-06-12 18:26:56 +00001621 Info.FirstArg = Param;
1622 Info.SecondArg = Arg;
1623 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001624 }
Mike Stump1eb44332009-09-09 15:08:12 +00001625
Douglas Gregor199d9912009-06-05 00:53:49 +00001626 // Can't deduce anything, but that's okay.
Douglas Gregorf67875d2009-06-12 18:26:56 +00001627 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001628 }
Anders Carlssond01b1da2009-06-15 17:04:53 +00001629 case TemplateArgument::Pack:
Douglas Gregor20a55e22010-12-22 18:17:10 +00001630 llvm_unreachable("Argument packs should be expanded by the caller!");
Douglas Gregor199d9912009-06-05 00:53:49 +00001631 }
Mike Stump1eb44332009-09-09 15:08:12 +00001632
Douglas Gregorf67875d2009-06-12 18:26:56 +00001633 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001634}
1635
Douglas Gregor20a55e22010-12-22 18:17:10 +00001636/// \brief Determine whether there is a template argument to be used for
1637/// deduction.
1638///
1639/// This routine "expands" argument packs in-place, overriding its input
1640/// parameters so that \c Args[ArgIdx] will be the available template argument.
1641///
1642/// \returns true if there is another template argument (which will be at
1643/// \c Args[ArgIdx]), false otherwise.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001644static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
Douglas Gregor20a55e22010-12-22 18:17:10 +00001645 unsigned &ArgIdx,
1646 unsigned &NumArgs) {
1647 if (ArgIdx == NumArgs)
1648 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001649
Douglas Gregor20a55e22010-12-22 18:17:10 +00001650 const TemplateArgument &Arg = Args[ArgIdx];
1651 if (Arg.getKind() != TemplateArgument::Pack)
1652 return true;
1653
1654 assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?");
1655 Args = Arg.pack_begin();
1656 NumArgs = Arg.pack_size();
1657 ArgIdx = 0;
1658 return ArgIdx < NumArgs;
1659}
1660
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001661/// \brief Determine whether the given set of template arguments has a pack
1662/// expansion that is not the last template argument.
1663static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args,
1664 unsigned NumArgs) {
1665 unsigned ArgIdx = 0;
1666 while (ArgIdx < NumArgs) {
1667 const TemplateArgument &Arg = Args[ArgIdx];
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001668
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001669 // Unwrap argument packs.
1670 if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
1671 Args = Arg.pack_begin();
1672 NumArgs = Arg.pack_size();
1673 ArgIdx = 0;
1674 continue;
1675 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001676
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001677 ++ArgIdx;
1678 if (ArgIdx == NumArgs)
1679 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001680
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001681 if (Arg.isPackExpansion())
1682 return true;
1683 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001684
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001685 return false;
1686}
1687
Douglas Gregor20a55e22010-12-22 18:17:10 +00001688static Sema::TemplateDeductionResult
1689DeduceTemplateArguments(Sema &S,
1690 TemplateParameterList *TemplateParams,
1691 const TemplateArgument *Params, unsigned NumParams,
1692 const TemplateArgument *Args, unsigned NumArgs,
1693 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001694 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor0972c862010-12-22 18:55:49 +00001695 bool NumberOfArgumentsMustMatch) {
Douglas Gregore02e2622010-12-22 21:19:48 +00001696 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001697 // If the template argument list of P contains a pack expansion that is not
1698 // the last template argument, the entire template argument list is a
Douglas Gregore02e2622010-12-22 21:19:48 +00001699 // non-deduced context.
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001700 if (hasPackExpansionBeforeEnd(Params, NumParams))
1701 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001702
Douglas Gregore02e2622010-12-22 21:19:48 +00001703 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001704 // If P has a form that contains <T> or <i>, then each argument Pi of the
1705 // respective template argument list P is compared with the corresponding
Douglas Gregore02e2622010-12-22 21:19:48 +00001706 // argument Ai of the corresponding template argument list of A.
Douglas Gregor20a55e22010-12-22 18:17:10 +00001707 unsigned ArgIdx = 0, ParamIdx = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001708 for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
Douglas Gregor20a55e22010-12-22 18:17:10 +00001709 ++ParamIdx) {
1710 if (!Params[ParamIdx].isPackExpansion()) {
Douglas Gregore02e2622010-12-22 21:19:48 +00001711 // The simple case: deduce template arguments by matching Pi and Ai.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001712
Douglas Gregor20a55e22010-12-22 18:17:10 +00001713 // Check whether we have enough arguments.
1714 if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
Douglas Gregor3cae5c92011-01-10 20:53:55 +00001715 return NumberOfArgumentsMustMatch? Sema::TDK_NonDeducedMismatch
Douglas Gregor0972c862010-12-22 18:55:49 +00001716 : Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001717
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001718 if (Args[ArgIdx].isPackExpansion()) {
1719 // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
1720 // but applied to pack expansions that are template arguments.
1721 return Sema::TDK_NonDeducedMismatch;
1722 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001723
Douglas Gregore02e2622010-12-22 21:19:48 +00001724 // Perform deduction for this Pi/Ai pair.
Douglas Gregor20a55e22010-12-22 18:17:10 +00001725 if (Sema::TemplateDeductionResult Result
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001726 = DeduceTemplateArguments(S, TemplateParams,
1727 Params[ParamIdx], Args[ArgIdx],
1728 Info, Deduced))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001729 return Result;
1730
Douglas Gregor20a55e22010-12-22 18:17:10 +00001731 // Move to the next argument.
1732 ++ArgIdx;
1733 continue;
1734 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001735
Douglas Gregore02e2622010-12-22 21:19:48 +00001736 // The parameter is a pack expansion.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001737
Douglas Gregore02e2622010-12-22 21:19:48 +00001738 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001739 // If Pi is a pack expansion, then the pattern of Pi is compared with
1740 // each remaining argument in the template argument list of A. Each
1741 // comparison deduces template arguments for subsequent positions in the
Douglas Gregore02e2622010-12-22 21:19:48 +00001742 // template parameter packs expanded by Pi.
1743 TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001744
Douglas Gregore02e2622010-12-22 21:19:48 +00001745 // Compute the set of template parameter indices that correspond to
1746 // parameter packs expanded by the pack expansion.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001747 SmallVector<unsigned, 2> PackIndices;
Douglas Gregore02e2622010-12-22 21:19:48 +00001748 {
1749 llvm::BitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001750 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregore02e2622010-12-22 21:19:48 +00001751 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1752 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
1753 unsigned Depth, Index;
1754 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
1755 if (Depth == 0 && !SawIndices[Index]) {
1756 SawIndices[Index] = true;
1757 PackIndices.push_back(Index);
1758 }
1759 }
1760 }
1761 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001762
Douglas Gregore02e2622010-12-22 21:19:48 +00001763 // FIXME: If there are no remaining arguments, we can bail out early
1764 // and set any deduced parameter packs to an empty argument pack.
1765 // The latter part of this is a (minor) correctness issue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001766
Douglas Gregore02e2622010-12-22 21:19:48 +00001767 // Save the deduced template arguments for each parameter pack expanded
1768 // by this pack expansion, then clear out the deduction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001769 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregore02e2622010-12-22 21:19:48 +00001770 SavedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001771 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregor54293852011-01-10 17:35:05 +00001772 NewlyDeducedPacks(PackIndices.size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001773 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Douglas Gregor54293852011-01-10 17:35:05 +00001774 NewlyDeducedPacks);
Douglas Gregore02e2622010-12-22 21:19:48 +00001775
1776 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001777 // expanded by this pack expansion (the outer index) and for each
Douglas Gregore02e2622010-12-22 21:19:48 +00001778 // template argument (the inner SmallVectors).
Douglas Gregore02e2622010-12-22 21:19:48 +00001779 bool HasAnyArguments = false;
1780 while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) {
1781 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001782
Douglas Gregore02e2622010-12-22 21:19:48 +00001783 // Deduce template arguments from the pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001784 if (Sema::TemplateDeductionResult Result
Douglas Gregore02e2622010-12-22 21:19:48 +00001785 = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
1786 Info, Deduced))
1787 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001788
Douglas Gregore02e2622010-12-22 21:19:48 +00001789 // Capture the deduced template arguments for each parameter pack expanded
1790 // by this pack expansion, add them to the list of arguments we've deduced
1791 // for that pack, then clear out the deduced argument.
1792 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
1793 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
1794 if (!DeducedArg.isNull()) {
1795 NewlyDeducedPacks[I].push_back(DeducedArg);
1796 DeducedArg = DeducedTemplateArgument();
1797 }
1798 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001799
Douglas Gregore02e2622010-12-22 21:19:48 +00001800 ++ArgIdx;
1801 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001802
Douglas Gregore02e2622010-12-22 21:19:48 +00001803 // Build argument packs for each of the parameter packs expanded by this
1804 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +00001805 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001806 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +00001807 Deduced, PackIndices, SavedPacks,
1808 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001809 return Result;
Douglas Gregor20a55e22010-12-22 18:17:10 +00001810 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001811
Douglas Gregor20a55e22010-12-22 18:17:10 +00001812 // If there is an argument remaining, then we had too many arguments.
Douglas Gregor0972c862010-12-22 18:55:49 +00001813 if (NumberOfArgumentsMustMatch &&
1814 hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
Douglas Gregor3cae5c92011-01-10 20:53:55 +00001815 return Sema::TDK_NonDeducedMismatch;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001816
Douglas Gregor20a55e22010-12-22 18:17:10 +00001817 return Sema::TDK_Success;
1818}
1819
Mike Stump1eb44332009-09-09 15:08:12 +00001820static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001821DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001822 TemplateParameterList *TemplateParams,
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001823 const TemplateArgumentList &ParamList,
1824 const TemplateArgumentList &ArgList,
John McCall2a7fb272010-08-25 05:32:35 +00001825 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001826 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001827 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +00001828 ParamList.data(), ParamList.size(),
1829 ArgList.data(), ArgList.size(),
1830 Info, Deduced);
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001831}
1832
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001833/// \brief Determine whether two template arguments are the same.
Mike Stump1eb44332009-09-09 15:08:12 +00001834static bool isSameTemplateArg(ASTContext &Context,
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001835 const TemplateArgument &X,
1836 const TemplateArgument &Y) {
1837 if (X.getKind() != Y.getKind())
1838 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001839
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001840 switch (X.getKind()) {
1841 case TemplateArgument::Null:
David Blaikieb219cfc2011-09-23 05:06:16 +00001842 llvm_unreachable("Comparing NULL template argument");
Mike Stump1eb44332009-09-09 15:08:12 +00001843
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001844 case TemplateArgument::Type:
1845 return Context.getCanonicalType(X.getAsType()) ==
1846 Context.getCanonicalType(Y.getAsType());
Mike Stump1eb44332009-09-09 15:08:12 +00001847
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001848 case TemplateArgument::Declaration:
Argyrios Kyrtzidis97fbaa22009-07-18 00:34:25 +00001849 return X.getAsDecl()->getCanonicalDecl() ==
1850 Y.getAsDecl()->getCanonicalDecl();
Mike Stump1eb44332009-09-09 15:08:12 +00001851
Douglas Gregor788cd062009-11-11 01:00:40 +00001852 case TemplateArgument::Template:
Douglas Gregora7fc9012011-01-05 18:58:31 +00001853 case TemplateArgument::TemplateExpansion:
1854 return Context.getCanonicalTemplateName(
1855 X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
1856 Context.getCanonicalTemplateName(
1857 Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001858
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001859 case TemplateArgument::Integral:
1860 return *X.getAsIntegral() == *Y.getAsIntegral();
Mike Stump1eb44332009-09-09 15:08:12 +00001861
Douglas Gregor788cd062009-11-11 01:00:40 +00001862 case TemplateArgument::Expression: {
1863 llvm::FoldingSetNodeID XID, YID;
1864 X.getAsExpr()->Profile(XID, Context, true);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001865 Y.getAsExpr()->Profile(YID, Context, true);
Douglas Gregor788cd062009-11-11 01:00:40 +00001866 return XID == YID;
1867 }
Mike Stump1eb44332009-09-09 15:08:12 +00001868
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001869 case TemplateArgument::Pack:
1870 if (X.pack_size() != Y.pack_size())
1871 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001872
1873 for (TemplateArgument::pack_iterator XP = X.pack_begin(),
1874 XPEnd = X.pack_end(),
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001875 YP = Y.pack_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001876 XP != XPEnd; ++XP, ++YP)
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001877 if (!isSameTemplateArg(Context, *XP, *YP))
1878 return false;
1879
1880 return true;
1881 }
1882
1883 return false;
1884}
1885
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001886/// \brief Allocate a TemplateArgumentLoc where all locations have
1887/// been initialized to the given location.
1888///
1889/// \param S The semantic analysis object.
1890///
1891/// \param The template argument we are producing template argument
1892/// location information for.
1893///
1894/// \param NTTPType For a declaration template argument, the type of
1895/// the non-type template parameter that corresponds to this template
1896/// argument.
1897///
1898/// \param Loc The source location to use for the resulting template
1899/// argument.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001900static TemplateArgumentLoc
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001901getTrivialTemplateArgumentLoc(Sema &S,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001902 const TemplateArgument &Arg,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001903 QualType NTTPType,
1904 SourceLocation Loc) {
1905 switch (Arg.getKind()) {
1906 case TemplateArgument::Null:
1907 llvm_unreachable("Can't get a NULL template argument here");
1908 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001909
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001910 case TemplateArgument::Type:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001911 return TemplateArgumentLoc(Arg,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001912 S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001913
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001914 case TemplateArgument::Declaration: {
1915 Expr *E
Douglas Gregorba68eca2011-01-05 17:40:24 +00001916 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001917 .takeAs<Expr>();
1918 return TemplateArgumentLoc(TemplateArgument(E), E);
1919 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001920
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001921 case TemplateArgument::Integral: {
1922 Expr *E
Douglas Gregorba68eca2011-01-05 17:40:24 +00001923 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001924 return TemplateArgumentLoc(TemplateArgument(E), E);
1925 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001926
Douglas Gregorb6744ef2011-03-02 17:09:35 +00001927 case TemplateArgument::Template:
1928 case TemplateArgument::TemplateExpansion: {
1929 NestedNameSpecifierLocBuilder Builder;
1930 TemplateName Template = Arg.getAsTemplate();
1931 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
1932 Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc);
1933 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
1934 Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc);
1935
1936 if (Arg.getKind() == TemplateArgument::Template)
1937 return TemplateArgumentLoc(Arg,
1938 Builder.getWithLocInContext(S.Context),
1939 Loc);
1940
1941
1942 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
1943 Loc, Loc);
1944 }
Douglas Gregora7fc9012011-01-05 18:58:31 +00001945
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001946 case TemplateArgument::Expression:
1947 return TemplateArgumentLoc(Arg, Arg.getAsExpr());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001948
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001949 case TemplateArgument::Pack:
1950 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
1951 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001952
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001953 return TemplateArgumentLoc();
1954}
1955
1956
1957/// \brief Convert the given deduced template argument and add it to the set of
1958/// fully-converted template arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001959static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001960 DeducedTemplateArgument Arg,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001961 NamedDecl *Template,
1962 QualType NTTPType,
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001963 unsigned ArgumentPackIndex,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001964 TemplateDeductionInfo &Info,
1965 bool InFunctionTemplate,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001966 SmallVectorImpl<TemplateArgument> &Output) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001967 if (Arg.getKind() == TemplateArgument::Pack) {
1968 // This is a template argument pack, so check each of its arguments against
1969 // the template parameter.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001970 SmallVector<TemplateArgument, 2> PackedArgsBuilder;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001971 for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
Douglas Gregor135ffa72011-01-05 21:00:53 +00001972 PAEnd = Arg.pack_end();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001973 PA != PAEnd; ++PA) {
Douglas Gregord53e16a2011-01-05 20:52:18 +00001974 // When converting the deduced template argument, append it to the
1975 // general output list. We need to do this so that the template argument
1976 // checking logic has all of the prior template arguments available.
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001977 DeducedTemplateArgument InnerArg(*PA);
1978 InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001979 if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template,
Douglas Gregor6952f1e2011-01-19 20:10:05 +00001980 NTTPType, PackedArgsBuilder.size(),
1981 Info, InFunctionTemplate, Output))
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001982 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001983
Douglas Gregord53e16a2011-01-05 20:52:18 +00001984 // Move the converted template argument into our argument pack.
1985 PackedArgsBuilder.push_back(Output.back());
1986 Output.pop_back();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001987 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001988
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001989 // Create the resulting argument pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001990 Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
Douglas Gregor203e6a32011-01-11 23:09:57 +00001991 PackedArgsBuilder.data(),
1992 PackedArgsBuilder.size()));
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001993 return false;
1994 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001995
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001996 // Convert the deduced template argument into a template
1997 // argument that we can check, almost as if the user had written
1998 // the template argument explicitly.
1999 TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
2000 Info.getLocation());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002001
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002002 // Check the template argument, converting it as necessary.
2003 return S.CheckTemplateArgument(Param, ArgLoc,
2004 Template,
2005 Template->getLocation(),
2006 Template->getSourceRange().getEnd(),
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002007 ArgumentPackIndex,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002008 Output,
2009 InFunctionTemplate
2010 ? (Arg.wasDeducedFromArrayBound()
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002011 ? Sema::CTAK_DeducedFromArrayBound
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002012 : Sema::CTAK_Deduced)
2013 : Sema::CTAK_Specified);
2014}
2015
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002016/// Complete template argument deduction for a class template partial
2017/// specialization.
2018static Sema::TemplateDeductionResult
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002019FinishTemplateArgumentDeduction(Sema &S,
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002020 ClassTemplatePartialSpecializationDecl *Partial,
2021 const TemplateArgumentList &TemplateArgs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002022 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
John McCall2a7fb272010-08-25 05:32:35 +00002023 TemplateDeductionInfo &Info) {
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002024 // Trap errors.
2025 Sema::SFINAETrap Trap(S);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002026
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002027 Sema::ContextRAII SavedContext(S, Partial);
2028
2029 // C++ [temp.deduct.type]p2:
2030 // [...] or if any template argument remains neither deduced nor
2031 // explicitly specified, template argument deduction fails.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002032 SmallVector<TemplateArgument, 4> Builder;
Douglas Gregor033a3ca2011-01-04 22:23:38 +00002033 TemplateParameterList *PartialParams = Partial->getTemplateParameters();
2034 for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002035 NamedDecl *Param = PartialParams->getParam(I);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002036 if (Deduced[I].isNull()) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002037 Info.Param = makeTemplateParameter(Param);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002038 return Sema::TDK_Incomplete;
2039 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002040
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002041 // We have deduced this argument, so it still needs to be
2042 // checked and converted.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002043
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002044 // First, for a non-type template parameter type that is
2045 // initialized by a declaration, we need the type of the
2046 // corresponding non-type template parameter.
2047 QualType NTTPType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002048 if (NonTypeTemplateParmDecl *NTTP
Douglas Gregord53e16a2011-01-05 20:52:18 +00002049 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002050 NTTPType = NTTP->getType();
Douglas Gregord53e16a2011-01-05 20:52:18 +00002051 if (NTTPType->isDependentType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002052 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Douglas Gregord53e16a2011-01-05 20:52:18 +00002053 Builder.data(), Builder.size());
2054 NTTPType = S.SubstType(NTTPType,
2055 MultiLevelTemplateArgumentList(TemplateArgs),
2056 NTTP->getLocation(),
2057 NTTP->getDeclName());
2058 if (NTTPType.isNull()) {
2059 Info.Param = makeTemplateParameter(Param);
2060 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002061 Info.reset(TemplateArgumentList::CreateCopy(S.Context,
2062 Builder.data(),
Douglas Gregord53e16a2011-01-05 20:52:18 +00002063 Builder.size()));
2064 return Sema::TDK_SubstitutionFailure;
2065 }
2066 }
2067 }
2068
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002069 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002070 Partial, NTTPType, 0, Info, false,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002071 Builder)) {
2072 Info.Param = makeTemplateParameter(Param);
2073 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002074 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2075 Builder.size()));
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002076 return Sema::TDK_SubstitutionFailure;
2077 }
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002078 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002079
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002080 // Form the template argument list from the deduced template arguments.
2081 TemplateArgumentList *DeducedArgumentList
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002082 = TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Douglas Gregor910f8002010-11-07 23:05:16 +00002083 Builder.size());
2084
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002085 Info.reset(DeducedArgumentList);
2086
2087 // Substitute the deduced template arguments into the template
2088 // arguments of the class template partial specialization, and
2089 // verify that the instantiated template arguments are both valid
2090 // and are equivalent to the template arguments originally provided
2091 // to the class template.
John McCall2a7fb272010-08-25 05:32:35 +00002092 LocalInstantiationScope InstScope(S);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002093 ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
2094 const TemplateArgumentLoc *PartialTemplateArgs
2095 = Partial->getTemplateArgsAsWritten();
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002096
2097 // Note that we don't provide the langle and rangle locations.
2098 TemplateArgumentListInfo InstArgs;
2099
Douglas Gregore02e2622010-12-22 21:19:48 +00002100 if (S.Subst(PartialTemplateArgs,
2101 Partial->getNumTemplateArgsAsWritten(),
2102 InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
2103 unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
2104 if (ParamIdx >= Partial->getTemplateParameters()->size())
2105 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2106
2107 Decl *Param
2108 = const_cast<NamedDecl *>(
2109 Partial->getTemplateParameters()->getParam(ParamIdx));
2110 Info.Param = makeTemplateParameter(Param);
2111 Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
2112 return Sema::TDK_SubstitutionFailure;
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002113 }
2114
Chris Lattner5f9e2722011-07-23 10:55:15 +00002115 SmallVector<TemplateArgument, 4> ConvertedInstArgs;
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002116 if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002117 InstArgs, false, ConvertedInstArgs))
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002118 return Sema::TDK_SubstitutionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002119
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002120 TemplateParameterList *TemplateParams
2121 = ClassTemplate->getTemplateParameters();
2122 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
Douglas Gregor910f8002010-11-07 23:05:16 +00002123 TemplateArgument InstArg = ConvertedInstArgs.data()[I];
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002124 if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
Douglas Gregor2fdc5e82011-01-05 00:13:17 +00002125 Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002126 Info.FirstArg = TemplateArgs[I];
2127 Info.SecondArg = InstArg;
2128 return Sema::TDK_NonDeducedMismatch;
2129 }
2130 }
2131
2132 if (Trap.hasErrorOccurred())
2133 return Sema::TDK_SubstitutionFailure;
2134
2135 return Sema::TDK_Success;
2136}
2137
Douglas Gregorc1efb3f2009-06-12 22:31:52 +00002138/// \brief Perform template argument deduction to determine whether
2139/// the given template arguments match the given class template
2140/// partial specialization per C++ [temp.class.spec.match].
Douglas Gregorf67875d2009-06-12 18:26:56 +00002141Sema::TemplateDeductionResult
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002142Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002143 const TemplateArgumentList &TemplateArgs,
2144 TemplateDeductionInfo &Info) {
Douglas Gregorc1efb3f2009-06-12 22:31:52 +00002145 // C++ [temp.class.spec.match]p2:
2146 // A partial specialization matches a given actual template
2147 // argument list if the template arguments of the partial
2148 // specialization can be deduced from the actual template argument
2149 // list (14.8.2).
Douglas Gregorbb260412009-06-14 08:02:22 +00002150 SFINAETrap Trap(*this);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002151 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002152 Deduced.resize(Partial->getTemplateParameters()->size());
Douglas Gregorf67875d2009-06-12 18:26:56 +00002153 if (TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00002154 = ::DeduceTemplateArguments(*this,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002155 Partial->getTemplateParameters(),
Mike Stump1eb44332009-09-09 15:08:12 +00002156 Partial->getTemplateArgs(),
Douglas Gregorf67875d2009-06-12 18:26:56 +00002157 TemplateArgs, Info, Deduced))
2158 return Result;
Douglas Gregor637a4092009-06-10 23:47:09 +00002159
Douglas Gregor637a4092009-06-10 23:47:09 +00002160 InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
Douglas Gregor9b623632010-10-12 23:32:35 +00002161 Deduced.data(), Deduced.size(), Info);
Douglas Gregor637a4092009-06-10 23:47:09 +00002162 if (Inst)
Douglas Gregorf67875d2009-06-12 18:26:56 +00002163 return TDK_InstantiationDepth;
Douglas Gregor199d9912009-06-05 00:53:49 +00002164
Douglas Gregorbb260412009-06-14 08:02:22 +00002165 if (Trap.hasErrorOccurred())
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002166 return Sema::TDK_SubstitutionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002167
2168 return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002169 Deduced, Info);
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002170}
Douglas Gregor031a5882009-06-13 00:26:55 +00002171
Douglas Gregor41128772009-06-26 23:27:24 +00002172/// \brief Determine whether the given type T is a simple-template-id type.
2173static bool isSimpleTemplateIdType(QualType T) {
Mike Stump1eb44332009-09-09 15:08:12 +00002174 if (const TemplateSpecializationType *Spec
John McCall183700f2009-09-21 23:43:11 +00002175 = T->getAs<TemplateSpecializationType>())
Douglas Gregor41128772009-06-26 23:27:24 +00002176 return Spec->getTemplateName().getAsTemplateDecl() != 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002177
Douglas Gregor41128772009-06-26 23:27:24 +00002178 return false;
2179}
Douglas Gregor83314aa2009-07-08 20:55:45 +00002180
2181/// \brief Substitute the explicitly-provided template arguments into the
2182/// given function template according to C++ [temp.arg.explicit].
2183///
2184/// \param FunctionTemplate the function template into which the explicit
2185/// template arguments will be substituted.
2186///
Mike Stump1eb44332009-09-09 15:08:12 +00002187/// \param ExplicitTemplateArguments the explicitly-specified template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002188/// arguments.
2189///
Mike Stump1eb44332009-09-09 15:08:12 +00002190/// \param Deduced the deduced template arguments, which will be populated
Douglas Gregor83314aa2009-07-08 20:55:45 +00002191/// with the converted and checked explicit template arguments.
2192///
Mike Stump1eb44332009-09-09 15:08:12 +00002193/// \param ParamTypes will be populated with the instantiated function
Douglas Gregor83314aa2009-07-08 20:55:45 +00002194/// parameters.
2195///
2196/// \param FunctionType if non-NULL, the result type of the function template
2197/// will also be instantiated and the pointed-to value will be updated with
2198/// the instantiated function type.
2199///
2200/// \param Info if substitution fails for any reason, this object will be
2201/// populated with more information about the failure.
2202///
2203/// \returns TDK_Success if substitution was successful, or some failure
2204/// condition.
2205Sema::TemplateDeductionResult
2206Sema::SubstituteExplicitTemplateArguments(
2207 FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00002208 TemplateArgumentListInfo &ExplicitTemplateArgs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002209 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2210 SmallVectorImpl<QualType> &ParamTypes,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002211 QualType *FunctionType,
2212 TemplateDeductionInfo &Info) {
2213 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
2214 TemplateParameterList *TemplateParams
2215 = FunctionTemplate->getTemplateParameters();
2216
John McCalld5532b62009-11-23 01:53:49 +00002217 if (ExplicitTemplateArgs.size() == 0) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00002218 // No arguments to substitute; just copy over the parameter types and
2219 // fill in the function type.
2220 for (FunctionDecl::param_iterator P = Function->param_begin(),
2221 PEnd = Function->param_end();
2222 P != PEnd;
2223 ++P)
2224 ParamTypes.push_back((*P)->getType());
Mike Stump1eb44332009-09-09 15:08:12 +00002225
Douglas Gregor83314aa2009-07-08 20:55:45 +00002226 if (FunctionType)
2227 *FunctionType = Function->getType();
2228 return TDK_Success;
2229 }
Mike Stump1eb44332009-09-09 15:08:12 +00002230
Douglas Gregor83314aa2009-07-08 20:55:45 +00002231 // Substitution of the explicit template arguments into a function template
2232 /// is a SFINAE context. Trap any errors that might occur.
Mike Stump1eb44332009-09-09 15:08:12 +00002233 SFINAETrap Trap(*this);
2234
Douglas Gregor83314aa2009-07-08 20:55:45 +00002235 // C++ [temp.arg.explicit]p3:
Mike Stump1eb44332009-09-09 15:08:12 +00002236 // Template arguments that are present shall be specified in the
2237 // declaration order of their corresponding template-parameters. The
Douglas Gregor83314aa2009-07-08 20:55:45 +00002238 // template argument list shall not specify more template-arguments than
Mike Stump1eb44332009-09-09 15:08:12 +00002239 // there are corresponding template-parameters.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002240 SmallVector<TemplateArgument, 4> Builder;
Mike Stump1eb44332009-09-09 15:08:12 +00002241
2242 // Enter a new template instantiation context where we check the
Douglas Gregor83314aa2009-07-08 20:55:45 +00002243 // explicitly-specified template arguments against this function template,
2244 // and then substitute them into the function parameter types.
Mike Stump1eb44332009-09-09 15:08:12 +00002245 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
Douglas Gregor83314aa2009-07-08 20:55:45 +00002246 FunctionTemplate, Deduced.data(), Deduced.size(),
Douglas Gregor9b623632010-10-12 23:32:35 +00002247 ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
2248 Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002249 if (Inst)
2250 return TDK_InstantiationDepth;
Mike Stump1eb44332009-09-09 15:08:12 +00002251
Douglas Gregor83314aa2009-07-08 20:55:45 +00002252 if (CheckTemplateArgumentList(FunctionTemplate,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002253 SourceLocation(),
John McCalld5532b62009-11-23 01:53:49 +00002254 ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002255 true,
Douglas Gregorf1a84452010-05-08 19:15:54 +00002256 Builder) || Trap.hasErrorOccurred()) {
Douglas Gregor910f8002010-11-07 23:05:16 +00002257 unsigned Index = Builder.size();
Douglas Gregorfe52c912010-05-09 01:26:06 +00002258 if (Index >= TemplateParams->size())
2259 Index = TemplateParams->size() - 1;
2260 Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
Douglas Gregor83314aa2009-07-08 20:55:45 +00002261 return TDK_InvalidExplicitArguments;
Douglas Gregorf1a84452010-05-08 19:15:54 +00002262 }
Mike Stump1eb44332009-09-09 15:08:12 +00002263
Douglas Gregor83314aa2009-07-08 20:55:45 +00002264 // Form the template argument list from the explicitly-specified
2265 // template arguments.
Mike Stump1eb44332009-09-09 15:08:12 +00002266 TemplateArgumentList *ExplicitArgumentList
Douglas Gregor910f8002010-11-07 23:05:16 +00002267 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Douglas Gregor83314aa2009-07-08 20:55:45 +00002268 Info.reset(ExplicitArgumentList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002269
John McCalldf41f182010-10-12 19:40:14 +00002270 // Template argument deduction and the final substitution should be
2271 // done in the context of the templated declaration. Explicit
2272 // argument substitution, on the other hand, needs to happen in the
2273 // calling context.
2274 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
2275
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002276 // If we deduced template arguments for a template parameter pack,
Douglas Gregord3731192011-01-10 07:32:04 +00002277 // note that the template argument pack is partially substituted and record
2278 // the explicit template arguments. They'll be used as part of deduction
2279 // for this template parameter pack.
Douglas Gregord3731192011-01-10 07:32:04 +00002280 for (unsigned I = 0, N = Builder.size(); I != N; ++I) {
2281 const TemplateArgument &Arg = Builder[I];
2282 if (Arg.getKind() == TemplateArgument::Pack) {
Douglas Gregord3731192011-01-10 07:32:04 +00002283 CurrentInstantiationScope->SetPartiallySubstitutedPack(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002284 TemplateParams->getParam(I),
Douglas Gregord3731192011-01-10 07:32:04 +00002285 Arg.pack_begin(),
2286 Arg.pack_size());
2287 break;
2288 }
2289 }
2290
Douglas Gregor83314aa2009-07-08 20:55:45 +00002291 // Instantiate the types of each of the function parameters given the
2292 // explicitly-specified template arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002293 if (SubstParmTypes(Function->getLocation(),
Douglas Gregora009b592011-01-07 00:20:55 +00002294 Function->param_begin(), Function->getNumParams(),
2295 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2296 ParamTypes))
2297 return TDK_SubstitutionFailure;
Douglas Gregor83314aa2009-07-08 20:55:45 +00002298
2299 // If the caller wants a full function type back, instantiate the return
2300 // type and form that function type.
2301 if (FunctionType) {
2302 // FIXME: exception-specifications?
Mike Stump1eb44332009-09-09 15:08:12 +00002303 const FunctionProtoType *Proto
John McCall183700f2009-09-21 23:43:11 +00002304 = Function->getType()->getAs<FunctionProtoType>();
Douglas Gregor83314aa2009-07-08 20:55:45 +00002305 assert(Proto && "Function template does not have a prototype?");
Mike Stump1eb44332009-09-09 15:08:12 +00002306
2307 QualType ResultType
Douglas Gregor357bbd02009-08-28 20:50:45 +00002308 = SubstType(Proto->getResultType(),
2309 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2310 Function->getTypeSpecStartLoc(),
2311 Function->getDeclName());
Douglas Gregor83314aa2009-07-08 20:55:45 +00002312 if (ResultType.isNull() || Trap.hasErrorOccurred())
2313 return TDK_SubstitutionFailure;
Mike Stump1eb44332009-09-09 15:08:12 +00002314
2315 *FunctionType = BuildFunctionType(ResultType,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002316 ParamTypes.data(), ParamTypes.size(),
2317 Proto->isVariadic(),
2318 Proto->getTypeQuals(),
Douglas Gregorc938c162011-01-26 05:01:58 +00002319 Proto->getRefQualifier(),
Douglas Gregor83314aa2009-07-08 20:55:45 +00002320 Function->getLocation(),
Eli Friedmanfa869542010-08-05 02:54:05 +00002321 Function->getDeclName(),
2322 Proto->getExtInfo());
Douglas Gregor83314aa2009-07-08 20:55:45 +00002323 if (FunctionType->isNull() || Trap.hasErrorOccurred())
2324 return TDK_SubstitutionFailure;
2325 }
Mike Stump1eb44332009-09-09 15:08:12 +00002326
Douglas Gregor83314aa2009-07-08 20:55:45 +00002327 // C++ [temp.arg.explicit]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00002328 // Trailing template arguments that can be deduced (14.8.2) may be
2329 // omitted from the list of explicit template-arguments. If all of the
Douglas Gregor83314aa2009-07-08 20:55:45 +00002330 // template arguments can be deduced, they may all be omitted; in this
2331 // case, the empty template argument list <> itself may also be omitted.
2332 //
Douglas Gregord3731192011-01-10 07:32:04 +00002333 // Take all of the explicitly-specified arguments and put them into
2334 // the set of deduced template arguments. Explicitly-specified
2335 // parameter packs, however, will be set to NULL since the deduction
2336 // mechanisms handle explicitly-specified argument packs directly.
Douglas Gregor83314aa2009-07-08 20:55:45 +00002337 Deduced.reserve(TemplateParams->size());
Douglas Gregord3731192011-01-10 07:32:04 +00002338 for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) {
2339 const TemplateArgument &Arg = ExplicitArgumentList->get(I);
2340 if (Arg.getKind() == TemplateArgument::Pack)
2341 Deduced.push_back(DeducedTemplateArgument());
2342 else
2343 Deduced.push_back(Arg);
2344 }
Mike Stump1eb44332009-09-09 15:08:12 +00002345
Douglas Gregor83314aa2009-07-08 20:55:45 +00002346 return TDK_Success;
2347}
2348
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002349/// \brief Check whether the deduced argument type for a call to a function
2350/// template matches the actual argument type per C++ [temp.deduct.call]p4.
2351static bool
2352CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
2353 QualType DeducedA) {
2354 ASTContext &Context = S.Context;
2355
2356 QualType A = OriginalArg.OriginalArgType;
2357 QualType OriginalParamType = OriginalArg.OriginalParamType;
2358
2359 // Check for type equality (top-level cv-qualifiers are ignored).
2360 if (Context.hasSameUnqualifiedType(A, DeducedA))
2361 return false;
2362
2363 // Strip off references on the argument types; they aren't needed for
2364 // the following checks.
2365 if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
2366 DeducedA = DeducedARef->getPointeeType();
2367 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
2368 A = ARef->getPointeeType();
2369
2370 // C++ [temp.deduct.call]p4:
2371 // [...] However, there are three cases that allow a difference:
2372 // - If the original P is a reference type, the deduced A (i.e., the
2373 // type referred to by the reference) can be more cv-qualified than
2374 // the transformed A.
2375 if (const ReferenceType *OriginalParamRef
2376 = OriginalParamType->getAs<ReferenceType>()) {
2377 // We don't want to keep the reference around any more.
2378 OriginalParamType = OriginalParamRef->getPointeeType();
2379
2380 Qualifiers AQuals = A.getQualifiers();
2381 Qualifiers DeducedAQuals = DeducedA.getQualifiers();
2382 if (AQuals == DeducedAQuals) {
2383 // Qualifiers match; there's nothing to do.
2384 } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
Douglas Gregorc99f0ec2011-06-17 14:36:00 +00002385 return true;
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002386 } else {
2387 // Qualifiers are compatible, so have the argument type adopt the
2388 // deduced argument type's qualifiers as if we had performed the
2389 // qualification conversion.
2390 A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
2391 }
2392 }
2393
2394 // - The transformed A can be another pointer or pointer to member
2395 // type that can be converted to the deduced A via a qualification
2396 // conversion.
Chandler Carruth18e04612011-06-18 01:19:03 +00002397 //
2398 // Also allow conversions which merely strip [[noreturn]] from function types
2399 // (recursively) as an extension.
2400 // FIXME: Currently, this doesn't place nicely with qualfication conversions.
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002401 bool ObjCLifetimeConversion = false;
Chandler Carruth18e04612011-06-18 01:19:03 +00002402 QualType ResultTy;
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002403 if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
Chandler Carruth18e04612011-06-18 01:19:03 +00002404 (S.IsQualificationConversion(A, DeducedA, false,
2405 ObjCLifetimeConversion) ||
2406 S.IsNoReturnConversion(A, DeducedA, ResultTy)))
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002407 return false;
2408
2409
2410 // - If P is a class and P has the form simple-template-id, then the
2411 // transformed A can be a derived class of the deduced A. [...]
2412 // [...] Likewise, if P is a pointer to a class of the form
2413 // simple-template-id, the transformed A can be a pointer to a
2414 // derived class pointed to by the deduced A.
2415 if (const PointerType *OriginalParamPtr
2416 = OriginalParamType->getAs<PointerType>()) {
2417 if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
2418 if (const PointerType *APtr = A->getAs<PointerType>()) {
2419 if (A->getPointeeType()->isRecordType()) {
2420 OriginalParamType = OriginalParamPtr->getPointeeType();
2421 DeducedA = DeducedAPtr->getPointeeType();
2422 A = APtr->getPointeeType();
2423 }
2424 }
2425 }
2426 }
2427
2428 if (Context.hasSameUnqualifiedType(A, DeducedA))
2429 return false;
2430
2431 if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
2432 S.IsDerivedFrom(A, DeducedA))
2433 return false;
2434
2435 return true;
2436}
2437
Mike Stump1eb44332009-09-09 15:08:12 +00002438/// \brief Finish template argument deduction for a function template,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002439/// checking the deduced template arguments for completeness and forming
2440/// the function template specialization.
Douglas Gregordbfb3712011-06-16 16:50:48 +00002441///
2442/// \param OriginalCallArgs If non-NULL, the original call arguments against
2443/// which the deduced argument types should be compared.
Mike Stump1eb44332009-09-09 15:08:12 +00002444Sema::TemplateDeductionResult
Douglas Gregor83314aa2009-07-08 20:55:45 +00002445Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002446 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor02024a92010-03-28 02:42:43 +00002447 unsigned NumExplicitlySpecified,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002448 FunctionDecl *&Specialization,
Douglas Gregordbfb3712011-06-16 16:50:48 +00002449 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002450 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00002451 TemplateParameterList *TemplateParams
2452 = FunctionTemplate->getTemplateParameters();
Mike Stump1eb44332009-09-09 15:08:12 +00002453
Douglas Gregor83314aa2009-07-08 20:55:45 +00002454 // Template argument deduction for function templates in a SFINAE context.
2455 // Trap any errors that might occur.
Mike Stump1eb44332009-09-09 15:08:12 +00002456 SFINAETrap Trap(*this);
2457
Douglas Gregor83314aa2009-07-08 20:55:45 +00002458 // Enter a new template instantiation context while we instantiate the
2459 // actual function declaration.
Mike Stump1eb44332009-09-09 15:08:12 +00002460 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
Douglas Gregor83314aa2009-07-08 20:55:45 +00002461 FunctionTemplate, Deduced.data(), Deduced.size(),
Douglas Gregor9b623632010-10-12 23:32:35 +00002462 ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
2463 Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002464 if (Inst)
Mike Stump1eb44332009-09-09 15:08:12 +00002465 return TDK_InstantiationDepth;
2466
John McCall96db3102010-04-29 01:18:58 +00002467 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
John McCallf5813822010-04-29 00:35:03 +00002468
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002469 // C++ [temp.deduct.type]p2:
2470 // [...] or if any template argument remains neither deduced nor
2471 // explicitly specified, template argument deduction fails.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002472 SmallVector<TemplateArgument, 4> Builder;
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002473 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
2474 NamedDecl *Param = TemplateParams->getParam(I);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002475
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002476 if (!Deduced[I].isNull()) {
Douglas Gregor3273b0c2010-10-12 18:51:08 +00002477 if (I < NumExplicitlySpecified) {
Douglas Gregor02024a92010-03-28 02:42:43 +00002478 // We have already fully type-checked and converted this
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002479 // argument, because it was explicitly-specified. Just record the
Douglas Gregor3273b0c2010-10-12 18:51:08 +00002480 // presence of this argument.
Douglas Gregor910f8002010-11-07 23:05:16 +00002481 Builder.push_back(Deduced[I]);
Douglas Gregor02024a92010-03-28 02:42:43 +00002482 continue;
2483 }
2484
2485 // We have deduced this argument, so it still needs to be
2486 // checked and converted.
2487
2488 // First, for a non-type template parameter type that is
2489 // initialized by a declaration, we need the type of the
2490 // corresponding non-type template parameter.
2491 QualType NTTPType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002492 if (NonTypeTemplateParmDecl *NTTP
2493 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002494 NTTPType = NTTP->getType();
2495 if (NTTPType->isDependentType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002496 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002497 Builder.data(), Builder.size());
2498 NTTPType = SubstType(NTTPType,
2499 MultiLevelTemplateArgumentList(TemplateArgs),
2500 NTTP->getLocation(),
2501 NTTP->getDeclName());
2502 if (NTTPType.isNull()) {
2503 Info.Param = makeTemplateParameter(Param);
2504 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002505 Info.reset(TemplateArgumentList::CreateCopy(Context,
2506 Builder.data(),
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002507 Builder.size()));
2508 return TDK_SubstitutionFailure;
Douglas Gregor02024a92010-03-28 02:42:43 +00002509 }
2510 }
2511 }
2512
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002513 if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002514 FunctionTemplate, NTTPType, 0, Info,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002515 true, Builder)) {
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002516 Info.Param = makeTemplateParameter(Param);
Douglas Gregor910f8002010-11-07 23:05:16 +00002517 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002518 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
2519 Builder.size()));
Douglas Gregor02024a92010-03-28 02:42:43 +00002520 return TDK_SubstitutionFailure;
2521 }
2522
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002523 continue;
2524 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002525
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002526 // C++0x [temp.arg.explicit]p3:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002527 // A trailing template parameter pack (14.5.3) not otherwise deduced will
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002528 // be deduced to an empty sequence of template arguments.
2529 // FIXME: Where did the word "trailing" come from?
2530 if (Param->isTemplateParameterPack()) {
Douglas Gregord3731192011-01-10 07:32:04 +00002531 // We may have had explicitly-specified template arguments for this
2532 // template parameter pack. If so, our empty deduction extends the
2533 // explicitly-specified set (C++0x [temp.arg.explicit]p9).
2534 const TemplateArgument *ExplicitArgs;
2535 unsigned NumExplicitArgs;
2536 if (CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
2537 &NumExplicitArgs)
2538 == Param)
2539 Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002540 else
Douglas Gregord3731192011-01-10 07:32:04 +00002541 Builder.push_back(TemplateArgument(0, 0));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002542
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002543 continue;
2544 }
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002545
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002546 // Substitute into the default template argument, if available.
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002547 TemplateArgumentLoc DefArg
2548 = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
2549 FunctionTemplate->getLocation(),
2550 FunctionTemplate->getSourceRange().getEnd(),
2551 Param,
2552 Builder);
2553
2554 // If there was no default argument, deduction is incomplete.
2555 if (DefArg.getArgument().isNull()) {
2556 Info.Param = makeTemplateParameter(
2557 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2558 return TDK_Incomplete;
2559 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002560
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002561 // Check whether we can actually use the default argument.
2562 if (CheckTemplateArgument(Param, DefArg,
2563 FunctionTemplate,
2564 FunctionTemplate->getLocation(),
2565 FunctionTemplate->getSourceRange().getEnd(),
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002566 0, Builder,
Douglas Gregor8735b292011-06-03 02:59:40 +00002567 CTAK_Specified)) {
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002568 Info.Param = makeTemplateParameter(
2569 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Douglas Gregor910f8002010-11-07 23:05:16 +00002570 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002571 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
Douglas Gregor910f8002010-11-07 23:05:16 +00002572 Builder.size()));
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002573 return TDK_SubstitutionFailure;
2574 }
2575
2576 // If we get here, we successfully used the default template argument.
2577 }
2578
2579 // Form the template argument list from the deduced template arguments.
2580 TemplateArgumentList *DeducedArgumentList
Douglas Gregor910f8002010-11-07 23:05:16 +00002581 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002582 Info.reset(DeducedArgumentList);
2583
Mike Stump1eb44332009-09-09 15:08:12 +00002584 // Substitute the deduced template arguments into the function template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002585 // declaration to produce the function template specialization.
Douglas Gregord4598a22010-04-28 04:52:24 +00002586 DeclContext *Owner = FunctionTemplate->getDeclContext();
2587 if (FunctionTemplate->getFriendObjectKind())
2588 Owner = FunctionTemplate->getLexicalDeclContext();
Douglas Gregor83314aa2009-07-08 20:55:45 +00002589 Specialization = cast_or_null<FunctionDecl>(
Douglas Gregord4598a22010-04-28 04:52:24 +00002590 SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
Douglas Gregor357bbd02009-08-28 20:50:45 +00002591 MultiLevelTemplateArgumentList(*DeducedArgumentList)));
Douglas Gregor5fad9b82011-10-12 20:35:48 +00002592 if (!Specialization || Specialization->isInvalidDecl())
Douglas Gregor83314aa2009-07-08 20:55:45 +00002593 return TDK_SubstitutionFailure;
Mike Stump1eb44332009-09-09 15:08:12 +00002594
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002595 assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
Douglas Gregorf8825742009-09-15 18:26:13 +00002596 FunctionTemplate->getCanonicalDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002597
Mike Stump1eb44332009-09-09 15:08:12 +00002598 // If the template argument list is owned by the function template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002599 // specialization, release it.
Douglas Gregorec20f462010-05-08 20:07:26 +00002600 if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
2601 !Trap.hasErrorOccurred())
Douglas Gregor83314aa2009-07-08 20:55:45 +00002602 Info.take();
Mike Stump1eb44332009-09-09 15:08:12 +00002603
Douglas Gregor5fad9b82011-10-12 20:35:48 +00002604 // There may have been an error that did not prevent us from constructing a
2605 // declaration. Mark the declaration invalid and return with a substitution
2606 // failure.
2607 if (Trap.hasErrorOccurred()) {
2608 Specialization->setInvalidDecl(true);
2609 return TDK_SubstitutionFailure;
2610 }
2611
Douglas Gregordbfb3712011-06-16 16:50:48 +00002612 if (OriginalCallArgs) {
2613 // C++ [temp.deduct.call]p4:
2614 // In general, the deduction process attempts to find template argument
2615 // values that will make the deduced A identical to A (after the type A
2616 // is transformed as described above). [...]
2617 for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
2618 OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
Douglas Gregordbfb3712011-06-16 16:50:48 +00002619 unsigned ParamIdx = OriginalArg.ArgIdx;
2620
2621 if (ParamIdx >= Specialization->getNumParams())
2622 continue;
2623
2624 QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002625 if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA))
2626 return Sema::TDK_SubstitutionFailure;
Douglas Gregordbfb3712011-06-16 16:50:48 +00002627 }
2628 }
2629
Douglas Gregor9b623632010-10-12 23:32:35 +00002630 // If we suppressed any diagnostics while performing template argument
2631 // deduction, and if we haven't already instantiated this declaration,
2632 // keep track of these diagnostics. They'll be emitted if this specialization
2633 // is actually used.
2634 if (Info.diag_begin() != Info.diag_end()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002635 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator
Douglas Gregor9b623632010-10-12 23:32:35 +00002636 Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
2637 if (Pos == SuppressedDiagnostics.end())
2638 SuppressedDiagnostics[Specialization->getCanonicalDecl()]
2639 .append(Info.diag_begin(), Info.diag_end());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002640 }
Douglas Gregor9b623632010-10-12 23:32:35 +00002641
Mike Stump1eb44332009-09-09 15:08:12 +00002642 return TDK_Success;
Douglas Gregor83314aa2009-07-08 20:55:45 +00002643}
2644
John McCall9c72c602010-08-27 09:08:28 +00002645/// Gets the type of a function for template-argument-deducton
2646/// purposes when it's considered as part of an overload set.
John McCalleff92132010-02-02 02:21:27 +00002647static QualType GetTypeOfFunction(ASTContext &Context,
John McCall9c72c602010-08-27 09:08:28 +00002648 const OverloadExpr::FindResult &R,
John McCalleff92132010-02-02 02:21:27 +00002649 FunctionDecl *Fn) {
John McCalleff92132010-02-02 02:21:27 +00002650 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
John McCall9c72c602010-08-27 09:08:28 +00002651 if (Method->isInstance()) {
2652 // An instance method that's referenced in a form that doesn't
2653 // look like a member pointer is just invalid.
2654 if (!R.HasFormOfMemberPointer) return QualType();
2655
John McCalleff92132010-02-02 02:21:27 +00002656 return Context.getMemberPointerType(Fn->getType(),
2657 Context.getTypeDeclType(Method->getParent()).getTypePtr());
John McCall9c72c602010-08-27 09:08:28 +00002658 }
2659
2660 if (!R.IsAddressOfOperand) return Fn->getType();
John McCalleff92132010-02-02 02:21:27 +00002661 return Context.getPointerType(Fn->getType());
2662}
2663
2664/// Apply the deduction rules for overload sets.
2665///
2666/// \return the null type if this argument should be treated as an
2667/// undeduced context
2668static QualType
2669ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
Douglas Gregor75f21af2010-08-30 21:04:23 +00002670 Expr *Arg, QualType ParamType,
2671 bool ParamWasReference) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002672
John McCall9c72c602010-08-27 09:08:28 +00002673 OverloadExpr::FindResult R = OverloadExpr::find(Arg);
John McCalleff92132010-02-02 02:21:27 +00002674
John McCall9c72c602010-08-27 09:08:28 +00002675 OverloadExpr *Ovl = R.Expression;
John McCalleff92132010-02-02 02:21:27 +00002676
Douglas Gregor75f21af2010-08-30 21:04:23 +00002677 // C++0x [temp.deduct.call]p4
2678 unsigned TDF = 0;
2679 if (ParamWasReference)
2680 TDF |= TDF_ParamWithReferenceType;
2681 if (R.IsAddressOfOperand)
2682 TDF |= TDF_IgnoreQualifiers;
2683
John McCalleff92132010-02-02 02:21:27 +00002684 // If there were explicit template arguments, we can only find
2685 // something via C++ [temp.arg.explicit]p3, i.e. if the arguments
2686 // unambiguously name a full specialization.
John McCall7bb12da2010-02-02 06:20:04 +00002687 if (Ovl->hasExplicitTemplateArgs()) {
John McCalleff92132010-02-02 02:21:27 +00002688 // But we can still look for an explicit specialization.
2689 if (FunctionDecl *ExplicitSpec
John McCall7bb12da2010-02-02 06:20:04 +00002690 = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
John McCall9c72c602010-08-27 09:08:28 +00002691 return GetTypeOfFunction(S.Context, R, ExplicitSpec);
John McCalleff92132010-02-02 02:21:27 +00002692 return QualType();
2693 }
2694
2695 // C++0x [temp.deduct.call]p6:
2696 // When P is a function type, pointer to function type, or pointer
2697 // to member function type:
2698
2699 if (!ParamType->isFunctionType() &&
2700 !ParamType->isFunctionPointerType() &&
2701 !ParamType->isMemberFunctionPointerType())
2702 return QualType();
2703
2704 QualType Match;
John McCall7bb12da2010-02-02 06:20:04 +00002705 for (UnresolvedSetIterator I = Ovl->decls_begin(),
2706 E = Ovl->decls_end(); I != E; ++I) {
John McCalleff92132010-02-02 02:21:27 +00002707 NamedDecl *D = (*I)->getUnderlyingDecl();
2708
2709 // - If the argument is an overload set containing one or more
2710 // function templates, the parameter is treated as a
2711 // non-deduced context.
2712 if (isa<FunctionTemplateDecl>(D))
2713 return QualType();
2714
2715 FunctionDecl *Fn = cast<FunctionDecl>(D);
John McCall9c72c602010-08-27 09:08:28 +00002716 QualType ArgType = GetTypeOfFunction(S.Context, R, Fn);
2717 if (ArgType.isNull()) continue;
John McCalleff92132010-02-02 02:21:27 +00002718
Douglas Gregor75f21af2010-08-30 21:04:23 +00002719 // Function-to-pointer conversion.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002720 if (!ParamWasReference && ParamType->isPointerType() &&
Douglas Gregor75f21af2010-08-30 21:04:23 +00002721 ArgType->isFunctionType())
2722 ArgType = S.Context.getPointerType(ArgType);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002723
John McCalleff92132010-02-02 02:21:27 +00002724 // - If the argument is an overload set (not containing function
2725 // templates), trial argument deduction is attempted using each
2726 // of the members of the set. If deduction succeeds for only one
2727 // of the overload set members, that member is used as the
2728 // argument value for the deduction. If deduction succeeds for
2729 // more than one member of the overload set the parameter is
2730 // treated as a non-deduced context.
2731
2732 // We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
2733 // Type deduction is done independently for each P/A pair, and
2734 // the deduced template argument values are then combined.
2735 // So we do not reject deductions which were made elsewhere.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002736 SmallVector<DeducedTemplateArgument, 8>
Douglas Gregor02024a92010-03-28 02:42:43 +00002737 Deduced(TemplateParams->size());
John McCall2a7fb272010-08-25 05:32:35 +00002738 TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc());
John McCalleff92132010-02-02 02:21:27 +00002739 Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00002740 = DeduceTemplateArguments(S, TemplateParams,
John McCalleff92132010-02-02 02:21:27 +00002741 ParamType, ArgType,
2742 Info, Deduced, TDF);
2743 if (Result) continue;
2744 if (!Match.isNull()) return QualType();
2745 Match = ArgType;
2746 }
2747
2748 return Match;
2749}
2750
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002751/// \brief Perform the adjustments to the parameter and argument types
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002752/// described in C++ [temp.deduct.call].
2753///
2754/// \returns true if the caller should not attempt to perform any template
2755/// argument deduction based on this P/A pair.
2756static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
2757 TemplateParameterList *TemplateParams,
2758 QualType &ParamType,
2759 QualType &ArgType,
2760 Expr *Arg,
2761 unsigned &TDF) {
2762 // C++0x [temp.deduct.call]p3:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00002763 // If P is a cv-qualified type, the top level cv-qualifiers of P's type
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002764 // are ignored for type deduction.
Douglas Gregora459cc22011-04-27 23:34:22 +00002765 if (ParamType.hasQualifiers())
2766 ParamType = ParamType.getUnqualifiedType();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002767 const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
2768 if (ParamRefType) {
Richard Smith34b41d92011-02-20 03:19:35 +00002769 QualType PointeeType = ParamRefType->getPointeeType();
2770
Douglas Gregorf15748a2011-06-03 03:35:07 +00002771 // If the argument has incomplete array type, try to complete it's type.
2772 if (ArgType->isIncompleteArrayType() &&
2773 !S.RequireCompleteExprType(Arg, S.PDiag(),
2774 std::make_pair(SourceLocation(), S.PDiag())))
2775 ArgType = Arg->getType();
2776
Douglas Gregor2ad746a2011-01-21 05:18:22 +00002777 // [C++0x] If P is an rvalue reference to a cv-unqualified
2778 // template parameter and the argument is an lvalue, the type
2779 // "lvalue reference to A" is used in place of A for type
2780 // deduction.
Richard Smith34b41d92011-02-20 03:19:35 +00002781 if (isa<RValueReferenceType>(ParamType)) {
2782 if (!PointeeType.getQualifiers() &&
2783 isa<TemplateTypeParmType>(PointeeType) &&
Douglas Gregor9625e442011-05-21 22:16:50 +00002784 Arg->Classify(S.Context).isLValue() &&
2785 Arg->getType() != S.Context.OverloadTy &&
2786 Arg->getType() != S.Context.BoundMemberTy)
Douglas Gregor2ad746a2011-01-21 05:18:22 +00002787 ArgType = S.Context.getLValueReferenceType(ArgType);
2788 }
2789
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002790 // [...] If P is a reference type, the type referred to by P is used
2791 // for type deduction.
Richard Smith34b41d92011-02-20 03:19:35 +00002792 ParamType = PointeeType;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002793 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002794
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002795 // Overload sets usually make this parameter an undeduced
2796 // context, but there are sometimes special circumstances.
2797 if (ArgType == S.Context.OverloadTy) {
2798 ArgType = ResolveOverloadForDeduction(S, TemplateParams,
2799 Arg, ParamType,
2800 ParamRefType != 0);
2801 if (ArgType.isNull())
2802 return true;
2803 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002804
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002805 if (ParamRefType) {
2806 // C++0x [temp.deduct.call]p3:
2807 // [...] If P is of the form T&&, where T is a template parameter, and
2808 // the argument is an lvalue, the type A& is used in place of A for
2809 // type deduction.
2810 if (ParamRefType->isRValueReferenceType() &&
2811 ParamRefType->getAs<TemplateTypeParmType>() &&
2812 Arg->isLValue())
2813 ArgType = S.Context.getLValueReferenceType(ArgType);
2814 } else {
2815 // C++ [temp.deduct.call]p2:
2816 // If P is not a reference type:
2817 // - If A is an array type, the pointer type produced by the
2818 // array-to-pointer standard conversion (4.2) is used in place of
2819 // A for type deduction; otherwise,
2820 if (ArgType->isArrayType())
2821 ArgType = S.Context.getArrayDecayedType(ArgType);
2822 // - If A is a function type, the pointer type produced by the
2823 // function-to-pointer standard conversion (4.3) is used in place
2824 // of A for type deduction; otherwise,
2825 else if (ArgType->isFunctionType())
2826 ArgType = S.Context.getPointerType(ArgType);
2827 else {
NAKAMURA Takumi00995302011-01-27 07:09:49 +00002828 // - If A is a cv-qualified type, the top level cv-qualifiers of A's
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002829 // type are ignored for type deduction.
Douglas Gregora459cc22011-04-27 23:34:22 +00002830 ArgType = ArgType.getUnqualifiedType();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002831 }
2832 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002833
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002834 // C++0x [temp.deduct.call]p4:
2835 // In general, the deduction process attempts to find template argument
2836 // values that will make the deduced A identical to A (after the type A
2837 // is transformed as described above). [...]
2838 TDF = TDF_SkipNonDependent;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002839
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002840 // - If the original P is a reference type, the deduced A (i.e., the
2841 // type referred to by the reference) can be more cv-qualified than
2842 // the transformed A.
2843 if (ParamRefType)
2844 TDF |= TDF_ParamWithReferenceType;
2845 // - The transformed A can be another pointer or pointer to member
2846 // type that can be converted to the deduced A via a qualification
2847 // conversion (4.4).
2848 if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
2849 ArgType->isObjCObjectPointerType())
2850 TDF |= TDF_IgnoreQualifiers;
2851 // - If P is a class and P has the form simple-template-id, then the
2852 // transformed A can be a derived class of the deduced A. Likewise,
2853 // if P is a pointer to a class of the form simple-template-id, the
2854 // transformed A can be a pointer to a derived class pointed to by
2855 // the deduced A.
2856 if (isSimpleTemplateIdType(ParamType) ||
2857 (isa<PointerType>(ParamType) &&
2858 isSimpleTemplateIdType(
2859 ParamType->getAs<PointerType>()->getPointeeType())))
2860 TDF |= TDF_DerivedClass;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002861
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002862 return false;
2863}
2864
Douglas Gregordbfb3712011-06-16 16:50:48 +00002865static bool hasDeducibleTemplateParameters(Sema &S,
2866 FunctionTemplateDecl *FunctionTemplate,
2867 QualType T);
2868
Douglas Gregore53060f2009-06-25 22:08:12 +00002869/// \brief Perform template argument deduction from a function call
2870/// (C++ [temp.deduct.call]).
2871///
2872/// \param FunctionTemplate the function template for which we are performing
2873/// template argument deduction.
2874///
Douglas Gregor48026d22010-01-11 18:40:55 +00002875/// \param ExplicitTemplateArguments the explicit template arguments provided
2876/// for this call.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002877///
Douglas Gregore53060f2009-06-25 22:08:12 +00002878/// \param Args the function call arguments
2879///
2880/// \param NumArgs the number of arguments in Args
2881///
Douglas Gregor48026d22010-01-11 18:40:55 +00002882/// \param Name the name of the function being called. This is only significant
2883/// when the function template is a conversion function template, in which
2884/// case this routine will also perform template argument deduction based on
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002885/// the function to which
Douglas Gregor48026d22010-01-11 18:40:55 +00002886///
Douglas Gregore53060f2009-06-25 22:08:12 +00002887/// \param Specialization if template argument deduction was successful,
Mike Stump1eb44332009-09-09 15:08:12 +00002888/// this will be set to the function template specialization produced by
Douglas Gregore53060f2009-06-25 22:08:12 +00002889/// template argument deduction.
2890///
2891/// \param Info the argument will be updated to provide additional information
2892/// about template argument deduction.
2893///
2894/// \returns the result of template argument deduction.
Douglas Gregore53060f2009-06-25 22:08:12 +00002895Sema::TemplateDeductionResult
2896Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00002897 TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +00002898 Expr **Args, unsigned NumArgs,
2899 FunctionDecl *&Specialization,
2900 TemplateDeductionInfo &Info) {
2901 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002902
Douglas Gregore53060f2009-06-25 22:08:12 +00002903 // C++ [temp.deduct.call]p1:
2904 // Template argument deduction is done by comparing each function template
2905 // parameter type (call it P) with the type of the corresponding argument
2906 // of the call (call it A) as described below.
2907 unsigned CheckArgs = NumArgs;
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002908 if (NumArgs < Function->getMinRequiredArguments())
Douglas Gregore53060f2009-06-25 22:08:12 +00002909 return TDK_TooFewArguments;
2910 else if (NumArgs > Function->getNumParams()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002911 const FunctionProtoType *Proto
John McCall183700f2009-09-21 23:43:11 +00002912 = Function->getType()->getAs<FunctionProtoType>();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002913 if (Proto->isTemplateVariadic())
2914 /* Do nothing */;
2915 else if (Proto->isVariadic())
2916 CheckArgs = Function->getNumParams();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002917 else
Douglas Gregore53060f2009-06-25 22:08:12 +00002918 return TDK_TooManyArguments;
Douglas Gregore53060f2009-06-25 22:08:12 +00002919 }
Mike Stump1eb44332009-09-09 15:08:12 +00002920
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002921 // The types of the parameters from which we will perform template argument
2922 // deduction.
John McCall2a7fb272010-08-25 05:32:35 +00002923 LocalInstantiationScope InstScope(*this);
Douglas Gregore53060f2009-06-25 22:08:12 +00002924 TemplateParameterList *TemplateParams
2925 = FunctionTemplate->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00002926 SmallVector<DeducedTemplateArgument, 4> Deduced;
2927 SmallVector<QualType, 4> ParamTypes;
Douglas Gregor02024a92010-03-28 02:42:43 +00002928 unsigned NumExplicitlySpecified = 0;
John McCalld5532b62009-11-23 01:53:49 +00002929 if (ExplicitTemplateArgs) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00002930 TemplateDeductionResult Result =
2931 SubstituteExplicitTemplateArguments(FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002932 *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002933 Deduced,
2934 ParamTypes,
2935 0,
2936 Info);
2937 if (Result)
2938 return Result;
Douglas Gregor02024a92010-03-28 02:42:43 +00002939
2940 NumExplicitlySpecified = Deduced.size();
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002941 } else {
2942 // Just fill in the parameter types from the function declaration.
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002943 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002944 ParamTypes.push_back(Function->getParamDecl(I)->getType());
2945 }
Mike Stump1eb44332009-09-09 15:08:12 +00002946
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002947 // Deduce template arguments from the function parameters.
Mike Stump1eb44332009-09-09 15:08:12 +00002948 Deduced.resize(TemplateParams->size());
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002949 unsigned ArgIdx = 0;
Chris Lattner5f9e2722011-07-23 10:55:15 +00002950 SmallVector<OriginalCallArg, 4> OriginalCallArgs;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002951 for (unsigned ParamIdx = 0, NumParams = ParamTypes.size();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002952 ParamIdx != NumParams; ++ParamIdx) {
Douglas Gregordbfb3712011-06-16 16:50:48 +00002953 QualType OrigParamType = ParamTypes[ParamIdx];
2954 QualType ParamType = OrigParamType;
2955
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002956 const PackExpansionType *ParamExpansion
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002957 = dyn_cast<PackExpansionType>(ParamType);
2958 if (!ParamExpansion) {
2959 // Simple case: matching a function parameter to a function argument.
2960 if (ArgIdx >= CheckArgs)
2961 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002962
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002963 Expr *Arg = Args[ArgIdx++];
2964 QualType ArgType = Arg->getType();
Douglas Gregordbfb3712011-06-16 16:50:48 +00002965
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002966 unsigned TDF = 0;
2967 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
2968 ParamType, ArgType, Arg,
2969 TDF))
2970 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002971
Douglas Gregord8f5b332011-10-09 22:06:46 +00002972 // If we have nothing to deduce, we're done.
2973 if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
2974 continue;
2975
Douglas Gregordbfb3712011-06-16 16:50:48 +00002976 // Keep track of the argument type and corresponding parameter index,
2977 // so we can check for compatibility between the deduced A and A.
Douglas Gregord8f5b332011-10-09 22:06:46 +00002978 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
2979 ArgType));
Douglas Gregordbfb3712011-06-16 16:50:48 +00002980
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002981 if (TemplateDeductionResult Result
Douglas Gregord8f5b332011-10-09 22:06:46 +00002982 = ::DeduceTemplateArguments(*this, TemplateParams,
2983 ParamType, ArgType, Info, Deduced,
2984 TDF))
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002985 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00002986
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002987 continue;
Douglas Gregor75f21af2010-08-30 21:04:23 +00002988 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002989
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002990 // C++0x [temp.deduct.call]p1:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002991 // For a function parameter pack that occurs at the end of the
2992 // parameter-declaration-list, the type A of each remaining argument of
2993 // the call is compared with the type P of the declarator-id of the
2994 // function parameter pack. Each comparison deduces template arguments
2995 // for subsequent positions in the template parameter packs expanded by
Douglas Gregor7d5c0c12011-01-11 01:52:23 +00002996 // the function parameter pack. For a function parameter pack that does
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002997 // not occur at the end of the parameter-declaration-list, the type of
Douglas Gregor7d5c0c12011-01-11 01:52:23 +00002998 // the parameter pack is a non-deduced context.
2999 if (ParamIdx + 1 < NumParams)
3000 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003001
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003002 QualType ParamPattern = ParamExpansion->getPattern();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003003 SmallVector<unsigned, 2> PackIndices;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003004 {
3005 llvm::BitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00003006 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003007 collectUnexpandedParameterPacks(ParamPattern, Unexpanded);
3008 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
3009 unsigned Depth, Index;
3010 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
3011 if (Depth == 0 && !SawIndices[Index]) {
3012 SawIndices[Index] = true;
3013 PackIndices.push_back(Index);
3014 }
Douglas Gregore53060f2009-06-25 22:08:12 +00003015 }
3016 }
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003017 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003018
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003019 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003020 // expanded by this pack expansion (the outer index) and for each
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003021 // template argument (the inner SmallVectors).
Chris Lattner5f9e2722011-07-23 10:55:15 +00003022 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregord3731192011-01-10 07:32:04 +00003023 NewlyDeducedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00003024 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregord3731192011-01-10 07:32:04 +00003025 SavedPacks(PackIndices.size());
Douglas Gregor54293852011-01-10 17:35:05 +00003026 PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003027 NewlyDeducedPacks);
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003028 bool HasAnyArguments = false;
3029 for (; ArgIdx < NumArgs; ++ArgIdx) {
3030 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003031
Douglas Gregordbfb3712011-06-16 16:50:48 +00003032 QualType OrigParamType = ParamPattern;
3033 ParamType = OrigParamType;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003034 Expr *Arg = Args[ArgIdx];
3035 QualType ArgType = Arg->getType();
Douglas Gregordbfb3712011-06-16 16:50:48 +00003036
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003037 unsigned TDF = 0;
3038 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
3039 ParamType, ArgType, Arg,
3040 TDF)) {
3041 // We can't actually perform any deduction for this argument, so stop
3042 // deduction at this point.
3043 ++ArgIdx;
3044 break;
3045 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003046
Douglas Gregordbfb3712011-06-16 16:50:48 +00003047 // Keep track of the argument type and corresponding argument index,
3048 // so we can check for compatibility between the deduced A and A.
3049 if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3050 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
3051 ArgType));
3052
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003053 if (TemplateDeductionResult Result
3054 = ::DeduceTemplateArguments(*this, TemplateParams,
3055 ParamType, ArgType, Info, Deduced,
3056 TDF))
3057 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00003058
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003059 // Capture the deduced template arguments for each parameter pack expanded
3060 // by this pack expansion, add them to the list of arguments we've deduced
3061 // for that pack, then clear out the deduced argument.
3062 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
3063 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
3064 if (!DeducedArg.isNull()) {
3065 NewlyDeducedPacks[I].push_back(DeducedArg);
3066 DeducedArg = DeducedTemplateArgument();
3067 }
3068 }
3069 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003070
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003071 // Build argument packs for each of the parameter packs expanded by this
3072 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +00003073 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003074 = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +00003075 Deduced, PackIndices, SavedPacks,
3076 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003077 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00003078
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003079 // After we've matching against a parameter pack, we're done.
3080 break;
Douglas Gregore53060f2009-06-25 22:08:12 +00003081 }
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003082
Mike Stump1eb44332009-09-09 15:08:12 +00003083 return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
Douglas Gregor02024a92010-03-28 02:42:43 +00003084 NumExplicitlySpecified,
Douglas Gregordbfb3712011-06-16 16:50:48 +00003085 Specialization, Info, &OriginalCallArgs);
Douglas Gregore53060f2009-06-25 22:08:12 +00003086}
3087
Douglas Gregor83314aa2009-07-08 20:55:45 +00003088/// \brief Deduce template arguments when taking the address of a function
Douglas Gregor4b52e252009-12-21 23:17:24 +00003089/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
3090/// a template.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003091///
3092/// \param FunctionTemplate the function template for which we are performing
3093/// template argument deduction.
3094///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003095/// \param ExplicitTemplateArguments the explicitly-specified template
Douglas Gregor4b52e252009-12-21 23:17:24 +00003096/// arguments.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003097///
3098/// \param ArgFunctionType the function type that will be used as the
3099/// "argument" type (A) when performing template argument deduction from the
Douglas Gregor4b52e252009-12-21 23:17:24 +00003100/// function template's function type. This type may be NULL, if there is no
3101/// argument type to compare against, in C++0x [temp.arg.explicit]p3.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003102///
3103/// \param Specialization if template argument deduction was successful,
Mike Stump1eb44332009-09-09 15:08:12 +00003104/// this will be set to the function template specialization produced by
Douglas Gregor83314aa2009-07-08 20:55:45 +00003105/// template argument deduction.
3106///
3107/// \param Info the argument will be updated to provide additional information
3108/// about template argument deduction.
3109///
3110/// \returns the result of template argument deduction.
3111Sema::TemplateDeductionResult
3112Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00003113 TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00003114 QualType ArgFunctionType,
3115 FunctionDecl *&Specialization,
3116 TemplateDeductionInfo &Info) {
3117 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3118 TemplateParameterList *TemplateParams
3119 = FunctionTemplate->getTemplateParameters();
3120 QualType FunctionType = Function->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003121
Douglas Gregor83314aa2009-07-08 20:55:45 +00003122 // Substitute any explicit template arguments.
John McCall2a7fb272010-08-25 05:32:35 +00003123 LocalInstantiationScope InstScope(*this);
Chris Lattner5f9e2722011-07-23 10:55:15 +00003124 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor02024a92010-03-28 02:42:43 +00003125 unsigned NumExplicitlySpecified = 0;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003126 SmallVector<QualType, 4> ParamTypes;
John McCalld5532b62009-11-23 01:53:49 +00003127 if (ExplicitTemplateArgs) {
Mike Stump1eb44332009-09-09 15:08:12 +00003128 if (TemplateDeductionResult Result
3129 = SubstituteExplicitTemplateArguments(FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00003130 *ExplicitTemplateArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00003131 Deduced, ParamTypes,
Douglas Gregor83314aa2009-07-08 20:55:45 +00003132 &FunctionType, Info))
3133 return Result;
Douglas Gregor02024a92010-03-28 02:42:43 +00003134
3135 NumExplicitlySpecified = Deduced.size();
Douglas Gregor83314aa2009-07-08 20:55:45 +00003136 }
3137
3138 // Template argument deduction for function templates in a SFINAE context.
3139 // Trap any errors that might occur.
Mike Stump1eb44332009-09-09 15:08:12 +00003140 SFINAETrap Trap(*this);
3141
John McCalleff92132010-02-02 02:21:27 +00003142 Deduced.resize(TemplateParams->size());
3143
Douglas Gregor4b52e252009-12-21 23:17:24 +00003144 if (!ArgFunctionType.isNull()) {
3145 // Deduce template arguments from the function type.
Douglas Gregor4b52e252009-12-21 23:17:24 +00003146 if (TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00003147 = ::DeduceTemplateArguments(*this, TemplateParams,
Douglas Gregor4b52e252009-12-21 23:17:24 +00003148 FunctionType, ArgFunctionType, Info,
Douglas Gregor73b3cf62011-01-25 17:19:08 +00003149 Deduced, TDF_TopLevelParameterTypeList))
Douglas Gregor4b52e252009-12-21 23:17:24 +00003150 return Result;
3151 }
Douglas Gregorfbb6fad2010-09-29 21:14:36 +00003152
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003153 if (TemplateDeductionResult Result
Douglas Gregorfbb6fad2010-09-29 21:14:36 +00003154 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3155 NumExplicitlySpecified,
3156 Specialization, Info))
3157 return Result;
3158
3159 // If the requested function type does not match the actual type of the
3160 // specialization, template argument deduction fails.
3161 if (!ArgFunctionType.isNull() &&
3162 !Context.hasSameType(ArgFunctionType, Specialization->getType()))
3163 return TDK_NonDeducedMismatch;
3164
3165 return TDK_Success;
Douglas Gregor83314aa2009-07-08 20:55:45 +00003166}
3167
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003168/// \brief Deduce template arguments for a templated conversion
3169/// function (C++ [temp.deduct.conv]) and, if successful, produce a
3170/// conversion function template specialization.
3171Sema::TemplateDeductionResult
3172Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
3173 QualType ToType,
3174 CXXConversionDecl *&Specialization,
3175 TemplateDeductionInfo &Info) {
Mike Stump1eb44332009-09-09 15:08:12 +00003176 CXXConversionDecl *Conv
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003177 = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
3178 QualType FromType = Conv->getConversionType();
3179
3180 // Canonicalize the types for deduction.
3181 QualType P = Context.getCanonicalType(FromType);
3182 QualType A = Context.getCanonicalType(ToType);
3183
Douglas Gregor5453d932011-03-06 09:03:20 +00003184 // C++0x [temp.deduct.conv]p2:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003185 // If P is a reference type, the type referred to by P is used for
3186 // type deduction.
3187 if (const ReferenceType *PRef = P->getAs<ReferenceType>())
3188 P = PRef->getPointeeType();
3189
Douglas Gregor5453d932011-03-06 09:03:20 +00003190 // C++0x [temp.deduct.conv]p4:
3191 // [...] If A is a reference type, the type referred to by A is used
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003192 // for type deduction.
3193 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
Douglas Gregor5453d932011-03-06 09:03:20 +00003194 A = ARef->getPointeeType().getUnqualifiedType();
3195 // C++ [temp.deduct.conv]p3:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003196 //
Mike Stump1eb44332009-09-09 15:08:12 +00003197 // If A is not a reference type:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003198 else {
3199 assert(!A->isReferenceType() && "Reference types were handled above");
3200
3201 // - If P is an array type, the pointer type produced by the
Mike Stump1eb44332009-09-09 15:08:12 +00003202 // array-to-pointer standard conversion (4.2) is used in place
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003203 // of P for type deduction; otherwise,
3204 if (P->isArrayType())
3205 P = Context.getArrayDecayedType(P);
3206 // - If P is a function type, the pointer type produced by the
3207 // function-to-pointer standard conversion (4.3) is used in
3208 // place of P for type deduction; otherwise,
3209 else if (P->isFunctionType())
3210 P = Context.getPointerType(P);
3211 // - If P is a cv-qualified type, the top level cv-qualifiers of
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003212 // P's type are ignored for type deduction.
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003213 else
3214 P = P.getUnqualifiedType();
3215
Douglas Gregor5453d932011-03-06 09:03:20 +00003216 // C++0x [temp.deduct.conv]p4:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003217 // If A is a cv-qualified type, the top level cv-qualifiers of A's
Douglas Gregor5453d932011-03-06 09:03:20 +00003218 // type are ignored for type deduction. If A is a reference type, the type
3219 // referred to by A is used for type deduction.
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003220 A = A.getUnqualifiedType();
3221 }
3222
3223 // Template argument deduction for function templates in a SFINAE context.
3224 // Trap any errors that might occur.
Mike Stump1eb44332009-09-09 15:08:12 +00003225 SFINAETrap Trap(*this);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003226
3227 // C++ [temp.deduct.conv]p1:
3228 // Template argument deduction is done by comparing the return
3229 // type of the template conversion function (call it P) with the
3230 // type that is required as the result of the conversion (call it
3231 // A) as described in 14.8.2.4.
3232 TemplateParameterList *TemplateParams
3233 = FunctionTemplate->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003234 SmallVector<DeducedTemplateArgument, 4> Deduced;
Mike Stump1eb44332009-09-09 15:08:12 +00003235 Deduced.resize(TemplateParams->size());
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003236
3237 // C++0x [temp.deduct.conv]p4:
3238 // In general, the deduction process attempts to find template
3239 // argument values that will make the deduced A identical to
3240 // A. However, there are two cases that allow a difference:
3241 unsigned TDF = 0;
3242 // - If the original A is a reference type, A can be more
3243 // cv-qualified than the deduced A (i.e., the type referred to
3244 // by the reference)
3245 if (ToType->isReferenceType())
3246 TDF |= TDF_ParamWithReferenceType;
3247 // - The deduced A can be another pointer or pointer to member
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003248 // type that can be converted to A via a qualification
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003249 // conversion.
3250 //
3251 // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
3252 // both P and A are pointers or member pointers. In this case, we
3253 // just ignore cv-qualifiers completely).
3254 if ((P->isPointerType() && A->isPointerType()) ||
Douglas Gregor2cae1e22011-08-30 00:37:54 +00003255 (P->isMemberPointerType() && A->isMemberPointerType()))
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003256 TDF |= TDF_IgnoreQualifiers;
3257 if (TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00003258 = ::DeduceTemplateArguments(*this, TemplateParams,
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003259 P, A, Info, Deduced, TDF))
3260 return Result;
3261
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003262 // Finish template argument deduction.
John McCall2a7fb272010-08-25 05:32:35 +00003263 LocalInstantiationScope InstScope(*this);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003264 FunctionDecl *Spec = 0;
3265 TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003266 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
Douglas Gregor02024a92010-03-28 02:42:43 +00003267 Info);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003268 Specialization = cast_or_null<CXXConversionDecl>(Spec);
3269 return Result;
3270}
3271
Douglas Gregor4b52e252009-12-21 23:17:24 +00003272/// \brief Deduce template arguments for a function template when there is
3273/// nothing to deduce against (C++0x [temp.arg.explicit]p3).
3274///
3275/// \param FunctionTemplate the function template for which we are performing
3276/// template argument deduction.
3277///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003278/// \param ExplicitTemplateArguments the explicitly-specified template
Douglas Gregor4b52e252009-12-21 23:17:24 +00003279/// arguments.
3280///
3281/// \param Specialization if template argument deduction was successful,
3282/// this will be set to the function template specialization produced by
3283/// template argument deduction.
3284///
3285/// \param Info the argument will be updated to provide additional information
3286/// about template argument deduction.
3287///
3288/// \returns the result of template argument deduction.
3289Sema::TemplateDeductionResult
3290Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00003291 TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor4b52e252009-12-21 23:17:24 +00003292 FunctionDecl *&Specialization,
3293 TemplateDeductionInfo &Info) {
3294 return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
3295 QualType(), Specialization, Info);
3296}
3297
Richard Smith34b41d92011-02-20 03:19:35 +00003298namespace {
3299 /// Substitute the 'auto' type specifier within a type for a given replacement
3300 /// type.
3301 class SubstituteAutoTransform :
3302 public TreeTransform<SubstituteAutoTransform> {
3303 QualType Replacement;
3304 public:
3305 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) :
3306 TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) {
3307 }
3308 QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
3309 // If we're building the type pattern to deduce against, don't wrap the
3310 // substituted type in an AutoType. Certain template deduction rules
3311 // apply only when a template type parameter appears directly (and not if
3312 // the parameter is found through desugaring). For instance:
3313 // auto &&lref = lvalue;
3314 // must transform into "rvalue reference to T" not "rvalue reference to
3315 // auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
3316 if (isa<TemplateTypeParmType>(Replacement)) {
3317 QualType Result = Replacement;
3318 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
3319 NewTL.setNameLoc(TL.getNameLoc());
3320 return Result;
3321 } else {
3322 QualType Result = RebuildAutoType(Replacement);
3323 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
3324 NewTL.setNameLoc(TL.getNameLoc());
3325 return Result;
3326 }
3327 }
3328 };
3329}
3330
3331/// \brief Deduce the type for an auto type-specifier (C++0x [dcl.spec.auto]p6)
3332///
3333/// \param Type the type pattern using the auto type-specifier.
3334///
3335/// \param Init the initializer for the variable whose type is to be deduced.
3336///
3337/// \param Result if type deduction was successful, this will be set to the
3338/// deduced type. This may still contain undeduced autos if the type is
Richard Smitha085da82011-03-17 16:11:59 +00003339/// dependent. This will be set to null if deduction succeeded, but auto
3340/// substitution failed; the appropriate diagnostic will already have been
3341/// produced in that case.
Richard Smith34b41d92011-02-20 03:19:35 +00003342///
3343/// \returns true if deduction succeeded, false if it failed.
3344bool
John McCall32509f12011-11-15 01:35:18 +00003345Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init,
Richard Smitha085da82011-03-17 16:11:59 +00003346 TypeSourceInfo *&Result) {
John McCall32509f12011-11-15 01:35:18 +00003347 if (Init->getType()->isNonOverloadPlaceholderType()) {
3348 ExprResult result = CheckPlaceholderExpr(Init);
3349 if (result.isInvalid()) return false;
3350 Init = result.take();
3351 }
3352
Richard Smith34b41d92011-02-20 03:19:35 +00003353 if (Init->isTypeDependent()) {
3354 Result = Type;
3355 return true;
3356 }
3357
3358 SourceLocation Loc = Init->getExprLoc();
3359
3360 LocalInstantiationScope InstScope(*this);
3361
3362 // Build template<class TemplParam> void Func(FuncParam);
Chandler Carruth4fb86f82011-05-01 00:51:33 +00003363 TemplateTypeParmDecl *TemplParam =
3364 TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0,
3365 false, false);
3366 QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
3367 NamedDecl *TemplParamPtr = TemplParam;
Richard Smith483b9f32011-02-21 20:05:19 +00003368 FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr,
3369 Loc);
3370
Richard Smitha085da82011-03-17 16:11:59 +00003371 TypeSourceInfo *FuncParamInfo =
Richard Smith34b41d92011-02-20 03:19:35 +00003372 SubstituteAutoTransform(*this, TemplArg).TransformType(Type);
Richard Smitha085da82011-03-17 16:11:59 +00003373 assert(FuncParamInfo && "substituting template parameter for 'auto' failed");
3374 QualType FuncParam = FuncParamInfo->getType();
Richard Smith34b41d92011-02-20 03:19:35 +00003375
3376 // Deduce type of TemplParam in Func(Init)
Chris Lattner5f9e2722011-07-23 10:55:15 +00003377 SmallVector<DeducedTemplateArgument, 1> Deduced;
Richard Smith34b41d92011-02-20 03:19:35 +00003378 Deduced.resize(1);
3379 QualType InitType = Init->getType();
3380 unsigned TDF = 0;
Richard Smith483b9f32011-02-21 20:05:19 +00003381 if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams,
Richard Smith34b41d92011-02-20 03:19:35 +00003382 FuncParam, InitType, Init,
3383 TDF))
3384 return false;
3385
3386 TemplateDeductionInfo Info(Context, Loc);
Richard Smith483b9f32011-02-21 20:05:19 +00003387 if (::DeduceTemplateArguments(*this, &TemplateParams,
Richard Smith34b41d92011-02-20 03:19:35 +00003388 FuncParam, InitType, Info, Deduced,
3389 TDF))
3390 return false;
3391
3392 QualType DeducedType = Deduced[0].getAsType();
3393 if (DeducedType.isNull())
3394 return false;
Douglas Gregor9a636e82011-06-17 05:31:46 +00003395
Richard Smith34b41d92011-02-20 03:19:35 +00003396 Result = SubstituteAutoTransform(*this, DeducedType).TransformType(Type);
Douglas Gregor9a636e82011-06-17 05:31:46 +00003397
3398 // Check that the deduced argument type is compatible with the original
3399 // argument type per C++ [temp.deduct.call]p4.
3400 if (Result &&
3401 CheckOriginalCallArgDeduction(*this,
3402 Sema::OriginalCallArg(FuncParam,0,InitType),
3403 Result->getType())) {
3404 Result = 0;
3405 return false;
3406 }
3407
Richard Smith34b41d92011-02-20 03:19:35 +00003408 return true;
3409}
3410
Douglas Gregor8a514912009-09-14 18:39:43 +00003411static void
Douglas Gregore73bb602009-09-14 21:25:05 +00003412MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
3413 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003414 unsigned Level,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003415 SmallVectorImpl<bool> &Deduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003416
3417/// \brief If this is a non-static member function,
Douglas Gregor77bc5722010-11-12 23:44:13 +00003418static void MaybeAddImplicitObjectParameterType(ASTContext &Context,
3419 CXXMethodDecl *Method,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003420 SmallVectorImpl<QualType> &ArgTypes) {
Douglas Gregor77bc5722010-11-12 23:44:13 +00003421 if (Method->isStatic())
3422 return;
3423
3424 // C++ [over.match.funcs]p4:
3425 //
3426 // For non-static member functions, the type of the implicit
3427 // object parameter is
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003428 // - "lvalue reference to cv X" for functions declared without a
Douglas Gregor77bc5722010-11-12 23:44:13 +00003429 // ref-qualifier or with the & ref-qualifier
3430 // - "rvalue reference to cv X" for functions declared with the
3431 // && ref-qualifier
3432 //
3433 // FIXME: We don't have ref-qualifiers yet, so we don't do that part.
3434 QualType ArgTy = Context.getTypeDeclType(Method->getParent());
3435 ArgTy = Context.getQualifiedType(ArgTy,
3436 Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
3437 ArgTy = Context.getLValueReferenceType(ArgTy);
3438 ArgTypes.push_back(ArgTy);
3439}
3440
Douglas Gregor8a514912009-09-14 18:39:43 +00003441/// \brief Determine whether the function template \p FT1 is at least as
3442/// specialized as \p FT2.
3443static bool isAtLeastAsSpecializedAs(Sema &S,
John McCall5769d612010-02-08 23:07:23 +00003444 SourceLocation Loc,
Douglas Gregor8a514912009-09-14 18:39:43 +00003445 FunctionTemplateDecl *FT1,
3446 FunctionTemplateDecl *FT2,
3447 TemplatePartialOrderingContext TPOC,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003448 unsigned NumCallArguments,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003449 SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
Douglas Gregor8a514912009-09-14 18:39:43 +00003450 FunctionDecl *FD1 = FT1->getTemplatedDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003451 FunctionDecl *FD2 = FT2->getTemplatedDecl();
Douglas Gregor8a514912009-09-14 18:39:43 +00003452 const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
3453 const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003454
Douglas Gregor8a514912009-09-14 18:39:43 +00003455 assert(Proto1 && Proto2 && "Function templates must have prototypes");
3456 TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003457 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor8a514912009-09-14 18:39:43 +00003458 Deduced.resize(TemplateParams->size());
3459
3460 // C++0x [temp.deduct.partial]p3:
3461 // The types used to determine the ordering depend on the context in which
3462 // the partial ordering is done:
John McCall2a7fb272010-08-25 05:32:35 +00003463 TemplateDeductionInfo Info(S.Context, Loc);
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003464 CXXMethodDecl *Method1 = 0;
3465 CXXMethodDecl *Method2 = 0;
3466 bool IsNonStatic2 = false;
3467 bool IsNonStatic1 = false;
3468 unsigned Skip2 = 0;
Douglas Gregor8a514912009-09-14 18:39:43 +00003469 switch (TPOC) {
3470 case TPOC_Call: {
3471 // - In the context of a function call, the function parameter types are
3472 // used.
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003473 Method1 = dyn_cast<CXXMethodDecl>(FD1);
3474 Method2 = dyn_cast<CXXMethodDecl>(FD2);
3475 IsNonStatic1 = Method1 && !Method1->isStatic();
3476 IsNonStatic2 = Method2 && !Method2->isStatic();
3477
3478 // C++0x [temp.func.order]p3:
3479 // [...] If only one of the function templates is a non-static
3480 // member, that function template is considered to have a new
3481 // first parameter inserted in its function parameter list. The
3482 // new parameter is of type "reference to cv A," where cv are
3483 // the cv-qualifiers of the function template (if any) and A is
3484 // the class of which the function template is a member.
3485 //
3486 // C++98/03 doesn't have this provision, so instead we drop the
3487 // first argument of the free function or static member, which
3488 // seems to match existing practice.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003489 SmallVector<QualType, 4> Args1;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003490 unsigned Skip1 = !S.getLangOptions().CPlusPlus0x &&
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003491 IsNonStatic2 && !IsNonStatic1;
3492 if (S.getLangOptions().CPlusPlus0x && IsNonStatic1 && !IsNonStatic2)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003493 MaybeAddImplicitObjectParameterType(S.Context, Method1, Args1);
3494 Args1.insert(Args1.end(),
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003495 Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end());
Douglas Gregor77bc5722010-11-12 23:44:13 +00003496
Chris Lattner5f9e2722011-07-23 10:55:15 +00003497 SmallVector<QualType, 4> Args2;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003498 Skip2 = !S.getLangOptions().CPlusPlus0x &&
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003499 IsNonStatic1 && !IsNonStatic2;
3500 if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1)
Douglas Gregor77bc5722010-11-12 23:44:13 +00003501 MaybeAddImplicitObjectParameterType(S.Context, Method2, Args2);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003502 Args2.insert(Args2.end(),
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003503 Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003504
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003505 // C++ [temp.func.order]p5:
3506 // The presence of unused ellipsis and default arguments has no effect on
3507 // the partial ordering of function templates.
3508 if (Args1.size() > NumCallArguments)
3509 Args1.resize(NumCallArguments);
3510 if (Args2.size() > NumCallArguments)
3511 Args2.resize(NumCallArguments);
3512 if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
3513 Args1.data(), Args1.size(), Info, Deduced,
3514 TDF_None, /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00003515 RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003516 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003517
Douglas Gregor8a514912009-09-14 18:39:43 +00003518 break;
3519 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003520
Douglas Gregor8a514912009-09-14 18:39:43 +00003521 case TPOC_Conversion:
3522 // - In the context of a call to a conversion operator, the return types
3523 // of the conversion function templates are used.
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003524 if (DeduceTemplateArguments(S, TemplateParams, Proto2->getResultType(),
3525 Proto1->getResultType(), Info, Deduced,
3526 TDF_None, /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00003527 RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003528 return false;
3529 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003530
Douglas Gregor8a514912009-09-14 18:39:43 +00003531 case TPOC_Other:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003532 // - In other contexts (14.6.6.2) the function template's function type
Douglas Gregor8a514912009-09-14 18:39:43 +00003533 // is used.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003534 if (DeduceTemplateArguments(S, TemplateParams, FD2->getType(),
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003535 FD1->getType(), Info, Deduced, TDF_None,
Douglas Gregorb939a192011-01-21 17:29:42 +00003536 /*PartialOrdering=*/true, RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003537 return false;
3538 break;
3539 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003540
Douglas Gregor8a514912009-09-14 18:39:43 +00003541 // C++0x [temp.deduct.partial]p11:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003542 // In most cases, all template parameters must have values in order for
3543 // deduction to succeed, but for partial ordering purposes a template
3544 // parameter may remain without a value provided it is not used in the
Douglas Gregor8a514912009-09-14 18:39:43 +00003545 // types being used for partial ordering. [ Note: a template parameter used
3546 // in a non-deduced context is considered used. -end note]
3547 unsigned ArgIdx = 0, NumArgs = Deduced.size();
3548 for (; ArgIdx != NumArgs; ++ArgIdx)
3549 if (Deduced[ArgIdx].isNull())
3550 break;
3551
3552 if (ArgIdx == NumArgs) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003553 // All template arguments were deduced. FT1 is at least as specialized
Douglas Gregor8a514912009-09-14 18:39:43 +00003554 // as FT2.
3555 return true;
3556 }
3557
Douglas Gregore73bb602009-09-14 21:25:05 +00003558 // Figure out which template parameters were used.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003559 SmallVector<bool, 4> UsedParameters;
Douglas Gregor8a514912009-09-14 18:39:43 +00003560 UsedParameters.resize(TemplateParams->size());
3561 switch (TPOC) {
3562 case TPOC_Call: {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003563 unsigned NumParams = std::min(NumCallArguments,
3564 std::min(Proto1->getNumArgs(),
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003565 Proto2->getNumArgs()));
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003566 if (S.getLangOptions().CPlusPlus0x && IsNonStatic2 && !IsNonStatic1)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003567 ::MarkUsedTemplateParameters(S, Method2->getThisType(S.Context), false,
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003568 TemplateParams->getDepth(), UsedParameters);
3569 for (unsigned I = Skip2; I < NumParams; ++I)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003570 ::MarkUsedTemplateParameters(S, Proto2->getArgType(I), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003571 TemplateParams->getDepth(),
Douglas Gregore73bb602009-09-14 21:25:05 +00003572 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003573 break;
3574 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003575
Douglas Gregor8a514912009-09-14 18:39:43 +00003576 case TPOC_Conversion:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003577 ::MarkUsedTemplateParameters(S, Proto2->getResultType(), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003578 TemplateParams->getDepth(),
Douglas Gregore73bb602009-09-14 21:25:05 +00003579 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003580 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003581
Douglas Gregor8a514912009-09-14 18:39:43 +00003582 case TPOC_Other:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003583 ::MarkUsedTemplateParameters(S, FD2->getType(), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003584 TemplateParams->getDepth(),
3585 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003586 break;
3587 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003588
Douglas Gregor8a514912009-09-14 18:39:43 +00003589 for (; ArgIdx != NumArgs; ++ArgIdx)
3590 // If this argument had no value deduced but was used in one of the types
3591 // used for partial ordering, then deduction fails.
3592 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
3593 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003594
Douglas Gregor8a514912009-09-14 18:39:43 +00003595 return true;
3596}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003597
Douglas Gregor9da95e62011-01-16 16:03:23 +00003598/// \brief Determine whether this a function template whose parameter-type-list
3599/// ends with a function parameter pack.
3600static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) {
3601 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
3602 unsigned NumParams = Function->getNumParams();
3603 if (NumParams == 0)
3604 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003605
Douglas Gregor9da95e62011-01-16 16:03:23 +00003606 ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
3607 if (!Last->isParameterPack())
3608 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003609
Douglas Gregor9da95e62011-01-16 16:03:23 +00003610 // Make sure that no previous parameter is a parameter pack.
3611 while (--NumParams > 0) {
3612 if (Function->getParamDecl(NumParams - 1)->isParameterPack())
3613 return false;
3614 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003615
Douglas Gregor9da95e62011-01-16 16:03:23 +00003616 return true;
3617}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003618
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003619/// \brief Returns the more specialized function template according
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003620/// to the rules of function template partial ordering (C++ [temp.func.order]).
3621///
3622/// \param FT1 the first function template
3623///
3624/// \param FT2 the second function template
3625///
Douglas Gregor8a514912009-09-14 18:39:43 +00003626/// \param TPOC the context in which we are performing partial ordering of
3627/// function templates.
Mike Stump1eb44332009-09-09 15:08:12 +00003628///
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003629/// \param NumCallArguments The number of arguments in a call, used only
3630/// when \c TPOC is \c TPOC_Call.
3631///
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003632/// \returns the more specialized function template. If neither
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003633/// template is more specialized, returns NULL.
3634FunctionTemplateDecl *
3635Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
3636 FunctionTemplateDecl *FT2,
John McCall5769d612010-02-08 23:07:23 +00003637 SourceLocation Loc,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003638 TemplatePartialOrderingContext TPOC,
3639 unsigned NumCallArguments) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00003640 SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003641 bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003642 NumCallArguments, 0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003643 bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003644 NumCallArguments,
Douglas Gregorb939a192011-01-21 17:29:42 +00003645 &RefParamComparisons);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003646
Douglas Gregor8a514912009-09-14 18:39:43 +00003647 if (Better1 != Better2) // We have a clear winner
3648 return Better1? FT1 : FT2;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003649
Douglas Gregor8a514912009-09-14 18:39:43 +00003650 if (!Better1 && !Better2) // Neither is better than the other
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003651 return 0;
Douglas Gregor8a514912009-09-14 18:39:43 +00003652
Douglas Gregor8a514912009-09-14 18:39:43 +00003653 // C++0x [temp.deduct.partial]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003654 // If for each type being considered a given template is at least as
Douglas Gregor8a514912009-09-14 18:39:43 +00003655 // specialized for all types and more specialized for some set of types and
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003656 // the other template is not more specialized for any types or is not at
Douglas Gregor8a514912009-09-14 18:39:43 +00003657 // least as specialized for any types, then the given template is more
3658 // specialized than the other template. Otherwise, neither template is more
3659 // specialized than the other.
3660 Better1 = false;
3661 Better2 = false;
Douglas Gregorb939a192011-01-21 17:29:42 +00003662 for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) {
Douglas Gregor8a514912009-09-14 18:39:43 +00003663 // C++0x [temp.deduct.partial]p9:
3664 // If, for a given type, deduction succeeds in both directions (i.e., the
Douglas Gregorb939a192011-01-21 17:29:42 +00003665 // types are identical after the transformations above) and both P and A
3666 // were reference types (before being replaced with the type referred to
3667 // above):
3668
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003669 // -- if the type from the argument template was an lvalue reference
Douglas Gregorb939a192011-01-21 17:29:42 +00003670 // and the type from the parameter template was not, the argument
3671 // type is considered to be more specialized than the other;
3672 // otherwise,
3673 if (!RefParamComparisons[I].ArgIsRvalueRef &&
3674 RefParamComparisons[I].ParamIsRvalueRef) {
3675 Better2 = true;
3676 if (Better1)
3677 return 0;
3678 continue;
3679 } else if (!RefParamComparisons[I].ParamIsRvalueRef &&
3680 RefParamComparisons[I].ArgIsRvalueRef) {
3681 Better1 = true;
3682 if (Better2)
3683 return 0;
3684 continue;
Douglas Gregor8a514912009-09-14 18:39:43 +00003685 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003686
Douglas Gregorb939a192011-01-21 17:29:42 +00003687 // -- if the type from the argument template is more cv-qualified than
3688 // the type from the parameter template (as described above), the
3689 // argument type is considered to be more specialized than the
3690 // other; otherwise,
3691 switch (RefParamComparisons[I].Qualifiers) {
3692 case NeitherMoreQualified:
3693 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003694
Douglas Gregorb939a192011-01-21 17:29:42 +00003695 case ParamMoreQualified:
3696 Better1 = true;
3697 if (Better2)
3698 return 0;
3699 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003700
Douglas Gregorb939a192011-01-21 17:29:42 +00003701 case ArgMoreQualified:
3702 Better2 = true;
3703 if (Better1)
3704 return 0;
3705 continue;
3706 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003707
Douglas Gregorb939a192011-01-21 17:29:42 +00003708 // -- neither type is more specialized than the other.
Douglas Gregor8a514912009-09-14 18:39:43 +00003709 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003710
Douglas Gregor8a514912009-09-14 18:39:43 +00003711 assert(!(Better1 && Better2) && "Should have broken out in the loop above");
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003712 if (Better1)
3713 return FT1;
Douglas Gregor8a514912009-09-14 18:39:43 +00003714 else if (Better2)
3715 return FT2;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003716
Douglas Gregor9da95e62011-01-16 16:03:23 +00003717 // FIXME: This mimics what GCC implements, but doesn't match up with the
3718 // proposed resolution for core issue 692. This area needs to be sorted out,
3719 // but for now we attempt to maintain compatibility.
3720 bool Variadic1 = isVariadicFunctionTemplate(FT1);
3721 bool Variadic2 = isVariadicFunctionTemplate(FT2);
3722 if (Variadic1 != Variadic2)
3723 return Variadic1? FT2 : FT1;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003724
Douglas Gregor9da95e62011-01-16 16:03:23 +00003725 return 0;
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003726}
Douglas Gregor83314aa2009-07-08 20:55:45 +00003727
Douglas Gregord5a423b2009-09-25 18:43:00 +00003728/// \brief Determine if the two templates are equivalent.
3729static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
3730 if (T1 == T2)
3731 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003732
Douglas Gregord5a423b2009-09-25 18:43:00 +00003733 if (!T1 || !T2)
3734 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003735
Douglas Gregord5a423b2009-09-25 18:43:00 +00003736 return T1->getCanonicalDecl() == T2->getCanonicalDecl();
3737}
3738
3739/// \brief Retrieve the most specialized of the given function template
3740/// specializations.
3741///
John McCallc373d482010-01-27 01:50:18 +00003742/// \param SpecBegin the start iterator of the function template
3743/// specializations that we will be comparing.
Douglas Gregord5a423b2009-09-25 18:43:00 +00003744///
John McCallc373d482010-01-27 01:50:18 +00003745/// \param SpecEnd the end iterator of the function template
3746/// specializations, paired with \p SpecBegin.
Douglas Gregord5a423b2009-09-25 18:43:00 +00003747///
3748/// \param TPOC the partial ordering context to use to compare the function
3749/// template specializations.
3750///
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003751/// \param NumCallArguments The number of arguments in a call, used only
3752/// when \c TPOC is \c TPOC_Call.
3753///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003754/// \param Loc the location where the ambiguity or no-specializations
Douglas Gregord5a423b2009-09-25 18:43:00 +00003755/// diagnostic should occur.
3756///
3757/// \param NoneDiag partial diagnostic used to diagnose cases where there are
3758/// no matching candidates.
3759///
3760/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
3761/// occurs.
3762///
3763/// \param CandidateDiag partial diagnostic used for each function template
3764/// specialization that is a candidate in the ambiguous ordering. One parameter
3765/// in this diagnostic should be unbound, which will correspond to the string
3766/// describing the template arguments for the function template specialization.
3767///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003768/// \param Index if non-NULL and the result of this function is non-nULL,
Douglas Gregord5a423b2009-09-25 18:43:00 +00003769/// receives the index corresponding to the resulting function template
3770/// specialization.
3771///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003772/// \returns the most specialized function template specialization, if
John McCallc373d482010-01-27 01:50:18 +00003773/// found. Otherwise, returns SpecEnd.
Douglas Gregord5a423b2009-09-25 18:43:00 +00003774///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003775/// \todo FIXME: Consider passing in the "also-ran" candidates that failed
Douglas Gregord5a423b2009-09-25 18:43:00 +00003776/// template argument deduction.
John McCallc373d482010-01-27 01:50:18 +00003777UnresolvedSetIterator
3778Sema::getMostSpecialized(UnresolvedSetIterator SpecBegin,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003779 UnresolvedSetIterator SpecEnd,
John McCallc373d482010-01-27 01:50:18 +00003780 TemplatePartialOrderingContext TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003781 unsigned NumCallArguments,
John McCallc373d482010-01-27 01:50:18 +00003782 SourceLocation Loc,
3783 const PartialDiagnostic &NoneDiag,
3784 const PartialDiagnostic &AmbigDiag,
Douglas Gregor1be8eec2011-02-19 21:32:49 +00003785 const PartialDiagnostic &CandidateDiag,
Richard Trieu6efd4c52011-11-23 22:32:32 +00003786 bool Complain,
3787 QualType TargetType) {
John McCallc373d482010-01-27 01:50:18 +00003788 if (SpecBegin == SpecEnd) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00003789 if (Complain)
3790 Diag(Loc, NoneDiag);
John McCallc373d482010-01-27 01:50:18 +00003791 return SpecEnd;
Douglas Gregord5a423b2009-09-25 18:43:00 +00003792 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003793
3794 if (SpecBegin + 1 == SpecEnd)
John McCallc373d482010-01-27 01:50:18 +00003795 return SpecBegin;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003796
Douglas Gregord5a423b2009-09-25 18:43:00 +00003797 // Find the function template that is better than all of the templates it
3798 // has been compared to.
John McCallc373d482010-01-27 01:50:18 +00003799 UnresolvedSetIterator Best = SpecBegin;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003800 FunctionTemplateDecl *BestTemplate
John McCallc373d482010-01-27 01:50:18 +00003801 = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00003802 assert(BestTemplate && "Not a function template specialization?");
John McCallc373d482010-01-27 01:50:18 +00003803 for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
3804 FunctionTemplateDecl *Challenger
3805 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00003806 assert(Challenger && "Not a function template specialization?");
John McCallc373d482010-01-27 01:50:18 +00003807 if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003808 Loc, TPOC, NumCallArguments),
Douglas Gregord5a423b2009-09-25 18:43:00 +00003809 Challenger)) {
3810 Best = I;
3811 BestTemplate = Challenger;
3812 }
3813 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003814
Douglas Gregord5a423b2009-09-25 18:43:00 +00003815 // Make sure that the "best" function template is more specialized than all
3816 // of the others.
3817 bool Ambiguous = false;
John McCallc373d482010-01-27 01:50:18 +00003818 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
3819 FunctionTemplateDecl *Challenger
3820 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00003821 if (I != Best &&
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003822 !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003823 Loc, TPOC, NumCallArguments),
Douglas Gregord5a423b2009-09-25 18:43:00 +00003824 BestTemplate)) {
3825 Ambiguous = true;
3826 break;
3827 }
3828 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003829
Douglas Gregord5a423b2009-09-25 18:43:00 +00003830 if (!Ambiguous) {
3831 // We found an answer. Return it.
John McCallc373d482010-01-27 01:50:18 +00003832 return Best;
Douglas Gregord5a423b2009-09-25 18:43:00 +00003833 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003834
Douglas Gregord5a423b2009-09-25 18:43:00 +00003835 // Diagnose the ambiguity.
Douglas Gregor1be8eec2011-02-19 21:32:49 +00003836 if (Complain)
3837 Diag(Loc, AmbigDiag);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003838
Douglas Gregor1be8eec2011-02-19 21:32:49 +00003839 if (Complain)
Douglas Gregord5a423b2009-09-25 18:43:00 +00003840 // FIXME: Can we order the candidates in some sane way?
Richard Trieu6efd4c52011-11-23 22:32:32 +00003841 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
3842 PartialDiagnostic PD = CandidateDiag;
3843 PD << getTemplateArgumentBindingsText(
Douglas Gregor1be8eec2011-02-19 21:32:49 +00003844 cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
John McCallc373d482010-01-27 01:50:18 +00003845 *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
Richard Trieu6efd4c52011-11-23 22:32:32 +00003846 if (!TargetType.isNull())
3847 HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(),
3848 TargetType);
3849 Diag((*I)->getLocation(), PD);
3850 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003851
John McCallc373d482010-01-27 01:50:18 +00003852 return SpecEnd;
Douglas Gregord5a423b2009-09-25 18:43:00 +00003853}
3854
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003855/// \brief Returns the more specialized class template partial specialization
3856/// according to the rules of partial ordering of class template partial
3857/// specializations (C++ [temp.class.order]).
3858///
3859/// \param PS1 the first class template partial specialization
3860///
3861/// \param PS2 the second class template partial specialization
3862///
3863/// \returns the more specialized class template partial specialization. If
3864/// neither partial specialization is more specialized, returns NULL.
3865ClassTemplatePartialSpecializationDecl *
3866Sema::getMoreSpecializedPartialSpecialization(
3867 ClassTemplatePartialSpecializationDecl *PS1,
John McCall5769d612010-02-08 23:07:23 +00003868 ClassTemplatePartialSpecializationDecl *PS2,
3869 SourceLocation Loc) {
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003870 // C++ [temp.class.order]p1:
3871 // For two class template partial specializations, the first is at least as
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003872 // specialized as the second if, given the following rewrite to two
3873 // function templates, the first function template is at least as
3874 // specialized as the second according to the ordering rules for function
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003875 // templates (14.6.6.2):
3876 // - the first function template has the same template parameters as the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003877 // first partial specialization and has a single function parameter
3878 // whose type is a class template specialization with the template
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003879 // arguments of the first partial specialization, and
3880 // - the second function template has the same template parameters as the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003881 // second partial specialization and has a single function parameter
3882 // whose type is a class template specialization with the template
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003883 // arguments of the second partial specialization.
3884 //
Douglas Gregor31dce8f2010-04-29 06:21:43 +00003885 // Rather than synthesize function templates, we merely perform the
3886 // equivalent partial ordering by performing deduction directly on
3887 // the template arguments of the class template partial
3888 // specializations. This computation is slightly simpler than the
3889 // general problem of function template partial ordering, because
3890 // class template partial specializations are more constrained. We
3891 // know that every template parameter is deducible from the class
3892 // template partial specialization's template arguments, for
3893 // example.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003894 SmallVector<DeducedTemplateArgument, 4> Deduced;
John McCall2a7fb272010-08-25 05:32:35 +00003895 TemplateDeductionInfo Info(Context, Loc);
John McCall31f17ec2010-04-27 00:57:59 +00003896
3897 QualType PT1 = PS1->getInjectedSpecializationType();
3898 QualType PT2 = PS2->getInjectedSpecializationType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003899
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003900 // Determine whether PS1 is at least as specialized as PS2
3901 Deduced.resize(PS2->getTemplateParameters()->size());
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003902 bool Better1 = !::DeduceTemplateArguments(*this, PS2->getTemplateParameters(),
3903 PT2, PT1, Info, Deduced, TDF_None,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003904 /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00003905 /*RefParamComparisons=*/0);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00003906 if (Better1) {
3907 InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
3908 Deduced.data(), Deduced.size(), Info);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003909 Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
3910 PS1->getTemplateArgs(),
Douglas Gregor516e6e02010-04-29 06:31:36 +00003911 Deduced, Info);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00003912 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003913
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003914 // Determine whether PS2 is at least as specialized as PS1
Douglas Gregordb0d4b72009-11-11 23:06:43 +00003915 Deduced.clear();
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003916 Deduced.resize(PS1->getTemplateParameters()->size());
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003917 bool Better2 = !::DeduceTemplateArguments(*this, PS1->getTemplateParameters(),
3918 PT1, PT2, Info, Deduced, TDF_None,
3919 /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00003920 /*RefParamComparisons=*/0);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00003921 if (Better2) {
3922 InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
3923 Deduced.data(), Deduced.size(), Info);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003924 Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
3925 PS2->getTemplateArgs(),
Douglas Gregor516e6e02010-04-29 06:31:36 +00003926 Deduced, Info);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00003927 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003928
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003929 if (Better1 == Better2)
3930 return 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003931
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003932 return Better1? PS1 : PS2;
3933}
3934
Mike Stump1eb44332009-09-09 15:08:12 +00003935static void
Douglas Gregore73bb602009-09-14 21:25:05 +00003936MarkUsedTemplateParameters(Sema &SemaRef,
3937 const TemplateArgument &TemplateArg,
3938 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003939 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003940 SmallVectorImpl<bool> &Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00003941
Douglas Gregore73bb602009-09-14 21:25:05 +00003942/// \brief Mark the template parameters that are used by the given
Douglas Gregor031a5882009-06-13 00:26:55 +00003943/// expression.
Mike Stump1eb44332009-09-09 15:08:12 +00003944static void
Douglas Gregore73bb602009-09-14 21:25:05 +00003945MarkUsedTemplateParameters(Sema &SemaRef,
3946 const Expr *E,
3947 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003948 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003949 SmallVectorImpl<bool> &Used) {
Douglas Gregorbe230c32011-01-03 17:17:50 +00003950 // We can deduce from a pack expansion.
3951 if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
3952 E = Expansion->getPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003953
Douglas Gregor54c53cc2011-01-04 23:35:54 +00003954 // Skip through any implicit casts we added while type-checking.
3955 while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
3956 E = ICE->getSubExpr();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003957
3958 // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
Douglas Gregore73bb602009-09-14 21:25:05 +00003959 // find other occurrences of template parameters.
Douglas Gregorf6ddb732009-06-18 18:45:36 +00003960 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
Douglas Gregorc781f9c2010-01-14 18:13:22 +00003961 if (!DRE)
Douglas Gregor031a5882009-06-13 00:26:55 +00003962 return;
3963
Mike Stump1eb44332009-09-09 15:08:12 +00003964 const NonTypeTemplateParmDecl *NTTP
Douglas Gregor031a5882009-06-13 00:26:55 +00003965 = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
3966 if (!NTTP)
3967 return;
3968
Douglas Gregored9c0f92009-10-29 00:04:11 +00003969 if (NTTP->getDepth() == Depth)
3970 Used[NTTP->getIndex()] = true;
Douglas Gregor031a5882009-06-13 00:26:55 +00003971}
3972
Douglas Gregore73bb602009-09-14 21:25:05 +00003973/// \brief Mark the template parameters that are used by the given
3974/// nested name specifier.
3975static void
3976MarkUsedTemplateParameters(Sema &SemaRef,
3977 NestedNameSpecifier *NNS,
3978 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003979 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003980 SmallVectorImpl<bool> &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00003981 if (!NNS)
3982 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003983
Douglas Gregored9c0f92009-10-29 00:04:11 +00003984 MarkUsedTemplateParameters(SemaRef, NNS->getPrefix(), OnlyDeduced, Depth,
3985 Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003986 MarkUsedTemplateParameters(SemaRef, QualType(NNS->getAsType(), 0),
Douglas Gregored9c0f92009-10-29 00:04:11 +00003987 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00003988}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003989
Douglas Gregore73bb602009-09-14 21:25:05 +00003990/// \brief Mark the template parameters that are used by the given
3991/// template name.
3992static void
3993MarkUsedTemplateParameters(Sema &SemaRef,
3994 TemplateName Name,
3995 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003996 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003997 SmallVectorImpl<bool> &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00003998 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
3999 if (TemplateTemplateParmDecl *TTP
Douglas Gregored9c0f92009-10-29 00:04:11 +00004000 = dyn_cast<TemplateTemplateParmDecl>(Template)) {
4001 if (TTP->getDepth() == Depth)
4002 Used[TTP->getIndex()] = true;
4003 }
Douglas Gregore73bb602009-09-14 21:25:05 +00004004 return;
4005 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004006
Douglas Gregor788cd062009-11-11 01:00:40 +00004007 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004008 MarkUsedTemplateParameters(SemaRef, QTN->getQualifier(), OnlyDeduced,
Douglas Gregor788cd062009-11-11 01:00:40 +00004009 Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004010 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004011 MarkUsedTemplateParameters(SemaRef, DTN->getQualifier(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004012 Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004013}
4014
4015/// \brief Mark the template parameters that are used by the given
Douglas Gregor031a5882009-06-13 00:26:55 +00004016/// type.
Mike Stump1eb44332009-09-09 15:08:12 +00004017static void
Douglas Gregore73bb602009-09-14 21:25:05 +00004018MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
4019 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004020 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004021 SmallVectorImpl<bool> &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00004022 if (T.isNull())
4023 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004024
Douglas Gregor031a5882009-06-13 00:26:55 +00004025 // Non-dependent types have nothing deducible
4026 if (!T->isDependentType())
4027 return;
4028
4029 T = SemaRef.Context.getCanonicalType(T);
4030 switch (T->getTypeClass()) {
Douglas Gregor031a5882009-06-13 00:26:55 +00004031 case Type::Pointer:
Douglas Gregore73bb602009-09-14 21:25:05 +00004032 MarkUsedTemplateParameters(SemaRef,
4033 cast<PointerType>(T)->getPointeeType(),
4034 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004035 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004036 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004037 break;
4038
4039 case Type::BlockPointer:
Douglas Gregore73bb602009-09-14 21:25:05 +00004040 MarkUsedTemplateParameters(SemaRef,
4041 cast<BlockPointerType>(T)->getPointeeType(),
4042 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004043 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004044 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004045 break;
4046
4047 case Type::LValueReference:
4048 case Type::RValueReference:
Douglas Gregore73bb602009-09-14 21:25:05 +00004049 MarkUsedTemplateParameters(SemaRef,
4050 cast<ReferenceType>(T)->getPointeeType(),
4051 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004052 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004053 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004054 break;
4055
4056 case Type::MemberPointer: {
4057 const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
Douglas Gregore73bb602009-09-14 21:25:05 +00004058 MarkUsedTemplateParameters(SemaRef, MemPtr->getPointeeType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004059 Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004060 MarkUsedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004061 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004062 break;
4063 }
4064
4065 case Type::DependentSizedArray:
Douglas Gregore73bb602009-09-14 21:25:05 +00004066 MarkUsedTemplateParameters(SemaRef,
4067 cast<DependentSizedArrayType>(T)->getSizeExpr(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004068 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004069 // Fall through to check the element type
4070
4071 case Type::ConstantArray:
4072 case Type::IncompleteArray:
Douglas Gregore73bb602009-09-14 21:25:05 +00004073 MarkUsedTemplateParameters(SemaRef,
4074 cast<ArrayType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004075 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004076 break;
4077
4078 case Type::Vector:
4079 case Type::ExtVector:
Douglas Gregore73bb602009-09-14 21:25:05 +00004080 MarkUsedTemplateParameters(SemaRef,
4081 cast<VectorType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004082 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004083 break;
4084
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004085 case Type::DependentSizedExtVector: {
4086 const DependentSizedExtVectorType *VecType
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004087 = cast<DependentSizedExtVectorType>(T);
Douglas Gregore73bb602009-09-14 21:25:05 +00004088 MarkUsedTemplateParameters(SemaRef, VecType->getElementType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004089 Depth, Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004090 MarkUsedTemplateParameters(SemaRef, VecType->getSizeExpr(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004091 Depth, Used);
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004092 break;
4093 }
4094
Douglas Gregor031a5882009-06-13 00:26:55 +00004095 case Type::FunctionProto: {
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004096 const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
Douglas Gregore73bb602009-09-14 21:25:05 +00004097 MarkUsedTemplateParameters(SemaRef, Proto->getResultType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004098 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004099 for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
Douglas Gregore73bb602009-09-14 21:25:05 +00004100 MarkUsedTemplateParameters(SemaRef, Proto->getArgType(I), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004101 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004102 break;
4103 }
4104
Douglas Gregored9c0f92009-10-29 00:04:11 +00004105 case Type::TemplateTypeParm: {
4106 const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
4107 if (TTP->getDepth() == Depth)
4108 Used[TTP->getIndex()] = true;
Douglas Gregor031a5882009-06-13 00:26:55 +00004109 break;
Douglas Gregored9c0f92009-10-29 00:04:11 +00004110 }
Douglas Gregor031a5882009-06-13 00:26:55 +00004111
Douglas Gregor0bc15d92011-01-14 05:11:40 +00004112 case Type::SubstTemplateTypeParmPack: {
4113 const SubstTemplateTypeParmPackType *Subst
4114 = cast<SubstTemplateTypeParmPackType>(T);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004115 MarkUsedTemplateParameters(SemaRef,
Douglas Gregor0bc15d92011-01-14 05:11:40 +00004116 QualType(Subst->getReplacedParameter(), 0),
4117 OnlyDeduced, Depth, Used);
4118 MarkUsedTemplateParameters(SemaRef, Subst->getArgumentPack(),
4119 OnlyDeduced, Depth, Used);
4120 break;
4121 }
4122
John McCall31f17ec2010-04-27 00:57:59 +00004123 case Type::InjectedClassName:
4124 T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
4125 // fall through
4126
Douglas Gregor031a5882009-06-13 00:26:55 +00004127 case Type::TemplateSpecialization: {
Mike Stump1eb44332009-09-09 15:08:12 +00004128 const TemplateSpecializationType *Spec
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004129 = cast<TemplateSpecializationType>(T);
Douglas Gregore73bb602009-09-14 21:25:05 +00004130 MarkUsedTemplateParameters(SemaRef, Spec->getTemplateName(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004131 Depth, Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004132
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004133 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004134 // If the template argument list of P contains a pack expansion that is not
4135 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004136 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004137 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004138 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4139 break;
4140
Douglas Gregore73bb602009-09-14 21:25:05 +00004141 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
Douglas Gregored9c0f92009-10-29 00:04:11 +00004142 MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth,
4143 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004144 break;
4145 }
4146
Douglas Gregore73bb602009-09-14 21:25:05 +00004147 case Type::Complex:
4148 if (!OnlyDeduced)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004149 MarkUsedTemplateParameters(SemaRef,
Douglas Gregore73bb602009-09-14 21:25:05 +00004150 cast<ComplexType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004151 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004152 break;
4153
Eli Friedmanb001de72011-10-06 23:00:33 +00004154 case Type::Atomic:
4155 if (!OnlyDeduced)
4156 MarkUsedTemplateParameters(SemaRef,
4157 cast<AtomicType>(T)->getValueType(),
4158 OnlyDeduced, Depth, Used);
4159 break;
4160
Douglas Gregor4714c122010-03-31 17:34:00 +00004161 case Type::DependentName:
Douglas Gregore73bb602009-09-14 21:25:05 +00004162 if (!OnlyDeduced)
4163 MarkUsedTemplateParameters(SemaRef,
Douglas Gregor4714c122010-03-31 17:34:00 +00004164 cast<DependentNameType>(T)->getQualifier(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004165 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004166 break;
4167
John McCall33500952010-06-11 00:33:02 +00004168 case Type::DependentTemplateSpecialization: {
4169 const DependentTemplateSpecializationType *Spec
4170 = cast<DependentTemplateSpecializationType>(T);
4171 if (!OnlyDeduced)
4172 MarkUsedTemplateParameters(SemaRef, Spec->getQualifier(),
4173 OnlyDeduced, Depth, Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004174
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004175 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004176 // If the template argument list of P contains a pack expansion that is not
4177 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004178 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004179 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004180 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4181 break;
4182
John McCall33500952010-06-11 00:33:02 +00004183 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
4184 MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth,
4185 Used);
4186 break;
4187 }
4188
John McCallad5e7382010-03-01 23:49:17 +00004189 case Type::TypeOf:
4190 if (!OnlyDeduced)
4191 MarkUsedTemplateParameters(SemaRef,
4192 cast<TypeOfType>(T)->getUnderlyingType(),
4193 OnlyDeduced, Depth, Used);
4194 break;
4195
4196 case Type::TypeOfExpr:
4197 if (!OnlyDeduced)
4198 MarkUsedTemplateParameters(SemaRef,
4199 cast<TypeOfExprType>(T)->getUnderlyingExpr(),
4200 OnlyDeduced, Depth, Used);
4201 break;
4202
4203 case Type::Decltype:
4204 if (!OnlyDeduced)
4205 MarkUsedTemplateParameters(SemaRef,
4206 cast<DecltypeType>(T)->getUnderlyingExpr(),
4207 OnlyDeduced, Depth, Used);
4208 break;
4209
Sean Huntca63c202011-05-24 22:41:36 +00004210 case Type::UnaryTransform:
4211 if (!OnlyDeduced)
4212 MarkUsedTemplateParameters(SemaRef,
4213 cast<UnaryTransformType>(T)->getUnderlyingType(),
4214 OnlyDeduced, Depth, Used);
4215 break;
4216
Douglas Gregor7536dd52010-12-20 02:24:11 +00004217 case Type::PackExpansion:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004218 MarkUsedTemplateParameters(SemaRef,
Douglas Gregor7536dd52010-12-20 02:24:11 +00004219 cast<PackExpansionType>(T)->getPattern(),
4220 OnlyDeduced, Depth, Used);
4221 break;
4222
Richard Smith34b41d92011-02-20 03:19:35 +00004223 case Type::Auto:
4224 MarkUsedTemplateParameters(SemaRef,
4225 cast<AutoType>(T)->getDeducedType(),
4226 OnlyDeduced, Depth, Used);
4227
Douglas Gregore73bb602009-09-14 21:25:05 +00004228 // None of these types have any template parameters in them.
Douglas Gregor031a5882009-06-13 00:26:55 +00004229 case Type::Builtin:
Douglas Gregor031a5882009-06-13 00:26:55 +00004230 case Type::VariableArray:
4231 case Type::FunctionNoProto:
4232 case Type::Record:
4233 case Type::Enum:
Douglas Gregor031a5882009-06-13 00:26:55 +00004234 case Type::ObjCInterface:
John McCallc12c5bb2010-05-15 11:32:37 +00004235 case Type::ObjCObject:
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00004236 case Type::ObjCObjectPointer:
John McCalled976492009-12-04 22:46:56 +00004237 case Type::UnresolvedUsing:
Douglas Gregor031a5882009-06-13 00:26:55 +00004238#define TYPE(Class, Base)
4239#define ABSTRACT_TYPE(Class, Base)
4240#define DEPENDENT_TYPE(Class, Base)
4241#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4242#include "clang/AST/TypeNodes.def"
4243 break;
4244 }
4245}
4246
Douglas Gregore73bb602009-09-14 21:25:05 +00004247/// \brief Mark the template parameters that are used by this
Douglas Gregor031a5882009-06-13 00:26:55 +00004248/// template argument.
Mike Stump1eb44332009-09-09 15:08:12 +00004249static void
Douglas Gregore73bb602009-09-14 21:25:05 +00004250MarkUsedTemplateParameters(Sema &SemaRef,
4251 const TemplateArgument &TemplateArg,
4252 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004253 unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004254 SmallVectorImpl<bool> &Used) {
Douglas Gregor031a5882009-06-13 00:26:55 +00004255 switch (TemplateArg.getKind()) {
4256 case TemplateArgument::Null:
4257 case TemplateArgument::Integral:
Douglas Gregor788cd062009-11-11 01:00:40 +00004258 case TemplateArgument::Declaration:
Douglas Gregor031a5882009-06-13 00:26:55 +00004259 break;
Mike Stump1eb44332009-09-09 15:08:12 +00004260
Douglas Gregor031a5882009-06-13 00:26:55 +00004261 case TemplateArgument::Type:
Douglas Gregore73bb602009-09-14 21:25:05 +00004262 MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004263 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004264 break;
4265
Douglas Gregor788cd062009-11-11 01:00:40 +00004266 case TemplateArgument::Template:
Douglas Gregora7fc9012011-01-05 18:58:31 +00004267 case TemplateArgument::TemplateExpansion:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004268 MarkUsedTemplateParameters(SemaRef,
4269 TemplateArg.getAsTemplateOrTemplatePattern(),
Douglas Gregor788cd062009-11-11 01:00:40 +00004270 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004271 break;
4272
4273 case TemplateArgument::Expression:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004274 MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsExpr(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004275 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004276 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004277
Anders Carlssond01b1da2009-06-15 17:04:53 +00004278 case TemplateArgument::Pack:
Douglas Gregore73bb602009-09-14 21:25:05 +00004279 for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
4280 PEnd = TemplateArg.pack_end();
4281 P != PEnd; ++P)
Douglas Gregored9c0f92009-10-29 00:04:11 +00004282 MarkUsedTemplateParameters(SemaRef, *P, OnlyDeduced, Depth, Used);
Anders Carlssond01b1da2009-06-15 17:04:53 +00004283 break;
Douglas Gregor031a5882009-06-13 00:26:55 +00004284 }
4285}
4286
4287/// \brief Mark the template parameters can be deduced by the given
4288/// template argument list.
4289///
4290/// \param TemplateArgs the template argument list from which template
4291/// parameters will be deduced.
4292///
4293/// \param Deduced a bit vector whose elements will be set to \c true
4294/// to indicate when the corresponding template parameter will be
4295/// deduced.
Mike Stump1eb44332009-09-09 15:08:12 +00004296void
Douglas Gregore73bb602009-09-14 21:25:05 +00004297Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004298 bool OnlyDeduced, unsigned Depth,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004299 SmallVectorImpl<bool> &Used) {
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004300 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004301 // If the template argument list of P contains a pack expansion that is not
4302 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004303 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004304 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004305 hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
4306 return;
4307
Douglas Gregor031a5882009-06-13 00:26:55 +00004308 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004309 ::MarkUsedTemplateParameters(*this, TemplateArgs[I], OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004310 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004311}
Douglas Gregor63f07c52009-09-18 23:21:38 +00004312
4313/// \brief Marks all of the template parameters that will be deduced by a
4314/// call to the given function template.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004315void
Douglas Gregor02024a92010-03-28 02:42:43 +00004316Sema::MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate,
Chris Lattner5f9e2722011-07-23 10:55:15 +00004317 SmallVectorImpl<bool> &Deduced) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004318 TemplateParameterList *TemplateParams
Douglas Gregor63f07c52009-09-18 23:21:38 +00004319 = FunctionTemplate->getTemplateParameters();
4320 Deduced.clear();
4321 Deduced.resize(TemplateParams->size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004322
Douglas Gregor63f07c52009-09-18 23:21:38 +00004323 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
4324 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
4325 ::MarkUsedTemplateParameters(*this, Function->getParamDecl(I)->getType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004326 true, TemplateParams->getDepth(), Deduced);
Douglas Gregor63f07c52009-09-18 23:21:38 +00004327}
Douglas Gregordbfb3712011-06-16 16:50:48 +00004328
4329bool hasDeducibleTemplateParameters(Sema &S,
4330 FunctionTemplateDecl *FunctionTemplate,
4331 QualType T) {
4332 if (!T->isDependentType())
4333 return false;
4334
4335 TemplateParameterList *TemplateParams
4336 = FunctionTemplate->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00004337 SmallVector<bool, 4> Deduced;
Douglas Gregordbfb3712011-06-16 16:50:48 +00004338 Deduced.resize(TemplateParams->size());
4339 ::MarkUsedTemplateParameters(S, T, true, TemplateParams->getDepth(),
4340 Deduced);
4341
4342 for (unsigned I = 0, N = Deduced.size(); I != N; ++I)
4343 if (Deduced[I])
4344 return true;
4345
4346 return false;
4347}