blob: f3bbe8a0f10cde551afb5738e88f47f1c9eefd25 [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
John McCall2a7fb272010-08-25 05:32:35 +000013#include "clang/Sema/TemplateDeduction.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000014#include "TreeTransform.h"
Douglas Gregor0b9247f2009-06-04 00:03:07 +000015#include "clang/AST/ASTContext.h"
John McCall7cd088e2010-08-24 07:21:54 +000016#include "clang/AST/DeclObjC.h"
Douglas Gregor0b9247f2009-06-04 00:03:07 +000017#include "clang/AST/DeclTemplate.h"
Douglas Gregor0b9247f2009-06-04 00:03:07 +000018#include "clang/AST/Expr.h"
19#include "clang/AST/ExprCXX.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000020#include "clang/AST/StmtVisitor.h"
21#include "clang/Sema/DeclSpec.h"
22#include "clang/Sema/Sema.h"
23#include "clang/Sema/Template.h"
Benjamin Kramer013b3662012-01-30 16:17:39 +000024#include "llvm/ADT/SmallBitVector.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
Sebastian Redlbb95e512012-01-17 22:49:52 +0000115DeduceTemplateArgumentsByTypeMatch(Sema &S,
116 TemplateParameterList *TemplateParams,
117 QualType Param,
118 QualType Arg,
119 TemplateDeductionInfo &Info,
120 SmallVectorImpl<DeducedTemplateArgument> &
121 Deduced,
122 unsigned TDF,
123 bool PartialOrdering = false,
124 SmallVectorImpl<RefParamPartialOrderingComparison> *
Douglas Gregorb939a192011-01-21 17:29:42 +0000125 RefParamComparisons = 0);
Douglas Gregor603cfb42011-01-05 23:12:31 +0000126
127static Sema::TemplateDeductionResult
128DeduceTemplateArguments(Sema &S,
129 TemplateParameterList *TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +0000130 const TemplateArgument *Params, unsigned NumParams,
131 const TemplateArgument *Args, unsigned NumArgs,
132 TemplateDeductionInfo &Info,
Richard Smith030a6642012-12-06 06:44:44 +0000133 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
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) {
Richard Smith5a343d72012-07-08 04:37:51 +0000139 // If we are within an alias template, the expression may have undergone
140 // any number of parameter substitutions already.
141 while (1) {
142 if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
143 E = IC->getSubExpr();
144 else if (SubstNonTypeTemplateParmExpr *Subst =
145 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
146 E = Subst->getReplacement();
147 else
148 break;
149 }
Mike Stump1eb44332009-09-09 15:08:12 +0000150
Douglas Gregor199d9912009-06-05 00:53:49 +0000151 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
152 return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000153
Douglas Gregor199d9912009-06-05 00:53:49 +0000154 return 0;
155}
156
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000157/// \brief Determine whether two declaration pointers refer to the same
158/// declaration.
159static bool isSameDeclaration(Decl *X, Decl *Y) {
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000160 if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
161 X = NX->getUnderlyingDecl();
162 if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
163 Y = NY->getUnderlyingDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000164
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000165 return X->getCanonicalDecl() == Y->getCanonicalDecl();
166}
167
168/// \brief Verify that the given, deduced template arguments are compatible.
169///
170/// \returns The deduced template argument, or a NULL template argument if
171/// the deduced template arguments were incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000172static DeducedTemplateArgument
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000173checkDeducedTemplateArguments(ASTContext &Context,
174 const DeducedTemplateArgument &X,
175 const DeducedTemplateArgument &Y) {
176 // We have no deduction for one or both of the arguments; they're compatible.
177 if (X.isNull())
178 return Y;
179 if (Y.isNull())
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000180 return X;
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000181
182 switch (X.getKind()) {
183 case TemplateArgument::Null:
184 llvm_unreachable("Non-deduced template arguments handled above");
185
186 case TemplateArgument::Type:
187 // If two template type arguments have the same type, they're compatible.
188 if (Y.getKind() == TemplateArgument::Type &&
189 Context.hasSameType(X.getAsType(), Y.getAsType()))
190 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000191
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000192 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000193
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000194 case TemplateArgument::Integral:
195 // If we deduced a constant in one case and either a dependent expression or
196 // declaration in another case, keep the integral constant.
197 // If both are integral constants with the same value, keep that value.
198 if (Y.getKind() == TemplateArgument::Expression ||
199 Y.getKind() == TemplateArgument::Declaration ||
200 (Y.getKind() == TemplateArgument::Integral &&
Benjamin Kramer85524372012-06-07 15:09:51 +0000201 hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral())))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000202 return DeducedTemplateArgument(X,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000203 X.wasDeducedFromArrayBound() &&
204 Y.wasDeducedFromArrayBound());
205
206 // All other combinations are incompatible.
207 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000208
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000209 case TemplateArgument::Template:
210 if (Y.getKind() == TemplateArgument::Template &&
211 Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate()))
212 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000213
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000214 // All other combinations are incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000215 return DeducedTemplateArgument();
Douglas Gregora7fc9012011-01-05 18:58:31 +0000216
217 case TemplateArgument::TemplateExpansion:
218 if (Y.getKind() == TemplateArgument::TemplateExpansion &&
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000219 Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(),
Douglas Gregora7fc9012011-01-05 18:58:31 +0000220 Y.getAsTemplateOrTemplatePattern()))
221 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000222
Douglas Gregora7fc9012011-01-05 18:58:31 +0000223 // All other combinations are incompatible.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000224 return DeducedTemplateArgument();
Douglas Gregora7fc9012011-01-05 18:58:31 +0000225
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000226 case TemplateArgument::Expression:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000227 // If we deduced a dependent expression in one case and either an integral
228 // constant or a declaration in another case, keep the integral constant
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000229 // or declaration.
230 if (Y.getKind() == TemplateArgument::Integral ||
231 Y.getKind() == TemplateArgument::Declaration)
232 return DeducedTemplateArgument(Y, X.wasDeducedFromArrayBound() &&
233 Y.wasDeducedFromArrayBound());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000234
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000235 if (Y.getKind() == TemplateArgument::Expression) {
236 // Compare the expressions for equality
237 llvm::FoldingSetNodeID ID1, ID2;
238 X.getAsExpr()->Profile(ID1, Context, true);
239 Y.getAsExpr()->Profile(ID2, Context, true);
240 if (ID1 == ID2)
241 return X;
242 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000243
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000244 // All other combinations are incompatible.
245 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000246
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000247 case TemplateArgument::Declaration:
248 // If we deduced a declaration and a dependent expression, keep the
249 // declaration.
250 if (Y.getKind() == TemplateArgument::Expression)
251 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000252
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000253 // If we deduced a declaration and an integral constant, keep the
254 // integral constant.
255 if (Y.getKind() == TemplateArgument::Integral)
256 return Y;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000257
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000258 // If we deduced two declarations, make sure they they refer to the
259 // same declaration.
260 if (Y.getKind() == TemplateArgument::Declaration &&
Eli Friedmand7a6b162012-09-26 02:36:12 +0000261 isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
262 X.isDeclForReferenceParam() == Y.isDeclForReferenceParam())
263 return X;
264
265 // All other combinations are incompatible.
266 return DeducedTemplateArgument();
267
268 case TemplateArgument::NullPtr:
269 // If we deduced a null pointer and a dependent expression, keep the
270 // null pointer.
271 if (Y.getKind() == TemplateArgument::Expression)
272 return X;
273
274 // If we deduced a null pointer and an integral constant, keep the
275 // integral constant.
276 if (Y.getKind() == TemplateArgument::Integral)
277 return Y;
278
279 // If we deduced two null pointers, make sure they have the same type.
280 if (Y.getKind() == TemplateArgument::NullPtr &&
281 Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()))
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000282 return X;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000283
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000284 // All other combinations are incompatible.
285 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000286
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000287 case TemplateArgument::Pack:
288 if (Y.getKind() != TemplateArgument::Pack ||
289 X.pack_size() != Y.pack_size())
290 return DeducedTemplateArgument();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000291
292 for (TemplateArgument::pack_iterator XA = X.pack_begin(),
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000293 XAEnd = X.pack_end(),
294 YA = Y.pack_begin();
295 XA != XAEnd; ++XA, ++YA) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000296 if (checkDeducedTemplateArguments(Context,
297 DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()),
Douglas Gregor135ffa72011-01-05 21:00:53 +0000298 DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound()))
299 .isNull())
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000300 return DeducedTemplateArgument();
301 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000302
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000303 return X;
304 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000305
David Blaikie30263482012-01-20 21:50:17 +0000306 llvm_unreachable("Invalid TemplateArgument Kind!");
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000307}
308
Mike Stump1eb44332009-09-09 15:08:12 +0000309/// \brief Deduce the value of the given non-type template parameter
Douglas Gregor199d9912009-06-05 00:53:49 +0000310/// from the given constant.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000311static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000312DeduceNonTypeTemplateArgument(Sema &S,
Mike Stump1eb44332009-09-09 15:08:12 +0000313 NonTypeTemplateParmDecl *NTTP,
Douglas Gregor9d0e4412010-03-26 05:50:28 +0000314 llvm::APSInt Value, QualType ValueType,
Douglas Gregor02024a92010-03-28 02:42:43 +0000315 bool DeducedFromArrayBound,
John McCall2a7fb272010-08-25 05:32:35 +0000316 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000317 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Mike Stump1eb44332009-09-09 15:08:12 +0000318 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +0000319 "Cannot deduce non-type template argument with depth > 0");
Mike Stump1eb44332009-09-09 15:08:12 +0000320
Benjamin Kramer85524372012-06-07 15:09:51 +0000321 DeducedTemplateArgument NewDeduced(S.Context, Value, ValueType,
322 DeducedFromArrayBound);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000323 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000324 Deduced[NTTP->getIndex()],
325 NewDeduced);
326 if (Result.isNull()) {
Douglas Gregorf67875d2009-06-12 18:26:56 +0000327 Info.Param = NTTP;
328 Info.FirstArg = Deduced[NTTP->getIndex()];
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000329 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000330 return Sema::TDK_Inconsistent;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000331 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000332
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000333 Deduced[NTTP->getIndex()] = Result;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000334 return Sema::TDK_Success;
Douglas Gregor199d9912009-06-05 00:53:49 +0000335}
336
Mike Stump1eb44332009-09-09 15:08:12 +0000337/// \brief Deduce the value of the given non-type template parameter
Douglas Gregor199d9912009-06-05 00:53:49 +0000338/// from the given type- or value-dependent expression.
339///
340/// \returns true if deduction succeeded, false otherwise.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000341static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000342DeduceNonTypeTemplateArgument(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +0000343 NonTypeTemplateParmDecl *NTTP,
344 Expr *Value,
John McCall2a7fb272010-08-25 05:32:35 +0000345 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000346 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Mike Stump1eb44332009-09-09 15:08:12 +0000347 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +0000348 "Cannot deduce non-type template argument with depth > 0");
349 assert((Value->isTypeDependent() || Value->isValueDependent()) &&
350 "Expression template argument must be type- or value-dependent.");
Mike Stump1eb44332009-09-09 15:08:12 +0000351
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000352 DeducedTemplateArgument NewDeduced(Value);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000353 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
354 Deduced[NTTP->getIndex()],
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000355 NewDeduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000356
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000357 if (Result.isNull()) {
358 Info.Param = NTTP;
359 Info.FirstArg = Deduced[NTTP->getIndex()];
360 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000361 return Sema::TDK_Inconsistent;
Douglas Gregor199d9912009-06-05 00:53:49 +0000362 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000363
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000364 Deduced[NTTP->getIndex()] = Result;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000365 return Sema::TDK_Success;
Douglas Gregor199d9912009-06-05 00:53:49 +0000366}
367
Douglas Gregor15755cb2009-11-13 23:45:44 +0000368/// \brief Deduce the value of the given non-type template parameter
369/// from the given declaration.
370///
371/// \returns true if deduction succeeded, false otherwise.
372static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000373DeduceNonTypeTemplateArgument(Sema &S,
Douglas Gregor15755cb2009-11-13 23:45:44 +0000374 NonTypeTemplateParmDecl *NTTP,
Eli Friedmand7a6b162012-09-26 02:36:12 +0000375 ValueDecl *D,
John McCall2a7fb272010-08-25 05:32:35 +0000376 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000377 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregor15755cb2009-11-13 23:45:44 +0000378 assert(NTTP->getDepth() == 0 &&
379 "Cannot deduce non-type template argument with depth > 0");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000380
Eli Friedmand7a6b162012-09-26 02:36:12 +0000381 D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0;
382 TemplateArgument New(D, NTTP->getType()->isReferenceType());
383 DeducedTemplateArgument NewDeduced(New);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000384 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000385 Deduced[NTTP->getIndex()],
386 NewDeduced);
387 if (Result.isNull()) {
388 Info.Param = NTTP;
389 Info.FirstArg = Deduced[NTTP->getIndex()];
390 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000391 return Sema::TDK_Inconsistent;
Douglas Gregor15755cb2009-11-13 23:45:44 +0000392 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000393
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000394 Deduced[NTTP->getIndex()] = Result;
Douglas Gregor15755cb2009-11-13 23:45:44 +0000395 return Sema::TDK_Success;
396}
397
Douglas Gregorf67875d2009-06-12 18:26:56 +0000398static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000399DeduceTemplateArguments(Sema &S,
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000400 TemplateParameterList *TemplateParams,
Douglas Gregorf67875d2009-06-12 18:26:56 +0000401 TemplateName Param,
402 TemplateName Arg,
John McCall2a7fb272010-08-25 05:32:35 +0000403 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000404 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregord708c722009-06-09 16:35:58 +0000405 TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000406 if (!ParamDecl) {
407 // The parameter type is dependent and is not a template template parameter,
408 // so there is nothing that we can deduce.
409 return Sema::TDK_Success;
410 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000411
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000412 if (TemplateTemplateParmDecl *TempParam
413 = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000414 DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000415 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000416 Deduced[TempParam->getIndex()],
417 NewDeduced);
418 if (Result.isNull()) {
419 Info.Param = TempParam;
420 Info.FirstArg = Deduced[TempParam->getIndex()];
421 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000422 return Sema::TDK_Inconsistent;
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000423 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000424
Douglas Gregor0d80abc2010-12-22 23:09:49 +0000425 Deduced[TempParam->getIndex()] = Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000426 return Sema::TDK_Success;
Douglas Gregorf67875d2009-06-12 18:26:56 +0000427 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000428
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000429 // Verify that the two template names are equivalent.
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000430 if (S.Context.hasSameTemplateName(Param, Arg))
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000431 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000432
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000433 // Mismatch of non-dependent template parameter to argument.
434 Info.FirstArg = TemplateArgument(Param);
435 Info.SecondArg = TemplateArgument(Arg);
436 return Sema::TDK_NonDeducedMismatch;
Douglas Gregord708c722009-06-09 16:35:58 +0000437}
438
Mike Stump1eb44332009-09-09 15:08:12 +0000439/// \brief Deduce the template arguments by comparing the template parameter
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000440/// type (which is a template-id) with the template argument type.
441///
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000442/// \param S the Sema
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000443///
444/// \param TemplateParams the template parameters that we are deducing
445///
446/// \param Param the parameter type
447///
448/// \param Arg the argument type
449///
450/// \param Info information about the template argument deduction itself
451///
452/// \param Deduced the deduced template arguments
453///
454/// \returns the result of template argument deduction so far. Note that a
455/// "success" result means that template argument deduction has not yet failed,
456/// but it may still fail, later, for other reasons.
457static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000458DeduceTemplateArguments(Sema &S,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000459 TemplateParameterList *TemplateParams,
460 const TemplateSpecializationType *Param,
461 QualType Arg,
John McCall2a7fb272010-08-25 05:32:35 +0000462 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000463 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
John McCall467b27b2009-10-22 20:10:53 +0000464 assert(Arg.isCanonical() && "Argument type must be canonical");
Mike Stump1eb44332009-09-09 15:08:12 +0000465
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000466 // Check whether the template argument is a dependent template-id.
Mike Stump1eb44332009-09-09 15:08:12 +0000467 if (const TemplateSpecializationType *SpecArg
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000468 = dyn_cast<TemplateSpecializationType>(Arg)) {
469 // Perform template argument deduction for the template name.
470 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000471 = DeduceTemplateArguments(S, TemplateParams,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000472 Param->getTemplateName(),
473 SpecArg->getTemplateName(),
474 Info, Deduced))
475 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +0000476
Mike Stump1eb44332009-09-09 15:08:12 +0000477
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000478 // Perform template argument deduction on each template
Douglas Gregor0972c862010-12-22 18:55:49 +0000479 // argument. Ignore any missing/extra arguments, since they could be
480 // filled in by default arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000481 return DeduceTemplateArguments(S, TemplateParams,
482 Param->getArgs(), Param->getNumArgs(),
Douglas Gregor0972c862010-12-22 18:55:49 +0000483 SpecArg->getArgs(), SpecArg->getNumArgs(),
Richard Smith030a6642012-12-06 06:44:44 +0000484 Info, Deduced);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000485 }
Mike Stump1eb44332009-09-09 15:08:12 +0000486
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000487 // If the argument type is a class template specialization, we
488 // perform template argument deduction using its template
489 // arguments.
490 const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
Richard Smith29805ca2013-01-31 05:19:49 +0000491 if (!RecordArg) {
492 Info.FirstArg = TemplateArgument(QualType(Param, 0));
493 Info.SecondArg = TemplateArgument(Arg);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000494 return Sema::TDK_NonDeducedMismatch;
Richard Smith29805ca2013-01-31 05:19:49 +0000495 }
Mike Stump1eb44332009-09-09 15:08:12 +0000496
497 ClassTemplateSpecializationDecl *SpecArg
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000498 = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
Richard Smith29805ca2013-01-31 05:19:49 +0000499 if (!SpecArg) {
500 Info.FirstArg = TemplateArgument(QualType(Param, 0));
501 Info.SecondArg = TemplateArgument(Arg);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000502 return Sema::TDK_NonDeducedMismatch;
Richard Smith29805ca2013-01-31 05:19:49 +0000503 }
Mike Stump1eb44332009-09-09 15:08:12 +0000504
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000505 // Perform template argument deduction for the template name.
506 if (Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000507 = DeduceTemplateArguments(S,
Douglas Gregordb0d4b72009-11-11 23:06:43 +0000508 TemplateParams,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000509 Param->getTemplateName(),
510 TemplateName(SpecArg->getSpecializedTemplate()),
511 Info, Deduced))
512 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +0000513
Douglas Gregor20a55e22010-12-22 18:17:10 +0000514 // Perform template argument deduction for the template arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000515 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +0000516 Param->getArgs(), Param->getNumArgs(),
517 SpecArg->getTemplateArgs().data(),
518 SpecArg->getTemplateArgs().size(),
519 Info, Deduced);
Douglas Gregorde0cb8b2009-07-07 23:09:34 +0000520}
521
John McCallcd05e812010-08-28 22:14:41 +0000522/// \brief Determines whether the given type is an opaque type that
523/// might be more qualified when instantiated.
524static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
525 switch (T->getTypeClass()) {
526 case Type::TypeOfExpr:
527 case Type::TypeOf:
528 case Type::DependentName:
529 case Type::Decltype:
530 case Type::UnresolvedUsing:
John McCall62c28c82011-01-18 07:41:22 +0000531 case Type::TemplateTypeParm:
John McCallcd05e812010-08-28 22:14:41 +0000532 return true;
533
534 case Type::ConstantArray:
535 case Type::IncompleteArray:
536 case Type::VariableArray:
537 case Type::DependentSizedArray:
538 return IsPossiblyOpaquelyQualifiedType(
539 cast<ArrayType>(T)->getElementType());
540
541 default:
542 return false;
543 }
544}
545
Douglas Gregord3731192011-01-10 07:32:04 +0000546/// \brief Retrieve the depth and index of a template parameter.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000547static std::pair<unsigned, unsigned>
Douglas Gregord3731192011-01-10 07:32:04 +0000548getDepthAndIndex(NamedDecl *ND) {
Douglas Gregor603cfb42011-01-05 23:12:31 +0000549 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
550 return std::make_pair(TTP->getDepth(), TTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000551
Douglas Gregor603cfb42011-01-05 23:12:31 +0000552 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
553 return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000554
Douglas Gregor603cfb42011-01-05 23:12:31 +0000555 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(ND);
556 return std::make_pair(TTP->getDepth(), TTP->getIndex());
557}
558
Douglas Gregord3731192011-01-10 07:32:04 +0000559/// \brief Retrieve the depth and index of an unexpanded parameter pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000560static std::pair<unsigned, unsigned>
Douglas Gregord3731192011-01-10 07:32:04 +0000561getDepthAndIndex(UnexpandedParameterPack UPP) {
562 if (const TemplateTypeParmType *TTP
563 = UPP.first.dyn_cast<const TemplateTypeParmType *>())
564 return std::make_pair(TTP->getDepth(), TTP->getIndex());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000565
Douglas Gregord3731192011-01-10 07:32:04 +0000566 return getDepthAndIndex(UPP.first.get<NamedDecl *>());
567}
568
Douglas Gregor603cfb42011-01-05 23:12:31 +0000569/// \brief Helper function to build a TemplateParameter when we don't
570/// know its type statically.
571static TemplateParameter makeTemplateParameter(Decl *D) {
572 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
573 return TemplateParameter(TTP);
574 else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
575 return TemplateParameter(NTTP);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000576
Douglas Gregor603cfb42011-01-05 23:12:31 +0000577 return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
578}
579
Douglas Gregor54293852011-01-10 17:35:05 +0000580/// \brief Prepare to perform template argument deduction for all of the
581/// arguments in a set of argument packs.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000582static void PrepareArgumentPackDeduction(Sema &S,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000583 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Bill Wendling4fe5be02012-02-22 09:38:11 +0000584 ArrayRef<unsigned> PackIndices,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000585 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
586 SmallVectorImpl<
587 SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks) {
Douglas Gregor54293852011-01-10 17:35:05 +0000588 // Save the deduced template arguments for each parameter pack expanded
589 // by this pack expansion, then clear out the deduction.
590 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
591 // Save the previously-deduced argument pack, then clear it out so that we
592 // can deduce a new argument pack.
593 SavedPacks[I] = Deduced[PackIndices[I]];
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000594 Deduced[PackIndices[I]] = TemplateArgument();
595
Richard Smitha8eaf002012-08-23 06:16:52 +0000596 if (!S.CurrentInstantiationScope)
597 continue;
598
Richard Smith6964b3f2012-09-07 02:06:42 +0000599 // If the template argument pack was explicitly specified, add that to
Douglas Gregor54293852011-01-10 17:35:05 +0000600 // the set of deduced arguments.
601 const TemplateArgument *ExplicitArgs;
602 unsigned NumExplicitArgs;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000603 if (NamedDecl *PartiallySubstitutedPack
Douglas Gregor54293852011-01-10 17:35:05 +0000604 = S.CurrentInstantiationScope->getPartiallySubstitutedPack(
605 &ExplicitArgs,
606 &NumExplicitArgs)) {
607 if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I])
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000608 NewlyDeducedPacks[I].append(ExplicitArgs,
Douglas Gregor54293852011-01-10 17:35:05 +0000609 ExplicitArgs + NumExplicitArgs);
610 }
611 }
612}
613
Douglas Gregor0216f812011-01-10 17:53:52 +0000614/// \brief Finish template argument deduction for a set of argument packs,
615/// producing the argument packs and checking for consistency with prior
616/// deductions.
617static Sema::TemplateDeductionResult
618FinishArgumentPackDeduction(Sema &S,
619 TemplateParameterList *TemplateParams,
620 bool HasAnyArguments,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000621 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Bill Wendling341785e2012-02-22 09:51:33 +0000622 ArrayRef<unsigned> PackIndices,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000623 SmallVectorImpl<DeducedTemplateArgument> &SavedPacks,
624 SmallVectorImpl<
625 SmallVector<DeducedTemplateArgument, 4> > &NewlyDeducedPacks,
Douglas Gregor0216f812011-01-10 17:53:52 +0000626 TemplateDeductionInfo &Info) {
627 // Build argument packs for each of the parameter packs expanded by this
628 // pack expansion.
629 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
630 if (HasAnyArguments && NewlyDeducedPacks[I].empty()) {
631 // We were not able to deduce anything for this parameter pack,
632 // so just restore the saved argument pack.
633 Deduced[PackIndices[I]] = SavedPacks[I];
634 continue;
635 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000636
Douglas Gregor0216f812011-01-10 17:53:52 +0000637 DeducedTemplateArgument NewPack;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000638
Douglas Gregor0216f812011-01-10 17:53:52 +0000639 if (NewlyDeducedPacks[I].empty()) {
640 // If we deduced an empty argument pack, create it now.
Eli Friedmand7a6b162012-09-26 02:36:12 +0000641 NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack());
Douglas Gregor0216f812011-01-10 17:53:52 +0000642 } else {
643 TemplateArgument *ArgumentPack
Douglas Gregor203e6a32011-01-11 23:09:57 +0000644 = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()];
Douglas Gregor0216f812011-01-10 17:53:52 +0000645 std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(),
646 ArgumentPack);
647 NewPack
Douglas Gregor203e6a32011-01-11 23:09:57 +0000648 = DeducedTemplateArgument(TemplateArgument(ArgumentPack,
649 NewlyDeducedPacks[I].size()),
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000650 NewlyDeducedPacks[I][0].wasDeducedFromArrayBound());
Douglas Gregor0216f812011-01-10 17:53:52 +0000651 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000652
Douglas Gregor0216f812011-01-10 17:53:52 +0000653 DeducedTemplateArgument Result
654 = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack);
655 if (Result.isNull()) {
656 Info.Param
657 = makeTemplateParameter(TemplateParams->getParam(PackIndices[I]));
658 Info.FirstArg = SavedPacks[I];
659 Info.SecondArg = NewPack;
660 return Sema::TDK_Inconsistent;
661 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000662
Douglas Gregor0216f812011-01-10 17:53:52 +0000663 Deduced[PackIndices[I]] = Result;
664 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000665
Douglas Gregor0216f812011-01-10 17:53:52 +0000666 return Sema::TDK_Success;
667}
668
Douglas Gregor603cfb42011-01-05 23:12:31 +0000669/// \brief Deduce the template arguments by comparing the list of parameter
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000670/// types to the list of argument types, as in the parameter-type-lists of
671/// function types (C++ [temp.deduct.type]p10).
Douglas Gregor603cfb42011-01-05 23:12:31 +0000672///
673/// \param S The semantic analysis object within which we are deducing
674///
675/// \param TemplateParams The template parameters that we are deducing
676///
677/// \param Params The list of parameter types
678///
679/// \param NumParams The number of types in \c Params
680///
681/// \param Args The list of argument types
682///
683/// \param NumArgs The number of types in \c Args
684///
685/// \param Info information about the template argument deduction itself
686///
687/// \param Deduced the deduced template arguments
688///
689/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
690/// how template argument deduction is performed.
691///
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000692/// \param PartialOrdering If true, we are performing template argument
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000693/// deduction for during partial ordering for a call
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000694/// (C++0x [temp.deduct.partial]).
695///
Douglas Gregorb939a192011-01-21 17:29:42 +0000696/// \param RefParamComparisons If we're performing template argument deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000697/// in the context of partial ordering, the set of qualifier comparisons.
698///
Douglas Gregor603cfb42011-01-05 23:12:31 +0000699/// \returns the result of template argument deduction so far. Note that a
700/// "success" result means that template argument deduction has not yet failed,
701/// but it may still fail, later, for other reasons.
702static Sema::TemplateDeductionResult
703DeduceTemplateArguments(Sema &S,
704 TemplateParameterList *TemplateParams,
705 const QualType *Params, unsigned NumParams,
706 const QualType *Args, unsigned NumArgs,
707 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000708 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000709 unsigned TDF,
710 bool PartialOrdering = false,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000711 SmallVectorImpl<RefParamPartialOrderingComparison> *
Douglas Gregorb939a192011-01-21 17:29:42 +0000712 RefParamComparisons = 0) {
Douglas Gregor0bbacf82011-01-05 23:23:17 +0000713 // Fast-path check to see if we have too many/too few arguments.
714 if (NumParams != NumArgs &&
715 !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) &&
716 !(NumArgs && isa<PackExpansionType>(Args[NumArgs - 1])))
Richard Smith29805ca2013-01-31 05:19:49 +0000717 return Sema::TDK_MiscellaneousDeductionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000718
Douglas Gregor603cfb42011-01-05 23:12:31 +0000719 // C++0x [temp.deduct.type]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000720 // Similarly, if P has a form that contains (T), then each parameter type
721 // Pi of the respective parameter-type- list of P is compared with the
722 // corresponding parameter type Ai of the corresponding parameter-type-list
723 // of A. [...]
Douglas Gregor603cfb42011-01-05 23:12:31 +0000724 unsigned ArgIdx = 0, ParamIdx = 0;
725 for (; ParamIdx != NumParams; ++ParamIdx) {
726 // Check argument types.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000727 const PackExpansionType *Expansion
Douglas Gregor603cfb42011-01-05 23:12:31 +0000728 = dyn_cast<PackExpansionType>(Params[ParamIdx]);
729 if (!Expansion) {
730 // Simple case: compare the parameter and argument types at this point.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000731
Douglas Gregor603cfb42011-01-05 23:12:31 +0000732 // Make sure we have an argument.
733 if (ArgIdx >= NumArgs)
Richard Smith29805ca2013-01-31 05:19:49 +0000734 return Sema::TDK_MiscellaneousDeductionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000735
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000736 if (isa<PackExpansionType>(Args[ArgIdx])) {
737 // C++0x [temp.deduct.type]p22:
738 // If the original function parameter associated with A is a function
739 // parameter pack and the function parameter associated with P is not
740 // a function parameter pack, then template argument deduction fails.
Richard Smith29805ca2013-01-31 05:19:49 +0000741 return Sema::TDK_MiscellaneousDeductionFailure;
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000742 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000743
Douglas Gregor603cfb42011-01-05 23:12:31 +0000744 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +0000745 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
746 Params[ParamIdx], Args[ArgIdx],
747 Info, Deduced, TDF,
748 PartialOrdering,
749 RefParamComparisons))
Douglas Gregor603cfb42011-01-05 23:12:31 +0000750 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000751
Douglas Gregor603cfb42011-01-05 23:12:31 +0000752 ++ArgIdx;
753 continue;
754 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000755
Douglas Gregor7d5c0c12011-01-11 01:52:23 +0000756 // C++0x [temp.deduct.type]p5:
757 // The non-deduced contexts are:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000758 // - A function parameter pack that does not occur at the end of the
Douglas Gregor7d5c0c12011-01-11 01:52:23 +0000759 // parameter-declaration-clause.
760 if (ParamIdx + 1 < NumParams)
761 return Sema::TDK_Success;
762
Douglas Gregor603cfb42011-01-05 23:12:31 +0000763 // C++0x [temp.deduct.type]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000764 // If the parameter-declaration corresponding to Pi is a function
Douglas Gregor603cfb42011-01-05 23:12:31 +0000765 // parameter pack, then the type of its declarator- id is compared with
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000766 // each remaining parameter type in the parameter-type-list of A. Each
Douglas Gregor603cfb42011-01-05 23:12:31 +0000767 // comparison deduces template arguments for subsequent positions in the
768 // template parameter packs expanded by the function parameter pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000769
Douglas Gregor603cfb42011-01-05 23:12:31 +0000770 // Compute the set of template parameter indices that correspond to
771 // parameter packs expanded by the pack expansion.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000772 SmallVector<unsigned, 2> PackIndices;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000773 QualType Pattern = Expansion->getPattern();
774 {
Benjamin Kramer013b3662012-01-30 16:17:39 +0000775 llvm::SmallBitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000776 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000777 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
778 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
779 unsigned Depth, Index;
780 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
781 if (Depth == 0 && !SawIndices[Index]) {
782 SawIndices[Index] = true;
783 PackIndices.push_back(Index);
784 }
785 }
786 }
787 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
788
Douglas Gregord3731192011-01-10 07:32:04 +0000789 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000790 // expanded by this pack expansion (the outer index) and for each
Douglas Gregord3731192011-01-10 07:32:04 +0000791 // template argument (the inner SmallVectors).
Chris Lattner5f9e2722011-07-23 10:55:15 +0000792 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregord3731192011-01-10 07:32:04 +0000793 NewlyDeducedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +0000794 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregor54293852011-01-10 17:35:05 +0000795 SavedPacks(PackIndices.size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000796 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Douglas Gregor54293852011-01-10 17:35:05 +0000797 NewlyDeducedPacks);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000798
Douglas Gregor603cfb42011-01-05 23:12:31 +0000799 bool HasAnyArguments = false;
800 for (; ArgIdx < NumArgs; ++ArgIdx) {
801 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000802
Douglas Gregor603cfb42011-01-05 23:12:31 +0000803 // Deduce template arguments from the pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000804 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +0000805 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
806 Args[ArgIdx], Info, Deduced,
807 TDF, PartialOrdering,
808 RefParamComparisons))
Douglas Gregor603cfb42011-01-05 23:12:31 +0000809 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000810
Douglas Gregor603cfb42011-01-05 23:12:31 +0000811 // Capture the deduced template arguments for each parameter pack expanded
812 // by this pack expansion, add them to the list of arguments we've deduced
813 // for that pack, then clear out the deduced argument.
814 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
815 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
816 if (!DeducedArg.isNull()) {
817 NewlyDeducedPacks[I].push_back(DeducedArg);
818 DeducedArg = DeducedTemplateArgument();
819 }
820 }
821 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000822
Douglas Gregor603cfb42011-01-05 23:12:31 +0000823 // Build argument packs for each of the parameter packs expanded by this
824 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +0000825 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000826 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +0000827 Deduced, PackIndices, SavedPacks,
828 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000829 return Result;
Douglas Gregor603cfb42011-01-05 23:12:31 +0000830 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000831
Douglas Gregor603cfb42011-01-05 23:12:31 +0000832 // Make sure we don't have any extra arguments.
833 if (ArgIdx < NumArgs)
Richard Smith29805ca2013-01-31 05:19:49 +0000834 return Sema::TDK_MiscellaneousDeductionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000835
Douglas Gregor603cfb42011-01-05 23:12:31 +0000836 return Sema::TDK_Success;
837}
838
Douglas Gregor61d0b6b2011-04-28 00:56:09 +0000839/// \brief Determine whether the parameter has qualifiers that are either
840/// inconsistent with or a superset of the argument's qualifiers.
841static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
842 QualType ArgType) {
843 Qualifiers ParamQs = ParamType.getQualifiers();
844 Qualifiers ArgQs = ArgType.getQualifiers();
845
846 if (ParamQs == ArgQs)
847 return false;
848
849 // Mismatched (but not missing) Objective-C GC attributes.
850 if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
851 ParamQs.hasObjCGCAttr())
852 return true;
853
854 // Mismatched (but not missing) address spaces.
855 if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
856 ParamQs.hasAddressSpace())
857 return true;
858
John McCallf85e1932011-06-15 23:02:42 +0000859 // Mismatched (but not missing) Objective-C lifetime qualifiers.
860 if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
861 ParamQs.hasObjCLifetime())
862 return true;
863
Douglas Gregor61d0b6b2011-04-28 00:56:09 +0000864 // CVR qualifier superset.
865 return (ParamQs.getCVRQualifiers() != ArgQs.getCVRQualifiers()) &&
866 ((ParamQs.getCVRQualifiers() | ArgQs.getCVRQualifiers())
867 == ParamQs.getCVRQualifiers());
868}
869
Douglas Gregor500d3312009-06-26 18:27:22 +0000870/// \brief Deduce the template arguments by comparing the parameter type and
871/// the argument type (C++ [temp.deduct.type]).
872///
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000873/// \param S the semantic analysis object within which we are deducing
Douglas Gregor500d3312009-06-26 18:27:22 +0000874///
875/// \param TemplateParams the template parameters that we are deducing
876///
877/// \param ParamIn the parameter type
878///
879/// \param ArgIn the argument type
880///
881/// \param Info information about the template argument deduction itself
882///
883/// \param Deduced the deduced template arguments
884///
Douglas Gregor508f1c82009-06-26 23:10:12 +0000885/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
Mike Stump1eb44332009-09-09 15:08:12 +0000886/// how template argument deduction is performed.
Douglas Gregor500d3312009-06-26 18:27:22 +0000887///
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000888/// \param PartialOrdering Whether we're performing template argument deduction
889/// in the context of partial ordering (C++0x [temp.deduct.partial]).
890///
Douglas Gregorb939a192011-01-21 17:29:42 +0000891/// \param RefParamComparisons If we're performing template argument deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000892/// in the context of partial ordering, the set of qualifier comparisons.
893///
Douglas Gregor500d3312009-06-26 18:27:22 +0000894/// \returns the result of template argument deduction so far. Note that a
895/// "success" result means that template argument deduction has not yet failed,
896/// but it may still fail, later, for other reasons.
Douglas Gregorf67875d2009-06-12 18:26:56 +0000897static Sema::TemplateDeductionResult
Sebastian Redlbb95e512012-01-17 22:49:52 +0000898DeduceTemplateArgumentsByTypeMatch(Sema &S,
899 TemplateParameterList *TemplateParams,
900 QualType ParamIn, QualType ArgIn,
901 TemplateDeductionInfo &Info,
902 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
903 unsigned TDF,
904 bool PartialOrdering,
905 SmallVectorImpl<RefParamPartialOrderingComparison> *
906 RefParamComparisons) {
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000907 // We only want to look at the canonical types, since typedefs and
908 // sugar are not part of template argument deduction.
Chandler Carrutha7ef1302010-02-07 21:33:28 +0000909 QualType Param = S.Context.getCanonicalType(ParamIn);
910 QualType Arg = S.Context.getCanonicalType(ArgIn);
Douglas Gregor0b9247f2009-06-04 00:03:07 +0000911
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000912 // If the argument type is a pack expansion, look at its pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000913 // This isn't explicitly called out
Douglas Gregor77d6bb92011-01-11 22:21:24 +0000914 if (const PackExpansionType *ArgExpansion
915 = dyn_cast<PackExpansionType>(Arg))
916 Arg = ArgExpansion->getPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000917
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000918 if (PartialOrdering) {
919 // C++0x [temp.deduct.partial]p5:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000920 // Before the partial ordering is done, certain transformations are
921 // performed on the types used for partial ordering:
922 // - If P is a reference type, P is replaced by the type referred to.
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000923 const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
924 if (ParamRef)
925 Param = ParamRef->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000926
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000927 // - If A is a reference type, A is replaced by the type referred to.
928 const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
929 if (ArgRef)
930 Arg = ArgRef->getPointeeType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000931
Douglas Gregorb939a192011-01-21 17:29:42 +0000932 if (RefParamComparisons && ParamRef && ArgRef) {
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000933 // C++0x [temp.deduct.partial]p6:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000934 // If both P and A were reference types (before being replaced with the
935 // type referred to above), determine which of the two types (if any) is
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000936 // more cv-qualified than the other; otherwise the types are considered
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000937 // to be equally cv-qualified for partial ordering purposes. The result
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000938 // of this determination will be used below.
939 //
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000940 // We save this information for later, using it only when deduction
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000941 // succeeds in both directions.
Douglas Gregorb939a192011-01-21 17:29:42 +0000942 RefParamPartialOrderingComparison Comparison;
943 Comparison.ParamIsRvalueRef = ParamRef->getAs<RValueReferenceType>();
944 Comparison.ArgIsRvalueRef = ArgRef->getAs<RValueReferenceType>();
945 Comparison.Qualifiers = NeitherMoreQualified;
Douglas Gregor769d0cc2011-04-30 17:07:52 +0000946
947 Qualifiers ParamQuals = Param.getQualifiers();
948 Qualifiers ArgQuals = Arg.getQualifiers();
949 if (ParamQuals.isStrictSupersetOf(ArgQuals))
Douglas Gregorb939a192011-01-21 17:29:42 +0000950 Comparison.Qualifiers = ParamMoreQualified;
Douglas Gregor769d0cc2011-04-30 17:07:52 +0000951 else if (ArgQuals.isStrictSupersetOf(ParamQuals))
Douglas Gregorb939a192011-01-21 17:29:42 +0000952 Comparison.Qualifiers = ArgMoreQualified;
953 RefParamComparisons->push_back(Comparison);
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000954 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000955
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000956 // C++0x [temp.deduct.partial]p7:
957 // Remove any top-level cv-qualifiers:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000958 // - If P is a cv-qualified type, P is replaced by the cv-unqualified
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000959 // version of P.
960 Param = Param.getUnqualifiedType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000961 // - If A is a cv-qualified type, A is replaced by the cv-unqualified
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000962 // version of A.
963 Arg = Arg.getUnqualifiedType();
964 } else {
965 // C++0x [temp.deduct.call]p4 bullet 1:
966 // - If the original P is a reference type, the deduced A (i.e., the type
967 // referred to by the reference) can be more cv-qualified than the
968 // transformed A.
969 if (TDF & TDF_ParamWithReferenceType) {
970 Qualifiers Quals;
971 QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
972 Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
John McCall62c28c82011-01-18 07:41:22 +0000973 Arg.getCVRQualifiers());
Douglas Gregor5c7bf422011-01-11 17:34:58 +0000974 Param = S.Context.getQualifiedType(UnqualParam, Quals);
975 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000976
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000977 if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
978 // C++0x [temp.deduct.type]p10:
979 // If P and A are function types that originated from deduction when
980 // taking the address of a function template (14.8.2.2) or when deducing
981 // template arguments from a function declaration (14.8.2.6) and Pi and
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000982 // Ai are parameters of the top-level parameter-type-list of P and A,
983 // respectively, Pi is adjusted if it is an rvalue reference to a
984 // cv-unqualified template parameter and Ai is an lvalue reference, in
985 // which case the type of Pi is changed to be the template parameter
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000986 // type (i.e., T&& is changed to simply T). [ Note: As a result, when
987 // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
NAKAMURA Takumi00995302011-01-27 07:09:49 +0000988 // deduced as X&. - end note ]
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000989 TDF &= ~TDF_TopLevelParameterTypeList;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000990
Douglas Gregor73b3cf62011-01-25 17:19:08 +0000991 if (const RValueReferenceType *ParamRef
992 = Param->getAs<RValueReferenceType>()) {
993 if (isa<TemplateTypeParmType>(ParamRef->getPointeeType()) &&
994 !ParamRef->getPointeeType().getQualifiers())
995 if (Arg->isLValueReferenceType())
996 Param = ParamRef->getPointeeType();
997 }
998 }
Douglas Gregor500d3312009-06-26 18:27:22 +0000999 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001000
Douglas Gregor199d9912009-06-05 00:53:49 +00001001 // C++ [temp.deduct.type]p9:
Mike Stump1eb44332009-09-09 15:08:12 +00001002 // A template type argument T, a template template argument TT or a
1003 // template non-type argument i can be deduced if P and A have one of
Douglas Gregor199d9912009-06-05 00:53:49 +00001004 // the following forms:
1005 //
1006 // T
1007 // cv-list T
Mike Stump1eb44332009-09-09 15:08:12 +00001008 if (const TemplateTypeParmType *TemplateTypeParm
John McCall183700f2009-09-21 23:43:11 +00001009 = Param->getAs<TemplateTypeParmType>()) {
Douglas Gregoraf1308232011-09-22 15:57:07 +00001010 // Just skip any attempts to deduce from a placeholder type.
1011 if (Arg->isPlaceholderType())
1012 return Sema::TDK_Success;
1013
Douglas Gregorf67875d2009-06-12 18:26:56 +00001014 unsigned Index = TemplateTypeParm->getIndex();
Douglas Gregorf290e0d2009-07-22 21:30:48 +00001015 bool RecanonicalizeArg = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001016
Douglas Gregor9e9fae42009-07-22 20:02:25 +00001017 // If the argument type is an array type, move the qualifiers up to the
1018 // top level, so they can be matched with the qualifiers on the parameter.
Douglas Gregorf290e0d2009-07-22 21:30:48 +00001019 if (isa<ArrayType>(Arg)) {
John McCall0953e762009-09-24 19:53:00 +00001020 Qualifiers Quals;
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001021 Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
John McCall0953e762009-09-24 19:53:00 +00001022 if (Quals) {
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001023 Arg = S.Context.getQualifiedType(Arg, Quals);
Douglas Gregorf290e0d2009-07-22 21:30:48 +00001024 RecanonicalizeArg = true;
1025 }
1026 }
Mike Stump1eb44332009-09-09 15:08:12 +00001027
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001028 // The argument type can not be less qualified than the parameter
1029 // type.
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001030 if (!(TDF & TDF_IgnoreQualifiers) &&
1031 hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
Douglas Gregorf67875d2009-06-12 18:26:56 +00001032 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
John McCall57e97782010-08-05 09:05:08 +00001033 Info.FirstArg = TemplateArgument(Param);
John McCall833ca992009-10-29 08:12:44 +00001034 Info.SecondArg = TemplateArgument(Arg);
John McCall57e97782010-08-05 09:05:08 +00001035 return Sema::TDK_Underqualified;
Douglas Gregorf67875d2009-06-12 18:26:56 +00001036 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001037
1038 assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001039 assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
John McCall0953e762009-09-24 19:53:00 +00001040 QualType DeducedType = Arg;
John McCall49f4e1c2010-12-10 11:01:00 +00001041
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001042 // Remove any qualifiers on the parameter from the deduced type.
1043 // We checked the qualifiers for consistency above.
1044 Qualifiers DeducedQs = DeducedType.getQualifiers();
1045 Qualifiers ParamQs = Param.getQualifiers();
1046 DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
1047 if (ParamQs.hasObjCGCAttr())
1048 DeducedQs.removeObjCGCAttr();
1049 if (ParamQs.hasAddressSpace())
1050 DeducedQs.removeAddressSpace();
John McCallf85e1932011-06-15 23:02:42 +00001051 if (ParamQs.hasObjCLifetime())
1052 DeducedQs.removeObjCLifetime();
Douglas Gregore559ca12011-06-17 22:11:49 +00001053
1054 // Objective-C ARC:
Douglas Gregorda8b2492011-07-26 14:53:44 +00001055 // If template deduction would produce a lifetime qualifier on a type
1056 // that is not a lifetime type, template argument deduction fails.
1057 if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
1058 !DeducedType->isDependentType()) {
1059 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1060 Info.FirstArg = TemplateArgument(Param);
1061 Info.SecondArg = TemplateArgument(Arg);
1062 return Sema::TDK_Underqualified;
1063 }
1064
1065 // Objective-C ARC:
Douglas Gregore559ca12011-06-17 22:11:49 +00001066 // If template deduction would produce an argument type with lifetime type
1067 // but no lifetime qualifier, the __strong lifetime qualifier is inferred.
David Blaikie4e4d0842012-03-11 07:00:24 +00001068 if (S.getLangOpts().ObjCAutoRefCount &&
Douglas Gregore559ca12011-06-17 22:11:49 +00001069 DeducedType->isObjCLifetimeType() &&
1070 !DeducedQs.hasObjCLifetime())
1071 DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
1072
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001073 DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
1074 DeducedQs);
1075
Douglas Gregorf290e0d2009-07-22 21:30:48 +00001076 if (RecanonicalizeArg)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001077 DeducedType = S.Context.getCanonicalType(DeducedType);
Mike Stump1eb44332009-09-09 15:08:12 +00001078
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001079 DeducedTemplateArgument NewDeduced(DeducedType);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001080 DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001081 Deduced[Index],
1082 NewDeduced);
1083 if (Result.isNull()) {
1084 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1085 Info.FirstArg = Deduced[Index];
1086 Info.SecondArg = NewDeduced;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001087 return Sema::TDK_Inconsistent;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001088 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001089
Douglas Gregor0d80abc2010-12-22 23:09:49 +00001090 Deduced[Index] = Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001091 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001092 }
1093
Douglas Gregorf67875d2009-06-12 18:26:56 +00001094 // Set up the template argument deduction information for a failure.
John McCall833ca992009-10-29 08:12:44 +00001095 Info.FirstArg = TemplateArgument(ParamIn);
1096 Info.SecondArg = TemplateArgument(ArgIn);
Douglas Gregorf67875d2009-06-12 18:26:56 +00001097
Douglas Gregor0bc15d92011-01-14 05:11:40 +00001098 // If the parameter is an already-substituted template parameter
1099 // pack, do nothing: we don't know which of its arguments to look
1100 // at, so we have to wait until all of the parameter packs in this
1101 // expansion have arguments.
1102 if (isa<SubstTemplateTypeParmPackType>(Param))
1103 return Sema::TDK_Success;
1104
Douglas Gregor508f1c82009-06-26 23:10:12 +00001105 // Check the cv-qualifiers on the parameter and argument types.
1106 if (!(TDF & TDF_IgnoreQualifiers)) {
1107 if (TDF & TDF_ParamWithReferenceType) {
Douglas Gregor61d0b6b2011-04-28 00:56:09 +00001108 if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
Douglas Gregor508f1c82009-06-26 23:10:12 +00001109 return Sema::TDK_NonDeducedMismatch;
John McCallcd05e812010-08-28 22:14:41 +00001110 } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
Douglas Gregor508f1c82009-06-26 23:10:12 +00001111 if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
Mike Stump1eb44332009-09-09 15:08:12 +00001112 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor508f1c82009-06-26 23:10:12 +00001113 }
Douglas Gregorfc55a822012-03-11 03:29:50 +00001114
1115 // If the parameter type is not dependent, there is nothing to deduce.
1116 if (!Param->isDependentType()) {
1117 if (!(TDF & TDF_SkipNonDependent) && Param != Arg)
1118 return Sema::TDK_NonDeducedMismatch;
1119
1120 return Sema::TDK_Success;
1121 }
1122 } else if (!Param->isDependentType() &&
1123 Param.getUnqualifiedType() == Arg.getUnqualifiedType()) {
1124 return Sema::TDK_Success;
Douglas Gregor508f1c82009-06-26 23:10:12 +00001125 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001126
Douglas Gregord560d502009-06-04 00:21:18 +00001127 switch (Param->getTypeClass()) {
Douglas Gregor4ac01402011-06-15 16:02:29 +00001128 // Non-canonical types cannot appear here.
1129#define NON_CANONICAL_TYPE(Class, Base) \
1130 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1131#define TYPE(Class, Base)
1132#include "clang/AST/TypeNodes.def"
1133
1134 case Type::TemplateTypeParm:
1135 case Type::SubstTemplateTypeParmPack:
1136 llvm_unreachable("Type nodes handled above");
Douglas Gregorfc55a822012-03-11 03:29:50 +00001137
1138 // These types cannot be dependent, so simply check whether the types are
1139 // the same.
Douglas Gregor199d9912009-06-05 00:53:49 +00001140 case Type::Builtin:
Douglas Gregor4ac01402011-06-15 16:02:29 +00001141 case Type::VariableArray:
1142 case Type::Vector:
1143 case Type::FunctionNoProto:
1144 case Type::Record:
1145 case Type::Enum:
1146 case Type::ObjCObject:
1147 case Type::ObjCInterface:
Douglas Gregorfc55a822012-03-11 03:29:50 +00001148 case Type::ObjCObjectPointer: {
1149 if (TDF & TDF_SkipNonDependent)
1150 return Sema::TDK_Success;
1151
1152 if (TDF & TDF_IgnoreQualifiers) {
1153 Param = Param.getUnqualifiedType();
1154 Arg = Arg.getUnqualifiedType();
1155 }
1156
1157 return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
1158 }
1159
Douglas Gregor4ac01402011-06-15 16:02:29 +00001160 // _Complex T [placeholder extension]
1161 case Type::Complex:
1162 if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
Sebastian Redlbb95e512012-01-17 22:49:52 +00001163 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Douglas Gregor4ac01402011-06-15 16:02:29 +00001164 cast<ComplexType>(Param)->getElementType(),
Sebastian Redlbb95e512012-01-17 22:49:52 +00001165 ComplexArg->getElementType(),
1166 Info, Deduced, TDF);
Douglas Gregor4ac01402011-06-15 16:02:29 +00001167
1168 return Sema::TDK_NonDeducedMismatch;
Eli Friedmanb001de72011-10-06 23:00:33 +00001169
1170 // _Atomic T [extension]
1171 case Type::Atomic:
1172 if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
Sebastian Redlbb95e512012-01-17 22:49:52 +00001173 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Eli Friedmanb001de72011-10-06 23:00:33 +00001174 cast<AtomicType>(Param)->getValueType(),
1175 AtomicArg->getValueType(),
1176 Info, Deduced, TDF);
1177
1178 return Sema::TDK_NonDeducedMismatch;
1179
Douglas Gregor199d9912009-06-05 00:53:49 +00001180 // T *
Douglas Gregord560d502009-06-04 00:21:18 +00001181 case Type::Pointer: {
John McCallc0008342010-05-13 07:48:05 +00001182 QualType PointeeType;
1183 if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
1184 PointeeType = PointerArg->getPointeeType();
1185 } else if (const ObjCObjectPointerType *PointerArg
1186 = Arg->getAs<ObjCObjectPointerType>()) {
1187 PointeeType = PointerArg->getPointeeType();
1188 } else {
Douglas Gregorf67875d2009-06-12 18:26:56 +00001189 return Sema::TDK_NonDeducedMismatch;
John McCallc0008342010-05-13 07:48:05 +00001190 }
Mike Stump1eb44332009-09-09 15:08:12 +00001191
Douglas Gregor41128772009-06-26 23:27:24 +00001192 unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
Sebastian Redlbb95e512012-01-17 22:49:52 +00001193 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1194 cast<PointerType>(Param)->getPointeeType(),
John McCallc0008342010-05-13 07:48:05 +00001195 PointeeType,
Douglas Gregor41128772009-06-26 23:27:24 +00001196 Info, Deduced, SubTDF);
Douglas Gregord560d502009-06-04 00:21:18 +00001197 }
Mike Stump1eb44332009-09-09 15:08:12 +00001198
Douglas Gregor199d9912009-06-05 00:53:49 +00001199 // T &
Douglas Gregord560d502009-06-04 00:21:18 +00001200 case Type::LValueReference: {
Ted Kremenek6217b802009-07-29 21:53:49 +00001201 const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
Douglas Gregord560d502009-06-04 00:21:18 +00001202 if (!ReferenceArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001203 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001204
Sebastian Redlbb95e512012-01-17 22:49:52 +00001205 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
Douglas Gregord560d502009-06-04 00:21:18 +00001206 cast<LValueReferenceType>(Param)->getPointeeType(),
Sebastian Redlbb95e512012-01-17 22:49:52 +00001207 ReferenceArg->getPointeeType(), Info, Deduced, 0);
Douglas Gregord560d502009-06-04 00:21:18 +00001208 }
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001209
Douglas Gregor199d9912009-06-05 00:53:49 +00001210 // T && [C++0x]
Douglas Gregord560d502009-06-04 00:21:18 +00001211 case Type::RValueReference: {
Ted Kremenek6217b802009-07-29 21:53:49 +00001212 const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
Douglas Gregord560d502009-06-04 00:21:18 +00001213 if (!ReferenceArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001214 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001215
Sebastian Redlbb95e512012-01-17 22:49:52 +00001216 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1217 cast<RValueReferenceType>(Param)->getPointeeType(),
1218 ReferenceArg->getPointeeType(),
1219 Info, Deduced, 0);
Douglas Gregord560d502009-06-04 00:21:18 +00001220 }
Mike Stump1eb44332009-09-09 15:08:12 +00001221
Douglas Gregor199d9912009-06-05 00:53:49 +00001222 // T [] (implied, but not stated explicitly)
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001223 case Type::IncompleteArray: {
Mike Stump1eb44332009-09-09 15:08:12 +00001224 const IncompleteArrayType *IncompleteArrayArg =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001225 S.Context.getAsIncompleteArrayType(Arg);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001226 if (!IncompleteArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001227 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001228
John McCalle4f26e52010-08-19 00:20:19 +00001229 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Sebastian Redlbb95e512012-01-17 22:49:52 +00001230 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1231 S.Context.getAsIncompleteArrayType(Param)->getElementType(),
1232 IncompleteArrayArg->getElementType(),
1233 Info, Deduced, SubTDF);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001234 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001235
1236 // T [integer-constant]
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001237 case Type::ConstantArray: {
Mike Stump1eb44332009-09-09 15:08:12 +00001238 const ConstantArrayType *ConstantArrayArg =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001239 S.Context.getAsConstantArrayType(Arg);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001240 if (!ConstantArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001241 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001242
1243 const ConstantArrayType *ConstantArrayParm =
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001244 S.Context.getAsConstantArrayType(Param);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001245 if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
Douglas Gregorf67875d2009-06-12 18:26:56 +00001246 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001247
John McCalle4f26e52010-08-19 00:20:19 +00001248 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
Sebastian Redlbb95e512012-01-17 22:49:52 +00001249 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1250 ConstantArrayParm->getElementType(),
1251 ConstantArrayArg->getElementType(),
1252 Info, Deduced, SubTDF);
Anders Carlsson4d6fb502009-06-04 04:11:30 +00001253 }
1254
Douglas Gregor199d9912009-06-05 00:53:49 +00001255 // type [i]
1256 case Type::DependentSizedArray: {
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001257 const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
Douglas Gregor199d9912009-06-05 00:53:49 +00001258 if (!ArrayArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001259 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001260
John McCalle4f26e52010-08-19 00:20:19 +00001261 unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1262
Douglas Gregor199d9912009-06-05 00:53:49 +00001263 // Check the element type of the arrays
1264 const DependentSizedArrayType *DependentArrayParm
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001265 = S.Context.getAsDependentSizedArrayType(Param);
Douglas Gregorf67875d2009-06-12 18:26:56 +00001266 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00001267 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1268 DependentArrayParm->getElementType(),
1269 ArrayArg->getElementType(),
1270 Info, Deduced, SubTDF))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001271 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001272
Douglas Gregor199d9912009-06-05 00:53:49 +00001273 // Determine the array bound is something we can deduce.
Mike Stump1eb44332009-09-09 15:08:12 +00001274 NonTypeTemplateParmDecl *NTTP
Douglas Gregor199d9912009-06-05 00:53:49 +00001275 = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
1276 if (!NTTP)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001277 return Sema::TDK_Success;
Mike Stump1eb44332009-09-09 15:08:12 +00001278
1279 // We can perform template argument deduction for the given non-type
Douglas Gregor199d9912009-06-05 00:53:49 +00001280 // template parameter.
Mike Stump1eb44332009-09-09 15:08:12 +00001281 assert(NTTP->getDepth() == 0 &&
Douglas Gregor199d9912009-06-05 00:53:49 +00001282 "Cannot deduce non-type template argument at depth > 0");
Mike Stump1eb44332009-09-09 15:08:12 +00001283 if (const ConstantArrayType *ConstantArrayArg
Anders Carlsson335e24a2009-06-16 22:44:31 +00001284 = dyn_cast<ConstantArrayType>(ArrayArg)) {
1285 llvm::APSInt Size(ConstantArrayArg->getSize());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001286 return DeduceNonTypeTemplateArgument(S, NTTP, Size,
Douglas Gregor9d0e4412010-03-26 05:50:28 +00001287 S.Context.getSizeType(),
Douglas Gregor02024a92010-03-28 02:42:43 +00001288 /*ArrayBound=*/true,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001289 Info, Deduced);
Anders Carlsson335e24a2009-06-16 22:44:31 +00001290 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001291 if (const DependentSizedArrayType *DependentArrayArg
1292 = dyn_cast<DependentSizedArrayType>(ArrayArg))
Douglas Gregor34c2f8c2010-12-22 23:15:38 +00001293 if (DependentArrayArg->getSizeExpr())
1294 return DeduceNonTypeTemplateArgument(S, NTTP,
1295 DependentArrayArg->getSizeExpr(),
1296 Info, Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001297
Douglas Gregor199d9912009-06-05 00:53:49 +00001298 // Incomplete type does not match a dependently-sized array type
Douglas Gregorf67875d2009-06-12 18:26:56 +00001299 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001300 }
Mike Stump1eb44332009-09-09 15:08:12 +00001301
1302 // type(*)(T)
1303 // T(*)()
1304 // T(*)(T)
Anders Carlssona27fad52009-06-08 15:19:08 +00001305 case Type::FunctionProto: {
Douglas Gregor73b3cf62011-01-25 17:19:08 +00001306 unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
Mike Stump1eb44332009-09-09 15:08:12 +00001307 const FunctionProtoType *FunctionProtoArg =
Anders Carlssona27fad52009-06-08 15:19:08 +00001308 dyn_cast<FunctionProtoType>(Arg);
1309 if (!FunctionProtoArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001310 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001311
1312 const FunctionProtoType *FunctionProtoParam =
Anders Carlssona27fad52009-06-08 15:19:08 +00001313 cast<FunctionProtoType>(Param);
Anders Carlsson994b6cb2009-06-08 19:22:23 +00001314
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001315 if (FunctionProtoParam->getTypeQuals()
Douglas Gregore3c7a7c2011-01-26 16:50:54 +00001316 != FunctionProtoArg->getTypeQuals() ||
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001317 FunctionProtoParam->getRefQualifier()
Douglas Gregore3c7a7c2011-01-26 16:50:54 +00001318 != FunctionProtoArg->getRefQualifier() ||
1319 FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
Douglas Gregorf67875d2009-06-12 18:26:56 +00001320 return Sema::TDK_NonDeducedMismatch;
Anders Carlsson994b6cb2009-06-08 19:22:23 +00001321
Anders Carlssona27fad52009-06-08 15:19:08 +00001322 // Check return types.
Douglas Gregorf67875d2009-06-12 18:26:56 +00001323 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00001324 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1325 FunctionProtoParam->getResultType(),
1326 FunctionProtoArg->getResultType(),
1327 Info, Deduced, 0))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001328 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00001329
Douglas Gregor603cfb42011-01-05 23:12:31 +00001330 return DeduceTemplateArguments(S, TemplateParams,
1331 FunctionProtoParam->arg_type_begin(),
1332 FunctionProtoParam->getNumArgs(),
1333 FunctionProtoArg->arg_type_begin(),
1334 FunctionProtoArg->getNumArgs(),
Douglas Gregor73b3cf62011-01-25 17:19:08 +00001335 Info, Deduced, SubTDF);
Anders Carlssona27fad52009-06-08 15:19:08 +00001336 }
Mike Stump1eb44332009-09-09 15:08:12 +00001337
John McCall3cb0ebd2010-03-10 03:28:59 +00001338 case Type::InjectedClassName: {
1339 // Treat a template's injected-class-name as if the template
1340 // specialization type had been used.
John McCall31f17ec2010-04-27 00:57:59 +00001341 Param = cast<InjectedClassNameType>(Param)
1342 ->getInjectedSpecializationType();
John McCall3cb0ebd2010-03-10 03:28:59 +00001343 assert(isa<TemplateSpecializationType>(Param) &&
1344 "injected class name is not a template specialization type");
1345 // fall through
1346 }
1347
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001348 // template-name<T> (where template-name refers to a class template)
Douglas Gregord708c722009-06-09 16:35:58 +00001349 // template-name<i>
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001350 // TT<T>
1351 // TT<i>
1352 // TT<>
Douglas Gregord708c722009-06-09 16:35:58 +00001353 case Type::TemplateSpecialization: {
1354 const TemplateSpecializationType *SpecParam
1355 = cast<TemplateSpecializationType>(Param);
Mike Stump1eb44332009-09-09 15:08:12 +00001356
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001357 // Try to deduce template arguments from the template-id.
1358 Sema::TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001359 = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001360 Info, Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001361
Douglas Gregor4a5c15f2009-09-30 22:13:51 +00001362 if (Result && (TDF & TDF_DerivedClass)) {
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001363 // C++ [temp.deduct.call]p3b3:
1364 // If P is a class, and P has the form template-id, then A can be a
1365 // derived class of the deduced A. Likewise, if P is a pointer to a
Mike Stump1eb44332009-09-09 15:08:12 +00001366 // class of the form template-id, A can be a pointer to a derived
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001367 // class pointed to by the deduced A.
1368 //
1369 // More importantly:
Mike Stump1eb44332009-09-09 15:08:12 +00001370 // These alternatives are considered only if type deduction would
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001371 // otherwise fail.
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001372 if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
1373 // We cannot inspect base classes as part of deduction when the type
1374 // is incomplete, so either instantiate any templates necessary to
1375 // complete the type, or skip over it if it cannot be completed.
John McCall5769d612010-02-08 23:07:23 +00001376 if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001377 return Result;
1378
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001379 // Use data recursion to crawl through the list of base classes.
Mike Stump1eb44332009-09-09 15:08:12 +00001380 // Visited contains the set of nodes we have already visited, while
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001381 // ToVisit is our stack of records that we still need to visit.
1382 llvm::SmallPtrSet<const RecordType *, 8> Visited;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001383 SmallVector<const RecordType *, 8> ToVisit;
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001384 ToVisit.push_back(RecordT);
1385 bool Successful = false;
Benjamin Kramer74fe6612012-01-20 16:39:18 +00001386 SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
1387 Deduced.end());
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001388 while (!ToVisit.empty()) {
1389 // Retrieve the next class in the inheritance hierarchy.
1390 const RecordType *NextT = ToVisit.back();
1391 ToVisit.pop_back();
Mike Stump1eb44332009-09-09 15:08:12 +00001392
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001393 // If we have already seen this type, skip it.
1394 if (!Visited.insert(NextT))
1395 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001396
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001397 // If this is a base class, try to perform template argument
1398 // deduction from it.
1399 if (NextT != RecordT) {
Richard Trieu910515b2012-11-07 21:17:13 +00001400 TemplateDeductionInfo BaseInfo(Info.getLocation());
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001401 Sema::TemplateDeductionResult BaseResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001402 = DeduceTemplateArguments(S, TemplateParams, SpecParam,
Richard Trieu910515b2012-11-07 21:17:13 +00001403 QualType(NextT, 0), BaseInfo,
1404 Deduced);
Mike Stump1eb44332009-09-09 15:08:12 +00001405
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001406 // If template argument deduction for this base was successful,
Douglas Gregor053105d2010-11-02 00:02:34 +00001407 // note that we had some success. Otherwise, ignore any deductions
1408 // from this base class.
1409 if (BaseResult == Sema::TDK_Success) {
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001410 Successful = true;
Benjamin Kramer74fe6612012-01-20 16:39:18 +00001411 DeducedOrig.clear();
1412 DeducedOrig.append(Deduced.begin(), Deduced.end());
Richard Trieu910515b2012-11-07 21:17:13 +00001413 Info.Param = BaseInfo.Param;
1414 Info.FirstArg = BaseInfo.FirstArg;
1415 Info.SecondArg = BaseInfo.SecondArg;
Douglas Gregor053105d2010-11-02 00:02:34 +00001416 }
1417 else
1418 Deduced = DeducedOrig;
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001419 }
Mike Stump1eb44332009-09-09 15:08:12 +00001420
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001421 // Visit base classes
1422 CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
1423 for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
1424 BaseEnd = Next->bases_end();
Sebastian Redl9994a342009-10-25 17:03:50 +00001425 Base != BaseEnd; ++Base) {
Mike Stump1eb44332009-09-09 15:08:12 +00001426 assert(Base->getType()->isRecordType() &&
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001427 "Base class that isn't a record?");
Ted Kremenek6217b802009-07-29 21:53:49 +00001428 ToVisit.push_back(Base->getType()->getAs<RecordType>());
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001429 }
1430 }
Mike Stump1eb44332009-09-09 15:08:12 +00001431
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001432 if (Successful)
1433 return Sema::TDK_Success;
1434 }
Mike Stump1eb44332009-09-09 15:08:12 +00001435
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001436 }
Mike Stump1eb44332009-09-09 15:08:12 +00001437
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00001438 return Result;
Douglas Gregord708c722009-06-09 16:35:58 +00001439 }
1440
Douglas Gregor637a4092009-06-10 23:47:09 +00001441 // T type::*
1442 // T T::*
1443 // T (type::*)()
1444 // type (T::*)()
1445 // type (type::*)(T)
1446 // type (T::*)(T)
1447 // T (type::*)(T)
1448 // T (T::*)()
1449 // T (T::*)(T)
1450 case Type::MemberPointer: {
1451 const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
1452 const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
1453 if (!MemPtrArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001454 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor637a4092009-06-10 23:47:09 +00001455
Douglas Gregorf67875d2009-06-12 18:26:56 +00001456 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00001457 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1458 MemPtrParam->getPointeeType(),
1459 MemPtrArg->getPointeeType(),
1460 Info, Deduced,
1461 TDF & TDF_IgnoreQualifiers))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001462 return Result;
1463
Sebastian Redlbb95e512012-01-17 22:49:52 +00001464 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1465 QualType(MemPtrParam->getClass(), 0),
1466 QualType(MemPtrArg->getClass(), 0),
Douglas Gregorfc55a822012-03-11 03:29:50 +00001467 Info, Deduced,
1468 TDF & TDF_IgnoreQualifiers);
Douglas Gregor637a4092009-06-10 23:47:09 +00001469 }
1470
Anders Carlsson9a917e42009-06-12 22:56:54 +00001471 // (clang extension)
1472 //
Mike Stump1eb44332009-09-09 15:08:12 +00001473 // type(^)(T)
1474 // T(^)()
1475 // T(^)(T)
Anders Carlsson859ba502009-06-12 16:23:10 +00001476 case Type::BlockPointer: {
1477 const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
1478 const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
Mike Stump1eb44332009-09-09 15:08:12 +00001479
Anders Carlsson859ba502009-06-12 16:23:10 +00001480 if (!BlockPtrArg)
Douglas Gregorf67875d2009-06-12 18:26:56 +00001481 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001482
Sebastian Redlbb95e512012-01-17 22:49:52 +00001483 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1484 BlockPtrParam->getPointeeType(),
1485 BlockPtrArg->getPointeeType(),
1486 Info, Deduced, 0);
Anders Carlsson859ba502009-06-12 16:23:10 +00001487 }
1488
Douglas Gregor4ac01402011-06-15 16:02:29 +00001489 // (clang extension)
1490 //
1491 // T __attribute__(((ext_vector_type(<integral constant>))))
1492 case Type::ExtVector: {
1493 const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
1494 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1495 // Make sure that the vectors have the same number of elements.
1496 if (VectorParam->getNumElements() != VectorArg->getNumElements())
1497 return Sema::TDK_NonDeducedMismatch;
1498
1499 // Perform deduction on the element types.
Sebastian Redlbb95e512012-01-17 22:49:52 +00001500 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1501 VectorParam->getElementType(),
1502 VectorArg->getElementType(),
1503 Info, Deduced, TDF);
Douglas Gregor4ac01402011-06-15 16:02:29 +00001504 }
1505
1506 if (const DependentSizedExtVectorType *VectorArg
1507 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1508 // We can't check the number of elements, since the argument has a
1509 // dependent number of elements. This can only occur during partial
1510 // ordering.
1511
1512 // Perform deduction on the element types.
Sebastian Redlbb95e512012-01-17 22:49:52 +00001513 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1514 VectorParam->getElementType(),
1515 VectorArg->getElementType(),
1516 Info, Deduced, TDF);
Douglas Gregor4ac01402011-06-15 16:02:29 +00001517 }
1518
1519 return Sema::TDK_NonDeducedMismatch;
1520 }
1521
1522 // (clang extension)
1523 //
1524 // T __attribute__(((ext_vector_type(N))))
1525 case Type::DependentSizedExtVector: {
1526 const DependentSizedExtVectorType *VectorParam
1527 = cast<DependentSizedExtVectorType>(Param);
1528
1529 if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1530 // Perform deduction on the element types.
1531 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00001532 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1533 VectorParam->getElementType(),
1534 VectorArg->getElementType(),
1535 Info, Deduced, TDF))
Douglas Gregor4ac01402011-06-15 16:02:29 +00001536 return Result;
1537
1538 // Perform deduction on the vector size, if we can.
1539 NonTypeTemplateParmDecl *NTTP
1540 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1541 if (!NTTP)
1542 return Sema::TDK_Success;
1543
1544 llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
1545 ArgSize = VectorArg->getNumElements();
1546 return DeduceNonTypeTemplateArgument(S, NTTP, ArgSize, S.Context.IntTy,
1547 false, Info, Deduced);
1548 }
1549
1550 if (const DependentSizedExtVectorType *VectorArg
1551 = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1552 // Perform deduction on the element types.
1553 if (Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00001554 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1555 VectorParam->getElementType(),
1556 VectorArg->getElementType(),
1557 Info, Deduced, TDF))
Douglas Gregor4ac01402011-06-15 16:02:29 +00001558 return Result;
1559
1560 // Perform deduction on the vector size, if we can.
1561 NonTypeTemplateParmDecl *NTTP
1562 = getDeducedParameterFromExpr(VectorParam->getSizeExpr());
1563 if (!NTTP)
1564 return Sema::TDK_Success;
1565
1566 return DeduceNonTypeTemplateArgument(S, NTTP, VectorArg->getSizeExpr(),
1567 Info, Deduced);
1568 }
1569
1570 return Sema::TDK_NonDeducedMismatch;
1571 }
1572
Douglas Gregor637a4092009-06-10 23:47:09 +00001573 case Type::TypeOfExpr:
1574 case Type::TypeOf:
Douglas Gregor4714c122010-03-31 17:34:00 +00001575 case Type::DependentName:
Douglas Gregor4ac01402011-06-15 16:02:29 +00001576 case Type::UnresolvedUsing:
1577 case Type::Decltype:
1578 case Type::UnaryTransform:
1579 case Type::Auto:
1580 case Type::DependentTemplateSpecialization:
1581 case Type::PackExpansion:
Douglas Gregor637a4092009-06-10 23:47:09 +00001582 // No template argument deduction for these types
Douglas Gregorf67875d2009-06-12 18:26:56 +00001583 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001584 }
1585
David Blaikie30263482012-01-20 21:50:17 +00001586 llvm_unreachable("Invalid Type Class!");
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001587}
1588
Douglas Gregorf67875d2009-06-12 18:26:56 +00001589static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001590DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001591 TemplateParameterList *TemplateParams,
1592 const TemplateArgument &Param,
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001593 TemplateArgument Arg,
John McCall2a7fb272010-08-25 05:32:35 +00001594 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001595 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001596 // If the template argument is a pack expansion, perform template argument
1597 // deduction against the pattern of that expansion. This only occurs during
1598 // partial ordering.
1599 if (Arg.isPackExpansion())
1600 Arg = Arg.getPackExpansionPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001601
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001602 switch (Param.getKind()) {
Douglas Gregor199d9912009-06-05 00:53:49 +00001603 case TemplateArgument::Null:
David Blaikieb219cfc2011-09-23 05:06:16 +00001604 llvm_unreachable("Null template argument in parameter list");
Mike Stump1eb44332009-09-09 15:08:12 +00001605
1606 case TemplateArgument::Type:
Douglas Gregor788cd062009-11-11 01:00:40 +00001607 if (Arg.getKind() == TemplateArgument::Type)
Sebastian Redlbb95e512012-01-17 22:49:52 +00001608 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1609 Param.getAsType(),
1610 Arg.getAsType(),
1611 Info, Deduced, 0);
Douglas Gregor788cd062009-11-11 01:00:40 +00001612 Info.FirstArg = Param;
1613 Info.SecondArg = Arg;
1614 return Sema::TDK_NonDeducedMismatch;
Douglas Gregora7fc9012011-01-05 18:58:31 +00001615
Douglas Gregor788cd062009-11-11 01:00:40 +00001616 case TemplateArgument::Template:
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001617 if (Arg.getKind() == TemplateArgument::Template)
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001618 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor788cd062009-11-11 01:00:40 +00001619 Param.getAsTemplate(),
Douglas Gregordb0d4b72009-11-11 23:06:43 +00001620 Arg.getAsTemplate(), Info, Deduced);
Douglas Gregor788cd062009-11-11 01:00:40 +00001621 Info.FirstArg = Param;
1622 Info.SecondArg = Arg;
1623 return Sema::TDK_NonDeducedMismatch;
Douglas Gregora7fc9012011-01-05 18:58:31 +00001624
1625 case TemplateArgument::TemplateExpansion:
1626 llvm_unreachable("caller should handle pack expansions");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001627
Douglas Gregor199d9912009-06-05 00:53:49 +00001628 case TemplateArgument::Declaration:
Douglas Gregor788cd062009-11-11 01:00:40 +00001629 if (Arg.getKind() == TemplateArgument::Declaration &&
Eli Friedmand7a6b162012-09-26 02:36:12 +00001630 isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()) &&
1631 Param.isDeclForReferenceParam() == Arg.isDeclForReferenceParam())
1632 return Sema::TDK_Success;
1633
1634 Info.FirstArg = Param;
1635 Info.SecondArg = Arg;
1636 return Sema::TDK_NonDeducedMismatch;
1637
1638 case TemplateArgument::NullPtr:
1639 if (Arg.getKind() == TemplateArgument::NullPtr &&
1640 S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType()))
Douglas Gregor788cd062009-11-11 01:00:40 +00001641 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001642
Douglas Gregorf67875d2009-06-12 18:26:56 +00001643 Info.FirstArg = Param;
1644 Info.SecondArg = Arg;
1645 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001646
Douglas Gregor199d9912009-06-05 00:53:49 +00001647 case TemplateArgument::Integral:
1648 if (Arg.getKind() == TemplateArgument::Integral) {
Benjamin Kramer85524372012-06-07 15:09:51 +00001649 if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
Douglas Gregorf67875d2009-06-12 18:26:56 +00001650 return Sema::TDK_Success;
1651
1652 Info.FirstArg = Param;
1653 Info.SecondArg = Arg;
1654 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001655 }
Douglas Gregorf67875d2009-06-12 18:26:56 +00001656
1657 if (Arg.getKind() == TemplateArgument::Expression) {
1658 Info.FirstArg = Param;
1659 Info.SecondArg = Arg;
1660 return Sema::TDK_NonDeducedMismatch;
1661 }
Douglas Gregor199d9912009-06-05 00:53:49 +00001662
Douglas Gregorf67875d2009-06-12 18:26:56 +00001663 Info.FirstArg = Param;
1664 Info.SecondArg = Arg;
1665 return Sema::TDK_NonDeducedMismatch;
Mike Stump1eb44332009-09-09 15:08:12 +00001666
Douglas Gregor199d9912009-06-05 00:53:49 +00001667 case TemplateArgument::Expression: {
Mike Stump1eb44332009-09-09 15:08:12 +00001668 if (NonTypeTemplateParmDecl *NTTP
Douglas Gregor199d9912009-06-05 00:53:49 +00001669 = getDeducedParameterFromExpr(Param.getAsExpr())) {
1670 if (Arg.getKind() == TemplateArgument::Integral)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001671 return DeduceNonTypeTemplateArgument(S, NTTP,
Benjamin Kramer85524372012-06-07 15:09:51 +00001672 Arg.getAsIntegral(),
Douglas Gregor9d0e4412010-03-26 05:50:28 +00001673 Arg.getIntegralType(),
Douglas Gregor02024a92010-03-28 02:42:43 +00001674 /*ArrayBound=*/false,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001675 Info, Deduced);
Douglas Gregor199d9912009-06-05 00:53:49 +00001676 if (Arg.getKind() == TemplateArgument::Expression)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001677 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
Douglas Gregorf67875d2009-06-12 18:26:56 +00001678 Info, Deduced);
Douglas Gregor15755cb2009-11-13 23:45:44 +00001679 if (Arg.getKind() == TemplateArgument::Declaration)
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001680 return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
Douglas Gregor15755cb2009-11-13 23:45:44 +00001681 Info, Deduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001682
Douglas Gregorf67875d2009-06-12 18:26:56 +00001683 Info.FirstArg = Param;
1684 Info.SecondArg = Arg;
1685 return Sema::TDK_NonDeducedMismatch;
Douglas Gregor199d9912009-06-05 00:53:49 +00001686 }
Mike Stump1eb44332009-09-09 15:08:12 +00001687
Douglas Gregor199d9912009-06-05 00:53:49 +00001688 // Can't deduce anything, but that's okay.
Douglas Gregorf67875d2009-06-12 18:26:56 +00001689 return Sema::TDK_Success;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001690 }
Anders Carlssond01b1da2009-06-15 17:04:53 +00001691 case TemplateArgument::Pack:
Douglas Gregor20a55e22010-12-22 18:17:10 +00001692 llvm_unreachable("Argument packs should be expanded by the caller!");
Douglas Gregor199d9912009-06-05 00:53:49 +00001693 }
Mike Stump1eb44332009-09-09 15:08:12 +00001694
David Blaikie30263482012-01-20 21:50:17 +00001695 llvm_unreachable("Invalid TemplateArgument Kind!");
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001696}
1697
Douglas Gregor20a55e22010-12-22 18:17:10 +00001698/// \brief Determine whether there is a template argument to be used for
1699/// deduction.
1700///
1701/// This routine "expands" argument packs in-place, overriding its input
1702/// parameters so that \c Args[ArgIdx] will be the available template argument.
1703///
1704/// \returns true if there is another template argument (which will be at
1705/// \c Args[ArgIdx]), false otherwise.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001706static bool hasTemplateArgumentForDeduction(const TemplateArgument *&Args,
Douglas Gregor20a55e22010-12-22 18:17:10 +00001707 unsigned &ArgIdx,
1708 unsigned &NumArgs) {
1709 if (ArgIdx == NumArgs)
1710 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001711
Douglas Gregor20a55e22010-12-22 18:17:10 +00001712 const TemplateArgument &Arg = Args[ArgIdx];
1713 if (Arg.getKind() != TemplateArgument::Pack)
1714 return true;
1715
1716 assert(ArgIdx == NumArgs - 1 && "Pack not at the end of argument list?");
1717 Args = Arg.pack_begin();
1718 NumArgs = Arg.pack_size();
1719 ArgIdx = 0;
1720 return ArgIdx < NumArgs;
1721}
1722
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001723/// \brief Determine whether the given set of template arguments has a pack
1724/// expansion that is not the last template argument.
1725static bool hasPackExpansionBeforeEnd(const TemplateArgument *Args,
1726 unsigned NumArgs) {
1727 unsigned ArgIdx = 0;
1728 while (ArgIdx < NumArgs) {
1729 const TemplateArgument &Arg = Args[ArgIdx];
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001730
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001731 // Unwrap argument packs.
1732 if (Args[ArgIdx].getKind() == TemplateArgument::Pack) {
1733 Args = Arg.pack_begin();
1734 NumArgs = Arg.pack_size();
1735 ArgIdx = 0;
1736 continue;
1737 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001738
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001739 ++ArgIdx;
1740 if (ArgIdx == NumArgs)
1741 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001742
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001743 if (Arg.isPackExpansion())
1744 return true;
1745 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001746
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001747 return false;
1748}
1749
Douglas Gregor20a55e22010-12-22 18:17:10 +00001750static Sema::TemplateDeductionResult
1751DeduceTemplateArguments(Sema &S,
1752 TemplateParameterList *TemplateParams,
1753 const TemplateArgument *Params, unsigned NumParams,
1754 const TemplateArgument *Args, unsigned NumArgs,
1755 TemplateDeductionInfo &Info,
Richard Smith030a6642012-12-06 06:44:44 +00001756 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
Douglas Gregore02e2622010-12-22 21:19:48 +00001757 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001758 // If the template argument list of P contains a pack expansion that is not
1759 // the last template argument, the entire template argument list is a
Douglas Gregore02e2622010-12-22 21:19:48 +00001760 // non-deduced context.
Douglas Gregor7b976ec2010-12-23 01:24:45 +00001761 if (hasPackExpansionBeforeEnd(Params, NumParams))
1762 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001763
Douglas Gregore02e2622010-12-22 21:19:48 +00001764 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001765 // If P has a form that contains <T> or <i>, then each argument Pi of the
1766 // respective template argument list P is compared with the corresponding
Douglas Gregore02e2622010-12-22 21:19:48 +00001767 // argument Ai of the corresponding template argument list of A.
Douglas Gregor20a55e22010-12-22 18:17:10 +00001768 unsigned ArgIdx = 0, ParamIdx = 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001769 for (; hasTemplateArgumentForDeduction(Params, ParamIdx, NumParams);
Douglas Gregor20a55e22010-12-22 18:17:10 +00001770 ++ParamIdx) {
1771 if (!Params[ParamIdx].isPackExpansion()) {
Douglas Gregore02e2622010-12-22 21:19:48 +00001772 // The simple case: deduce template arguments by matching Pi and Ai.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001773
Douglas Gregor20a55e22010-12-22 18:17:10 +00001774 // Check whether we have enough arguments.
1775 if (!hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs))
Richard Smith030a6642012-12-06 06:44:44 +00001776 return Sema::TDK_Success;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001777
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001778 if (Args[ArgIdx].isPackExpansion()) {
1779 // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here,
1780 // but applied to pack expansions that are template arguments.
Richard Smith29805ca2013-01-31 05:19:49 +00001781 return Sema::TDK_MiscellaneousDeductionFailure;
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001782 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001783
Douglas Gregore02e2622010-12-22 21:19:48 +00001784 // Perform deduction for this Pi/Ai pair.
Douglas Gregor20a55e22010-12-22 18:17:10 +00001785 if (Sema::TemplateDeductionResult Result
Douglas Gregor77d6bb92011-01-11 22:21:24 +00001786 = DeduceTemplateArguments(S, TemplateParams,
1787 Params[ParamIdx], Args[ArgIdx],
1788 Info, Deduced))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001789 return Result;
1790
Douglas Gregor20a55e22010-12-22 18:17:10 +00001791 // Move to the next argument.
1792 ++ArgIdx;
1793 continue;
1794 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001795
Douglas Gregore02e2622010-12-22 21:19:48 +00001796 // The parameter is a pack expansion.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001797
Douglas Gregore02e2622010-12-22 21:19:48 +00001798 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001799 // If Pi is a pack expansion, then the pattern of Pi is compared with
1800 // each remaining argument in the template argument list of A. Each
1801 // comparison deduces template arguments for subsequent positions in the
Douglas Gregore02e2622010-12-22 21:19:48 +00001802 // template parameter packs expanded by Pi.
1803 TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001804
Douglas Gregore02e2622010-12-22 21:19:48 +00001805 // Compute the set of template parameter indices that correspond to
1806 // parameter packs expanded by the pack expansion.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001807 SmallVector<unsigned, 2> PackIndices;
Douglas Gregore02e2622010-12-22 21:19:48 +00001808 {
Benjamin Kramer013b3662012-01-30 16:17:39 +00001809 llvm::SmallBitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001810 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregore02e2622010-12-22 21:19:48 +00001811 S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
1812 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
1813 unsigned Depth, Index;
1814 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
1815 if (Depth == 0 && !SawIndices[Index]) {
1816 SawIndices[Index] = true;
1817 PackIndices.push_back(Index);
1818 }
1819 }
1820 }
1821 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001822
Douglas Gregore02e2622010-12-22 21:19:48 +00001823 // FIXME: If there are no remaining arguments, we can bail out early
1824 // and set any deduced parameter packs to an empty argument pack.
1825 // The latter part of this is a (minor) correctness issue.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001826
Douglas Gregore02e2622010-12-22 21:19:48 +00001827 // Save the deduced template arguments for each parameter pack expanded
1828 // by this pack expansion, then clear out the deduction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001829 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregore02e2622010-12-22 21:19:48 +00001830 SavedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00001831 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregor54293852011-01-10 17:35:05 +00001832 NewlyDeducedPacks(PackIndices.size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001833 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
Douglas Gregor54293852011-01-10 17:35:05 +00001834 NewlyDeducedPacks);
Douglas Gregore02e2622010-12-22 21:19:48 +00001835
1836 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001837 // expanded by this pack expansion (the outer index) and for each
Douglas Gregore02e2622010-12-22 21:19:48 +00001838 // template argument (the inner SmallVectors).
Douglas Gregore02e2622010-12-22 21:19:48 +00001839 bool HasAnyArguments = false;
1840 while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) {
1841 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001842
Douglas Gregore02e2622010-12-22 21:19:48 +00001843 // Deduce template arguments from the pattern.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001844 if (Sema::TemplateDeductionResult Result
Douglas Gregore02e2622010-12-22 21:19:48 +00001845 = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
1846 Info, Deduced))
1847 return Result;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001848
Douglas Gregore02e2622010-12-22 21:19:48 +00001849 // Capture the deduced template arguments for each parameter pack expanded
1850 // by this pack expansion, add them to the list of arguments we've deduced
1851 // for that pack, then clear out the deduced argument.
1852 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
1853 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
1854 if (!DeducedArg.isNull()) {
1855 NewlyDeducedPacks[I].push_back(DeducedArg);
1856 DeducedArg = DeducedTemplateArgument();
1857 }
1858 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001859
Douglas Gregore02e2622010-12-22 21:19:48 +00001860 ++ArgIdx;
1861 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001862
Douglas Gregore02e2622010-12-22 21:19:48 +00001863 // Build argument packs for each of the parameter packs expanded by this
1864 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +00001865 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001866 = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +00001867 Deduced, PackIndices, SavedPacks,
1868 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001869 return Result;
Douglas Gregor20a55e22010-12-22 18:17:10 +00001870 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001871
Douglas Gregor20a55e22010-12-22 18:17:10 +00001872 return Sema::TDK_Success;
1873}
1874
Mike Stump1eb44332009-09-09 15:08:12 +00001875static Sema::TemplateDeductionResult
Chandler Carrutha7ef1302010-02-07 21:33:28 +00001876DeduceTemplateArguments(Sema &S,
Douglas Gregorf67875d2009-06-12 18:26:56 +00001877 TemplateParameterList *TemplateParams,
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001878 const TemplateArgumentList &ParamList,
1879 const TemplateArgumentList &ArgList,
John McCall2a7fb272010-08-25 05:32:35 +00001880 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001881 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001882 return DeduceTemplateArguments(S, TemplateParams,
Douglas Gregor20a55e22010-12-22 18:17:10 +00001883 ParamList.data(), ParamList.size(),
1884 ArgList.data(), ArgList.size(),
1885 Info, Deduced);
Douglas Gregor0b9247f2009-06-04 00:03:07 +00001886}
1887
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001888/// \brief Determine whether two template arguments are the same.
Mike Stump1eb44332009-09-09 15:08:12 +00001889static bool isSameTemplateArg(ASTContext &Context,
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001890 const TemplateArgument &X,
1891 const TemplateArgument &Y) {
1892 if (X.getKind() != Y.getKind())
1893 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001894
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001895 switch (X.getKind()) {
1896 case TemplateArgument::Null:
David Blaikieb219cfc2011-09-23 05:06:16 +00001897 llvm_unreachable("Comparing NULL template argument");
Mike Stump1eb44332009-09-09 15:08:12 +00001898
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001899 case TemplateArgument::Type:
1900 return Context.getCanonicalType(X.getAsType()) ==
1901 Context.getCanonicalType(Y.getAsType());
Mike Stump1eb44332009-09-09 15:08:12 +00001902
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001903 case TemplateArgument::Declaration:
Eli Friedmand7a6b162012-09-26 02:36:12 +00001904 return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()) &&
1905 X.isDeclForReferenceParam() == Y.isDeclForReferenceParam();
1906
1907 case TemplateArgument::NullPtr:
1908 return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType());
Mike Stump1eb44332009-09-09 15:08:12 +00001909
Douglas Gregor788cd062009-11-11 01:00:40 +00001910 case TemplateArgument::Template:
Douglas Gregora7fc9012011-01-05 18:58:31 +00001911 case TemplateArgument::TemplateExpansion:
1912 return Context.getCanonicalTemplateName(
1913 X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
1914 Context.getCanonicalTemplateName(
1915 Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001916
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001917 case TemplateArgument::Integral:
Benjamin Kramer85524372012-06-07 15:09:51 +00001918 return X.getAsIntegral() == Y.getAsIntegral();
Mike Stump1eb44332009-09-09 15:08:12 +00001919
Douglas Gregor788cd062009-11-11 01:00:40 +00001920 case TemplateArgument::Expression: {
1921 llvm::FoldingSetNodeID XID, YID;
1922 X.getAsExpr()->Profile(XID, Context, true);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001923 Y.getAsExpr()->Profile(YID, Context, true);
Douglas Gregor788cd062009-11-11 01:00:40 +00001924 return XID == YID;
1925 }
Mike Stump1eb44332009-09-09 15:08:12 +00001926
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001927 case TemplateArgument::Pack:
1928 if (X.pack_size() != Y.pack_size())
1929 return false;
Mike Stump1eb44332009-09-09 15:08:12 +00001930
1931 for (TemplateArgument::pack_iterator XP = X.pack_begin(),
1932 XPEnd = X.pack_end(),
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001933 YP = Y.pack_begin();
Mike Stump1eb44332009-09-09 15:08:12 +00001934 XP != XPEnd; ++XP, ++YP)
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001935 if (!isSameTemplateArg(Context, *XP, *YP))
1936 return false;
1937
1938 return true;
1939 }
1940
David Blaikie30263482012-01-20 21:50:17 +00001941 llvm_unreachable("Invalid TemplateArgument Kind!");
Douglas Gregorf670c8c2009-06-26 20:57:09 +00001942}
1943
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001944/// \brief Allocate a TemplateArgumentLoc where all locations have
1945/// been initialized to the given location.
1946///
1947/// \param S The semantic analysis object.
1948///
James Dennett1dfbd922012-06-14 21:40:34 +00001949/// \param Arg The template argument we are producing template argument
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001950/// location information for.
1951///
1952/// \param NTTPType For a declaration template argument, the type of
1953/// the non-type template parameter that corresponds to this template
1954/// argument.
1955///
1956/// \param Loc The source location to use for the resulting template
1957/// argument.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001958static TemplateArgumentLoc
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001959getTrivialTemplateArgumentLoc(Sema &S,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001960 const TemplateArgument &Arg,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001961 QualType NTTPType,
1962 SourceLocation Loc) {
1963 switch (Arg.getKind()) {
1964 case TemplateArgument::Null:
1965 llvm_unreachable("Can't get a NULL template argument here");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001966
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001967 case TemplateArgument::Type:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001968 return TemplateArgumentLoc(Arg,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001969 S.Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001970
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001971 case TemplateArgument::Declaration: {
1972 Expr *E
Douglas Gregorba68eca2011-01-05 17:40:24 +00001973 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
Douglas Gregord2008e22012-04-06 22:40:38 +00001974 .takeAs<Expr>();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001975 return TemplateArgumentLoc(TemplateArgument(E), E);
1976 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001977
Eli Friedmand7a6b162012-09-26 02:36:12 +00001978 case TemplateArgument::NullPtr: {
1979 Expr *E
1980 = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
1981 .takeAs<Expr>();
1982 return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true),
1983 E);
1984 }
1985
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001986 case TemplateArgument::Integral: {
1987 Expr *E
Douglas Gregorba68eca2011-01-05 17:40:24 +00001988 = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00001989 return TemplateArgumentLoc(TemplateArgument(E), E);
1990 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00001991
Douglas Gregorb6744ef2011-03-02 17:09:35 +00001992 case TemplateArgument::Template:
1993 case TemplateArgument::TemplateExpansion: {
1994 NestedNameSpecifierLocBuilder Builder;
1995 TemplateName Template = Arg.getAsTemplate();
1996 if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
1997 Builder.MakeTrivial(S.Context, DTN->getQualifier(), Loc);
1998 else if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
1999 Builder.MakeTrivial(S.Context, QTN->getQualifier(), Loc);
2000
2001 if (Arg.getKind() == TemplateArgument::Template)
2002 return TemplateArgumentLoc(Arg,
2003 Builder.getWithLocInContext(S.Context),
2004 Loc);
2005
2006
2007 return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(S.Context),
2008 Loc, Loc);
2009 }
Douglas Gregora7fc9012011-01-05 18:58:31 +00002010
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002011 case TemplateArgument::Expression:
2012 return TemplateArgumentLoc(Arg, Arg.getAsExpr());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002013
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002014 case TemplateArgument::Pack:
2015 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo());
2016 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002017
David Blaikie30263482012-01-20 21:50:17 +00002018 llvm_unreachable("Invalid TemplateArgument Kind!");
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002019}
2020
2021
2022/// \brief Convert the given deduced template argument and add it to the set of
2023/// fully-converted template arguments.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002024static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002025 DeducedTemplateArgument Arg,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002026 NamedDecl *Template,
2027 QualType NTTPType,
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002028 unsigned ArgumentPackIndex,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002029 TemplateDeductionInfo &Info,
2030 bool InFunctionTemplate,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002031 SmallVectorImpl<TemplateArgument> &Output) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002032 if (Arg.getKind() == TemplateArgument::Pack) {
2033 // This is a template argument pack, so check each of its arguments against
2034 // the template parameter.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002035 SmallVector<TemplateArgument, 2> PackedArgsBuilder;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002036 for (TemplateArgument::pack_iterator PA = Arg.pack_begin(),
Douglas Gregor135ffa72011-01-05 21:00:53 +00002037 PAEnd = Arg.pack_end();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002038 PA != PAEnd; ++PA) {
Douglas Gregord53e16a2011-01-05 20:52:18 +00002039 // When converting the deduced template argument, append it to the
2040 // general output list. We need to do this so that the template argument
2041 // checking logic has all of the prior template arguments available.
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002042 DeducedTemplateArgument InnerArg(*PA);
2043 InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002044 if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template,
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002045 NTTPType, PackedArgsBuilder.size(),
2046 Info, InFunctionTemplate, Output))
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002047 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002048
Douglas Gregord53e16a2011-01-05 20:52:18 +00002049 // Move the converted template argument into our argument pack.
2050 PackedArgsBuilder.push_back(Output.back());
2051 Output.pop_back();
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002052 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002053
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002054 // Create the resulting argument pack.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002055 Output.push_back(TemplateArgument::CreatePackCopy(S.Context,
Douglas Gregor203e6a32011-01-11 23:09:57 +00002056 PackedArgsBuilder.data(),
2057 PackedArgsBuilder.size()));
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002058 return false;
2059 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002060
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002061 // Convert the deduced template argument into a template
2062 // argument that we can check, almost as if the user had written
2063 // the template argument explicitly.
2064 TemplateArgumentLoc ArgLoc = getTrivialTemplateArgumentLoc(S, Arg, NTTPType,
2065 Info.getLocation());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002066
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002067 // Check the template argument, converting it as necessary.
2068 return S.CheckTemplateArgument(Param, ArgLoc,
2069 Template,
2070 Template->getLocation(),
2071 Template->getSourceRange().getEnd(),
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002072 ArgumentPackIndex,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002073 Output,
2074 InFunctionTemplate
2075 ? (Arg.wasDeducedFromArrayBound()
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002076 ? Sema::CTAK_DeducedFromArrayBound
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002077 : Sema::CTAK_Deduced)
2078 : Sema::CTAK_Specified);
2079}
2080
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002081/// Complete template argument deduction for a class template partial
2082/// specialization.
2083static Sema::TemplateDeductionResult
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002084FinishTemplateArgumentDeduction(Sema &S,
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002085 ClassTemplatePartialSpecializationDecl *Partial,
2086 const TemplateArgumentList &TemplateArgs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002087 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
John McCall2a7fb272010-08-25 05:32:35 +00002088 TemplateDeductionInfo &Info) {
Eli Friedman59a839c2012-02-08 03:07:05 +00002089 // Unevaluated SFINAE context.
2090 EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002091 Sema::SFINAETrap Trap(S);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002092
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002093 Sema::ContextRAII SavedContext(S, Partial);
2094
2095 // C++ [temp.deduct.type]p2:
2096 // [...] or if any template argument remains neither deduced nor
2097 // explicitly specified, template argument deduction fails.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002098 SmallVector<TemplateArgument, 4> Builder;
Douglas Gregor033a3ca2011-01-04 22:23:38 +00002099 TemplateParameterList *PartialParams = Partial->getTemplateParameters();
2100 for (unsigned I = 0, N = PartialParams->size(); I != N; ++I) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002101 NamedDecl *Param = PartialParams->getParam(I);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002102 if (Deduced[I].isNull()) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002103 Info.Param = makeTemplateParameter(Param);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002104 return Sema::TDK_Incomplete;
2105 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002106
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002107 // We have deduced this argument, so it still needs to be
2108 // checked and converted.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002109
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002110 // First, for a non-type template parameter type that is
2111 // initialized by a declaration, we need the type of the
2112 // corresponding non-type template parameter.
2113 QualType NTTPType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002114 if (NonTypeTemplateParmDecl *NTTP
Douglas Gregord53e16a2011-01-05 20:52:18 +00002115 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002116 NTTPType = NTTP->getType();
Douglas Gregord53e16a2011-01-05 20:52:18 +00002117 if (NTTPType->isDependentType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002118 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Douglas Gregord53e16a2011-01-05 20:52:18 +00002119 Builder.data(), Builder.size());
2120 NTTPType = S.SubstType(NTTPType,
2121 MultiLevelTemplateArgumentList(TemplateArgs),
2122 NTTP->getLocation(),
2123 NTTP->getDeclName());
2124 if (NTTPType.isNull()) {
2125 Info.Param = makeTemplateParameter(Param);
2126 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002127 Info.reset(TemplateArgumentList::CreateCopy(S.Context,
2128 Builder.data(),
Douglas Gregord53e16a2011-01-05 20:52:18 +00002129 Builder.size()));
2130 return Sema::TDK_SubstitutionFailure;
2131 }
2132 }
2133 }
2134
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002135 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002136 Partial, NTTPType, 0, Info, false,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002137 Builder)) {
2138 Info.Param = makeTemplateParameter(Param);
2139 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002140 Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
2141 Builder.size()));
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002142 return Sema::TDK_SubstitutionFailure;
2143 }
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002144 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002145
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002146 // Form the template argument list from the deduced template arguments.
2147 TemplateArgumentList *DeducedArgumentList
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002148 = TemplateArgumentList::CreateCopy(S.Context, Builder.data(),
Douglas Gregor910f8002010-11-07 23:05:16 +00002149 Builder.size());
2150
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002151 Info.reset(DeducedArgumentList);
2152
2153 // Substitute the deduced template arguments into the template
2154 // arguments of the class template partial specialization, and
2155 // verify that the instantiated template arguments are both valid
2156 // and are equivalent to the template arguments originally provided
2157 // to the class template.
John McCall2a7fb272010-08-25 05:32:35 +00002158 LocalInstantiationScope InstScope(S);
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002159 ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
2160 const TemplateArgumentLoc *PartialTemplateArgs
2161 = Partial->getTemplateArgsAsWritten();
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002162
2163 // Note that we don't provide the langle and rangle locations.
2164 TemplateArgumentListInfo InstArgs;
2165
Douglas Gregore02e2622010-12-22 21:19:48 +00002166 if (S.Subst(PartialTemplateArgs,
2167 Partial->getNumTemplateArgsAsWritten(),
2168 InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
2169 unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
2170 if (ParamIdx >= Partial->getTemplateParameters()->size())
2171 ParamIdx = Partial->getTemplateParameters()->size() - 1;
2172
2173 Decl *Param
2174 = const_cast<NamedDecl *>(
2175 Partial->getTemplateParameters()->getParam(ParamIdx));
2176 Info.Param = makeTemplateParameter(Param);
2177 Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
2178 return Sema::TDK_SubstitutionFailure;
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002179 }
2180
Chris Lattner5f9e2722011-07-23 10:55:15 +00002181 SmallVector<TemplateArgument, 4> ConvertedInstArgs;
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002182 if (S.CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002183 InstArgs, false, ConvertedInstArgs))
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002184 return Sema::TDK_SubstitutionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002185
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002186 TemplateParameterList *TemplateParams
2187 = ClassTemplate->getTemplateParameters();
2188 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
Douglas Gregor910f8002010-11-07 23:05:16 +00002189 TemplateArgument InstArg = ConvertedInstArgs.data()[I];
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002190 if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
Douglas Gregor2fdc5e82011-01-05 00:13:17 +00002191 Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002192 Info.FirstArg = TemplateArgs[I];
2193 Info.SecondArg = InstArg;
2194 return Sema::TDK_NonDeducedMismatch;
2195 }
2196 }
2197
2198 if (Trap.hasErrorOccurred())
2199 return Sema::TDK_SubstitutionFailure;
2200
2201 return Sema::TDK_Success;
2202}
2203
Douglas Gregorc1efb3f2009-06-12 22:31:52 +00002204/// \brief Perform template argument deduction to determine whether
2205/// the given template arguments match the given class template
2206/// partial specialization per C++ [temp.class.spec.match].
Douglas Gregorf67875d2009-06-12 18:26:56 +00002207Sema::TemplateDeductionResult
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002208Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002209 const TemplateArgumentList &TemplateArgs,
2210 TemplateDeductionInfo &Info) {
Douglas Gregorae19fbb2012-09-13 21:01:57 +00002211 if (Partial->isInvalidDecl())
2212 return TDK_Invalid;
2213
Douglas Gregorc1efb3f2009-06-12 22:31:52 +00002214 // C++ [temp.class.spec.match]p2:
2215 // A partial specialization matches a given actual template
2216 // argument list if the template arguments of the partial
2217 // specialization can be deduced from the actual template argument
2218 // list (14.8.2).
Eli Friedman59a839c2012-02-08 03:07:05 +00002219
2220 // Unevaluated SFINAE context.
2221 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Douglas Gregorbb260412009-06-14 08:02:22 +00002222 SFINAETrap Trap(*this);
Eli Friedman59a839c2012-02-08 03:07:05 +00002223
Chris Lattner5f9e2722011-07-23 10:55:15 +00002224 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002225 Deduced.resize(Partial->getTemplateParameters()->size());
Douglas Gregorf67875d2009-06-12 18:26:56 +00002226 if (TemplateDeductionResult Result
Chandler Carrutha7ef1302010-02-07 21:33:28 +00002227 = ::DeduceTemplateArguments(*this,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002228 Partial->getTemplateParameters(),
Mike Stump1eb44332009-09-09 15:08:12 +00002229 Partial->getTemplateArgs(),
Douglas Gregorf67875d2009-06-12 18:26:56 +00002230 TemplateArgs, Info, Deduced))
2231 return Result;
Douglas Gregor637a4092009-06-10 23:47:09 +00002232
Richard Smith7e54fb52012-07-16 01:09:10 +00002233 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
Douglas Gregor637a4092009-06-10 23:47:09 +00002234 InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
Richard Smith7e54fb52012-07-16 01:09:10 +00002235 DeducedArgs, Info);
Douglas Gregor637a4092009-06-10 23:47:09 +00002236 if (Inst)
Douglas Gregorf67875d2009-06-12 18:26:56 +00002237 return TDK_InstantiationDepth;
Douglas Gregor199d9912009-06-05 00:53:49 +00002238
Douglas Gregorbb260412009-06-14 08:02:22 +00002239 if (Trap.hasErrorOccurred())
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002240 return Sema::TDK_SubstitutionFailure;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002241
2242 return ::FinishTemplateArgumentDeduction(*this, Partial, TemplateArgs,
Douglas Gregor31dce8f2010-04-29 06:21:43 +00002243 Deduced, Info);
Douglas Gregor0b9247f2009-06-04 00:03:07 +00002244}
Douglas Gregor031a5882009-06-13 00:26:55 +00002245
Douglas Gregor41128772009-06-26 23:27:24 +00002246/// \brief Determine whether the given type T is a simple-template-id type.
2247static bool isSimpleTemplateIdType(QualType T) {
Mike Stump1eb44332009-09-09 15:08:12 +00002248 if (const TemplateSpecializationType *Spec
John McCall183700f2009-09-21 23:43:11 +00002249 = T->getAs<TemplateSpecializationType>())
Douglas Gregor41128772009-06-26 23:27:24 +00002250 return Spec->getTemplateName().getAsTemplateDecl() != 0;
Mike Stump1eb44332009-09-09 15:08:12 +00002251
Douglas Gregor41128772009-06-26 23:27:24 +00002252 return false;
2253}
Douglas Gregor83314aa2009-07-08 20:55:45 +00002254
2255/// \brief Substitute the explicitly-provided template arguments into the
2256/// given function template according to C++ [temp.arg.explicit].
2257///
2258/// \param FunctionTemplate the function template into which the explicit
2259/// template arguments will be substituted.
2260///
James Dennett1dfbd922012-06-14 21:40:34 +00002261/// \param ExplicitTemplateArgs the explicitly-specified template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002262/// arguments.
2263///
Mike Stump1eb44332009-09-09 15:08:12 +00002264/// \param Deduced the deduced template arguments, which will be populated
Douglas Gregor83314aa2009-07-08 20:55:45 +00002265/// with the converted and checked explicit template arguments.
2266///
Mike Stump1eb44332009-09-09 15:08:12 +00002267/// \param ParamTypes will be populated with the instantiated function
Douglas Gregor83314aa2009-07-08 20:55:45 +00002268/// parameters.
2269///
2270/// \param FunctionType if non-NULL, the result type of the function template
2271/// will also be instantiated and the pointed-to value will be updated with
2272/// the instantiated function type.
2273///
2274/// \param Info if substitution fails for any reason, this object will be
2275/// populated with more information about the failure.
2276///
2277/// \returns TDK_Success if substitution was successful, or some failure
2278/// condition.
2279Sema::TemplateDeductionResult
2280Sema::SubstituteExplicitTemplateArguments(
2281 FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00002282 TemplateArgumentListInfo &ExplicitTemplateArgs,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002283 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2284 SmallVectorImpl<QualType> &ParamTypes,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002285 QualType *FunctionType,
2286 TemplateDeductionInfo &Info) {
2287 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
2288 TemplateParameterList *TemplateParams
2289 = FunctionTemplate->getTemplateParameters();
2290
John McCalld5532b62009-11-23 01:53:49 +00002291 if (ExplicitTemplateArgs.size() == 0) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00002292 // No arguments to substitute; just copy over the parameter types and
2293 // fill in the function type.
2294 for (FunctionDecl::param_iterator P = Function->param_begin(),
2295 PEnd = Function->param_end();
2296 P != PEnd;
2297 ++P)
2298 ParamTypes.push_back((*P)->getType());
Mike Stump1eb44332009-09-09 15:08:12 +00002299
Douglas Gregor83314aa2009-07-08 20:55:45 +00002300 if (FunctionType)
2301 *FunctionType = Function->getType();
2302 return TDK_Success;
2303 }
Mike Stump1eb44332009-09-09 15:08:12 +00002304
Eli Friedman59a839c2012-02-08 03:07:05 +00002305 // Unevaluated SFINAE context.
2306 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Mike Stump1eb44332009-09-09 15:08:12 +00002307 SFINAETrap Trap(*this);
2308
Douglas Gregor83314aa2009-07-08 20:55:45 +00002309 // C++ [temp.arg.explicit]p3:
Mike Stump1eb44332009-09-09 15:08:12 +00002310 // Template arguments that are present shall be specified in the
2311 // declaration order of their corresponding template-parameters. The
Douglas Gregor83314aa2009-07-08 20:55:45 +00002312 // template argument list shall not specify more template-arguments than
Mike Stump1eb44332009-09-09 15:08:12 +00002313 // there are corresponding template-parameters.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002314 SmallVector<TemplateArgument, 4> Builder;
Mike Stump1eb44332009-09-09 15:08:12 +00002315
2316 // Enter a new template instantiation context where we check the
Douglas Gregor83314aa2009-07-08 20:55:45 +00002317 // explicitly-specified template arguments against this function template,
2318 // and then substitute them into the function parameter types.
Richard Smith7e54fb52012-07-16 01:09:10 +00002319 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
Mike Stump1eb44332009-09-09 15:08:12 +00002320 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
Richard Smith7e54fb52012-07-16 01:09:10 +00002321 FunctionTemplate, DeducedArgs,
Douglas Gregor9b623632010-10-12 23:32:35 +00002322 ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution,
2323 Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002324 if (Inst)
2325 return TDK_InstantiationDepth;
Mike Stump1eb44332009-09-09 15:08:12 +00002326
Douglas Gregor83314aa2009-07-08 20:55:45 +00002327 if (CheckTemplateArgumentList(FunctionTemplate,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002328 SourceLocation(),
John McCalld5532b62009-11-23 01:53:49 +00002329 ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002330 true,
Douglas Gregorf1a84452010-05-08 19:15:54 +00002331 Builder) || Trap.hasErrorOccurred()) {
Douglas Gregor910f8002010-11-07 23:05:16 +00002332 unsigned Index = Builder.size();
Douglas Gregorfe52c912010-05-09 01:26:06 +00002333 if (Index >= TemplateParams->size())
2334 Index = TemplateParams->size() - 1;
2335 Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
Douglas Gregor83314aa2009-07-08 20:55:45 +00002336 return TDK_InvalidExplicitArguments;
Douglas Gregorf1a84452010-05-08 19:15:54 +00002337 }
Mike Stump1eb44332009-09-09 15:08:12 +00002338
Douglas Gregor83314aa2009-07-08 20:55:45 +00002339 // Form the template argument list from the explicitly-specified
2340 // template arguments.
Mike Stump1eb44332009-09-09 15:08:12 +00002341 TemplateArgumentList *ExplicitArgumentList
Douglas Gregor910f8002010-11-07 23:05:16 +00002342 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Douglas Gregor83314aa2009-07-08 20:55:45 +00002343 Info.reset(ExplicitArgumentList);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002344
John McCalldf41f182010-10-12 19:40:14 +00002345 // Template argument deduction and the final substitution should be
2346 // done in the context of the templated declaration. Explicit
2347 // argument substitution, on the other hand, needs to happen in the
2348 // calling context.
2349 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
2350
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002351 // If we deduced template arguments for a template parameter pack,
Douglas Gregord3731192011-01-10 07:32:04 +00002352 // note that the template argument pack is partially substituted and record
2353 // the explicit template arguments. They'll be used as part of deduction
2354 // for this template parameter pack.
Douglas Gregord3731192011-01-10 07:32:04 +00002355 for (unsigned I = 0, N = Builder.size(); I != N; ++I) {
2356 const TemplateArgument &Arg = Builder[I];
2357 if (Arg.getKind() == TemplateArgument::Pack) {
Douglas Gregord3731192011-01-10 07:32:04 +00002358 CurrentInstantiationScope->SetPartiallySubstitutedPack(
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002359 TemplateParams->getParam(I),
Douglas Gregord3731192011-01-10 07:32:04 +00002360 Arg.pack_begin(),
2361 Arg.pack_size());
2362 break;
2363 }
2364 }
2365
Richard Smitheefb3d52012-02-10 09:58:53 +00002366 const FunctionProtoType *Proto
2367 = Function->getType()->getAs<FunctionProtoType>();
2368 assert(Proto && "Function template does not have a prototype?");
2369
Douglas Gregor83314aa2009-07-08 20:55:45 +00002370 // Instantiate the types of each of the function parameters given the
Richard Smitheefb3d52012-02-10 09:58:53 +00002371 // explicitly-specified template arguments. If the function has a trailing
2372 // return type, substitute it after the arguments to ensure we substitute
2373 // in lexical order.
Douglas Gregorcefc3af2012-04-16 07:05:22 +00002374 if (Proto->hasTrailingReturn()) {
2375 if (SubstParmTypes(Function->getLocation(),
2376 Function->param_begin(), Function->getNumParams(),
2377 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2378 ParamTypes))
2379 return TDK_SubstitutionFailure;
2380 }
2381
Richard Smitheefb3d52012-02-10 09:58:53 +00002382 // Instantiate the return type.
2383 // FIXME: exception-specifications?
Douglas Gregorcefc3af2012-04-16 07:05:22 +00002384 QualType ResultType;
2385 {
2386 // C++11 [expr.prim.general]p3:
2387 // If a declaration declares a member function or member function
2388 // template of a class X, the expression this is a prvalue of type
2389 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
2390 // and the end of the function-definition, member-declarator, or
2391 // declarator.
2392 unsigned ThisTypeQuals = 0;
2393 CXXRecordDecl *ThisContext = 0;
2394 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
2395 ThisContext = Method->getParent();
2396 ThisTypeQuals = Method->getTypeQualifiers();
2397 }
2398
2399 CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
Richard Smith80ad52f2013-01-02 11:42:31 +00002400 getLangOpts().CPlusPlus11);
Douglas Gregorcefc3af2012-04-16 07:05:22 +00002401
2402 ResultType = SubstType(Proto->getResultType(),
2403 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2404 Function->getTypeSpecStartLoc(),
2405 Function->getDeclName());
2406 if (ResultType.isNull() || Trap.hasErrorOccurred())
2407 return TDK_SubstitutionFailure;
2408 }
2409
Richard Smitheefb3d52012-02-10 09:58:53 +00002410 // Instantiate the types of each of the function parameters given the
2411 // explicitly-specified template arguments if we didn't do so earlier.
2412 if (!Proto->hasTrailingReturn() &&
2413 SubstParmTypes(Function->getLocation(),
2414 Function->param_begin(), Function->getNumParams(),
2415 MultiLevelTemplateArgumentList(*ExplicitArgumentList),
2416 ParamTypes))
2417 return TDK_SubstitutionFailure;
2418
Douglas Gregor83314aa2009-07-08 20:55:45 +00002419 if (FunctionType) {
Jordan Rosebea522f2013-03-08 21:51:21 +00002420 *FunctionType = BuildFunctionType(ResultType, ParamTypes,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002421 Function->getLocation(),
Eli Friedmanfa869542010-08-05 02:54:05 +00002422 Function->getDeclName(),
Jordan Rose09189892013-03-08 22:25:36 +00002423 Proto->getExtProtoInfo());
Douglas Gregor83314aa2009-07-08 20:55:45 +00002424 if (FunctionType->isNull() || Trap.hasErrorOccurred())
2425 return TDK_SubstitutionFailure;
2426 }
Mike Stump1eb44332009-09-09 15:08:12 +00002427
Douglas Gregor83314aa2009-07-08 20:55:45 +00002428 // C++ [temp.arg.explicit]p2:
Mike Stump1eb44332009-09-09 15:08:12 +00002429 // Trailing template arguments that can be deduced (14.8.2) may be
2430 // omitted from the list of explicit template-arguments. If all of the
Douglas Gregor83314aa2009-07-08 20:55:45 +00002431 // template arguments can be deduced, they may all be omitted; in this
2432 // case, the empty template argument list <> itself may also be omitted.
2433 //
Douglas Gregord3731192011-01-10 07:32:04 +00002434 // Take all of the explicitly-specified arguments and put them into
2435 // the set of deduced template arguments. Explicitly-specified
2436 // parameter packs, however, will be set to NULL since the deduction
2437 // mechanisms handle explicitly-specified argument packs directly.
Douglas Gregor83314aa2009-07-08 20:55:45 +00002438 Deduced.reserve(TemplateParams->size());
Douglas Gregord3731192011-01-10 07:32:04 +00002439 for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) {
2440 const TemplateArgument &Arg = ExplicitArgumentList->get(I);
2441 if (Arg.getKind() == TemplateArgument::Pack)
2442 Deduced.push_back(DeducedTemplateArgument());
2443 else
2444 Deduced.push_back(Arg);
2445 }
Mike Stump1eb44332009-09-09 15:08:12 +00002446
Douglas Gregor83314aa2009-07-08 20:55:45 +00002447 return TDK_Success;
2448}
2449
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002450/// \brief Check whether the deduced argument type for a call to a function
2451/// template matches the actual argument type per C++ [temp.deduct.call]p4.
2452static bool
2453CheckOriginalCallArgDeduction(Sema &S, Sema::OriginalCallArg OriginalArg,
2454 QualType DeducedA) {
2455 ASTContext &Context = S.Context;
2456
2457 QualType A = OriginalArg.OriginalArgType;
2458 QualType OriginalParamType = OriginalArg.OriginalParamType;
2459
2460 // Check for type equality (top-level cv-qualifiers are ignored).
2461 if (Context.hasSameUnqualifiedType(A, DeducedA))
2462 return false;
2463
2464 // Strip off references on the argument types; they aren't needed for
2465 // the following checks.
2466 if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
2467 DeducedA = DeducedARef->getPointeeType();
2468 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
2469 A = ARef->getPointeeType();
2470
2471 // C++ [temp.deduct.call]p4:
2472 // [...] However, there are three cases that allow a difference:
2473 // - If the original P is a reference type, the deduced A (i.e., the
2474 // type referred to by the reference) can be more cv-qualified than
2475 // the transformed A.
2476 if (const ReferenceType *OriginalParamRef
2477 = OriginalParamType->getAs<ReferenceType>()) {
2478 // We don't want to keep the reference around any more.
2479 OriginalParamType = OriginalParamRef->getPointeeType();
2480
2481 Qualifiers AQuals = A.getQualifiers();
2482 Qualifiers DeducedAQuals = DeducedA.getQualifiers();
Douglas Gregorb2513022012-07-18 00:14:59 +00002483
2484 // Under Objective-C++ ARC, the deduced type may have implicitly been
2485 // given strong lifetime. If so, update the original qualifiers to
2486 // include this strong lifetime.
2487 if (S.getLangOpts().ObjCAutoRefCount &&
2488 DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong &&
2489 AQuals.getObjCLifetime() == Qualifiers::OCL_None) {
2490 AQuals.setObjCLifetime(Qualifiers::OCL_Strong);
2491 }
2492
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002493 if (AQuals == DeducedAQuals) {
2494 // Qualifiers match; there's nothing to do.
2495 } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
Douglas Gregorc99f0ec2011-06-17 14:36:00 +00002496 return true;
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002497 } else {
2498 // Qualifiers are compatible, so have the argument type adopt the
2499 // deduced argument type's qualifiers as if we had performed the
2500 // qualification conversion.
2501 A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
2502 }
2503 }
2504
2505 // - The transformed A can be another pointer or pointer to member
2506 // type that can be converted to the deduced A via a qualification
2507 // conversion.
Chandler Carruth18e04612011-06-18 01:19:03 +00002508 //
2509 // Also allow conversions which merely strip [[noreturn]] from function types
2510 // (recursively) as an extension.
2511 // FIXME: Currently, this doesn't place nicely with qualfication conversions.
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002512 bool ObjCLifetimeConversion = false;
Chandler Carruth18e04612011-06-18 01:19:03 +00002513 QualType ResultTy;
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002514 if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
Chandler Carruth18e04612011-06-18 01:19:03 +00002515 (S.IsQualificationConversion(A, DeducedA, false,
2516 ObjCLifetimeConversion) ||
2517 S.IsNoReturnConversion(A, DeducedA, ResultTy)))
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002518 return false;
2519
2520
2521 // - If P is a class and P has the form simple-template-id, then the
2522 // transformed A can be a derived class of the deduced A. [...]
2523 // [...] Likewise, if P is a pointer to a class of the form
2524 // simple-template-id, the transformed A can be a pointer to a
2525 // derived class pointed to by the deduced A.
2526 if (const PointerType *OriginalParamPtr
2527 = OriginalParamType->getAs<PointerType>()) {
2528 if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
2529 if (const PointerType *APtr = A->getAs<PointerType>()) {
2530 if (A->getPointeeType()->isRecordType()) {
2531 OriginalParamType = OriginalParamPtr->getPointeeType();
2532 DeducedA = DeducedAPtr->getPointeeType();
2533 A = APtr->getPointeeType();
2534 }
2535 }
2536 }
2537 }
2538
2539 if (Context.hasSameUnqualifiedType(A, DeducedA))
2540 return false;
2541
2542 if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
2543 S.IsDerivedFrom(A, DeducedA))
2544 return false;
2545
2546 return true;
2547}
2548
Mike Stump1eb44332009-09-09 15:08:12 +00002549/// \brief Finish template argument deduction for a function template,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002550/// checking the deduced template arguments for completeness and forming
2551/// the function template specialization.
Douglas Gregordbfb3712011-06-16 16:50:48 +00002552///
2553/// \param OriginalCallArgs If non-NULL, the original call arguments against
2554/// which the deduced argument types should be compared.
Mike Stump1eb44332009-09-09 15:08:12 +00002555Sema::TemplateDeductionResult
Douglas Gregor83314aa2009-07-08 20:55:45 +00002556Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002557 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
Douglas Gregor02024a92010-03-28 02:42:43 +00002558 unsigned NumExplicitlySpecified,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002559 FunctionDecl *&Specialization,
Douglas Gregordbfb3712011-06-16 16:50:48 +00002560 TemplateDeductionInfo &Info,
Chris Lattner5f9e2722011-07-23 10:55:15 +00002561 SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00002562 TemplateParameterList *TemplateParams
2563 = FunctionTemplate->getTemplateParameters();
Mike Stump1eb44332009-09-09 15:08:12 +00002564
Eli Friedman59a839c2012-02-08 03:07:05 +00002565 // Unevaluated SFINAE context.
2566 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Mike Stump1eb44332009-09-09 15:08:12 +00002567 SFINAETrap Trap(*this);
2568
Douglas Gregor83314aa2009-07-08 20:55:45 +00002569 // Enter a new template instantiation context while we instantiate the
2570 // actual function declaration.
Richard Smith7e54fb52012-07-16 01:09:10 +00002571 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
Mike Stump1eb44332009-09-09 15:08:12 +00002572 InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
Richard Smith7e54fb52012-07-16 01:09:10 +00002573 FunctionTemplate, DeducedArgs,
Douglas Gregor9b623632010-10-12 23:32:35 +00002574 ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution,
2575 Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002576 if (Inst)
Mike Stump1eb44332009-09-09 15:08:12 +00002577 return TDK_InstantiationDepth;
2578
John McCall96db3102010-04-29 01:18:58 +00002579 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
John McCallf5813822010-04-29 00:35:03 +00002580
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002581 // C++ [temp.deduct.type]p2:
2582 // [...] or if any template argument remains neither deduced nor
2583 // explicitly specified, template argument deduction fails.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002584 SmallVector<TemplateArgument, 4> Builder;
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002585 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
2586 NamedDecl *Param = TemplateParams->getParam(I);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002587
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002588 if (!Deduced[I].isNull()) {
Douglas Gregor3273b0c2010-10-12 18:51:08 +00002589 if (I < NumExplicitlySpecified) {
Douglas Gregor02024a92010-03-28 02:42:43 +00002590 // We have already fully type-checked and converted this
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002591 // argument, because it was explicitly-specified. Just record the
Douglas Gregor3273b0c2010-10-12 18:51:08 +00002592 // presence of this argument.
Douglas Gregor910f8002010-11-07 23:05:16 +00002593 Builder.push_back(Deduced[I]);
Douglas Gregor02024a92010-03-28 02:42:43 +00002594 continue;
2595 }
2596
2597 // We have deduced this argument, so it still needs to be
2598 // checked and converted.
2599
2600 // First, for a non-type template parameter type that is
2601 // initialized by a declaration, we need the type of the
2602 // corresponding non-type template parameter.
2603 QualType NTTPType;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002604 if (NonTypeTemplateParmDecl *NTTP
2605 = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002606 NTTPType = NTTP->getType();
2607 if (NTTPType->isDependentType()) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002608 TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002609 Builder.data(), Builder.size());
2610 NTTPType = SubstType(NTTPType,
2611 MultiLevelTemplateArgumentList(TemplateArgs),
2612 NTTP->getLocation(),
2613 NTTP->getDeclName());
2614 if (NTTPType.isNull()) {
2615 Info.Param = makeTemplateParameter(Param);
2616 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002617 Info.reset(TemplateArgumentList::CreateCopy(Context,
2618 Builder.data(),
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002619 Builder.size()));
2620 return TDK_SubstitutionFailure;
Douglas Gregor02024a92010-03-28 02:42:43 +00002621 }
2622 }
2623 }
2624
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002625 if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002626 FunctionTemplate, NTTPType, 0, Info,
Douglas Gregor54c53cc2011-01-04 23:35:54 +00002627 true, Builder)) {
Douglas Gregorb9a7d6f2011-01-04 22:13:36 +00002628 Info.Param = makeTemplateParameter(Param);
Douglas Gregor910f8002010-11-07 23:05:16 +00002629 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002630 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
2631 Builder.size()));
Douglas Gregor02024a92010-03-28 02:42:43 +00002632 return TDK_SubstitutionFailure;
2633 }
2634
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002635 continue;
2636 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002637
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002638 // C++0x [temp.arg.explicit]p3:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002639 // A trailing template parameter pack (14.5.3) not otherwise deduced will
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002640 // be deduced to an empty sequence of template arguments.
2641 // FIXME: Where did the word "trailing" come from?
2642 if (Param->isTemplateParameterPack()) {
Douglas Gregord3731192011-01-10 07:32:04 +00002643 // We may have had explicitly-specified template arguments for this
2644 // template parameter pack. If so, our empty deduction extends the
2645 // explicitly-specified set (C++0x [temp.arg.explicit]p9).
2646 const TemplateArgument *ExplicitArgs;
2647 unsigned NumExplicitArgs;
Richard Smitha8eaf002012-08-23 06:16:52 +00002648 if (CurrentInstantiationScope &&
2649 CurrentInstantiationScope->getPartiallySubstitutedPack(&ExplicitArgs,
Douglas Gregord3731192011-01-10 07:32:04 +00002650 &NumExplicitArgs)
Douglas Gregor22eaced2013-01-18 22:27:09 +00002651 == Param) {
Douglas Gregord3731192011-01-10 07:32:04 +00002652 Builder.push_back(TemplateArgument(ExplicitArgs, NumExplicitArgs));
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002653
Douglas Gregor22eaced2013-01-18 22:27:09 +00002654 // Forget the partially-substituted pack; it's substitution is now
2655 // complete.
2656 CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2657 } else {
2658 Builder.push_back(TemplateArgument::getEmptyPack());
2659 }
Douglas Gregorea6c96f2010-12-23 01:52:01 +00002660 continue;
2661 }
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002662
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002663 // Substitute into the default template argument, if available.
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002664 TemplateArgumentLoc DefArg
2665 = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
2666 FunctionTemplate->getLocation(),
2667 FunctionTemplate->getSourceRange().getEnd(),
2668 Param,
2669 Builder);
2670
2671 // If there was no default argument, deduction is incomplete.
2672 if (DefArg.getArgument().isNull()) {
2673 Info.Param = makeTemplateParameter(
2674 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2675 return TDK_Incomplete;
2676 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002677
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002678 // Check whether we can actually use the default argument.
2679 if (CheckTemplateArgument(Param, DefArg,
2680 FunctionTemplate,
2681 FunctionTemplate->getLocation(),
2682 FunctionTemplate->getSourceRange().getEnd(),
Douglas Gregor6952f1e2011-01-19 20:10:05 +00002683 0, Builder,
Douglas Gregor8735b292011-06-03 02:59:40 +00002684 CTAK_Specified)) {
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002685 Info.Param = makeTemplateParameter(
2686 const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Douglas Gregor910f8002010-11-07 23:05:16 +00002687 // FIXME: These template arguments are temporary. Free them!
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002688 Info.reset(TemplateArgumentList::CreateCopy(Context, Builder.data(),
Douglas Gregor910f8002010-11-07 23:05:16 +00002689 Builder.size()));
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002690 return TDK_SubstitutionFailure;
2691 }
2692
2693 // If we get here, we successfully used the default template argument.
2694 }
2695
2696 // Form the template argument list from the deduced template arguments.
2697 TemplateArgumentList *DeducedArgumentList
Douglas Gregor910f8002010-11-07 23:05:16 +00002698 = TemplateArgumentList::CreateCopy(Context, Builder.data(), Builder.size());
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002699 Info.reset(DeducedArgumentList);
2700
Mike Stump1eb44332009-09-09 15:08:12 +00002701 // Substitute the deduced template arguments into the function template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002702 // declaration to produce the function template specialization.
Douglas Gregord4598a22010-04-28 04:52:24 +00002703 DeclContext *Owner = FunctionTemplate->getDeclContext();
2704 if (FunctionTemplate->getFriendObjectKind())
2705 Owner = FunctionTemplate->getLexicalDeclContext();
Douglas Gregor83314aa2009-07-08 20:55:45 +00002706 Specialization = cast_or_null<FunctionDecl>(
Douglas Gregord4598a22010-04-28 04:52:24 +00002707 SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner,
Douglas Gregor357bbd02009-08-28 20:50:45 +00002708 MultiLevelTemplateArgumentList(*DeducedArgumentList)));
Douglas Gregor5fad9b82011-10-12 20:35:48 +00002709 if (!Specialization || Specialization->isInvalidDecl())
Douglas Gregor83314aa2009-07-08 20:55:45 +00002710 return TDK_SubstitutionFailure;
Mike Stump1eb44332009-09-09 15:08:12 +00002711
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002712 assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
Douglas Gregorf8825742009-09-15 18:26:13 +00002713 FunctionTemplate->getCanonicalDecl());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002714
Mike Stump1eb44332009-09-09 15:08:12 +00002715 // If the template argument list is owned by the function template
Douglas Gregor83314aa2009-07-08 20:55:45 +00002716 // specialization, release it.
Douglas Gregorec20f462010-05-08 20:07:26 +00002717 if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
2718 !Trap.hasErrorOccurred())
Douglas Gregor83314aa2009-07-08 20:55:45 +00002719 Info.take();
Mike Stump1eb44332009-09-09 15:08:12 +00002720
Douglas Gregor5fad9b82011-10-12 20:35:48 +00002721 // There may have been an error that did not prevent us from constructing a
2722 // declaration. Mark the declaration invalid and return with a substitution
2723 // failure.
2724 if (Trap.hasErrorOccurred()) {
2725 Specialization->setInvalidDecl(true);
2726 return TDK_SubstitutionFailure;
2727 }
2728
Douglas Gregordbfb3712011-06-16 16:50:48 +00002729 if (OriginalCallArgs) {
2730 // C++ [temp.deduct.call]p4:
2731 // In general, the deduction process attempts to find template argument
2732 // values that will make the deduced A identical to A (after the type A
2733 // is transformed as described above). [...]
2734 for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
2735 OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
Douglas Gregordbfb3712011-06-16 16:50:48 +00002736 unsigned ParamIdx = OriginalArg.ArgIdx;
2737
2738 if (ParamIdx >= Specialization->getNumParams())
2739 continue;
2740
2741 QualType DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
Douglas Gregorb7edc4f2011-06-17 05:18:17 +00002742 if (CheckOriginalCallArgDeduction(*this, OriginalArg, DeducedA))
2743 return Sema::TDK_SubstitutionFailure;
Douglas Gregordbfb3712011-06-16 16:50:48 +00002744 }
2745 }
2746
Douglas Gregor9b623632010-10-12 23:32:35 +00002747 // If we suppressed any diagnostics while performing template argument
2748 // deduction, and if we haven't already instantiated this declaration,
2749 // keep track of these diagnostics. They'll be emitted if this specialization
2750 // is actually used.
2751 if (Info.diag_begin() != Info.diag_end()) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002752 llvm::DenseMap<Decl *, SmallVector<PartialDiagnosticAt, 1> >::iterator
Douglas Gregor9b623632010-10-12 23:32:35 +00002753 Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
2754 if (Pos == SuppressedDiagnostics.end())
2755 SuppressedDiagnostics[Specialization->getCanonicalDecl()]
2756 .append(Info.diag_begin(), Info.diag_end());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002757 }
Douglas Gregor9b623632010-10-12 23:32:35 +00002758
Mike Stump1eb44332009-09-09 15:08:12 +00002759 return TDK_Success;
Douglas Gregor83314aa2009-07-08 20:55:45 +00002760}
2761
John McCall9c72c602010-08-27 09:08:28 +00002762/// Gets the type of a function for template-argument-deducton
2763/// purposes when it's considered as part of an overload set.
John McCalleff92132010-02-02 02:21:27 +00002764static QualType GetTypeOfFunction(ASTContext &Context,
John McCall9c72c602010-08-27 09:08:28 +00002765 const OverloadExpr::FindResult &R,
John McCalleff92132010-02-02 02:21:27 +00002766 FunctionDecl *Fn) {
John McCalleff92132010-02-02 02:21:27 +00002767 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
John McCall9c72c602010-08-27 09:08:28 +00002768 if (Method->isInstance()) {
2769 // An instance method that's referenced in a form that doesn't
2770 // look like a member pointer is just invalid.
2771 if (!R.HasFormOfMemberPointer) return QualType();
2772
John McCalleff92132010-02-02 02:21:27 +00002773 return Context.getMemberPointerType(Fn->getType(),
2774 Context.getTypeDeclType(Method->getParent()).getTypePtr());
John McCall9c72c602010-08-27 09:08:28 +00002775 }
2776
2777 if (!R.IsAddressOfOperand) return Fn->getType();
John McCalleff92132010-02-02 02:21:27 +00002778 return Context.getPointerType(Fn->getType());
2779}
2780
2781/// Apply the deduction rules for overload sets.
2782///
2783/// \return the null type if this argument should be treated as an
2784/// undeduced context
2785static QualType
2786ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
Douglas Gregor75f21af2010-08-30 21:04:23 +00002787 Expr *Arg, QualType ParamType,
2788 bool ParamWasReference) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002789
John McCall9c72c602010-08-27 09:08:28 +00002790 OverloadExpr::FindResult R = OverloadExpr::find(Arg);
John McCalleff92132010-02-02 02:21:27 +00002791
John McCall9c72c602010-08-27 09:08:28 +00002792 OverloadExpr *Ovl = R.Expression;
John McCalleff92132010-02-02 02:21:27 +00002793
Douglas Gregor75f21af2010-08-30 21:04:23 +00002794 // C++0x [temp.deduct.call]p4
2795 unsigned TDF = 0;
2796 if (ParamWasReference)
2797 TDF |= TDF_ParamWithReferenceType;
2798 if (R.IsAddressOfOperand)
2799 TDF |= TDF_IgnoreQualifiers;
2800
John McCalleff92132010-02-02 02:21:27 +00002801 // C++0x [temp.deduct.call]p6:
2802 // When P is a function type, pointer to function type, or pointer
2803 // to member function type:
2804
2805 if (!ParamType->isFunctionType() &&
2806 !ParamType->isFunctionPointerType() &&
Douglas Gregor860d9b72012-03-12 21:09:16 +00002807 !ParamType->isMemberFunctionPointerType()) {
2808 if (Ovl->hasExplicitTemplateArgs()) {
2809 // But we can still look for an explicit specialization.
2810 if (FunctionDecl *ExplicitSpec
2811 = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
2812 return GetTypeOfFunction(S.Context, R, ExplicitSpec);
2813 }
John McCalleff92132010-02-02 02:21:27 +00002814
Douglas Gregor860d9b72012-03-12 21:09:16 +00002815 return QualType();
2816 }
2817
2818 // Gather the explicit template arguments, if any.
2819 TemplateArgumentListInfo ExplicitTemplateArgs;
2820 if (Ovl->hasExplicitTemplateArgs())
2821 Ovl->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs);
John McCalleff92132010-02-02 02:21:27 +00002822 QualType Match;
John McCall7bb12da2010-02-02 06:20:04 +00002823 for (UnresolvedSetIterator I = Ovl->decls_begin(),
2824 E = Ovl->decls_end(); I != E; ++I) {
John McCalleff92132010-02-02 02:21:27 +00002825 NamedDecl *D = (*I)->getUnderlyingDecl();
2826
Douglas Gregor860d9b72012-03-12 21:09:16 +00002827 if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
2828 // - If the argument is an overload set containing one or more
2829 // function templates, the parameter is treated as a
2830 // non-deduced context.
2831 if (!Ovl->hasExplicitTemplateArgs())
2832 return QualType();
2833
2834 // Otherwise, see if we can resolve a function type
2835 FunctionDecl *Specialization = 0;
Craig Topper93e45992012-09-19 02:26:47 +00002836 TemplateDeductionInfo Info(Ovl->getNameLoc());
Douglas Gregor860d9b72012-03-12 21:09:16 +00002837 if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
2838 Specialization, Info))
2839 continue;
2840
2841 D = Specialization;
2842 }
John McCalleff92132010-02-02 02:21:27 +00002843
2844 FunctionDecl *Fn = cast<FunctionDecl>(D);
John McCall9c72c602010-08-27 09:08:28 +00002845 QualType ArgType = GetTypeOfFunction(S.Context, R, Fn);
2846 if (ArgType.isNull()) continue;
John McCalleff92132010-02-02 02:21:27 +00002847
Douglas Gregor75f21af2010-08-30 21:04:23 +00002848 // Function-to-pointer conversion.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002849 if (!ParamWasReference && ParamType->isPointerType() &&
Douglas Gregor75f21af2010-08-30 21:04:23 +00002850 ArgType->isFunctionType())
2851 ArgType = S.Context.getPointerType(ArgType);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002852
John McCalleff92132010-02-02 02:21:27 +00002853 // - If the argument is an overload set (not containing function
2854 // templates), trial argument deduction is attempted using each
2855 // of the members of the set. If deduction succeeds for only one
2856 // of the overload set members, that member is used as the
2857 // argument value for the deduction. If deduction succeeds for
2858 // more than one member of the overload set the parameter is
2859 // treated as a non-deduced context.
2860
2861 // We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
2862 // Type deduction is done independently for each P/A pair, and
2863 // the deduced template argument values are then combined.
2864 // So we do not reject deductions which were made elsewhere.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002865 SmallVector<DeducedTemplateArgument, 8>
Douglas Gregor02024a92010-03-28 02:42:43 +00002866 Deduced(TemplateParams->size());
Craig Topper93e45992012-09-19 02:26:47 +00002867 TemplateDeductionInfo Info(Ovl->getNameLoc());
John McCalleff92132010-02-02 02:21:27 +00002868 Sema::TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00002869 = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
2870 ArgType, Info, Deduced, TDF);
John McCalleff92132010-02-02 02:21:27 +00002871 if (Result) continue;
2872 if (!Match.isNull()) return QualType();
2873 Match = ArgType;
2874 }
2875
2876 return Match;
2877}
2878
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002879/// \brief Perform the adjustments to the parameter and argument types
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002880/// described in C++ [temp.deduct.call].
2881///
2882/// \returns true if the caller should not attempt to perform any template
Richard Smith0efa62f2013-01-31 04:03:12 +00002883/// argument deduction based on this P/A pair because the argument is an
2884/// overloaded function set that could not be resolved.
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002885static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S,
2886 TemplateParameterList *TemplateParams,
2887 QualType &ParamType,
2888 QualType &ArgType,
2889 Expr *Arg,
2890 unsigned &TDF) {
2891 // C++0x [temp.deduct.call]p3:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00002892 // If P is a cv-qualified type, the top level cv-qualifiers of P's type
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002893 // are ignored for type deduction.
Douglas Gregora459cc22011-04-27 23:34:22 +00002894 if (ParamType.hasQualifiers())
2895 ParamType = ParamType.getUnqualifiedType();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002896 const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
2897 if (ParamRefType) {
Richard Smith34b41d92011-02-20 03:19:35 +00002898 QualType PointeeType = ParamRefType->getPointeeType();
2899
Richard Smith0efa62f2013-01-31 04:03:12 +00002900 // If the argument has incomplete array type, try to complete its type.
Douglas Gregord10099e2012-05-04 16:32:21 +00002901 if (ArgType->isIncompleteArrayType() && !S.RequireCompleteExprType(Arg, 0))
Douglas Gregorf15748a2011-06-03 03:35:07 +00002902 ArgType = Arg->getType();
2903
Douglas Gregor2ad746a2011-01-21 05:18:22 +00002904 // [C++0x] If P is an rvalue reference to a cv-unqualified
2905 // template parameter and the argument is an lvalue, the type
2906 // "lvalue reference to A" is used in place of A for type
2907 // deduction.
Richard Smith34b41d92011-02-20 03:19:35 +00002908 if (isa<RValueReferenceType>(ParamType)) {
2909 if (!PointeeType.getQualifiers() &&
2910 isa<TemplateTypeParmType>(PointeeType) &&
Douglas Gregor9625e442011-05-21 22:16:50 +00002911 Arg->Classify(S.Context).isLValue() &&
2912 Arg->getType() != S.Context.OverloadTy &&
2913 Arg->getType() != S.Context.BoundMemberTy)
Douglas Gregor2ad746a2011-01-21 05:18:22 +00002914 ArgType = S.Context.getLValueReferenceType(ArgType);
2915 }
2916
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002917 // [...] If P is a reference type, the type referred to by P is used
2918 // for type deduction.
Richard Smith34b41d92011-02-20 03:19:35 +00002919 ParamType = PointeeType;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002920 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002921
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002922 // Overload sets usually make this parameter an undeduced
2923 // context, but there are sometimes special circumstances.
2924 if (ArgType == S.Context.OverloadTy) {
2925 ArgType = ResolveOverloadForDeduction(S, TemplateParams,
2926 Arg, ParamType,
2927 ParamRefType != 0);
2928 if (ArgType.isNull())
2929 return true;
2930 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002931
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002932 if (ParamRefType) {
2933 // C++0x [temp.deduct.call]p3:
2934 // [...] If P is of the form T&&, where T is a template parameter, and
2935 // the argument is an lvalue, the type A& is used in place of A for
2936 // type deduction.
2937 if (ParamRefType->isRValueReferenceType() &&
2938 ParamRefType->getAs<TemplateTypeParmType>() &&
2939 Arg->isLValue())
2940 ArgType = S.Context.getLValueReferenceType(ArgType);
2941 } else {
2942 // C++ [temp.deduct.call]p2:
2943 // If P is not a reference type:
2944 // - If A is an array type, the pointer type produced by the
2945 // array-to-pointer standard conversion (4.2) is used in place of
2946 // A for type deduction; otherwise,
2947 if (ArgType->isArrayType())
2948 ArgType = S.Context.getArrayDecayedType(ArgType);
2949 // - If A is a function type, the pointer type produced by the
2950 // function-to-pointer standard conversion (4.3) is used in place
2951 // of A for type deduction; otherwise,
2952 else if (ArgType->isFunctionType())
2953 ArgType = S.Context.getPointerType(ArgType);
2954 else {
NAKAMURA Takumi00995302011-01-27 07:09:49 +00002955 // - If A is a cv-qualified type, the top level cv-qualifiers of A's
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002956 // type are ignored for type deduction.
Douglas Gregora459cc22011-04-27 23:34:22 +00002957 ArgType = ArgType.getUnqualifiedType();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002958 }
2959 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002960
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002961 // C++0x [temp.deduct.call]p4:
2962 // In general, the deduction process attempts to find template argument
2963 // values that will make the deduced A identical to A (after the type A
2964 // is transformed as described above). [...]
2965 TDF = TDF_SkipNonDependent;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002966
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002967 // - If the original P is a reference type, the deduced A (i.e., the
2968 // type referred to by the reference) can be more cv-qualified than
2969 // the transformed A.
2970 if (ParamRefType)
2971 TDF |= TDF_ParamWithReferenceType;
2972 // - The transformed A can be another pointer or pointer to member
2973 // type that can be converted to the deduced A via a qualification
2974 // conversion (4.4).
2975 if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
2976 ArgType->isObjCObjectPointerType())
2977 TDF |= TDF_IgnoreQualifiers;
2978 // - If P is a class and P has the form simple-template-id, then the
2979 // transformed A can be a derived class of the deduced A. Likewise,
2980 // if P is a pointer to a class of the form simple-template-id, the
2981 // transformed A can be a pointer to a derived class pointed to by
2982 // the deduced A.
2983 if (isSimpleTemplateIdType(ParamType) ||
2984 (isa<PointerType>(ParamType) &&
2985 isSimpleTemplateIdType(
2986 ParamType->getAs<PointerType>()->getPointeeType())))
2987 TDF |= TDF_DerivedClass;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00002988
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00002989 return false;
2990}
2991
Douglas Gregordbfb3712011-06-16 16:50:48 +00002992static bool hasDeducibleTemplateParameters(Sema &S,
2993 FunctionTemplateDecl *FunctionTemplate,
2994 QualType T);
2995
Sebastian Redl4b911e62012-03-15 21:40:51 +00002996/// \brief Perform template argument deduction by matching a parameter type
2997/// against a single expression, where the expression is an element of
Richard Smith0efa62f2013-01-31 04:03:12 +00002998/// an initializer list that was originally matched against a parameter
2999/// of type \c initializer_list\<ParamType\>.
Sebastian Redl4b911e62012-03-15 21:40:51 +00003000static Sema::TemplateDeductionResult
3001DeduceTemplateArgumentByListElement(Sema &S,
3002 TemplateParameterList *TemplateParams,
3003 QualType ParamType, Expr *Arg,
3004 TemplateDeductionInfo &Info,
3005 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3006 unsigned TDF) {
3007 // Handle the case where an init list contains another init list as the
3008 // element.
3009 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3010 QualType X;
3011 if (!S.isStdInitializerList(ParamType.getNonReferenceType(), &X))
3012 return Sema::TDK_Success; // Just ignore this expression.
3013
3014 // Recurse down into the init list.
3015 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3016 if (Sema::TemplateDeductionResult Result =
3017 DeduceTemplateArgumentByListElement(S, TemplateParams, X,
3018 ILE->getInit(i),
3019 Info, Deduced, TDF))
3020 return Result;
3021 }
3022 return Sema::TDK_Success;
3023 }
3024
3025 // For all other cases, just match by type.
Douglas Gregord2803892012-04-04 05:10:53 +00003026 QualType ArgType = Arg->getType();
3027 if (AdjustFunctionParmAndArgTypesForDeduction(S, TemplateParams, ParamType,
Richard Smith0efa62f2013-01-31 04:03:12 +00003028 ArgType, Arg, TDF)) {
3029 Info.Expression = Arg;
Douglas Gregord2803892012-04-04 05:10:53 +00003030 return Sema::TDK_FailedOverloadResolution;
Richard Smith0efa62f2013-01-31 04:03:12 +00003031 }
Sebastian Redl4b911e62012-03-15 21:40:51 +00003032 return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
Douglas Gregord2803892012-04-04 05:10:53 +00003033 ArgType, Info, Deduced, TDF);
Sebastian Redl4b911e62012-03-15 21:40:51 +00003034}
3035
Douglas Gregore53060f2009-06-25 22:08:12 +00003036/// \brief Perform template argument deduction from a function call
3037/// (C++ [temp.deduct.call]).
3038///
3039/// \param FunctionTemplate the function template for which we are performing
3040/// template argument deduction.
3041///
James Dennett40ae6662012-06-22 08:52:37 +00003042/// \param ExplicitTemplateArgs the explicit template arguments provided
Douglas Gregor48026d22010-01-11 18:40:55 +00003043/// for this call.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003044///
Douglas Gregore53060f2009-06-25 22:08:12 +00003045/// \param Args the function call arguments
3046///
Douglas Gregore53060f2009-06-25 22:08:12 +00003047/// \param Specialization if template argument deduction was successful,
Mike Stump1eb44332009-09-09 15:08:12 +00003048/// this will be set to the function template specialization produced by
Douglas Gregore53060f2009-06-25 22:08:12 +00003049/// template argument deduction.
3050///
3051/// \param Info the argument will be updated to provide additional information
3052/// about template argument deduction.
3053///
3054/// \returns the result of template argument deduction.
Douglas Gregore53060f2009-06-25 22:08:12 +00003055Sema::TemplateDeductionResult
3056Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00003057 TemplateArgumentListInfo *ExplicitTemplateArgs,
Ahmed Charles13a140c2012-02-25 11:00:22 +00003058 llvm::ArrayRef<Expr *> Args,
Douglas Gregore53060f2009-06-25 22:08:12 +00003059 FunctionDecl *&Specialization,
3060 TemplateDeductionInfo &Info) {
Douglas Gregorae19fbb2012-09-13 21:01:57 +00003061 if (FunctionTemplate->isInvalidDecl())
3062 return TDK_Invalid;
3063
Douglas Gregore53060f2009-06-25 22:08:12 +00003064 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003065
Douglas Gregore53060f2009-06-25 22:08:12 +00003066 // C++ [temp.deduct.call]p1:
3067 // Template argument deduction is done by comparing each function template
3068 // parameter type (call it P) with the type of the corresponding argument
3069 // of the call (call it A) as described below.
Ahmed Charles13a140c2012-02-25 11:00:22 +00003070 unsigned CheckArgs = Args.size();
3071 if (Args.size() < Function->getMinRequiredArguments())
Douglas Gregore53060f2009-06-25 22:08:12 +00003072 return TDK_TooFewArguments;
Ahmed Charles13a140c2012-02-25 11:00:22 +00003073 else if (Args.size() > Function->getNumParams()) {
Mike Stump1eb44332009-09-09 15:08:12 +00003074 const FunctionProtoType *Proto
John McCall183700f2009-09-21 23:43:11 +00003075 = Function->getType()->getAs<FunctionProtoType>();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003076 if (Proto->isTemplateVariadic())
3077 /* Do nothing */;
3078 else if (Proto->isVariadic())
3079 CheckArgs = Function->getNumParams();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003080 else
Douglas Gregore53060f2009-06-25 22:08:12 +00003081 return TDK_TooManyArguments;
Douglas Gregore53060f2009-06-25 22:08:12 +00003082 }
Mike Stump1eb44332009-09-09 15:08:12 +00003083
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003084 // The types of the parameters from which we will perform template argument
3085 // deduction.
John McCall2a7fb272010-08-25 05:32:35 +00003086 LocalInstantiationScope InstScope(*this);
Douglas Gregore53060f2009-06-25 22:08:12 +00003087 TemplateParameterList *TemplateParams
3088 = FunctionTemplate->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003089 SmallVector<DeducedTemplateArgument, 4> Deduced;
3090 SmallVector<QualType, 4> ParamTypes;
Douglas Gregor02024a92010-03-28 02:42:43 +00003091 unsigned NumExplicitlySpecified = 0;
John McCalld5532b62009-11-23 01:53:49 +00003092 if (ExplicitTemplateArgs) {
Douglas Gregor83314aa2009-07-08 20:55:45 +00003093 TemplateDeductionResult Result =
3094 SubstituteExplicitTemplateArguments(FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00003095 *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00003096 Deduced,
3097 ParamTypes,
3098 0,
3099 Info);
3100 if (Result)
3101 return Result;
Douglas Gregor02024a92010-03-28 02:42:43 +00003102
3103 NumExplicitlySpecified = Deduced.size();
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003104 } else {
3105 // Just fill in the parameter types from the function declaration.
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003106 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003107 ParamTypes.push_back(Function->getParamDecl(I)->getType());
3108 }
Mike Stump1eb44332009-09-09 15:08:12 +00003109
Douglas Gregor6db8ed42009-06-30 23:57:56 +00003110 // Deduce template arguments from the function parameters.
Mike Stump1eb44332009-09-09 15:08:12 +00003111 Deduced.resize(TemplateParams->size());
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003112 unsigned ArgIdx = 0;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003113 SmallVector<OriginalCallArg, 4> OriginalCallArgs;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003114 for (unsigned ParamIdx = 0, NumParams = ParamTypes.size();
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003115 ParamIdx != NumParams; ++ParamIdx) {
Douglas Gregordbfb3712011-06-16 16:50:48 +00003116 QualType OrigParamType = ParamTypes[ParamIdx];
3117 QualType ParamType = OrigParamType;
3118
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003119 const PackExpansionType *ParamExpansion
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003120 = dyn_cast<PackExpansionType>(ParamType);
3121 if (!ParamExpansion) {
3122 // Simple case: matching a function parameter to a function argument.
3123 if (ArgIdx >= CheckArgs)
3124 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003125
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003126 Expr *Arg = Args[ArgIdx++];
3127 QualType ArgType = Arg->getType();
Douglas Gregordbfb3712011-06-16 16:50:48 +00003128
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003129 unsigned TDF = 0;
3130 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
3131 ParamType, ArgType, Arg,
3132 TDF))
3133 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003134
Douglas Gregord8f5b332011-10-09 22:06:46 +00003135 // If we have nothing to deduce, we're done.
3136 if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3137 continue;
3138
Sebastian Redl84760e32012-01-17 22:49:58 +00003139 // If the argument is an initializer list ...
3140 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3141 // ... then the parameter is an undeduced context, unless the parameter
3142 // type is (reference to cv) std::initializer_list<P'>, in which case
3143 // deduction is done for each element of the initializer list, and the
3144 // result is the deduced type if it's the same for all elements.
3145 QualType X;
3146 // Removing references was already done.
3147 if (!isStdInitializerList(ParamType, &X))
3148 continue;
3149
3150 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3151 if (TemplateDeductionResult Result =
Sebastian Redl4b911e62012-03-15 21:40:51 +00003152 DeduceTemplateArgumentByListElement(*this, TemplateParams, X,
3153 ILE->getInit(i),
3154 Info, Deduced, TDF))
Sebastian Redl84760e32012-01-17 22:49:58 +00003155 return Result;
3156 }
3157 // Don't track the argument type, since an initializer list has none.
3158 continue;
3159 }
3160
Douglas Gregordbfb3712011-06-16 16:50:48 +00003161 // Keep track of the argument type and corresponding parameter index,
3162 // so we can check for compatibility between the deduced A and A.
Douglas Gregord8f5b332011-10-09 22:06:46 +00003163 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx-1,
3164 ArgType));
Douglas Gregordbfb3712011-06-16 16:50:48 +00003165
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003166 if (TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00003167 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3168 ParamType, ArgType,
3169 Info, Deduced, TDF))
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003170 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00003171
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003172 continue;
Douglas Gregor75f21af2010-08-30 21:04:23 +00003173 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003174
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003175 // C++0x [temp.deduct.call]p1:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003176 // For a function parameter pack that occurs at the end of the
3177 // parameter-declaration-list, the type A of each remaining argument of
3178 // the call is compared with the type P of the declarator-id of the
3179 // function parameter pack. Each comparison deduces template arguments
3180 // for subsequent positions in the template parameter packs expanded by
Douglas Gregor7d5c0c12011-01-11 01:52:23 +00003181 // the function parameter pack. For a function parameter pack that does
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003182 // not occur at the end of the parameter-declaration-list, the type of
Douglas Gregor7d5c0c12011-01-11 01:52:23 +00003183 // the parameter pack is a non-deduced context.
3184 if (ParamIdx + 1 < NumParams)
3185 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003186
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003187 QualType ParamPattern = ParamExpansion->getPattern();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003188 SmallVector<unsigned, 2> PackIndices;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003189 {
Benjamin Kramer013b3662012-01-30 16:17:39 +00003190 llvm::SmallBitVector SawIndices(TemplateParams->size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00003191 SmallVector<UnexpandedParameterPack, 2> Unexpanded;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003192 collectUnexpandedParameterPacks(ParamPattern, Unexpanded);
3193 for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
3194 unsigned Depth, Index;
3195 llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
3196 if (Depth == 0 && !SawIndices[Index]) {
3197 SawIndices[Index] = true;
3198 PackIndices.push_back(Index);
3199 }
Douglas Gregore53060f2009-06-25 22:08:12 +00003200 }
3201 }
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003202 assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?");
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003203
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003204 // Keep track of the deduced template arguments for each parameter pack
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003205 // expanded by this pack expansion (the outer index) and for each
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003206 // template argument (the inner SmallVectors).
Chris Lattner5f9e2722011-07-23 10:55:15 +00003207 SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2>
Douglas Gregord3731192011-01-10 07:32:04 +00003208 NewlyDeducedPacks(PackIndices.size());
Chris Lattner5f9e2722011-07-23 10:55:15 +00003209 SmallVector<DeducedTemplateArgument, 2>
Douglas Gregord3731192011-01-10 07:32:04 +00003210 SavedPacks(PackIndices.size());
Douglas Gregor54293852011-01-10 17:35:05 +00003211 PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003212 NewlyDeducedPacks);
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003213 bool HasAnyArguments = false;
Ahmed Charles13a140c2012-02-25 11:00:22 +00003214 for (; ArgIdx < Args.size(); ++ArgIdx) {
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003215 HasAnyArguments = true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003216
Douglas Gregordbfb3712011-06-16 16:50:48 +00003217 QualType OrigParamType = ParamPattern;
3218 ParamType = OrigParamType;
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003219 Expr *Arg = Args[ArgIdx];
3220 QualType ArgType = Arg->getType();
Douglas Gregordbfb3712011-06-16 16:50:48 +00003221
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003222 unsigned TDF = 0;
3223 if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams,
3224 ParamType, ArgType, Arg,
3225 TDF)) {
3226 // We can't actually perform any deduction for this argument, so stop
3227 // deduction at this point.
3228 ++ArgIdx;
3229 break;
3230 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003231
Sebastian Redl84760e32012-01-17 22:49:58 +00003232 // As above, initializer lists need special handling.
3233 if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg)) {
3234 QualType X;
3235 if (!isStdInitializerList(ParamType, &X)) {
3236 ++ArgIdx;
3237 break;
3238 }
Douglas Gregordbfb3712011-06-16 16:50:48 +00003239
Sebastian Redl84760e32012-01-17 22:49:58 +00003240 for (unsigned i = 0, e = ILE->getNumInits(); i < e; ++i) {
3241 if (TemplateDeductionResult Result =
3242 DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, X,
3243 ILE->getInit(i)->getType(),
3244 Info, Deduced, TDF))
3245 return Result;
3246 }
3247 } else {
3248
3249 // Keep track of the argument type and corresponding argument index,
3250 // so we can check for compatibility between the deduced A and A.
3251 if (hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3252 OriginalCallArgs.push_back(OriginalCallArg(OrigParamType, ArgIdx,
3253 ArgType));
3254
3255 if (TemplateDeductionResult Result
3256 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3257 ParamType, ArgType, Info,
3258 Deduced, TDF))
3259 return Result;
3260 }
Mike Stump1eb44332009-09-09 15:08:12 +00003261
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003262 // Capture the deduced template arguments for each parameter pack expanded
3263 // by this pack expansion, add them to the list of arguments we've deduced
3264 // for that pack, then clear out the deduced argument.
3265 for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) {
3266 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
3267 if (!DeducedArg.isNull()) {
3268 NewlyDeducedPacks[I].push_back(DeducedArg);
3269 DeducedArg = DeducedTemplateArgument();
3270 }
3271 }
3272 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003273
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003274 // Build argument packs for each of the parameter packs expanded by this
3275 // pack expansion.
Douglas Gregor0216f812011-01-10 17:53:52 +00003276 if (Sema::TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003277 = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments,
Douglas Gregor0216f812011-01-10 17:53:52 +00003278 Deduced, PackIndices, SavedPacks,
3279 NewlyDeducedPacks, Info))
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003280 return Result;
Mike Stump1eb44332009-09-09 15:08:12 +00003281
Douglas Gregorf5c65ff2011-01-06 22:09:01 +00003282 // After we've matching against a parameter pack, we're done.
3283 break;
Douglas Gregore53060f2009-06-25 22:08:12 +00003284 }
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003285
Mike Stump1eb44332009-09-09 15:08:12 +00003286 return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
Douglas Gregor02024a92010-03-28 02:42:43 +00003287 NumExplicitlySpecified,
Douglas Gregordbfb3712011-06-16 16:50:48 +00003288 Specialization, Info, &OriginalCallArgs);
Douglas Gregore53060f2009-06-25 22:08:12 +00003289}
3290
Douglas Gregor83314aa2009-07-08 20:55:45 +00003291/// \brief Deduce template arguments when taking the address of a function
Douglas Gregor4b52e252009-12-21 23:17:24 +00003292/// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
3293/// a template.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003294///
3295/// \param FunctionTemplate the function template for which we are performing
3296/// template argument deduction.
3297///
James Dennett40ae6662012-06-22 08:52:37 +00003298/// \param ExplicitTemplateArgs the explicitly-specified template
Douglas Gregor4b52e252009-12-21 23:17:24 +00003299/// arguments.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003300///
3301/// \param ArgFunctionType the function type that will be used as the
3302/// "argument" type (A) when performing template argument deduction from the
Douglas Gregor4b52e252009-12-21 23:17:24 +00003303/// function template's function type. This type may be NULL, if there is no
3304/// argument type to compare against, in C++0x [temp.arg.explicit]p3.
Douglas Gregor83314aa2009-07-08 20:55:45 +00003305///
3306/// \param Specialization if template argument deduction was successful,
Mike Stump1eb44332009-09-09 15:08:12 +00003307/// this will be set to the function template specialization produced by
Douglas Gregor83314aa2009-07-08 20:55:45 +00003308/// template argument deduction.
3309///
3310/// \param Info the argument will be updated to provide additional information
3311/// about template argument deduction.
3312///
3313/// \returns the result of template argument deduction.
3314Sema::TemplateDeductionResult
3315Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00003316 TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00003317 QualType ArgFunctionType,
3318 FunctionDecl *&Specialization,
3319 TemplateDeductionInfo &Info) {
Douglas Gregorae19fbb2012-09-13 21:01:57 +00003320 if (FunctionTemplate->isInvalidDecl())
3321 return TDK_Invalid;
3322
Douglas Gregor83314aa2009-07-08 20:55:45 +00003323 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3324 TemplateParameterList *TemplateParams
3325 = FunctionTemplate->getTemplateParameters();
3326 QualType FunctionType = Function->getType();
Mike Stump1eb44332009-09-09 15:08:12 +00003327
Douglas Gregor83314aa2009-07-08 20:55:45 +00003328 // Substitute any explicit template arguments.
John McCall2a7fb272010-08-25 05:32:35 +00003329 LocalInstantiationScope InstScope(*this);
Chris Lattner5f9e2722011-07-23 10:55:15 +00003330 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor02024a92010-03-28 02:42:43 +00003331 unsigned NumExplicitlySpecified = 0;
Chris Lattner5f9e2722011-07-23 10:55:15 +00003332 SmallVector<QualType, 4> ParamTypes;
John McCalld5532b62009-11-23 01:53:49 +00003333 if (ExplicitTemplateArgs) {
Mike Stump1eb44332009-09-09 15:08:12 +00003334 if (TemplateDeductionResult Result
3335 = SubstituteExplicitTemplateArguments(FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00003336 *ExplicitTemplateArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00003337 Deduced, ParamTypes,
Douglas Gregor83314aa2009-07-08 20:55:45 +00003338 &FunctionType, Info))
3339 return Result;
Douglas Gregor02024a92010-03-28 02:42:43 +00003340
3341 NumExplicitlySpecified = Deduced.size();
Douglas Gregor83314aa2009-07-08 20:55:45 +00003342 }
3343
Eli Friedman59a839c2012-02-08 03:07:05 +00003344 // Unevaluated SFINAE context.
3345 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Mike Stump1eb44332009-09-09 15:08:12 +00003346 SFINAETrap Trap(*this);
3347
John McCalleff92132010-02-02 02:21:27 +00003348 Deduced.resize(TemplateParams->size());
3349
Douglas Gregor4b52e252009-12-21 23:17:24 +00003350 if (!ArgFunctionType.isNull()) {
3351 // Deduce template arguments from the function type.
Douglas Gregor4b52e252009-12-21 23:17:24 +00003352 if (TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00003353 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
Douglas Gregor4b52e252009-12-21 23:17:24 +00003354 FunctionType, ArgFunctionType, Info,
Douglas Gregor73b3cf62011-01-25 17:19:08 +00003355 Deduced, TDF_TopLevelParameterTypeList))
Douglas Gregor4b52e252009-12-21 23:17:24 +00003356 return Result;
3357 }
Douglas Gregorfbb6fad2010-09-29 21:14:36 +00003358
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003359 if (TemplateDeductionResult Result
Douglas Gregorfbb6fad2010-09-29 21:14:36 +00003360 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3361 NumExplicitlySpecified,
3362 Specialization, Info))
3363 return Result;
3364
3365 // If the requested function type does not match the actual type of the
3366 // specialization, template argument deduction fails.
3367 if (!ArgFunctionType.isNull() &&
3368 !Context.hasSameType(ArgFunctionType, Specialization->getType()))
Richard Smith29805ca2013-01-31 05:19:49 +00003369 return TDK_MiscellaneousDeductionFailure;
Douglas Gregorfbb6fad2010-09-29 21:14:36 +00003370
3371 return TDK_Success;
Douglas Gregor83314aa2009-07-08 20:55:45 +00003372}
3373
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003374/// \brief Deduce template arguments for a templated conversion
3375/// function (C++ [temp.deduct.conv]) and, if successful, produce a
3376/// conversion function template specialization.
3377Sema::TemplateDeductionResult
3378Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
3379 QualType ToType,
3380 CXXConversionDecl *&Specialization,
3381 TemplateDeductionInfo &Info) {
Douglas Gregorae19fbb2012-09-13 21:01:57 +00003382 if (FunctionTemplate->isInvalidDecl())
3383 return TDK_Invalid;
3384
Mike Stump1eb44332009-09-09 15:08:12 +00003385 CXXConversionDecl *Conv
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003386 = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
3387 QualType FromType = Conv->getConversionType();
3388
3389 // Canonicalize the types for deduction.
3390 QualType P = Context.getCanonicalType(FromType);
3391 QualType A = Context.getCanonicalType(ToType);
3392
Douglas Gregor5453d932011-03-06 09:03:20 +00003393 // C++0x [temp.deduct.conv]p2:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003394 // If P is a reference type, the type referred to by P is used for
3395 // type deduction.
3396 if (const ReferenceType *PRef = P->getAs<ReferenceType>())
3397 P = PRef->getPointeeType();
3398
Douglas Gregor5453d932011-03-06 09:03:20 +00003399 // C++0x [temp.deduct.conv]p4:
3400 // [...] If A is a reference type, the type referred to by A is used
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003401 // for type deduction.
3402 if (const ReferenceType *ARef = A->getAs<ReferenceType>())
Douglas Gregor5453d932011-03-06 09:03:20 +00003403 A = ARef->getPointeeType().getUnqualifiedType();
3404 // C++ [temp.deduct.conv]p3:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003405 //
Mike Stump1eb44332009-09-09 15:08:12 +00003406 // If A is not a reference type:
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003407 else {
3408 assert(!A->isReferenceType() && "Reference types were handled above");
3409
3410 // - If P is an array type, the pointer type produced by the
Mike Stump1eb44332009-09-09 15:08:12 +00003411 // array-to-pointer standard conversion (4.2) is used in place
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003412 // of P for type deduction; otherwise,
3413 if (P->isArrayType())
3414 P = Context.getArrayDecayedType(P);
3415 // - If P is a function type, the pointer type produced by the
3416 // function-to-pointer standard conversion (4.3) is used in
3417 // place of P for type deduction; otherwise,
3418 else if (P->isFunctionType())
3419 P = Context.getPointerType(P);
3420 // - If P is a cv-qualified type, the top level cv-qualifiers of
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003421 // P's type are ignored for type deduction.
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003422 else
3423 P = P.getUnqualifiedType();
3424
Douglas Gregor5453d932011-03-06 09:03:20 +00003425 // C++0x [temp.deduct.conv]p4:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003426 // If A is a cv-qualified type, the top level cv-qualifiers of A's
Douglas Gregor5453d932011-03-06 09:03:20 +00003427 // type are ignored for type deduction. If A is a reference type, the type
3428 // referred to by A is used for type deduction.
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003429 A = A.getUnqualifiedType();
3430 }
3431
Eli Friedman59a839c2012-02-08 03:07:05 +00003432 // Unevaluated SFINAE context.
3433 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated);
Mike Stump1eb44332009-09-09 15:08:12 +00003434 SFINAETrap Trap(*this);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003435
3436 // C++ [temp.deduct.conv]p1:
3437 // Template argument deduction is done by comparing the return
3438 // type of the template conversion function (call it P) with the
3439 // type that is required as the result of the conversion (call it
3440 // A) as described in 14.8.2.4.
3441 TemplateParameterList *TemplateParams
3442 = FunctionTemplate->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003443 SmallVector<DeducedTemplateArgument, 4> Deduced;
Mike Stump1eb44332009-09-09 15:08:12 +00003444 Deduced.resize(TemplateParams->size());
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003445
3446 // C++0x [temp.deduct.conv]p4:
3447 // In general, the deduction process attempts to find template
3448 // argument values that will make the deduced A identical to
3449 // A. However, there are two cases that allow a difference:
3450 unsigned TDF = 0;
3451 // - If the original A is a reference type, A can be more
3452 // cv-qualified than the deduced A (i.e., the type referred to
3453 // by the reference)
3454 if (ToType->isReferenceType())
3455 TDF |= TDF_ParamWithReferenceType;
3456 // - The deduced A can be another pointer or pointer to member
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003457 // type that can be converted to A via a qualification
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003458 // conversion.
3459 //
3460 // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
3461 // both P and A are pointers or member pointers. In this case, we
3462 // just ignore cv-qualifiers completely).
3463 if ((P->isPointerType() && A->isPointerType()) ||
Douglas Gregor2cae1e22011-08-30 00:37:54 +00003464 (P->isMemberPointerType() && A->isMemberPointerType()))
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003465 TDF |= TDF_IgnoreQualifiers;
3466 if (TemplateDeductionResult Result
Sebastian Redlbb95e512012-01-17 22:49:52 +00003467 = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
3468 P, A, Info, Deduced, TDF))
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003469 return Result;
3470
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003471 // Finish template argument deduction.
John McCall2a7fb272010-08-25 05:32:35 +00003472 LocalInstantiationScope InstScope(*this);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003473 FunctionDecl *Spec = 0;
3474 TemplateDeductionResult Result
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003475 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
Douglas Gregor02024a92010-03-28 02:42:43 +00003476 Info);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003477 Specialization = cast_or_null<CXXConversionDecl>(Spec);
3478 return Result;
3479}
3480
Douglas Gregor4b52e252009-12-21 23:17:24 +00003481/// \brief Deduce template arguments for a function template when there is
3482/// nothing to deduce against (C++0x [temp.arg.explicit]p3).
3483///
3484/// \param FunctionTemplate the function template for which we are performing
3485/// template argument deduction.
3486///
James Dennett40ae6662012-06-22 08:52:37 +00003487/// \param ExplicitTemplateArgs the explicitly-specified template
Douglas Gregor4b52e252009-12-21 23:17:24 +00003488/// arguments.
3489///
3490/// \param Specialization if template argument deduction was successful,
3491/// this will be set to the function template specialization produced by
3492/// template argument deduction.
3493///
3494/// \param Info the argument will be updated to provide additional information
3495/// about template argument deduction.
3496///
3497/// \returns the result of template argument deduction.
3498Sema::TemplateDeductionResult
3499Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor67714232011-03-03 02:41:12 +00003500 TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor4b52e252009-12-21 23:17:24 +00003501 FunctionDecl *&Specialization,
3502 TemplateDeductionInfo &Info) {
3503 return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
3504 QualType(), Specialization, Info);
3505}
3506
Richard Smith34b41d92011-02-20 03:19:35 +00003507namespace {
3508 /// Substitute the 'auto' type specifier within a type for a given replacement
3509 /// type.
3510 class SubstituteAutoTransform :
3511 public TreeTransform<SubstituteAutoTransform> {
3512 QualType Replacement;
3513 public:
3514 SubstituteAutoTransform(Sema &SemaRef, QualType Replacement) :
3515 TreeTransform<SubstituteAutoTransform>(SemaRef), Replacement(Replacement) {
3516 }
3517 QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
3518 // If we're building the type pattern to deduce against, don't wrap the
3519 // substituted type in an AutoType. Certain template deduction rules
3520 // apply only when a template type parameter appears directly (and not if
3521 // the parameter is found through desugaring). For instance:
3522 // auto &&lref = lvalue;
3523 // must transform into "rvalue reference to T" not "rvalue reference to
3524 // auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
3525 if (isa<TemplateTypeParmType>(Replacement)) {
3526 QualType Result = Replacement;
3527 TemplateTypeParmTypeLoc NewTL = TLB.push<TemplateTypeParmTypeLoc>(Result);
3528 NewTL.setNameLoc(TL.getNameLoc());
3529 return Result;
3530 } else {
3531 QualType Result = RebuildAutoType(Replacement);
3532 AutoTypeLoc NewTL = TLB.push<AutoTypeLoc>(Result);
3533 NewTL.setNameLoc(TL.getNameLoc());
3534 return Result;
3535 }
3536 }
Douglas Gregordfca6f52012-02-13 22:00:16 +00003537
3538 ExprResult TransformLambdaExpr(LambdaExpr *E) {
3539 // Lambdas never need to be transformed.
3540 return E;
3541 }
Richard Smith34b41d92011-02-20 03:19:35 +00003542 };
Richard Smith8ad6c862012-07-08 04:13:07 +00003543
3544 /// Determine whether the specified type (which contains an 'auto' type
3545 /// specifier) is dependent. This is not trivial, because the 'auto' specifier
3546 /// itself claims to be type-dependent.
3547 bool isDependentAutoType(QualType Ty) {
3548 while (1) {
3549 QualType Pointee = Ty->getPointeeType();
3550 if (!Pointee.isNull()) {
3551 Ty = Pointee;
3552 } else if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()){
3553 if (MPT->getClass()->isDependentType())
3554 return true;
3555 Ty = MPT->getPointeeType();
3556 } else if (const FunctionProtoType *FPT = Ty->getAs<FunctionProtoType>()){
3557 for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(),
3558 E = FPT->arg_type_end();
3559 I != E; ++I)
3560 if ((*I)->isDependentType())
3561 return true;
3562 Ty = FPT->getResultType();
3563 } else if (Ty->isDependentSizedArrayType()) {
3564 return true;
3565 } else if (const ArrayType *AT = Ty->getAsArrayTypeUnsafe()) {
3566 Ty = AT->getElementType();
3567 } else if (Ty->getAs<DependentSizedExtVectorType>()) {
3568 return true;
3569 } else if (const VectorType *VT = Ty->getAs<VectorType>()) {
3570 Ty = VT->getElementType();
3571 } else {
3572 break;
3573 }
3574 }
3575 assert(Ty->getAs<AutoType>() && "didn't find 'auto' in auto type");
3576 return false;
3577 }
Richard Smith34b41d92011-02-20 03:19:35 +00003578}
3579
3580/// \brief Deduce the type for an auto type-specifier (C++0x [dcl.spec.auto]p6)
3581///
3582/// \param Type the type pattern using the auto type-specifier.
3583///
3584/// \param Init the initializer for the variable whose type is to be deduced.
3585///
3586/// \param Result if type deduction was successful, this will be set to the
3587/// deduced type. This may still contain undeduced autos if the type is
Richard Smitha085da82011-03-17 16:11:59 +00003588/// dependent. This will be set to null if deduction succeeded, but auto
3589/// substitution failed; the appropriate diagnostic will already have been
3590/// produced in that case.
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003591Sema::DeduceAutoResult
John McCall32509f12011-11-15 01:35:18 +00003592Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init,
Richard Smitha085da82011-03-17 16:11:59 +00003593 TypeSourceInfo *&Result) {
John McCall32509f12011-11-15 01:35:18 +00003594 if (Init->getType()->isNonOverloadPlaceholderType()) {
3595 ExprResult result = CheckPlaceholderExpr(Init);
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003596 if (result.isInvalid()) return DAR_FailedAlreadyDiagnosed;
John McCall32509f12011-11-15 01:35:18 +00003597 Init = result.take();
3598 }
3599
Richard Smith8ad6c862012-07-08 04:13:07 +00003600 if (Init->isTypeDependent() || isDependentAutoType(Type->getType())) {
Richard Smith34b41d92011-02-20 03:19:35 +00003601 Result = Type;
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003602 return DAR_Succeeded;
Richard Smith34b41d92011-02-20 03:19:35 +00003603 }
3604
3605 SourceLocation Loc = Init->getExprLoc();
3606
3607 LocalInstantiationScope InstScope(*this);
3608
3609 // Build template<class TemplParam> void Func(FuncParam);
Chandler Carruth4fb86f82011-05-01 00:51:33 +00003610 TemplateTypeParmDecl *TemplParam =
3611 TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0,
3612 false, false);
3613 QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
3614 NamedDecl *TemplParamPtr = TemplParam;
Richard Smith483b9f32011-02-21 20:05:19 +00003615 FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr,
3616 Loc);
3617
Richard Smitha085da82011-03-17 16:11:59 +00003618 TypeSourceInfo *FuncParamInfo =
Richard Smith34b41d92011-02-20 03:19:35 +00003619 SubstituteAutoTransform(*this, TemplArg).TransformType(Type);
Richard Smitha085da82011-03-17 16:11:59 +00003620 assert(FuncParamInfo && "substituting template parameter for 'auto' failed");
3621 QualType FuncParam = FuncParamInfo->getType();
Richard Smith34b41d92011-02-20 03:19:35 +00003622
3623 // Deduce type of TemplParam in Func(Init)
Chris Lattner5f9e2722011-07-23 10:55:15 +00003624 SmallVector<DeducedTemplateArgument, 1> Deduced;
Richard Smith34b41d92011-02-20 03:19:35 +00003625 Deduced.resize(1);
3626 QualType InitType = Init->getType();
3627 unsigned TDF = 0;
Richard Smith34b41d92011-02-20 03:19:35 +00003628
Craig Topper93e45992012-09-19 02:26:47 +00003629 TemplateDeductionInfo Info(Loc);
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003630
Richard Smith8ad6c862012-07-08 04:13:07 +00003631 InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003632 if (InitList) {
3633 for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
Richard Smith8ad6c862012-07-08 04:13:07 +00003634 if (DeduceTemplateArgumentByListElement(*this, &TemplateParams,
Douglas Gregord2803892012-04-04 05:10:53 +00003635 TemplArg,
3636 InitList->getInit(i),
3637 Info, Deduced, TDF))
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003638 return DAR_Failed;
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003639 }
3640 } else {
Douglas Gregord2803892012-04-04 05:10:53 +00003641 if (AdjustFunctionParmAndArgTypesForDeduction(*this, &TemplateParams,
3642 FuncParam, InitType, Init,
3643 TDF))
3644 return DAR_Failed;
Richard Smith8ad6c862012-07-08 04:13:07 +00003645
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003646 if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam,
3647 InitType, Info, Deduced, TDF))
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003648 return DAR_Failed;
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003649 }
Richard Smith34b41d92011-02-20 03:19:35 +00003650
Eli Friedman70a01892012-11-06 23:56:42 +00003651 if (Deduced[0].getKind() != TemplateArgument::Type)
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003652 return DAR_Failed;
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003653
Eli Friedman70a01892012-11-06 23:56:42 +00003654 QualType DeducedType = Deduced[0].getAsType();
3655
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003656 if (InitList) {
3657 DeducedType = BuildStdInitializerList(DeducedType, Loc);
3658 if (DeducedType.isNull())
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003659 return DAR_FailedAlreadyDiagnosed;
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003660 }
3661
Richard Smith34b41d92011-02-20 03:19:35 +00003662 Result = SubstituteAutoTransform(*this, DeducedType).TransformType(Type);
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003663
Douglas Gregor9a636e82011-06-17 05:31:46 +00003664 // Check that the deduced argument type is compatible with the original
3665 // argument type per C++ [temp.deduct.call]p4.
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003666 if (!InitList && Result &&
Douglas Gregor9a636e82011-06-17 05:31:46 +00003667 CheckOriginalCallArgDeduction(*this,
3668 Sema::OriginalCallArg(FuncParam,0,InitType),
3669 Result->getType())) {
3670 Result = 0;
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003671 return DAR_Failed;
Douglas Gregor9a636e82011-06-17 05:31:46 +00003672 }
3673
Sebastian Redlb832f6d2012-01-23 22:09:39 +00003674 return DAR_Succeeded;
Richard Smith34b41d92011-02-20 03:19:35 +00003675}
3676
Sebastian Redl62b7cfb2012-01-17 22:50:08 +00003677void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) {
3678 if (isa<InitListExpr>(Init))
3679 Diag(VDecl->getLocation(),
3680 diag::err_auto_var_deduction_failure_from_init_list)
3681 << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
3682 else
3683 Diag(VDecl->getLocation(), diag::err_auto_var_deduction_failure)
3684 << VDecl->getDeclName() << VDecl->getType() << Init->getType()
3685 << Init->getSourceRange();
3686}
3687
Douglas Gregor8a514912009-09-14 18:39:43 +00003688static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00003689MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
Douglas Gregore73bb602009-09-14 21:25:05 +00003690 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003691 unsigned Level,
Benjamin Kramer013b3662012-01-30 16:17:39 +00003692 llvm::SmallBitVector &Deduced);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003693
3694/// \brief If this is a non-static member function,
Eli Friedman407c8472012-09-19 23:52:13 +00003695static void AddImplicitObjectParameterType(ASTContext &Context,
Douglas Gregor77bc5722010-11-12 23:44:13 +00003696 CXXMethodDecl *Method,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003697 SmallVectorImpl<QualType> &ArgTypes) {
Eli Friedman407c8472012-09-19 23:52:13 +00003698 // C++11 [temp.func.order]p3:
3699 // [...] The new parameter is of type "reference to cv A," where cv are
3700 // the cv-qualifiers of the function template (if any) and A is
3701 // the class of which the function template is a member.
Douglas Gregor77bc5722010-11-12 23:44:13 +00003702 //
Eli Friedman407c8472012-09-19 23:52:13 +00003703 // The standard doesn't say explicitly, but we pick the appropriate kind of
3704 // reference type based on [over.match.funcs]p4.
Douglas Gregor77bc5722010-11-12 23:44:13 +00003705 QualType ArgTy = Context.getTypeDeclType(Method->getParent());
3706 ArgTy = Context.getQualifiedType(ArgTy,
3707 Qualifiers::fromCVRMask(Method->getTypeQualifiers()));
Eli Friedman407c8472012-09-19 23:52:13 +00003708 if (Method->getRefQualifier() == RQ_RValue)
3709 ArgTy = Context.getRValueReferenceType(ArgTy);
3710 else
3711 ArgTy = Context.getLValueReferenceType(ArgTy);
Douglas Gregor77bc5722010-11-12 23:44:13 +00003712 ArgTypes.push_back(ArgTy);
3713}
3714
Douglas Gregor8a514912009-09-14 18:39:43 +00003715/// \brief Determine whether the function template \p FT1 is at least as
3716/// specialized as \p FT2.
3717static bool isAtLeastAsSpecializedAs(Sema &S,
John McCall5769d612010-02-08 23:07:23 +00003718 SourceLocation Loc,
Douglas Gregor8a514912009-09-14 18:39:43 +00003719 FunctionTemplateDecl *FT1,
3720 FunctionTemplateDecl *FT2,
3721 TemplatePartialOrderingContext TPOC,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003722 unsigned NumCallArguments,
Chris Lattner5f9e2722011-07-23 10:55:15 +00003723 SmallVectorImpl<RefParamPartialOrderingComparison> *RefParamComparisons) {
Douglas Gregor8a514912009-09-14 18:39:43 +00003724 FunctionDecl *FD1 = FT1->getTemplatedDecl();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003725 FunctionDecl *FD2 = FT2->getTemplatedDecl();
Douglas Gregor8a514912009-09-14 18:39:43 +00003726 const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
3727 const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003728
Douglas Gregor8a514912009-09-14 18:39:43 +00003729 assert(Proto1 && Proto2 && "Function templates must have prototypes");
3730 TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
Chris Lattner5f9e2722011-07-23 10:55:15 +00003731 SmallVector<DeducedTemplateArgument, 4> Deduced;
Douglas Gregor8a514912009-09-14 18:39:43 +00003732 Deduced.resize(TemplateParams->size());
3733
3734 // C++0x [temp.deduct.partial]p3:
3735 // The types used to determine the ordering depend on the context in which
3736 // the partial ordering is done:
Craig Topper93e45992012-09-19 02:26:47 +00003737 TemplateDeductionInfo Info(Loc);
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003738 CXXMethodDecl *Method1 = 0;
3739 CXXMethodDecl *Method2 = 0;
3740 bool IsNonStatic2 = false;
3741 bool IsNonStatic1 = false;
3742 unsigned Skip2 = 0;
Douglas Gregor8a514912009-09-14 18:39:43 +00003743 switch (TPOC) {
3744 case TPOC_Call: {
3745 // - In the context of a function call, the function parameter types are
3746 // used.
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003747 Method1 = dyn_cast<CXXMethodDecl>(FD1);
3748 Method2 = dyn_cast<CXXMethodDecl>(FD2);
3749 IsNonStatic1 = Method1 && !Method1->isStatic();
3750 IsNonStatic2 = Method2 && !Method2->isStatic();
3751
Eli Friedman9cef0062012-09-19 23:27:04 +00003752 // C++11 [temp.func.order]p3:
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003753 // [...] If only one of the function templates is a non-static
3754 // member, that function template is considered to have a new
3755 // first parameter inserted in its function parameter list. The
3756 // new parameter is of type "reference to cv A," where cv are
3757 // the cv-qualifiers of the function template (if any) and A is
3758 // the class of which the function template is a member.
3759 //
Eli Friedman9cef0062012-09-19 23:27:04 +00003760 // Note that we interpret this to mean "if one of the function
3761 // templates is a non-static member and the other is a non-member";
3762 // otherwise, the ordering rules for static functions against non-static
3763 // functions don't make any sense.
3764 //
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003765 // C++98/03 doesn't have this provision, so instead we drop the
Eli Friedman9cef0062012-09-19 23:27:04 +00003766 // first argument of the free function, which seems to match
3767 // existing practice.
Chris Lattner5f9e2722011-07-23 10:55:15 +00003768 SmallVector<QualType, 4> Args1;
Richard Smith80ad52f2013-01-02 11:42:31 +00003769 unsigned Skip1 = !S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1;
3770 if (S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2)
Eli Friedman407c8472012-09-19 23:52:13 +00003771 AddImplicitObjectParameterType(S.Context, Method1, Args1);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003772 Args1.insert(Args1.end(),
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003773 Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end());
Douglas Gregor77bc5722010-11-12 23:44:13 +00003774
Chris Lattner5f9e2722011-07-23 10:55:15 +00003775 SmallVector<QualType, 4> Args2;
Richard Smith80ad52f2013-01-02 11:42:31 +00003776 Skip2 = !S.getLangOpts().CPlusPlus11 && IsNonStatic1 && !Method2;
3777 if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !Method1)
Eli Friedman407c8472012-09-19 23:52:13 +00003778 AddImplicitObjectParameterType(S.Context, Method2, Args2);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003779 Args2.insert(Args2.end(),
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003780 Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003781
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003782 // C++ [temp.func.order]p5:
3783 // The presence of unused ellipsis and default arguments has no effect on
3784 // the partial ordering of function templates.
3785 if (Args1.size() > NumCallArguments)
3786 Args1.resize(NumCallArguments);
3787 if (Args2.size() > NumCallArguments)
3788 Args2.resize(NumCallArguments);
3789 if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
3790 Args1.data(), Args1.size(), Info, Deduced,
3791 TDF_None, /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00003792 RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003793 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003794
Douglas Gregor8a514912009-09-14 18:39:43 +00003795 break;
3796 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003797
Douglas Gregor8a514912009-09-14 18:39:43 +00003798 case TPOC_Conversion:
3799 // - In the context of a call to a conversion operator, the return types
3800 // of the conversion function templates are used.
Sebastian Redlbb95e512012-01-17 22:49:52 +00003801 if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
3802 Proto2->getResultType(),
3803 Proto1->getResultType(),
3804 Info, Deduced, TDF_None,
3805 /*PartialOrdering=*/true,
3806 RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003807 return false;
3808 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003809
Douglas Gregor8a514912009-09-14 18:39:43 +00003810 case TPOC_Other:
NAKAMURA Takumi00995302011-01-27 07:09:49 +00003811 // - In other contexts (14.6.6.2) the function template's function type
Douglas Gregor8a514912009-09-14 18:39:43 +00003812 // is used.
Sebastian Redlbb95e512012-01-17 22:49:52 +00003813 if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
3814 FD2->getType(), FD1->getType(),
3815 Info, Deduced, TDF_None,
3816 /*PartialOrdering=*/true,
3817 RefParamComparisons))
Douglas Gregor8a514912009-09-14 18:39:43 +00003818 return false;
3819 break;
3820 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003821
Douglas Gregor8a514912009-09-14 18:39:43 +00003822 // C++0x [temp.deduct.partial]p11:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003823 // In most cases, all template parameters must have values in order for
3824 // deduction to succeed, but for partial ordering purposes a template
3825 // parameter may remain without a value provided it is not used in the
Douglas Gregor8a514912009-09-14 18:39:43 +00003826 // types being used for partial ordering. [ Note: a template parameter used
3827 // in a non-deduced context is considered used. -end note]
3828 unsigned ArgIdx = 0, NumArgs = Deduced.size();
3829 for (; ArgIdx != NumArgs; ++ArgIdx)
3830 if (Deduced[ArgIdx].isNull())
3831 break;
3832
3833 if (ArgIdx == NumArgs) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003834 // All template arguments were deduced. FT1 is at least as specialized
Douglas Gregor8a514912009-09-14 18:39:43 +00003835 // as FT2.
3836 return true;
3837 }
3838
Douglas Gregore73bb602009-09-14 21:25:05 +00003839 // Figure out which template parameters were used.
Benjamin Kramer013b3662012-01-30 16:17:39 +00003840 llvm::SmallBitVector UsedParameters(TemplateParams->size());
Douglas Gregor8a514912009-09-14 18:39:43 +00003841 switch (TPOC) {
3842 case TPOC_Call: {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003843 unsigned NumParams = std::min(NumCallArguments,
3844 std::min(Proto1->getNumArgs(),
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003845 Proto2->getNumArgs()));
Richard Smith80ad52f2013-01-02 11:42:31 +00003846 if (S.getLangOpts().CPlusPlus11 && IsNonStatic2 && !IsNonStatic1)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00003847 ::MarkUsedTemplateParameters(S.Context, Method2->getThisType(S.Context),
3848 false,
Douglas Gregor8d706ec2010-11-15 15:41:16 +00003849 TemplateParams->getDepth(), UsedParameters);
3850 for (unsigned I = Skip2; I < NumParams; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00003851 ::MarkUsedTemplateParameters(S.Context, Proto2->getArgType(I), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003852 TemplateParams->getDepth(),
Douglas Gregore73bb602009-09-14 21:25:05 +00003853 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003854 break;
3855 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003856
Douglas Gregor8a514912009-09-14 18:39:43 +00003857 case TPOC_Conversion:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00003858 ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003859 TemplateParams->getDepth(),
Douglas Gregore73bb602009-09-14 21:25:05 +00003860 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003861 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003862
Douglas Gregor8a514912009-09-14 18:39:43 +00003863 case TPOC_Other:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00003864 ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
Douglas Gregored9c0f92009-10-29 00:04:11 +00003865 TemplateParams->getDepth(),
3866 UsedParameters);
Douglas Gregor8a514912009-09-14 18:39:43 +00003867 break;
3868 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003869
Douglas Gregor8a514912009-09-14 18:39:43 +00003870 for (; ArgIdx != NumArgs; ++ArgIdx)
3871 // If this argument had no value deduced but was used in one of the types
3872 // used for partial ordering, then deduction fails.
3873 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
3874 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003875
Douglas Gregor8a514912009-09-14 18:39:43 +00003876 return true;
3877}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003878
Douglas Gregor9da95e62011-01-16 16:03:23 +00003879/// \brief Determine whether this a function template whose parameter-type-list
3880/// ends with a function parameter pack.
3881static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl) {
3882 FunctionDecl *Function = FunTmpl->getTemplatedDecl();
3883 unsigned NumParams = Function->getNumParams();
3884 if (NumParams == 0)
3885 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003886
Douglas Gregor9da95e62011-01-16 16:03:23 +00003887 ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
3888 if (!Last->isParameterPack())
3889 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003890
Douglas Gregor9da95e62011-01-16 16:03:23 +00003891 // Make sure that no previous parameter is a parameter pack.
3892 while (--NumParams > 0) {
3893 if (Function->getParamDecl(NumParams - 1)->isParameterPack())
3894 return false;
3895 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003896
Douglas Gregor9da95e62011-01-16 16:03:23 +00003897 return true;
3898}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003899
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003900/// \brief Returns the more specialized function template according
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003901/// to the rules of function template partial ordering (C++ [temp.func.order]).
3902///
3903/// \param FT1 the first function template
3904///
3905/// \param FT2 the second function template
3906///
Douglas Gregor8a514912009-09-14 18:39:43 +00003907/// \param TPOC the context in which we are performing partial ordering of
3908/// function templates.
Mike Stump1eb44332009-09-09 15:08:12 +00003909///
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003910/// \param NumCallArguments The number of arguments in a call, used only
3911/// when \c TPOC is \c TPOC_Call.
3912///
Douglas Gregorbf4ea562009-09-15 16:23:51 +00003913/// \returns the more specialized function template. If neither
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003914/// template is more specialized, returns NULL.
3915FunctionTemplateDecl *
3916Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
3917 FunctionTemplateDecl *FT2,
John McCall5769d612010-02-08 23:07:23 +00003918 SourceLocation Loc,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003919 TemplatePartialOrderingContext TPOC,
3920 unsigned NumCallArguments) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00003921 SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003922 bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003923 NumCallArguments, 0);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003924 bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00003925 NumCallArguments,
Douglas Gregorb939a192011-01-21 17:29:42 +00003926 &RefParamComparisons);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003927
Douglas Gregor8a514912009-09-14 18:39:43 +00003928 if (Better1 != Better2) // We have a clear winner
3929 return Better1? FT1 : FT2;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003930
Douglas Gregor8a514912009-09-14 18:39:43 +00003931 if (!Better1 && !Better2) // Neither is better than the other
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003932 return 0;
Douglas Gregor8a514912009-09-14 18:39:43 +00003933
Douglas Gregor8a514912009-09-14 18:39:43 +00003934 // C++0x [temp.deduct.partial]p10:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003935 // If for each type being considered a given template is at least as
Douglas Gregor8a514912009-09-14 18:39:43 +00003936 // specialized for all types and more specialized for some set of types and
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003937 // the other template is not more specialized for any types or is not at
Douglas Gregor8a514912009-09-14 18:39:43 +00003938 // least as specialized for any types, then the given template is more
3939 // specialized than the other template. Otherwise, neither template is more
3940 // specialized than the other.
3941 Better1 = false;
3942 Better2 = false;
Douglas Gregorb939a192011-01-21 17:29:42 +00003943 for (unsigned I = 0, N = RefParamComparisons.size(); I != N; ++I) {
Douglas Gregor8a514912009-09-14 18:39:43 +00003944 // C++0x [temp.deduct.partial]p9:
3945 // If, for a given type, deduction succeeds in both directions (i.e., the
Douglas Gregorb939a192011-01-21 17:29:42 +00003946 // types are identical after the transformations above) and both P and A
3947 // were reference types (before being replaced with the type referred to
3948 // above):
3949
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003950 // -- if the type from the argument template was an lvalue reference
Douglas Gregorb939a192011-01-21 17:29:42 +00003951 // and the type from the parameter template was not, the argument
3952 // type is considered to be more specialized than the other;
3953 // otherwise,
3954 if (!RefParamComparisons[I].ArgIsRvalueRef &&
3955 RefParamComparisons[I].ParamIsRvalueRef) {
3956 Better2 = true;
3957 if (Better1)
3958 return 0;
3959 continue;
3960 } else if (!RefParamComparisons[I].ParamIsRvalueRef &&
3961 RefParamComparisons[I].ArgIsRvalueRef) {
3962 Better1 = true;
3963 if (Better2)
3964 return 0;
3965 continue;
Douglas Gregor8a514912009-09-14 18:39:43 +00003966 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003967
Douglas Gregorb939a192011-01-21 17:29:42 +00003968 // -- if the type from the argument template is more cv-qualified than
3969 // the type from the parameter template (as described above), the
3970 // argument type is considered to be more specialized than the
3971 // other; otherwise,
3972 switch (RefParamComparisons[I].Qualifiers) {
3973 case NeitherMoreQualified:
3974 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003975
Douglas Gregorb939a192011-01-21 17:29:42 +00003976 case ParamMoreQualified:
3977 Better1 = true;
3978 if (Better2)
3979 return 0;
3980 continue;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003981
Douglas Gregorb939a192011-01-21 17:29:42 +00003982 case ArgMoreQualified:
3983 Better2 = true;
3984 if (Better1)
3985 return 0;
3986 continue;
3987 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003988
Douglas Gregorb939a192011-01-21 17:29:42 +00003989 // -- neither type is more specialized than the other.
Douglas Gregor8a514912009-09-14 18:39:43 +00003990 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003991
Douglas Gregor8a514912009-09-14 18:39:43 +00003992 assert(!(Better1 && Better2) && "Should have broken out in the loop above");
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00003993 if (Better1)
3994 return FT1;
Douglas Gregor8a514912009-09-14 18:39:43 +00003995 else if (Better2)
3996 return FT2;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00003997
Douglas Gregor9da95e62011-01-16 16:03:23 +00003998 // FIXME: This mimics what GCC implements, but doesn't match up with the
3999 // proposed resolution for core issue 692. This area needs to be sorted out,
4000 // but for now we attempt to maintain compatibility.
4001 bool Variadic1 = isVariadicFunctionTemplate(FT1);
4002 bool Variadic2 = isVariadicFunctionTemplate(FT2);
4003 if (Variadic1 != Variadic2)
4004 return Variadic1? FT2 : FT1;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004005
Douglas Gregor9da95e62011-01-16 16:03:23 +00004006 return 0;
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00004007}
Douglas Gregor83314aa2009-07-08 20:55:45 +00004008
Douglas Gregord5a423b2009-09-25 18:43:00 +00004009/// \brief Determine if the two templates are equivalent.
4010static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
4011 if (T1 == T2)
4012 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004013
Douglas Gregord5a423b2009-09-25 18:43:00 +00004014 if (!T1 || !T2)
4015 return false;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004016
Douglas Gregord5a423b2009-09-25 18:43:00 +00004017 return T1->getCanonicalDecl() == T2->getCanonicalDecl();
4018}
4019
4020/// \brief Retrieve the most specialized of the given function template
4021/// specializations.
4022///
John McCallc373d482010-01-27 01:50:18 +00004023/// \param SpecBegin the start iterator of the function template
4024/// specializations that we will be comparing.
Douglas Gregord5a423b2009-09-25 18:43:00 +00004025///
John McCallc373d482010-01-27 01:50:18 +00004026/// \param SpecEnd the end iterator of the function template
4027/// specializations, paired with \p SpecBegin.
Douglas Gregord5a423b2009-09-25 18:43:00 +00004028///
4029/// \param TPOC the partial ordering context to use to compare the function
4030/// template specializations.
4031///
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004032/// \param NumCallArguments The number of arguments in a call, used only
4033/// when \c TPOC is \c TPOC_Call.
4034///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004035/// \param Loc the location where the ambiguity or no-specializations
Douglas Gregord5a423b2009-09-25 18:43:00 +00004036/// diagnostic should occur.
4037///
4038/// \param NoneDiag partial diagnostic used to diagnose cases where there are
4039/// no matching candidates.
4040///
4041/// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
4042/// occurs.
4043///
4044/// \param CandidateDiag partial diagnostic used for each function template
4045/// specialization that is a candidate in the ambiguous ordering. One parameter
4046/// in this diagnostic should be unbound, which will correspond to the string
4047/// describing the template arguments for the function template specialization.
4048///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004049/// \returns the most specialized function template specialization, if
John McCallc373d482010-01-27 01:50:18 +00004050/// found. Otherwise, returns SpecEnd.
Douglas Gregord5a423b2009-09-25 18:43:00 +00004051///
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004052/// \todo FIXME: Consider passing in the "also-ran" candidates that failed
Douglas Gregord5a423b2009-09-25 18:43:00 +00004053/// template argument deduction.
John McCallc373d482010-01-27 01:50:18 +00004054UnresolvedSetIterator
4055Sema::getMostSpecialized(UnresolvedSetIterator SpecBegin,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004056 UnresolvedSetIterator SpecEnd,
John McCallc373d482010-01-27 01:50:18 +00004057 TemplatePartialOrderingContext TPOC,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004058 unsigned NumCallArguments,
John McCallc373d482010-01-27 01:50:18 +00004059 SourceLocation Loc,
4060 const PartialDiagnostic &NoneDiag,
4061 const PartialDiagnostic &AmbigDiag,
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004062 const PartialDiagnostic &CandidateDiag,
Richard Trieu6efd4c52011-11-23 22:32:32 +00004063 bool Complain,
4064 QualType TargetType) {
John McCallc373d482010-01-27 01:50:18 +00004065 if (SpecBegin == SpecEnd) {
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004066 if (Complain)
4067 Diag(Loc, NoneDiag);
John McCallc373d482010-01-27 01:50:18 +00004068 return SpecEnd;
Douglas Gregord5a423b2009-09-25 18:43:00 +00004069 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004070
4071 if (SpecBegin + 1 == SpecEnd)
John McCallc373d482010-01-27 01:50:18 +00004072 return SpecBegin;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004073
Douglas Gregord5a423b2009-09-25 18:43:00 +00004074 // Find the function template that is better than all of the templates it
4075 // has been compared to.
John McCallc373d482010-01-27 01:50:18 +00004076 UnresolvedSetIterator Best = SpecBegin;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004077 FunctionTemplateDecl *BestTemplate
John McCallc373d482010-01-27 01:50:18 +00004078 = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00004079 assert(BestTemplate && "Not a function template specialization?");
John McCallc373d482010-01-27 01:50:18 +00004080 for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
4081 FunctionTemplateDecl *Challenger
4082 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00004083 assert(Challenger && "Not a function template specialization?");
John McCallc373d482010-01-27 01:50:18 +00004084 if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004085 Loc, TPOC, NumCallArguments),
Douglas Gregord5a423b2009-09-25 18:43:00 +00004086 Challenger)) {
4087 Best = I;
4088 BestTemplate = Challenger;
4089 }
4090 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004091
Douglas Gregord5a423b2009-09-25 18:43:00 +00004092 // Make sure that the "best" function template is more specialized than all
4093 // of the others.
4094 bool Ambiguous = false;
John McCallc373d482010-01-27 01:50:18 +00004095 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
4096 FunctionTemplateDecl *Challenger
4097 = cast<FunctionDecl>(*I)->getPrimaryTemplate();
Douglas Gregord5a423b2009-09-25 18:43:00 +00004098 if (I != Best &&
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004099 !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004100 Loc, TPOC, NumCallArguments),
Douglas Gregord5a423b2009-09-25 18:43:00 +00004101 BestTemplate)) {
4102 Ambiguous = true;
4103 break;
4104 }
4105 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004106
Douglas Gregord5a423b2009-09-25 18:43:00 +00004107 if (!Ambiguous) {
4108 // We found an answer. Return it.
John McCallc373d482010-01-27 01:50:18 +00004109 return Best;
Douglas Gregord5a423b2009-09-25 18:43:00 +00004110 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004111
Douglas Gregord5a423b2009-09-25 18:43:00 +00004112 // Diagnose the ambiguity.
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004113 if (Complain)
4114 Diag(Loc, AmbigDiag);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004115
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004116 if (Complain)
Douglas Gregord5a423b2009-09-25 18:43:00 +00004117 // FIXME: Can we order the candidates in some sane way?
Richard Trieu6efd4c52011-11-23 22:32:32 +00004118 for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
4119 PartialDiagnostic PD = CandidateDiag;
4120 PD << getTemplateArgumentBindingsText(
Douglas Gregor1be8eec2011-02-19 21:32:49 +00004121 cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
John McCallc373d482010-01-27 01:50:18 +00004122 *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
Richard Trieu6efd4c52011-11-23 22:32:32 +00004123 if (!TargetType.isNull())
4124 HandleFunctionTypeMismatch(PD, cast<FunctionDecl>(*I)->getType(),
4125 TargetType);
4126 Diag((*I)->getLocation(), PD);
4127 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004128
John McCallc373d482010-01-27 01:50:18 +00004129 return SpecEnd;
Douglas Gregord5a423b2009-09-25 18:43:00 +00004130}
4131
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004132/// \brief Returns the more specialized class template partial specialization
4133/// according to the rules of partial ordering of class template partial
4134/// specializations (C++ [temp.class.order]).
4135///
4136/// \param PS1 the first class template partial specialization
4137///
4138/// \param PS2 the second class template partial specialization
4139///
4140/// \returns the more specialized class template partial specialization. If
4141/// neither partial specialization is more specialized, returns NULL.
4142ClassTemplatePartialSpecializationDecl *
4143Sema::getMoreSpecializedPartialSpecialization(
4144 ClassTemplatePartialSpecializationDecl *PS1,
John McCall5769d612010-02-08 23:07:23 +00004145 ClassTemplatePartialSpecializationDecl *PS2,
4146 SourceLocation Loc) {
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004147 // C++ [temp.class.order]p1:
4148 // For two class template partial specializations, the first is at least as
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004149 // specialized as the second if, given the following rewrite to two
4150 // function templates, the first function template is at least as
4151 // specialized as the second according to the ordering rules for function
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004152 // templates (14.6.6.2):
4153 // - the first function template has the same template parameters as the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004154 // first partial specialization and has a single function parameter
4155 // whose type is a class template specialization with the template
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004156 // arguments of the first partial specialization, and
4157 // - the second function template has the same template parameters as the
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004158 // second partial specialization and has a single function parameter
4159 // whose type is a class template specialization with the template
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004160 // arguments of the second partial specialization.
4161 //
Douglas Gregor31dce8f2010-04-29 06:21:43 +00004162 // Rather than synthesize function templates, we merely perform the
4163 // equivalent partial ordering by performing deduction directly on
4164 // the template arguments of the class template partial
4165 // specializations. This computation is slightly simpler than the
4166 // general problem of function template partial ordering, because
4167 // class template partial specializations are more constrained. We
4168 // know that every template parameter is deducible from the class
4169 // template partial specialization's template arguments, for
4170 // example.
Chris Lattner5f9e2722011-07-23 10:55:15 +00004171 SmallVector<DeducedTemplateArgument, 4> Deduced;
Craig Topper93e45992012-09-19 02:26:47 +00004172 TemplateDeductionInfo Info(Loc);
John McCall31f17ec2010-04-27 00:57:59 +00004173
4174 QualType PT1 = PS1->getInjectedSpecializationType();
4175 QualType PT2 = PS2->getInjectedSpecializationType();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004176
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004177 // Determine whether PS1 is at least as specialized as PS2
4178 Deduced.resize(PS2->getTemplateParameters()->size());
Sebastian Redlbb95e512012-01-17 22:49:52 +00004179 bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this,
4180 PS2->getTemplateParameters(),
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004181 PT2, PT1, Info, Deduced, TDF_None,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004182 /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00004183 /*RefParamComparisons=*/0);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004184 if (Better1) {
Richard Smith7e54fb52012-07-16 01:09:10 +00004185 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004186 InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2,
Richard Smith7e54fb52012-07-16 01:09:10 +00004187 DeducedArgs, Info);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004188 Better1 = !::FinishTemplateArgumentDeduction(*this, PS2,
4189 PS1->getTemplateArgs(),
Douglas Gregor516e6e02010-04-29 06:31:36 +00004190 Deduced, Info);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004191 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004192
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004193 // Determine whether PS2 is at least as specialized as PS1
Douglas Gregordb0d4b72009-11-11 23:06:43 +00004194 Deduced.clear();
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004195 Deduced.resize(PS1->getTemplateParameters()->size());
Sebastian Redlbb95e512012-01-17 22:49:52 +00004196 bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this,
4197 PS1->getTemplateParameters(),
Douglas Gregor5c7bf422011-01-11 17:34:58 +00004198 PT1, PT2, Info, Deduced, TDF_None,
4199 /*PartialOrdering=*/true,
Douglas Gregorb939a192011-01-21 17:29:42 +00004200 /*RefParamComparisons=*/0);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004201 if (Better2) {
Richard Smith7e54fb52012-07-16 01:09:10 +00004202 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004203 InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1,
Richard Smith7e54fb52012-07-16 01:09:10 +00004204 DeducedArgs, Info);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004205 Better2 = !::FinishTemplateArgumentDeduction(*this, PS1,
4206 PS2->getTemplateArgs(),
Douglas Gregor516e6e02010-04-29 06:31:36 +00004207 Deduced, Info);
Argyrios Kyrtzidis2c4792c2010-11-05 23:25:18 +00004208 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004209
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004210 if (Better1 == Better2)
4211 return 0;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004212
Douglas Gregorbf4ea562009-09-15 16:23:51 +00004213 return Better1? PS1 : PS2;
4214}
4215
Mike Stump1eb44332009-09-09 15:08:12 +00004216static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004217MarkUsedTemplateParameters(ASTContext &Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004218 const TemplateArgument &TemplateArg,
4219 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004220 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004221 llvm::SmallBitVector &Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004222
Douglas Gregore73bb602009-09-14 21:25:05 +00004223/// \brief Mark the template parameters that are used by the given
Douglas Gregor031a5882009-06-13 00:26:55 +00004224/// expression.
Mike Stump1eb44332009-09-09 15:08:12 +00004225static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004226MarkUsedTemplateParameters(ASTContext &Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004227 const Expr *E,
4228 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004229 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004230 llvm::SmallBitVector &Used) {
Douglas Gregorbe230c32011-01-03 17:17:50 +00004231 // We can deduce from a pack expansion.
4232 if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
4233 E = Expansion->getPattern();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004234
Richard Smith60983812012-07-09 03:07:20 +00004235 // Skip through any implicit casts we added while type-checking, and any
4236 // substitutions performed by template alias expansion.
4237 while (1) {
4238 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
4239 E = ICE->getSubExpr();
4240 else if (const SubstNonTypeTemplateParmExpr *Subst =
4241 dyn_cast<SubstNonTypeTemplateParmExpr>(E))
4242 E = Subst->getReplacement();
4243 else
4244 break;
4245 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004246
4247 // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
Douglas Gregore73bb602009-09-14 21:25:05 +00004248 // find other occurrences of template parameters.
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004249 const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
Douglas Gregorc781f9c2010-01-14 18:13:22 +00004250 if (!DRE)
Douglas Gregor031a5882009-06-13 00:26:55 +00004251 return;
4252
Mike Stump1eb44332009-09-09 15:08:12 +00004253 const NonTypeTemplateParmDecl *NTTP
Douglas Gregor031a5882009-06-13 00:26:55 +00004254 = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
4255 if (!NTTP)
4256 return;
4257
Douglas Gregored9c0f92009-10-29 00:04:11 +00004258 if (NTTP->getDepth() == Depth)
4259 Used[NTTP->getIndex()] = true;
Douglas Gregor031a5882009-06-13 00:26:55 +00004260}
4261
Douglas Gregore73bb602009-09-14 21:25:05 +00004262/// \brief Mark the template parameters that are used by the given
4263/// nested name specifier.
4264static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004265MarkUsedTemplateParameters(ASTContext &Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004266 NestedNameSpecifier *NNS,
4267 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004268 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004269 llvm::SmallBitVector &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00004270 if (!NNS)
4271 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004272
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004273 MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004274 Used);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004275 MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004276 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004277}
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004278
Douglas Gregore73bb602009-09-14 21:25:05 +00004279/// \brief Mark the template parameters that are used by the given
4280/// template name.
4281static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004282MarkUsedTemplateParameters(ASTContext &Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004283 TemplateName Name,
4284 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004285 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004286 llvm::SmallBitVector &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00004287 if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
4288 if (TemplateTemplateParmDecl *TTP
Douglas Gregored9c0f92009-10-29 00:04:11 +00004289 = dyn_cast<TemplateTemplateParmDecl>(Template)) {
4290 if (TTP->getDepth() == Depth)
4291 Used[TTP->getIndex()] = true;
4292 }
Douglas Gregore73bb602009-09-14 21:25:05 +00004293 return;
4294 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004295
Douglas Gregor788cd062009-11-11 01:00:40 +00004296 if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004297 MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced,
Douglas Gregor788cd062009-11-11 01:00:40 +00004298 Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004299 if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004300 MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004301 Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004302}
4303
4304/// \brief Mark the template parameters that are used by the given
Douglas Gregor031a5882009-06-13 00:26:55 +00004305/// type.
Mike Stump1eb44332009-09-09 15:08:12 +00004306static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004307MarkUsedTemplateParameters(ASTContext &Ctx, QualType T,
Douglas Gregore73bb602009-09-14 21:25:05 +00004308 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004309 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004310 llvm::SmallBitVector &Used) {
Douglas Gregore73bb602009-09-14 21:25:05 +00004311 if (T.isNull())
4312 return;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004313
Douglas Gregor031a5882009-06-13 00:26:55 +00004314 // Non-dependent types have nothing deducible
4315 if (!T->isDependentType())
4316 return;
4317
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004318 T = Ctx.getCanonicalType(T);
Douglas Gregor031a5882009-06-13 00:26:55 +00004319 switch (T->getTypeClass()) {
Douglas Gregor031a5882009-06-13 00:26:55 +00004320 case Type::Pointer:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004321 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004322 cast<PointerType>(T)->getPointeeType(),
4323 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004324 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004325 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004326 break;
4327
4328 case Type::BlockPointer:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004329 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004330 cast<BlockPointerType>(T)->getPointeeType(),
4331 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004332 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004333 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004334 break;
4335
4336 case Type::LValueReference:
4337 case Type::RValueReference:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004338 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004339 cast<ReferenceType>(T)->getPointeeType(),
4340 OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004341 Depth,
Douglas Gregore73bb602009-09-14 21:25:05 +00004342 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004343 break;
4344
4345 case Type::MemberPointer: {
4346 const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004347 MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004348 Depth, Used);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004349 MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004350 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004351 break;
4352 }
4353
4354 case Type::DependentSizedArray:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004355 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004356 cast<DependentSizedArrayType>(T)->getSizeExpr(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004357 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004358 // Fall through to check the element type
4359
4360 case Type::ConstantArray:
4361 case Type::IncompleteArray:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004362 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004363 cast<ArrayType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004364 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004365 break;
4366
4367 case Type::Vector:
4368 case Type::ExtVector:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004369 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004370 cast<VectorType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004371 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004372 break;
4373
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004374 case Type::DependentSizedExtVector: {
4375 const DependentSizedExtVectorType *VecType
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004376 = cast<DependentSizedExtVectorType>(T);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004377 MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004378 Depth, Used);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004379 MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004380 Depth, Used);
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00004381 break;
4382 }
4383
Douglas Gregor031a5882009-06-13 00:26:55 +00004384 case Type::FunctionProto: {
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004385 const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004386 MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004387 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004388 for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004389 MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004390 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004391 break;
4392 }
4393
Douglas Gregored9c0f92009-10-29 00:04:11 +00004394 case Type::TemplateTypeParm: {
4395 const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
4396 if (TTP->getDepth() == Depth)
4397 Used[TTP->getIndex()] = true;
Douglas Gregor031a5882009-06-13 00:26:55 +00004398 break;
Douglas Gregored9c0f92009-10-29 00:04:11 +00004399 }
Douglas Gregor031a5882009-06-13 00:26:55 +00004400
Douglas Gregor0bc15d92011-01-14 05:11:40 +00004401 case Type::SubstTemplateTypeParmPack: {
4402 const SubstTemplateTypeParmPackType *Subst
4403 = cast<SubstTemplateTypeParmPackType>(T);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004404 MarkUsedTemplateParameters(Ctx,
Douglas Gregor0bc15d92011-01-14 05:11:40 +00004405 QualType(Subst->getReplacedParameter(), 0),
4406 OnlyDeduced, Depth, Used);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004407 MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(),
Douglas Gregor0bc15d92011-01-14 05:11:40 +00004408 OnlyDeduced, Depth, Used);
4409 break;
4410 }
4411
John McCall31f17ec2010-04-27 00:57:59 +00004412 case Type::InjectedClassName:
4413 T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
4414 // fall through
4415
Douglas Gregor031a5882009-06-13 00:26:55 +00004416 case Type::TemplateSpecialization: {
Mike Stump1eb44332009-09-09 15:08:12 +00004417 const TemplateSpecializationType *Spec
Douglas Gregorf6ddb732009-06-18 18:45:36 +00004418 = cast<TemplateSpecializationType>(T);
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004419 MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004420 Depth, Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004421
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004422 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004423 // If the template argument list of P contains a pack expansion that is not
4424 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004425 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004426 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004427 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4428 break;
4429
Douglas Gregore73bb602009-09-14 21:25:05 +00004430 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004431 MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004432 Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004433 break;
4434 }
4435
Douglas Gregore73bb602009-09-14 21:25:05 +00004436 case Type::Complex:
4437 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004438 MarkUsedTemplateParameters(Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004439 cast<ComplexType>(T)->getElementType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004440 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004441 break;
4442
Eli Friedmanb001de72011-10-06 23:00:33 +00004443 case Type::Atomic:
4444 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004445 MarkUsedTemplateParameters(Ctx,
Eli Friedmanb001de72011-10-06 23:00:33 +00004446 cast<AtomicType>(T)->getValueType(),
4447 OnlyDeduced, Depth, Used);
4448 break;
4449
Douglas Gregor4714c122010-03-31 17:34:00 +00004450 case Type::DependentName:
Douglas Gregore73bb602009-09-14 21:25:05 +00004451 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004452 MarkUsedTemplateParameters(Ctx,
Douglas Gregor4714c122010-03-31 17:34:00 +00004453 cast<DependentNameType>(T)->getQualifier(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004454 OnlyDeduced, Depth, Used);
Douglas Gregore73bb602009-09-14 21:25:05 +00004455 break;
4456
John McCall33500952010-06-11 00:33:02 +00004457 case Type::DependentTemplateSpecialization: {
4458 const DependentTemplateSpecializationType *Spec
4459 = cast<DependentTemplateSpecializationType>(T);
4460 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004461 MarkUsedTemplateParameters(Ctx, Spec->getQualifier(),
John McCall33500952010-06-11 00:33:02 +00004462 OnlyDeduced, Depth, Used);
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004463
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004464 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004465 // If the template argument list of P contains a pack expansion that is not
4466 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004467 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004468 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004469 hasPackExpansionBeforeEnd(Spec->getArgs(), Spec->getNumArgs()))
4470 break;
4471
John McCall33500952010-06-11 00:33:02 +00004472 for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004473 MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
John McCall33500952010-06-11 00:33:02 +00004474 Used);
4475 break;
4476 }
4477
John McCallad5e7382010-03-01 23:49:17 +00004478 case Type::TypeOf:
4479 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004480 MarkUsedTemplateParameters(Ctx,
John McCallad5e7382010-03-01 23:49:17 +00004481 cast<TypeOfType>(T)->getUnderlyingType(),
4482 OnlyDeduced, Depth, Used);
4483 break;
4484
4485 case Type::TypeOfExpr:
4486 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004487 MarkUsedTemplateParameters(Ctx,
John McCallad5e7382010-03-01 23:49:17 +00004488 cast<TypeOfExprType>(T)->getUnderlyingExpr(),
4489 OnlyDeduced, Depth, Used);
4490 break;
4491
4492 case Type::Decltype:
4493 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004494 MarkUsedTemplateParameters(Ctx,
John McCallad5e7382010-03-01 23:49:17 +00004495 cast<DecltypeType>(T)->getUnderlyingExpr(),
4496 OnlyDeduced, Depth, Used);
4497 break;
4498
Sean Huntca63c202011-05-24 22:41:36 +00004499 case Type::UnaryTransform:
4500 if (!OnlyDeduced)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004501 MarkUsedTemplateParameters(Ctx,
Sean Huntca63c202011-05-24 22:41:36 +00004502 cast<UnaryTransformType>(T)->getUnderlyingType(),
4503 OnlyDeduced, Depth, Used);
4504 break;
4505
Douglas Gregor7536dd52010-12-20 02:24:11 +00004506 case Type::PackExpansion:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004507 MarkUsedTemplateParameters(Ctx,
Douglas Gregor7536dd52010-12-20 02:24:11 +00004508 cast<PackExpansionType>(T)->getPattern(),
4509 OnlyDeduced, Depth, Used);
4510 break;
4511
Richard Smith34b41d92011-02-20 03:19:35 +00004512 case Type::Auto:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004513 MarkUsedTemplateParameters(Ctx,
Richard Smith34b41d92011-02-20 03:19:35 +00004514 cast<AutoType>(T)->getDeducedType(),
4515 OnlyDeduced, Depth, Used);
4516
Douglas Gregore73bb602009-09-14 21:25:05 +00004517 // None of these types have any template parameters in them.
Douglas Gregor031a5882009-06-13 00:26:55 +00004518 case Type::Builtin:
Douglas Gregor031a5882009-06-13 00:26:55 +00004519 case Type::VariableArray:
4520 case Type::FunctionNoProto:
4521 case Type::Record:
4522 case Type::Enum:
Douglas Gregor031a5882009-06-13 00:26:55 +00004523 case Type::ObjCInterface:
John McCallc12c5bb2010-05-15 11:32:37 +00004524 case Type::ObjCObject:
Steve Naroffd1b3c2d2009-06-17 22:40:22 +00004525 case Type::ObjCObjectPointer:
John McCalled976492009-12-04 22:46:56 +00004526 case Type::UnresolvedUsing:
Douglas Gregor031a5882009-06-13 00:26:55 +00004527#define TYPE(Class, Base)
4528#define ABSTRACT_TYPE(Class, Base)
4529#define DEPENDENT_TYPE(Class, Base)
4530#define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
4531#include "clang/AST/TypeNodes.def"
4532 break;
4533 }
4534}
4535
Douglas Gregore73bb602009-09-14 21:25:05 +00004536/// \brief Mark the template parameters that are used by this
Douglas Gregor031a5882009-06-13 00:26:55 +00004537/// template argument.
Mike Stump1eb44332009-09-09 15:08:12 +00004538static void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004539MarkUsedTemplateParameters(ASTContext &Ctx,
Douglas Gregore73bb602009-09-14 21:25:05 +00004540 const TemplateArgument &TemplateArg,
4541 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004542 unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004543 llvm::SmallBitVector &Used) {
Douglas Gregor031a5882009-06-13 00:26:55 +00004544 switch (TemplateArg.getKind()) {
4545 case TemplateArgument::Null:
4546 case TemplateArgument::Integral:
Douglas Gregord2008e22012-04-06 22:40:38 +00004547 case TemplateArgument::Declaration:
Douglas Gregor031a5882009-06-13 00:26:55 +00004548 break;
Mike Stump1eb44332009-09-09 15:08:12 +00004549
Eli Friedmand7a6b162012-09-26 02:36:12 +00004550 case TemplateArgument::NullPtr:
4551 MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced,
4552 Depth, Used);
4553 break;
4554
Douglas Gregor031a5882009-06-13 00:26:55 +00004555 case TemplateArgument::Type:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004556 MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004557 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004558 break;
4559
Douglas Gregor788cd062009-11-11 01:00:40 +00004560 case TemplateArgument::Template:
Douglas Gregora7fc9012011-01-05 18:58:31 +00004561 case TemplateArgument::TemplateExpansion:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004562 MarkUsedTemplateParameters(Ctx,
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004563 TemplateArg.getAsTemplateOrTemplatePattern(),
Douglas Gregor788cd062009-11-11 01:00:40 +00004564 OnlyDeduced, Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004565 break;
4566
4567 case TemplateArgument::Expression:
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004568 MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004569 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004570 break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004571
Anders Carlssond01b1da2009-06-15 17:04:53 +00004572 case TemplateArgument::Pack:
Douglas Gregore73bb602009-09-14 21:25:05 +00004573 for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
4574 PEnd = TemplateArg.pack_end();
4575 P != PEnd; ++P)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004576 MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used);
Anders Carlssond01b1da2009-06-15 17:04:53 +00004577 break;
Douglas Gregor031a5882009-06-13 00:26:55 +00004578 }
4579}
4580
James Dennett16ae9de2012-06-22 10:16:05 +00004581/// \brief Mark which template parameters can be deduced from a given
Douglas Gregor031a5882009-06-13 00:26:55 +00004582/// template argument list.
4583///
4584/// \param TemplateArgs the template argument list from which template
4585/// parameters will be deduced.
4586///
James Dennett16ae9de2012-06-22 10:16:05 +00004587/// \param Used a bit vector whose elements will be set to \c true
Douglas Gregor031a5882009-06-13 00:26:55 +00004588/// to indicate when the corresponding template parameter will be
4589/// deduced.
Mike Stump1eb44332009-09-09 15:08:12 +00004590void
Douglas Gregore73bb602009-09-14 21:25:05 +00004591Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004592 bool OnlyDeduced, unsigned Depth,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004593 llvm::SmallBitVector &Used) {
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004594 // C++0x [temp.deduct.type]p9:
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004595 // If the template argument list of P contains a pack expansion that is not
4596 // the last template argument, the entire template argument list is a
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004597 // non-deduced context.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004598 if (OnlyDeduced &&
Douglas Gregor7b976ec2010-12-23 01:24:45 +00004599 hasPackExpansionBeforeEnd(TemplateArgs.data(), TemplateArgs.size()))
4600 return;
4601
Douglas Gregor031a5882009-06-13 00:26:55 +00004602 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004603 ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00004604 Depth, Used);
Douglas Gregor031a5882009-06-13 00:26:55 +00004605}
Douglas Gregor63f07c52009-09-18 23:21:38 +00004606
4607/// \brief Marks all of the template parameters that will be deduced by a
4608/// call to the given function template.
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004609void
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004610Sema::MarkDeducedTemplateParameters(ASTContext &Ctx,
Dmitri Gribenko89cf4252013-01-23 17:21:11 +00004611 const FunctionTemplateDecl *FunctionTemplate,
Benjamin Kramer013b3662012-01-30 16:17:39 +00004612 llvm::SmallBitVector &Deduced) {
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004613 TemplateParameterList *TemplateParams
Douglas Gregor63f07c52009-09-18 23:21:38 +00004614 = FunctionTemplate->getTemplateParameters();
4615 Deduced.clear();
4616 Deduced.resize(TemplateParams->size());
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +00004617
Douglas Gregor63f07c52009-09-18 23:21:38 +00004618 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
4619 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004620 ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(),
Douglas Gregored9c0f92009-10-29 00:04:11 +00004621 true, TemplateParams->getDepth(), Deduced);
Douglas Gregor63f07c52009-09-18 23:21:38 +00004622}
Douglas Gregordbfb3712011-06-16 16:50:48 +00004623
4624bool hasDeducibleTemplateParameters(Sema &S,
4625 FunctionTemplateDecl *FunctionTemplate,
4626 QualType T) {
4627 if (!T->isDependentType())
4628 return false;
4629
4630 TemplateParameterList *TemplateParams
4631 = FunctionTemplate->getTemplateParameters();
Benjamin Kramer013b3662012-01-30 16:17:39 +00004632 llvm::SmallBitVector Deduced(TemplateParams->size());
Argyrios Kyrtzidis6fc9e1d2012-01-17 02:15:41 +00004633 ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
Douglas Gregordbfb3712011-06-16 16:50:48 +00004634 Deduced);
4635
Benjamin Kramer013b3662012-01-30 16:17:39 +00004636 return Deduced.any();
Douglas Gregordbfb3712011-06-16 16:50:48 +00004637}