 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
76.0% |
495 / 651 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
92.3% |
601 / 651 |
| |
|
Line Coverage: |
84.5% |
710 / 840 |
| |
 |
|
 |
1 : //===------- 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 :
13 : #include "Sema.h"
14 : #include "clang/AST/ASTContext.h"
15 : #include "clang/AST/DeclTemplate.h"
16 : #include "clang/AST/StmtVisitor.h"
17 : #include "clang/AST/Expr.h"
18 : #include "clang/AST/ExprCXX.h"
19 : #include "clang/Parse/DeclSpec.h"
20 : #include <algorithm>
21 :
22 : namespace clang {
23 : /// \brief Various flags that control template argument deduction.
24 : ///
25 : /// These flags can be bitwise-OR'd together.
26 : enum TemplateDeductionFlags {
27 : /// \brief No template argument deduction flags, which indicates the
28 : /// strictest results for template argument deduction (as used for, e.g.,
29 : /// matching class template partial specializations).
30 : TDF_None = 0,
31 : /// \brief Within template argument deduction from a function call, we are
32 : /// matching with a parameter type for which the original parameter was
33 : /// a reference.
34 : TDF_ParamWithReferenceType = 0x1,
35 : /// \brief Within template argument deduction from a function call, we
36 : /// are matching in a case where we ignore cv-qualifiers.
37 : TDF_IgnoreQualifiers = 0x02,
38 : /// \brief Within template argument deduction from a function call,
39 : /// we are matching in a case where we can perform template argument
40 : /// deduction from a template-id of a derived class of the argument type.
41 : TDF_DerivedClass = 0x04,
42 : /// \brief Allow non-dependent types to differ, e.g., when performing
43 : /// template argument deduction from a function call where conversions
44 : /// may apply.
45 : TDF_SkipNonDependent = 0x08
46 : };
47 : }
48 :
49 : using namespace clang;
50 :
51 : static Sema::TemplateDeductionResult
52 : DeduceTemplateArguments(Sema &S,
53 : TemplateParameterList *TemplateParams,
54 : const TemplateArgument &Param,
55 : const TemplateArgument &Arg,
56 : Sema::TemplateDeductionInfo &Info,
57 : llvm::SmallVectorImpl<TemplateArgument> &Deduced);
58 :
59 : /// \brief If the given expression is of a form that permits the deduction
60 : /// of a non-type template parameter, return the declaration of that
61 : /// non-type template parameter.
62 490: static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) {
0: branch 1 not taken
490: branch 2 taken
63 490: if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
64 0: E = IC->getSubExpr();
65 :
488: branch 1 taken
2: branch 2 taken
66 490: if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
67 488: return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
68 :
69 2: return 0;
70 : }
71 :
72 : /// \brief Deduce the value of the given non-type template parameter
73 : /// from the given constant.
74 : static Sema::TemplateDeductionResult
75 : DeduceNonTypeTemplateArgument(Sema &S,
76 : NonTypeTemplateParmDecl *NTTP,
77 : llvm::APSInt Value,
78 : Sema::TemplateDeductionInfo &Info,
79 475: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
80 : assert(NTTP->getDepth() == 0 &&
475: branch 1 taken
0: branch 2 not taken
81 475: "Cannot deduce non-type template argument with depth > 0");
82 :
472: branch 3 taken
3: branch 4 taken
83 475: if (Deduced[NTTP->getIndex()].isNull()) {
84 472: QualType T = NTTP->getType();
85 :
86 : // FIXME: Make sure we didn't overflow our data type!
87 472: unsigned AllowedBits = S.Context.getTypeSize(T);
0: branch 1 not taken
472: branch 2 taken
88 472: if (Value.getBitWidth() != AllowedBits)
89 0: Value.extOrTrunc(AllowedBits);
90 472: Value.setIsSigned(T->isSignedIntegerType());
91 :
92 472: Deduced[NTTP->getIndex()] = TemplateArgument(Value, T);
93 472: return Sema::TDK_Success;
94 : }
95 :
0: branch 3 not taken
3: branch 4 taken
96 3: assert(Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral);
97 :
98 : // If the template argument was previously deduced to a negative value,
99 : // then our deduction fails.
100 3: const llvm::APSInt *PrevValuePtr = Deduced[NTTP->getIndex()].getAsIntegral();
0: branch 1 not taken
3: branch 2 taken
101 3: if (PrevValuePtr->isNegative()) {
102 0: Info.Param = NTTP;
103 0: Info.FirstArg = Deduced[NTTP->getIndex()];
104 0: Info.SecondArg = TemplateArgument(Value, NTTP->getType());
105 0: return Sema::TDK_Inconsistent;
106 : }
107 :
108 3: llvm::APSInt PrevValue = *PrevValuePtr;
0: branch 2 not taken
3: branch 3 taken
109 3: if (Value.getBitWidth() > PrevValue.getBitWidth())
110 0: PrevValue.zext(Value.getBitWidth());
0: branch 2 not taken
3: branch 3 taken
111 3: else if (Value.getBitWidth() < PrevValue.getBitWidth())
112 0: Value.zext(PrevValue.getBitWidth());
113 :
1: branch 1 taken
2: branch 2 taken
114 3: if (Value != PrevValue) {
115 1: Info.Param = NTTP;
116 1: Info.FirstArg = Deduced[NTTP->getIndex()];
117 1: Info.SecondArg = TemplateArgument(Value, NTTP->getType());
118 1: return Sema::TDK_Inconsistent;
119 : }
120 :
121 2: return Sema::TDK_Success;
122 : }
123 :
124 : /// \brief Deduce the value of the given non-type template parameter
125 : /// from the given type- or value-dependent expression.
126 : ///
127 : /// \returns true if deduction succeeded, false otherwise.
128 : static Sema::TemplateDeductionResult
129 : DeduceNonTypeTemplateArgument(Sema &S,
130 : NonTypeTemplateParmDecl *NTTP,
131 : Expr *Value,
132 : Sema::TemplateDeductionInfo &Info,
133 10: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
134 : assert(NTTP->getDepth() == 0 &&
10: branch 1 taken
0: branch 2 not taken
135 10: "Cannot deduce non-type template argument with depth > 0");
136 : assert((Value->isTypeDependent() || Value->isValueDependent()) &&
10: branch 1 taken
0: branch 2 not taken
10: branch 4 taken
0: branch 5 not taken
137 20: "Expression template argument must be type- or value-dependent.");
138 :
8: branch 3 taken
2: branch 4 taken
139 10: if (Deduced[NTTP->getIndex()].isNull()) {
140 : // FIXME: Clone the Value?
141 8: Deduced[NTTP->getIndex()] = TemplateArgument(Value);
142 8: return Sema::TDK_Success;
143 : }
144 :
0: branch 3 not taken
2: branch 4 taken
145 2: if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Integral) {
146 : // Okay, we deduced a constant in one case and a dependent expression
147 : // in another case. FIXME: Later, we will check that instantiating the
148 : // dependent expression gives us the constant value.
149 0: return Sema::TDK_Success;
150 : }
151 :
2: branch 3 taken
0: branch 4 not taken
152 2: if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Expression) {
153 : // Compare the expressions for equality
154 2: llvm::FoldingSetNodeID ID1, ID2;
155 2: Deduced[NTTP->getIndex()].getAsExpr()->Profile(ID1, S.Context, true);
156 2: Value->Profile(ID2, S.Context, true);
0: branch 1 not taken
2: branch 2 taken
157 2: if (ID1 == ID2)
158 0: return Sema::TDK_Success;
159 :
160 : // FIXME: Fill in argument mismatch information
161 2: return Sema::TDK_NonDeducedMismatch;
162 : }
163 :
164 0: return Sema::TDK_Success;
165 : }
166 :
167 : /// \brief Deduce the value of the given non-type template parameter
168 : /// from the given declaration.
169 : ///
170 : /// \returns true if deduction succeeded, false otherwise.
171 : static Sema::TemplateDeductionResult
172 : DeduceNonTypeTemplateArgument(Sema &S,
173 : NonTypeTemplateParmDecl *NTTP,
174 : Decl *D,
175 : Sema::TemplateDeductionInfo &Info,
176 1: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
177 : assert(NTTP->getDepth() == 0 &&
1: branch 1 taken
0: branch 2 not taken
178 1: "Cannot deduce non-type template argument with depth > 0");
179 :
1: branch 3 taken
0: branch 4 not taken
180 1: if (Deduced[NTTP->getIndex()].isNull()) {
181 1: Deduced[NTTP->getIndex()] = TemplateArgument(D->getCanonicalDecl());
182 1: return Sema::TDK_Success;
183 : }
184 :
0: branch 3 not taken
0: branch 4 not taken
185 0: if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Expression) {
186 : // Okay, we deduced a declaration in one case and a dependent expression
187 : // in another case.
188 0: return Sema::TDK_Success;
189 : }
190 :
0: branch 3 not taken
0: branch 4 not taken
191 0: if (Deduced[NTTP->getIndex()].getKind() == TemplateArgument::Declaration) {
192 : // Compare the declarations for equality
0: branch 5 not taken
0: branch 6 not taken
193 0: if (Deduced[NTTP->getIndex()].getAsDecl()->getCanonicalDecl() ==
194 : D->getCanonicalDecl())
195 0: return Sema::TDK_Success;
196 :
197 : // FIXME: Fill in argument mismatch information
198 0: return Sema::TDK_NonDeducedMismatch;
199 : }
200 :
201 0: return Sema::TDK_Success;
202 : }
203 :
204 : static Sema::TemplateDeductionResult
205 : DeduceTemplateArguments(Sema &S,
206 : TemplateParameterList *TemplateParams,
207 : TemplateName Param,
208 : TemplateName Arg,
209 : Sema::TemplateDeductionInfo &Info,
210 164: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
211 164: TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
0: branch 0 not taken
164: branch 1 taken
212 164: if (!ParamDecl) {
213 : // The parameter type is dependent and is not a template template parameter,
214 : // so there is nothing that we can deduce.
215 0: return Sema::TDK_Success;
216 : }
217 :
22: branch 0 taken
142: branch 1 taken
218 164: if (TemplateTemplateParmDecl *TempParam
219 164: = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
220 : // Bind the template template parameter to the given template name.
221 22: TemplateArgument &ExistingArg = Deduced[TempParam->getIndex()];
22: branch 1 taken
0: branch 2 not taken
222 22: if (ExistingArg.isNull()) {
223 : // This is the first deduction for this template template parameter.
224 22: ExistingArg = TemplateArgument(S.Context.getCanonicalTemplateName(Arg));
225 22: return Sema::TDK_Success;
226 : }
227 :
228 : // Verify that the previous binding matches this deduction.
0: branch 1 not taken
0: branch 2 not taken
229 0: assert(ExistingArg.getKind() == TemplateArgument::Template);
0: branch 2 not taken
0: branch 3 not taken
230 0: if (S.Context.hasSameTemplateName(ExistingArg.getAsTemplate(), Arg))
231 0: return Sema::TDK_Success;
232 :
233 : // Inconsistent deduction.
234 0: Info.Param = TempParam;
235 0: Info.FirstArg = ExistingArg;
236 0: Info.SecondArg = TemplateArgument(Arg);
237 0: return Sema::TDK_Inconsistent;
238 : }
239 :
240 : // Verify that the two template names are equivalent.
140: branch 1 taken
2: branch 2 taken
241 142: if (S.Context.hasSameTemplateName(Param, Arg))
242 140: return Sema::TDK_Success;
243 :
244 : // Mismatch of non-dependent template parameter to argument.
245 2: Info.FirstArg = TemplateArgument(Param);
246 2: Info.SecondArg = TemplateArgument(Arg);
247 2: return Sema::TDK_NonDeducedMismatch;
248 : }
249 :
250 : /// \brief Deduce the template arguments by comparing the template parameter
251 : /// type (which is a template-id) with the template argument type.
252 : ///
253 : /// \param S the Sema
254 : ///
255 : /// \param TemplateParams the template parameters that we are deducing
256 : ///
257 : /// \param Param the parameter type
258 : ///
259 : /// \param Arg the argument type
260 : ///
261 : /// \param Info information about the template argument deduction itself
262 : ///
263 : /// \param Deduced the deduced template arguments
264 : ///
265 : /// \returns the result of template argument deduction so far. Note that a
266 : /// "success" result means that template argument deduction has not yet failed,
267 : /// but it may still fail, later, for other reasons.
268 : static Sema::TemplateDeductionResult
269 : DeduceTemplateArguments(Sema &S,
270 : TemplateParameterList *TemplateParams,
271 : const TemplateSpecializationType *Param,
272 : QualType Arg,
273 : Sema::TemplateDeductionInfo &Info,
274 189: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
189: branch 1 taken
0: branch 2 not taken
275 189: assert(Arg.isCanonical() && "Argument type must be canonical");
276 :
277 : // Check whether the template argument is a dependent template-id.
60: branch 0 taken
129: branch 1 taken
278 189: if (const TemplateSpecializationType *SpecArg
279 189: = dyn_cast<TemplateSpecializationType>(Arg)) {
280 : // Perform template argument deduction for the template name.
0: branch 0 not taken
60: branch 1 taken
281 60: if (Sema::TemplateDeductionResult Result
282 : = DeduceTemplateArguments(S, TemplateParams,
283 : Param->getTemplateName(),
284 : SpecArg->getTemplateName(),
285 60: Info, Deduced))
286 0: return Result;
287 :
288 :
289 : // Perform template argument deduction on each template
290 : // argument.
291 60: unsigned NumArgs = std::min(SpecArg->getNumArgs(), Param->getNumArgs());
101: branch 0 taken
28: branch 1 taken
292 129: for (unsigned I = 0; I != NumArgs; ++I)
32: branch 0 taken
69: branch 1 taken
293 101: if (Sema::TemplateDeductionResult Result
294 : = DeduceTemplateArguments(S, TemplateParams,
295 : Param->getArg(I),
296 : SpecArg->getArg(I),
297 101: Info, Deduced))
298 32: return Result;
299 :
300 28: return Sema::TDK_Success;
301 : }
302 :
303 : // If the argument type is a class template specialization, we
304 : // perform template argument deduction using its template
305 : // arguments.
306 129: const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
10: branch 0 taken
119: branch 1 taken
307 129: if (!RecordArg)
308 10: return Sema::TDK_NonDeducedMismatch;
309 :
310 : ClassTemplateSpecializationDecl *SpecArg
311 119: = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
16: branch 0 taken
103: branch 1 taken
312 119: if (!SpecArg)
313 16: return Sema::TDK_NonDeducedMismatch;
314 :
315 : // Perform template argument deduction for the template name.
2: branch 0 taken
101: branch 1 taken
316 103: if (Sema::TemplateDeductionResult Result
317 : = DeduceTemplateArguments(S,
318 : TemplateParams,
319 : Param->getTemplateName(),
320 : TemplateName(SpecArg->getSpecializedTemplate()),
321 103: Info, Deduced))
322 2: return Result;
323 :
324 101: unsigned NumArgs = Param->getNumArgs();
325 101: const TemplateArgumentList &ArgArgs = SpecArg->getTemplateArgs();
7: branch 1 taken
94: branch 2 taken
326 101: if (NumArgs != ArgArgs.size())
327 7: return Sema::TDK_NonDeducedMismatch;
328 :
141: branch 0 taken
82: branch 1 taken
329 223: for (unsigned I = 0; I != NumArgs; ++I)
12: branch 0 taken
129: branch 1 taken
330 141: if (Sema::TemplateDeductionResult Result
331 : = DeduceTemplateArguments(S, TemplateParams,
332 : Param->getArg(I),
333 : ArgArgs.get(I),
334 141: Info, Deduced))
335 12: return Result;
336 :
337 82: return Sema::TDK_Success;
338 : }
339 :
340 : /// \brief Deduce the template arguments by comparing the parameter type and
341 : /// the argument type (C++ [temp.deduct.type]).
342 : ///
343 : /// \param S the semantic analysis object within which we are deducing
344 : ///
345 : /// \param TemplateParams the template parameters that we are deducing
346 : ///
347 : /// \param ParamIn the parameter type
348 : ///
349 : /// \param ArgIn the argument type
350 : ///
351 : /// \param Info information about the template argument deduction itself
352 : ///
353 : /// \param Deduced the deduced template arguments
354 : ///
355 : /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
356 : /// how template argument deduction is performed.
357 : ///
358 : /// \returns the result of template argument deduction so far. Note that a
359 : /// "success" result means that template argument deduction has not yet failed,
360 : /// but it may still fail, later, for other reasons.
361 : static Sema::TemplateDeductionResult
362 : DeduceTemplateArguments(Sema &S,
363 : TemplateParameterList *TemplateParams,
364 : QualType ParamIn, QualType ArgIn,
365 : Sema::TemplateDeductionInfo &Info,
366 : llvm::SmallVectorImpl<TemplateArgument> &Deduced,
367 3056: unsigned TDF) {
368 : // We only want to look at the canonical types, since typedefs and
369 : // sugar are not part of template argument deduction.
370 3056: QualType Param = S.Context.getCanonicalType(ParamIn);
371 3056: QualType Arg = S.Context.getCanonicalType(ArgIn);
372 :
373 : // C++0x [temp.deduct.call]p4 bullet 1:
374 : // - If the original P is a reference type, the deduced A (i.e., the type
375 : // referred to by the reference) can be more cv-qualified than the
376 : // transformed A.
129: branch 0 taken
2927: branch 1 taken
377 3056: if (TDF & TDF_ParamWithReferenceType) {
378 129: Qualifiers Quals;
379 129: QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
380 : Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
381 129: Arg.getCVRQualifiersThroughArrayTypes());
382 129: Param = S.Context.getQualifiedType(UnqualParam, Quals);
383 : }
384 :
385 : // If the parameter type is not dependent, there is nothing to deduce.
444: branch 2 taken
2612: branch 3 taken
386 3056: if (!Param->isDependentType()) {
342: branch 0 taken
102: branch 1 taken
69: branch 3 taken
273: branch 4 taken
69: branch 5 taken
375: branch 6 taken
387 444: if (!(TDF & TDF_SkipNonDependent) && Param != Arg) {
388 :
389 69: return Sema::TDK_NonDeducedMismatch;
390 : }
391 :
392 375: return Sema::TDK_Success;
393 : }
394 :
395 : // C++ [temp.deduct.type]p9:
396 : // A template type argument T, a template template argument TT or a
397 : // template non-type argument i can be deduced if P and A have one of
398 : // the following forms:
399 : //
400 : // T
401 : // cv-list T
1508: branch 0 taken
1104: branch 1 taken
402 2612: if (const TemplateTypeParmType *TemplateTypeParm
403 2612: = Param->getAs<TemplateTypeParmType>()) {
404 1508: unsigned Index = TemplateTypeParm->getIndex();
405 1508: bool RecanonicalizeArg = false;
406 :
407 : // If the argument type is an array type, move the qualifiers up to the
408 : // top level, so they can be matched with the qualifiers on the parameter.
409 : // FIXME: address spaces, ObjC GC qualifiers
17: branch 1 taken
1491: branch 2 taken
410 1508: if (isa<ArrayType>(Arg)) {
411 17: Qualifiers Quals;
412 17: Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
10: branch 1 taken
7: branch 2 taken
413 17: if (Quals) {
414 10: Arg = S.Context.getQualifiedType(Arg, Quals);
415 10: RecanonicalizeArg = true;
416 : }
417 : }
418 :
419 : // The argument type can not be less qualified than the parameter
420 : // type.
33: branch 1 taken
1475: branch 2 taken
32: branch 3 taken
1: branch 4 taken
32: branch 5 taken
1476: branch 6 taken
421 1508: if (Param.isMoreQualifiedThan(Arg) && !(TDF & TDF_IgnoreQualifiers)) {
422 32: Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
423 32: Info.FirstArg = Deduced[Index];
424 32: Info.SecondArg = TemplateArgument(Arg);
425 32: return Sema::TDK_InconsistentQuals;
426 : }
427 :
1476: branch 1 taken
0: branch 2 not taken
428 1476: assert(TemplateTypeParm->getDepth() == 0 && "Can't deduce with depth > 0");
1476: branch 2 taken
0: branch 3 not taken
429 1476: assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
430 1476: QualType DeducedType = Arg;
431 1476: DeducedType.removeCVRQualifiers(Param.getCVRQualifiers());
10: branch 0 taken
1466: branch 1 taken
432 1476: if (RecanonicalizeArg)
433 10: DeducedType = S.Context.getCanonicalType(DeducedType);
434 :
1159: branch 2 taken
317: branch 3 taken
435 1476: if (Deduced[Index].isNull())
436 1159: Deduced[Index] = TemplateArgument(DeducedType);
437 : else {
438 : // C++ [temp.deduct.type]p2:
439 : // [...] If type deduction cannot be done for any P/A pair, or if for
440 : // any pair the deduction leads to more than one possible set of
441 : // deduced values, or if different pairs yield different deduced
442 : // values, or if any template argument remains neither deduced nor
443 : // explicitly specified, template argument deduction fails.
46: branch 3 taken
271: branch 4 taken
444 317: if (Deduced[Index].getAsType() != DeducedType) {
445 : Info.Param
446 46: = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
447 46: Info.FirstArg = Deduced[Index];
448 46: Info.SecondArg = TemplateArgument(Arg);
449 46: return Sema::TDK_Inconsistent;
450 : }
451 : }
452 1430: return Sema::TDK_Success;
453 : }
454 :
455 : // Set up the template argument deduction information for a failure.
456 1104: Info.FirstArg = TemplateArgument(ParamIn);
457 1104: Info.SecondArg = TemplateArgument(ArgIn);
458 :
459 : // Check the cv-qualifiers on the parameter and argument types.
1010: branch 0 taken
94: branch 1 taken
460 1104: if (!(TDF & TDF_IgnoreQualifiers)) {
39: branch 0 taken
971: branch 1 taken
461 1010: if (TDF & TDF_ParamWithReferenceType) {
0: branch 1 not taken
39: branch 2 taken
462 39: if (Param.isMoreQualifiedThan(Arg))
463 0: return Sema::TDK_NonDeducedMismatch;
464 : } else {
5: branch 2 taken
966: branch 3 taken
465 971: if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
466 5: return Sema::TDK_NonDeducedMismatch;
467 : }
468 : }
469 :
0: branch 2 not taken
259: branch 3 taken
51: branch 4 taken
0: branch 5 not taken
6: branch 6 taken
8: branch 7 taken
27: branch 8 taken
503: branch 9 taken
177: branch 10 taken
47: branch 11 taken
11: branch 12 taken
10: branch 13 taken
0: branch 14 not taken
470 1099: switch (Param->getTypeClass()) {
471 : // No deduction possible for these types
472 : case Type::Builtin:
473 0: return Sema::TDK_NonDeducedMismatch;
474 :
475 : // T *
476 : case Type::Pointer: {
477 259: const PointerType *PointerArg = Arg->getAs<PointerType>();
46: branch 0 taken
213: branch 1 taken
478 259: if (!PointerArg)
479 46: return Sema::TDK_NonDeducedMismatch;
480 :
481 213: unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
482 : return DeduceTemplateArguments(S, TemplateParams,
483 : cast<PointerType>(Param)->getPointeeType(),
484 : PointerArg->getPointeeType(),
485 213: Info, Deduced, SubTDF);
486 : }
487 :
488 : // T &
489 : case Type::LValueReference: {
490 51: const LValueReferenceType *ReferenceArg = Arg->getAs<LValueReferenceType>();
2: branch 0 taken
49: branch 1 taken
491 51: if (!ReferenceArg)
492 2: return Sema::TDK_NonDeducedMismatch;
493 :
494 : return DeduceTemplateArguments(S, TemplateParams,
495 : cast<LValueReferenceType>(Param)->getPointeeType(),
496 : ReferenceArg->getPointeeType(),
497 49: Info, Deduced, 0);
498 : }
499 :
500 : // T && [C++0x]
501 : case Type::RValueReference: {
502 0: const RValueReferenceType *ReferenceArg = Arg->getAs<RValueReferenceType>();
0: branch 0 not taken
0: branch 1 not taken
503 0: if (!ReferenceArg)
504 0: return Sema::TDK_NonDeducedMismatch;
505 :
506 : return DeduceTemplateArguments(S, TemplateParams,
507 : cast<RValueReferenceType>(Param)->getPointeeType(),
508 : ReferenceArg->getPointeeType(),
509 0: Info, Deduced, 0);
510 : }
511 :
512 : // T [] (implied, but not stated explicitly)
513 : case Type::IncompleteArray: {
514 : const IncompleteArrayType *IncompleteArrayArg =
515 6: S.Context.getAsIncompleteArrayType(Arg);
2: branch 0 taken
4: branch 1 taken
516 6: if (!IncompleteArrayArg)
517 2: return Sema::TDK_NonDeducedMismatch;
518 :
519 : return DeduceTemplateArguments(S, TemplateParams,
520 : S.Context.getAsIncompleteArrayType(Param)->getElementType(),
521 : IncompleteArrayArg->getElementType(),
522 4: Info, Deduced, 0);
523 : }
524 :
525 : // T [integer-constant]
526 : case Type::ConstantArray: {
527 : const ConstantArrayType *ConstantArrayArg =
528 8: S.Context.getAsConstantArrayType(Arg);
4: branch 0 taken
4: branch 1 taken
529 8: if (!ConstantArrayArg)
530 4: return Sema::TDK_NonDeducedMismatch;
531 :
532 : const ConstantArrayType *ConstantArrayParm =
533 4: S.Context.getAsConstantArrayType(Param);
1: branch 3 taken
3: branch 4 taken
534 4: if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
535 1: return Sema::TDK_NonDeducedMismatch;
536 :
537 : return DeduceTemplateArguments(S, TemplateParams,
538 : ConstantArrayParm->getElementType(),
539 : ConstantArrayArg->getElementType(),
540 3: Info, Deduced, 0);
541 : }
542 :
543 : // type [i]
544 : case Type::DependentSizedArray: {
545 27: const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
0: branch 0 not taken
27: branch 1 taken
546 27: if (!ArrayArg)
547 0: return Sema::TDK_NonDeducedMismatch;
548 :
549 : // Check the element type of the arrays
550 : const DependentSizedArrayType *DependentArrayParm
551 27: = S.Context.getAsDependentSizedArrayType(Param);
6: branch 0 taken
21: branch 1 taken
552 27: if (Sema::TemplateDeductionResult Result
553 : = DeduceTemplateArguments(S, TemplateParams,
554 : DependentArrayParm->getElementType(),
555 : ArrayArg->getElementType(),
556 27: Info, Deduced, 0))
557 6: return Result;
558 :
559 : // Determine the array bound is something we can deduce.
560 : NonTypeTemplateParmDecl *NTTP
561 21: = getDeducedParameterFromExpr(DependentArrayParm->getSizeExpr());
2: branch 0 taken
19: branch 1 taken
562 21: if (!NTTP)
563 2: return Sema::TDK_Success;
564 :
565 : // We can perform template argument deduction for the given non-type
566 : // template parameter.
567 : assert(NTTP->getDepth() == 0 &&
19: branch 1 taken
0: branch 2 not taken
568 19: "Cannot deduce non-type template argument at depth > 0");
15: branch 0 taken
4: branch 1 taken
569 19: if (const ConstantArrayType *ConstantArrayArg
570 19: = dyn_cast<ConstantArrayType>(ArrayArg)) {
571 15: llvm::APSInt Size(ConstantArrayArg->getSize());
572 : return DeduceNonTypeTemplateArgument(S, NTTP, Size,
573 15: Info, Deduced);
574 : }
2: branch 0 taken
2: branch 1 taken
575 4: if (const DependentSizedArrayType *DependentArrayArg
576 4: = dyn_cast<DependentSizedArrayType>(ArrayArg))
577 : return DeduceNonTypeTemplateArgument(S, NTTP,
578 : DependentArrayArg->getSizeExpr(),
579 2: Info, Deduced);
580 :
581 : // Incomplete type does not match a dependently-sized array type
582 2: return Sema::TDK_NonDeducedMismatch;
583 : }
584 :
585 : // type(*)(T)
586 : // T(*)()
587 : // T(*)(T)
588 : case Type::FunctionProto: {
589 : const FunctionProtoType *FunctionProtoArg =
590 503: dyn_cast<FunctionProtoType>(Arg);
8: branch 0 taken
495: branch 1 taken
591 503: if (!FunctionProtoArg)
592 8: return Sema::TDK_NonDeducedMismatch;
593 :
594 : const FunctionProtoType *FunctionProtoParam =
595 495: cast<FunctionProtoType>(Param);
596 :
25: branch 2 taken
470: branch 3 taken
597 495: if (FunctionProtoParam->getTypeQuals() !=
598 : FunctionProtoArg->getTypeQuals())
599 25: return Sema::TDK_NonDeducedMismatch;
600 :
41: branch 2 taken
429: branch 3 taken
601 470: if (FunctionProtoParam->getNumArgs() != FunctionProtoArg->getNumArgs())
602 41: return Sema::TDK_NonDeducedMismatch;
603 :
2: branch 2 taken
427: branch 3 taken
604 429: if (FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
605 2: return Sema::TDK_NonDeducedMismatch;
606 :
607 : // Check return types.
12: branch 0 taken
415: branch 1 taken
608 427: if (Sema::TemplateDeductionResult Result
609 : = DeduceTemplateArguments(S, TemplateParams,
610 : FunctionProtoParam->getResultType(),
611 : FunctionProtoArg->getResultType(),
612 427: Info, Deduced, 0))
613 12: return Result;
614 :
434: branch 1 taken
382: branch 2 taken
615 816: for (unsigned I = 0, N = FunctionProtoParam->getNumArgs(); I != N; ++I) {
616 : // Check argument types.
33: branch 0 taken
401: branch 1 taken
617 434: if (Sema::TemplateDeductionResult Result
618 : = DeduceTemplateArguments(S, TemplateParams,
619 : FunctionProtoParam->getArgType(I),
620 : FunctionProtoArg->getArgType(I),
621 434: Info, Deduced, 0))
622 33: return Result;
623 : }
624 :
625 382: return Sema::TDK_Success;
626 : }
627 :
628 : // template-name<T> (where template-name refers to a class template)
629 : // template-name<i>
630 : // TT<T>
631 : // TT<i>
632 : // TT<>
633 : case Type::TemplateSpecialization: {
634 : const TemplateSpecializationType *SpecParam
635 177: = cast<TemplateSpecializationType>(Param);
636 :
637 : // Try to deduce template arguments from the template-id.
638 : Sema::TemplateDeductionResult Result
639 : = DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg,
640 177: Info, Deduced);
641 :
74: branch 0 taken
103: branch 1 taken
13: branch 2 taken
61: branch 3 taken
642 177: if (Result && (TDF & TDF_DerivedClass)) {
643 : // C++ [temp.deduct.call]p3b3:
644 : // If P is a class, and P has the form template-id, then A can be a
645 : // derived class of the deduced A. Likewise, if P is a pointer to a
646 : // class of the form template-id, A can be a pointer to a derived
647 : // class pointed to by the deduced A.
648 : //
649 : // More importantly:
650 : // These alternatives are considered only if type deduction would
651 : // otherwise fail.
10: branch 2 taken
3: branch 3 taken
652 13: if (const RecordType *RecordT = Arg->getAs<RecordType>()) {
653 : // We cannot inspect base classes as part of deduction when the type
654 : // is incomplete, so either instantiate any templates necessary to
655 : // complete the type, or skip over it if it cannot be completed.
1: branch 9 taken
9: branch 10 taken
656 10: if (S.RequireCompleteType(Info.getLocation(), Arg, 0))
657 1: return Result;
658 :
659 : // Use data recursion to crawl through the list of base classes.
660 : // Visited contains the set of nodes we have already visited, while
661 : // ToVisit is our stack of records that we still need to visit.
662 9: llvm::SmallPtrSet<const RecordType *, 8> Visited;
663 9: llvm::SmallVector<const RecordType *, 8> ToVisit;
664 9: ToVisit.push_back(RecordT);
665 9: bool Successful = false;
21: branch 1 taken
9: branch 2 taken
666 39: while (!ToVisit.empty()) {
667 : // Retrieve the next class in the inheritance hierarchy.
668 21: const RecordType *NextT = ToVisit.back();
669 21: ToVisit.pop_back();
670 :
671 : // If we have already seen this type, skip it.
0: branch 1 not taken
21: branch 2 taken
672 21: if (!Visited.insert(NextT))
673 0: continue;
674 :
675 : // If this is a base class, try to perform template argument
676 : // deduction from it.
12: branch 0 taken
9: branch 1 taken
677 21: if (NextT != RecordT) {
678 : Sema::TemplateDeductionResult BaseResult
679 : = DeduceTemplateArguments(S, TemplateParams, SpecParam,
680 12: QualType(NextT, 0), Info, Deduced);
681 :
682 : // If template argument deduction for this base was successful,
683 : // note that we had some success.
7: branch 0 taken
5: branch 1 taken
684 12: if (BaseResult == Sema::TDK_Success)
685 7: Successful = true;
686 : }
687 :
688 : // Visit base classes
689 21: CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
12: branch 1 taken
21: branch 2 taken
690 87: for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(),
691 21: BaseEnd = Next->bases_end();
692 : Base != BaseEnd; ++Base) {
693 : assert(Base->getType()->isRecordType() &&
12: branch 3 taken
0: branch 4 not taken
694 12: "Base class that isn't a record?");
695 12: ToVisit.push_back(Base->getType()->getAs<RecordType>());
696 : }
697 : }
698 :
7: branch 0 taken
2: branch 1 taken
699 9: if (Successful)
2: branch 1 taken
7: branch 2 taken
2: branch 4 taken
7: branch 5 taken
700 7: return Sema::TDK_Success;
701 : }
702 :
703 : }
704 :
705 169: return Result;
706 : }
707 :
708 : // T type::*
709 : // T T::*
710 : // T (type::*)()
711 : // type (T::*)()
712 : // type (type::*)(T)
713 : // type (T::*)(T)
714 : // T (type::*)(T)
715 : // T (T::*)()
716 : // T (T::*)(T)
717 : case Type::MemberPointer: {
718 47: const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
719 47: const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
2: branch 0 taken
45: branch 1 taken
720 47: if (!MemPtrArg)
721 2: return Sema::TDK_NonDeducedMismatch;
722 :
36: branch 0 taken
9: branch 1 taken
723 45: if (Sema::TemplateDeductionResult Result
724 : = DeduceTemplateArguments(S, TemplateParams,
725 : MemPtrParam->getPointeeType(),
726 : MemPtrArg->getPointeeType(),
727 : Info, Deduced,
728 45: TDF & TDF_IgnoreQualifiers))
729 36: return Result;
730 :
731 : return DeduceTemplateArguments(S, TemplateParams,
732 : QualType(MemPtrParam->getClass(), 0),
733 : QualType(MemPtrArg->getClass(), 0),
734 9: Info, Deduced, 0);
735 : }
736 :
737 : // (clang extension)
738 : //
739 : // type(^)(T)
740 : // T(^)()
741 : // T(^)(T)
742 : case Type::BlockPointer: {
743 11: const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
744 11: const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
745 :
2: branch 0 taken
9: branch 1 taken
746 11: if (!BlockPtrArg)
747 2: return Sema::TDK_NonDeducedMismatch;
748 :
749 : return DeduceTemplateArguments(S, TemplateParams,
750 : BlockPtrParam->getPointeeType(),
751 : BlockPtrArg->getPointeeType(), Info,
752 9: Deduced, 0);
753 : }
754 :
755 : case Type::TypeOfExpr:
756 : case Type::TypeOf:
757 : case Type::Typename:
758 : // No template argument deduction for these types
759 10: return Sema::TDK_Success;
760 :
761 : default:
762 : break;
763 : }
764 :
765 : // FIXME: Many more cases to go (to go).
766 0: return Sema::TDK_Success;
767 : }
768 :
769 : static Sema::TemplateDeductionResult
770 : DeduceTemplateArguments(Sema &S,
771 : TemplateParameterList *TemplateParams,
772 : const TemplateArgument &Param,
773 : const TemplateArgument &Arg,
774 : Sema::TemplateDeductionInfo &Info,
775 1667: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
0: branch 1 not taken
564: branch 2 taken
1: branch 3 taken
0: branch 4 not taken
633: branch 5 taken
469: branch 6 taken
0: branch 7 not taken
0: branch 8 not taken
776 1667: switch (Param.getKind()) {
777 : case TemplateArgument::Null:
778 0: assert(false && "Null template argument in parameter list");
779 : break;
780 :
781 : case TemplateArgument::Type:
564: branch 1 taken
0: branch 2 not taken
782 564: if (Arg.getKind() == TemplateArgument::Type)
783 : return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(),
784 564: Arg.getAsType(), Info, Deduced, 0);
785 0: Info.FirstArg = Param;
786 0: Info.SecondArg = Arg;
787 0: return Sema::TDK_NonDeducedMismatch;
788 :
789 : case TemplateArgument::Template:
1: branch 1 taken
0: branch 2 not taken
790 1: if (Arg.getKind() == TemplateArgument::Template)
791 : return DeduceTemplateArguments(S, TemplateParams,
792 : Param.getAsTemplate(),
793 1: Arg.getAsTemplate(), Info, Deduced);
794 0: Info.FirstArg = Param;
795 0: Info.SecondArg = Arg;
796 0: return Sema::TDK_NonDeducedMismatch;
797 :
798 : case TemplateArgument::Declaration:
0: branch 1 not taken
0: branch 2 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
0: branch 10 not taken
799 0: if (Arg.getKind() == TemplateArgument::Declaration &&
800 : Param.getAsDecl()->getCanonicalDecl() ==
801 : Arg.getAsDecl()->getCanonicalDecl())
802 0: return Sema::TDK_Success;
803 :
804 0: Info.FirstArg = Param;
805 0: Info.SecondArg = Arg;
806 0: return Sema::TDK_NonDeducedMismatch;
807 :
808 : case TemplateArgument::Integral:
633: branch 1 taken
0: branch 2 not taken
809 633: if (Arg.getKind() == TemplateArgument::Integral) {
810 : // FIXME: Zero extension + sign checking here?
129: branch 3 taken
504: branch 4 taken
811 633: if (*Param.getAsIntegral() == *Arg.getAsIntegral())
812 129: return Sema::TDK_Success;
813 :
814 504: Info.FirstArg = Param;
815 504: Info.SecondArg = Arg;
816 504: return Sema::TDK_NonDeducedMismatch;
817 : }
818 :
0: branch 1 not taken
0: branch 2 not taken
819 0: if (Arg.getKind() == TemplateArgument::Expression) {
820 0: Info.FirstArg = Param;
821 0: Info.SecondArg = Arg;
822 0: return Sema::TDK_NonDeducedMismatch;
823 : }
824 :
825 0: assert(false && "Type/value mismatch");
826 : Info.FirstArg = Param;
827 : Info.SecondArg = Arg;
828 : return Sema::TDK_NonDeducedMismatch;
829 :
830 : case TemplateArgument::Expression: {
469: branch 0 taken
0: branch 1 not taken
831 469: if (NonTypeTemplateParmDecl *NTTP
832 469: = getDeducedParameterFromExpr(Param.getAsExpr())) {
460: branch 1 taken
9: branch 2 taken
833 469: if (Arg.getKind() == TemplateArgument::Integral)
834 : // FIXME: Sign problems here
835 : return DeduceNonTypeTemplateArgument(S, NTTP,
836 : *Arg.getAsIntegral(),
837 460: Info, Deduced);
8: branch 1 taken
1: branch 2 taken
838 9: if (Arg.getKind() == TemplateArgument::Expression)
839 : return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsExpr(),
840 8: Info, Deduced);
1: branch 1 taken
0: branch 2 not taken
841 1: if (Arg.getKind() == TemplateArgument::Declaration)
842 : return DeduceNonTypeTemplateArgument(S, NTTP, Arg.getAsDecl(),
843 1: Info, Deduced);
844 :
845 0: assert(false && "Type/value mismatch");
846 : Info.FirstArg = Param;
847 : Info.SecondArg = Arg;
848 : return Sema::TDK_NonDeducedMismatch;
849 : }
850 :
851 : // Can't deduce anything, but that's okay.
852 0: return Sema::TDK_Success;
853 : }
854 : case TemplateArgument::Pack:
855 0: assert(0 && "FIXME: Implement!");
856 : break;
857 : }
858 :
859 0: return Sema::TDK_Success;
860 : }
861 :
862 : static Sema::TemplateDeductionResult
863 : DeduceTemplateArguments(Sema &S,
864 : TemplateParameterList *TemplateParams,
865 : const TemplateArgumentList &ParamList,
866 : const TemplateArgumentList &ArgList,
867 : Sema::TemplateDeductionInfo &Info,
868 898: llvm::SmallVectorImpl<TemplateArgument> &Deduced) {
0: branch 2 not taken
898: branch 3 taken
869 898: assert(ParamList.size() == ArgList.size());
1425: branch 1 taken
244: branch 2 taken
870 1669: for (unsigned I = 0, N = ParamList.size(); I != N; ++I) {
654: branch 0 taken
771: branch 1 taken
871 1425: if (Sema::TemplateDeductionResult Result
872 : = DeduceTemplateArguments(S, TemplateParams,
873 : ParamList[I], ArgList[I],
874 1425: Info, Deduced))
875 654: return Result;
876 : }
877 244: return Sema::TDK_Success;
878 : }
879 :
880 : /// \brief Determine whether two template arguments are the same.
881 : static bool isSameTemplateArg(ASTContext &Context,
882 : const TemplateArgument &X,
883 443: const TemplateArgument &Y) {
0: branch 2 not taken
443: branch 3 taken
884 443: if (X.getKind() != Y.getKind())
885 0: return false;
886 :
0: branch 1 not taken
180: branch 2 taken
0: branch 3 not taken
1: branch 4 taken
262: branch 5 taken
0: branch 6 not taken
0: branch 7 not taken
0: branch 8 not taken
887 443: switch (X.getKind()) {
888 : case TemplateArgument::Null:
889 0: assert(false && "Comparing NULL template argument");
890 : break;
891 :
892 : case TemplateArgument::Type:
893 : return Context.getCanonicalType(X.getAsType()) ==
894 180: Context.getCanonicalType(Y.getAsType());
895 :
896 : case TemplateArgument::Declaration:
897 : return X.getAsDecl()->getCanonicalDecl() ==
898 0: Y.getAsDecl()->getCanonicalDecl();
899 :
900 : case TemplateArgument::Template:
901 : return Context.getCanonicalTemplateName(X.getAsTemplate())
902 : .getAsVoidPointer() ==
903 : Context.getCanonicalTemplateName(Y.getAsTemplate())
904 1: .getAsVoidPointer();
905 :
906 : case TemplateArgument::Integral:
907 262: return *X.getAsIntegral() == *Y.getAsIntegral();
908 :
909 : case TemplateArgument::Expression: {
910 0: llvm::FoldingSetNodeID XID, YID;
911 0: X.getAsExpr()->Profile(XID, Context, true);
912 0: Y.getAsExpr()->Profile(YID, Context, true);
913 0: return XID == YID;
914 : }
915 :
916 : case TemplateArgument::Pack:
0: branch 2 not taken
0: branch 3 not taken
917 0: if (X.pack_size() != Y.pack_size())
918 0: return false;
919 :
0: branch 1 not taken
0: branch 2 not taken
920 0: for (TemplateArgument::pack_iterator XP = X.pack_begin(),
921 0: XPEnd = X.pack_end(),
922 0: YP = Y.pack_begin();
923 : XP != XPEnd; ++XP, ++YP)
0: branch 1 not taken
0: branch 2 not taken
924 0: if (!isSameTemplateArg(Context, *XP, *YP))
925 0: return false;
926 :
927 0: return true;
928 : }
929 :
930 0: return false;
931 : }
932 :
933 : /// \brief Helper function to build a TemplateParameter when we don't
934 : /// know its type statically.
935 18: static TemplateParameter makeTemplateParameter(Decl *D) {
17: branch 1 taken
1: branch 2 taken
936 18: if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
937 17: return TemplateParameter(TTP);
1: branch 1 taken
0: branch 2 not taken
938 1: else if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
939 1: return TemplateParameter(NTTP);
940 :
941 0: return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
942 : }
943 :
944 : /// \brief Perform template argument deduction to determine whether
945 : /// the given template arguments match the given class template
946 : /// partial specialization per C++ [temp.class.spec.match].
947 : Sema::TemplateDeductionResult
948 : Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
949 : const TemplateArgumentList &TemplateArgs,
950 898: TemplateDeductionInfo &Info) {
951 : // C++ [temp.class.spec.match]p2:
952 : // A partial specialization matches a given actual template
953 : // argument list if the template arguments of the partial
954 : // specialization can be deduced from the actual template argument
955 : // list (14.8.2).
956 898: SFINAETrap Trap(*this);
957 898: llvm::SmallVector<TemplateArgument, 4> Deduced;
958 898: Deduced.resize(Partial->getTemplateParameters()->size());
654: branch 0 taken
244: branch 1 taken
959 898: if (TemplateDeductionResult Result
960 : = ::DeduceTemplateArguments(*this,
961 : Partial->getTemplateParameters(),
962 : Partial->getTemplateArgs(),
963 898: TemplateArgs, Info, Deduced))
964 654: return Result;
965 :
966 : InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial,
967 244: Deduced.data(), Deduced.size());
0: branch 1 not taken
244: branch 2 taken
968 244: if (Inst)
969 0: return TDK_InstantiationDepth;
970 :
971 : // C++ [temp.deduct.type]p2:
972 : // [...] or if any template argument remains neither deduced nor
973 : // explicitly specified, template argument deduction fails.
974 : TemplateArgumentListBuilder Builder(Partial->getTemplateParameters(),
975 244: Deduced.size());
300: branch 1 taken
244: branch 2 taken
976 544: for (unsigned I = 0, N = Deduced.size(); I != N; ++I) {
0: branch 2 not taken
300: branch 3 taken
977 300: if (Deduced[I].isNull()) {
978 : Decl *Param
979 : = const_cast<NamedDecl *>(
980 0: Partial->getTemplateParameters()->getParam(I));
0: branch 1 not taken
0: branch 2 not taken
981 0: if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
982 0: Info.Param = TTP;
0: branch 0 not taken
0: branch 1 not taken
983 0: else if (NonTypeTemplateParmDecl *NTTP
984 0: = dyn_cast<NonTypeTemplateParmDecl>(Param))
985 0: Info.Param = NTTP;
986 : else
987 0: Info.Param = cast<TemplateTemplateParmDecl>(Param);
988 0: return TDK_Incomplete;
989 : }
990 :
991 300: Builder.Append(Deduced[I]);
992 : }
993 :
994 : // Form the template argument list from the deduced template arguments.
995 : TemplateArgumentList *DeducedArgumentList
244: branch 1 taken
0: branch 2 not taken
996 244: = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true);
997 244: Info.reset(DeducedArgumentList);
998 :
999 : // Substitute the deduced template arguments into the template
1000 : // arguments of the class template partial specialization, and
1001 : // verify that the instantiated template arguments are both valid
1002 : // and are equivalent to the template arguments originally provided
1003 : // to the class template.
1004 244: ClassTemplateDecl *ClassTemplate = Partial->getSpecializedTemplate();
1005 : const TemplateArgumentLoc *PartialTemplateArgs
1006 244: = Partial->getTemplateArgsAsWritten();
1007 244: unsigned N = Partial->getNumTemplateArgsAsWritten();
1008 :
1009 : // Note that we don't provide the langle and rangle locations.
1010 244: TemplateArgumentListInfo InstArgs;
1011 :
444: branch 1 taken
1: branch 2 taken
445: branch 3 taken
243: branch 4 taken
1012 689: for (unsigned I = 0; I != N; ++I) {
1013 : Decl *Param = const_cast<NamedDecl *>(
1014 445: ClassTemplate->getTemplateParameters()->getParam(I));
1015 445: TemplateArgumentLoc InstArg;
1: branch 3 taken
444: branch 4 taken
1016 445: if (Subst(PartialTemplateArgs[I], InstArg,
1017 : MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
1018 1: Info.Param = makeTemplateParameter(Param);
1019 1: Info.FirstArg = PartialTemplateArgs[I].getArgument();
1020 1: return TDK_SubstitutionFailure;
1021 : }
1022 444: InstArgs.addArgument(InstArg);
1023 : }
1024 :
1025 : TemplateArgumentListBuilder ConvertedInstArgs(
1026 243: ClassTemplate->getTemplateParameters(), N);
1027 :
0: branch 2 not taken
243: branch 3 taken
1028 243: if (CheckTemplateArgumentList(ClassTemplate, Partial->getLocation(),
1029 : InstArgs, false, ConvertedInstArgs)) {
1030 : // FIXME: fail with more useful information?
1031 0: return TDK_SubstitutionFailure;
1032 : }
1033 :
441: branch 2 taken
2: branch 3 taken
443: branch 4 taken
241: branch 5 taken
1034 686: for (unsigned I = 0, E = ConvertedInstArgs.flatSize(); I != E; ++I) {
1035 443: TemplateArgument InstArg = ConvertedInstArgs.getFlatArguments()[I];
1036 :
1037 : Decl *Param = const_cast<NamedDecl *>(
1038 443: ClassTemplate->getTemplateParameters()->getParam(I));
1039 :
0: branch 1 not taken
443: branch 2 taken
1040 443: if (InstArg.getKind() == TemplateArgument::Expression) {
1041 : // When the argument is an expression, check the expression result
1042 : // against the actual template parameter to get down to the canonical
1043 : // template argument.
1044 0: Expr *InstExpr = InstArg.getAsExpr();
0: branch 0 not taken
0: branch 1 not taken
1045 0: if (NonTypeTemplateParmDecl *NTTP
1046 0: = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
0: branch 2 not taken
0: branch 3 not taken
1047 0: if (CheckTemplateArgument(NTTP, NTTP->getType(), InstExpr, InstArg)) {
1048 0: Info.Param = makeTemplateParameter(Param);
1049 0: Info.FirstArg = Partial->getTemplateArgs()[I];
1050 0: return TDK_SubstitutionFailure;
1051 : }
1052 : }
1053 : }
1054 :
2: branch 2 taken
441: branch 3 taken
1055 443: if (!isSameTemplateArg(Context, TemplateArgs[I], InstArg)) {
1056 2: Info.Param = makeTemplateParameter(Param);
1057 2: Info.FirstArg = TemplateArgs[I];
1058 2: Info.SecondArg = InstArg;
1059 2: return TDK_NonDeducedMismatch;
1060 : }
1061 : }
1062 :
0: branch 1 not taken
241: branch 2 taken
1063 241: if (Trap.hasErrorOccurred())
1064 0: return TDK_SubstitutionFailure;
1065 :
1066 241: return TDK_Success;
1067 : }
1068 :
1069 : /// \brief Determine whether the given type T is a simple-template-id type.
1070 555: static bool isSimpleTemplateIdType(QualType T) {
64: branch 0 taken
491: branch 1 taken
1071 555: if (const TemplateSpecializationType *Spec
1072 555: = T->getAs<TemplateSpecializationType>())
1073 64: return Spec->getTemplateName().getAsTemplateDecl() != 0;
1074 :
1075 491: return false;
1076 : }
1077 :
1078 : /// \brief Substitute the explicitly-provided template arguments into the
1079 : /// given function template according to C++ [temp.arg.explicit].
1080 : ///
1081 : /// \param FunctionTemplate the function template into which the explicit
1082 : /// template arguments will be substituted.
1083 : ///
1084 : /// \param ExplicitTemplateArguments the explicitly-specified template
1085 : /// arguments.
1086 : ///
1087 : /// \param Deduced the deduced template arguments, which will be populated
1088 : /// with the converted and checked explicit template arguments.
1089 : ///
1090 : /// \param ParamTypes will be populated with the instantiated function
1091 : /// parameters.
1092 : ///
1093 : /// \param FunctionType if non-NULL, the result type of the function template
1094 : /// will also be instantiated and the pointed-to value will be updated with
1095 : /// the instantiated function type.
1096 : ///
1097 : /// \param Info if substitution fails for any reason, this object will be
1098 : /// populated with more information about the failure.
1099 : ///
1100 : /// \returns TDK_Success if substitution was successful, or some failure
1101 : /// condition.
1102 : Sema::TemplateDeductionResult
1103 : Sema::SubstituteExplicitTemplateArguments(
1104 : FunctionTemplateDecl *FunctionTemplate,
1105 : const TemplateArgumentListInfo &ExplicitTemplateArgs,
1106 : llvm::SmallVectorImpl<TemplateArgument> &Deduced,
1107 : llvm::SmallVectorImpl<QualType> &ParamTypes,
1108 : QualType *FunctionType,
1109 312: TemplateDeductionInfo &Info) {
1110 312: FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
1111 : TemplateParameterList *TemplateParams
1112 312: = FunctionTemplate->getTemplateParameters();
1113 :
35: branch 1 taken
277: branch 2 taken
1114 312: if (ExplicitTemplateArgs.size() == 0) {
1115 : // No arguments to substitute; just copy over the parameter types and
1116 : // fill in the function type.
38: branch 1 taken
35: branch 2 taken
1117 108: for (FunctionDecl::param_iterator P = Function->param_begin(),
1118 35: PEnd = Function->param_end();
1119 : P != PEnd;
1120 : ++P)
1121 38: ParamTypes.push_back((*P)->getType());
1122 :
33: branch 0 taken
2: branch 1 taken
1123 35: if (FunctionType)
1124 33: *FunctionType = Function->getType();
1125 35: return TDK_Success;
1126 : }
1127 :
1128 : // Substitution of the explicit template arguments into a function template
1129 : /// is a SFINAE context. Trap any errors that might occur.
1130 277: SFINAETrap Trap(*this);
1131 :
1132 : // C++ [temp.arg.explicit]p3:
1133 : // Template arguments that are present shall be specified in the
1134 : // declaration order of their corresponding template-parameters. The
1135 : // template argument list shall not specify more template-arguments than
1136 : // there are corresponding template-parameters.
1137 : TemplateArgumentListBuilder Builder(TemplateParams,
1138 277: ExplicitTemplateArgs.size());
1139 :
1140 : // Enter a new template instantiation context where we check the
1141 : // explicitly-specified template arguments against this function template,
1142 : // and then substitute them into the function parameter types.
1143 : InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
1144 : FunctionTemplate, Deduced.data(), Deduced.size(),
1145 277: ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution);
0: branch 1 not taken
277: branch 2 taken
1146 277: if (Inst)
1147 0: return TDK_InstantiationDepth;
1148 :
257: branch 2 taken
20: branch 3 taken
0: branch 5 not taken
257: branch 6 taken
20: branch 7 taken
257: branch 8 taken
1149 277: if (CheckTemplateArgumentList(FunctionTemplate,
1150 : SourceLocation(),
1151 : ExplicitTemplateArgs,
1152 : true,
1153 : Builder) || Trap.hasErrorOccurred())
1154 20: return TDK_InvalidExplicitArguments;
1155 :
1156 : // Form the template argument list from the explicitly-specified
1157 : // template arguments.
1158 : TemplateArgumentList *ExplicitArgumentList
257: branch 1 taken
0: branch 2 not taken
1159 257: = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true);
1160 257: Info.reset(ExplicitArgumentList);
1161 :
1162 : // Instantiate the types of each of the function parameters given the
1163 : // explicitly-specified template arguments.
200: branch 1 taken
255: branch 2 taken
1164 712: for (FunctionDecl::param_iterator P = Function->param_begin(),
1165 257: PEnd = Function->param_end();
1166 : P != PEnd;
1167 : ++P) {
1168 : QualType ParamType
1169 : = SubstType((*P)->getType(),
1170 : MultiLevelTemplateArgumentList(*ExplicitArgumentList),
1171 200: (*P)->getLocation(), (*P)->getDeclName());
198: branch 1 taken
2: branch 2 taken
0: branch 4 not taken
198: branch 5 taken
2: branch 6 taken
198: branch 7 taken
1172 200: if (ParamType.isNull() || Trap.hasErrorOccurred())
1173 2: return TDK_SubstitutionFailure;
1174 :
1175 198: ParamTypes.push_back(ParamType);
1176 : }
1177 :
1178 : // If the caller wants a full function type back, instantiate the return
1179 : // type and form that function type.
119: branch 0 taken
136: branch 1 taken
1180 255: if (FunctionType) {
1181 : // FIXME: exception-specifications?
1182 : const FunctionProtoType *Proto
1183 119: = Function->getType()->getAs<FunctionProtoType>();
0: branch 0 not taken
119: branch 1 taken
1184 119: assert(Proto && "Function template does not have a prototype?");
1185 :
1186 : QualType ResultType
1187 : = SubstType(Proto->getResultType(),
1188 : MultiLevelTemplateArgumentList(*ExplicitArgumentList),
1189 : Function->getTypeSpecStartLoc(),
1190 119: Function->getDeclName());
119: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
119: branch 5 taken
0: branch 6 not taken
119: branch 7 taken
1191 119: if (ResultType.isNull() || Trap.hasErrorOccurred())
1192 0: return TDK_SubstitutionFailure;
1193 :
1194 : *FunctionType = BuildFunctionType(ResultType,
1195 : ParamTypes.data(), ParamTypes.size(),
1196 : Proto->isVariadic(),
1197 : Proto->getTypeQuals(),
1198 : Function->getLocation(),
1199 119: Function->getDeclName());
119: branch 1 taken
0: branch 2 not taken
0: branch 4 not taken
119: branch 5 taken
0: branch 6 not taken
119: branch 7 taken
1200 119: if (FunctionType->isNull() || Trap.hasErrorOccurred())
1201 0: return TDK_SubstitutionFailure;
1202 : }
1203 :
1204 : // C++ [temp.arg.explicit]p2:
1205 : // Trailing template arguments that can be deduced (14.8.2) may be
1206 : // omitted from the list of explicit template-arguments. If all of the
1207 : // template arguments can be deduced, they may all be omitted; in this
1208 : // case, the empty template argument list <> itself may also be omitted.
1209 : //
1210 : // Take all of the explicitly-specified arguments and put them into the
1211 : // set of deduced template arguments.
1212 255: Deduced.reserve(TemplateParams->size());
271: branch 1 taken
255: branch 2 taken
1213 526: for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I)
1214 271: Deduced.push_back(ExplicitArgumentList->get(I));
1215 :
1216 255: return TDK_Success;
1217 : }
1218 :
1219 : /// \brief Finish template argument deduction for a function template,
1220 : /// checking the deduced template arguments for completeness and forming
1221 : /// the function template specialization.
1222 : Sema::TemplateDeductionResult
1223 : Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
1224 : llvm::SmallVectorImpl<TemplateArgument> &Deduced,
1225 : FunctionDecl *&Specialization,
1226 975: TemplateDeductionInfo &Info) {
1227 : TemplateParameterList *TemplateParams
1228 975: = FunctionTemplate->getTemplateParameters();
1229 :
1230 : // Template argument deduction for function templates in a SFINAE context.
1231 : // Trap any errors that might occur.
1232 975: SFINAETrap Trap(*this);
1233 :
1234 : // Enter a new template instantiation context while we instantiate the
1235 : // actual function declaration.
1236 : InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(),
1237 : FunctionTemplate, Deduced.data(), Deduced.size(),
1238 975: ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution);
0: branch 1 not taken
975: branch 2 taken
1239 975: if (Inst)
1240 0: return TDK_InstantiationDepth;
1241 :
1242 : // C++ [temp.deduct.type]p2:
1243 : // [...] or if any template argument remains neither deduced nor
1244 : // explicitly specified, template argument deduction fails.
1245 975: TemplateArgumentListBuilder Builder(TemplateParams, Deduced.size());
2: branch 2 taken
15: branch 3 taken
1104: branch 4 taken
960: branch 5 taken
1246 2081: for (unsigned I = 0, N = Deduced.size(); I != N; ++I) {
1087: branch 2 taken
17: branch 3 taken
1247 1104: if (!Deduced[I].isNull()) {
1248 1087: Builder.Append(Deduced[I]);
1249 1087: continue;
1250 : }
1251 :
1252 : // Substitute into the default template argument, if available.
1253 17: NamedDecl *Param = FunctionTemplate->getTemplateParameters()->getParam(I);
1254 : TemplateArgumentLoc DefArg
1255 : = SubstDefaultTemplateArgumentIfAvailable(FunctionTemplate,
1256 : FunctionTemplate->getLocation(),
1257 : FunctionTemplate->getSourceRange().getEnd(),
1258 : Param,
1259 17: Builder);
1260 :
1261 : // If there was no default argument, deduction is incomplete.
15: branch 2 taken
2: branch 3 taken
1262 17: if (DefArg.getArgument().isNull()) {
1263 : Info.Param = makeTemplateParameter(
1264 15: const_cast<NamedDecl *>(TemplateParams->getParam(I)));
1265 15: return TDK_Incomplete;
1266 : }
1267 :
1268 : // Check whether we can actually use the default argument.
0: branch 4 not taken
2: branch 5 taken
1269 2: if (CheckTemplateArgument(Param, DefArg,
1270 : FunctionTemplate,
1271 : FunctionTemplate->getLocation(),
1272 : FunctionTemplate->getSourceRange().getEnd(),
1273 : Builder)) {
1274 : Info.Param = makeTemplateParameter(
1275 0: const_cast<NamedDecl *>(TemplateParams->getParam(I)));
1276 0: return TDK_SubstitutionFailure;
1277 : }
1278 :
1279 : // If we get here, we successfully used the default template argument.
1280 : }
1281 :
1282 : // Form the template argument list from the deduced template arguments.
1283 : TemplateArgumentList *DeducedArgumentList
960: branch 1 taken
0: branch 2 not taken
1284 960: = new (Context) TemplateArgumentList(Context, Builder, /*TakeArgs=*/true);
1285 960: Info.reset(DeducedArgumentList);
1286 :
1287 : // Substitute the deduced template arguments into the function template
1288 : // declaration to produce the function template specialization.
1289 : Specialization = cast_or_null<FunctionDecl>(
1290 : SubstDecl(FunctionTemplate->getTemplatedDecl(),
1291 : FunctionTemplate->getDeclContext(),
1292 960: MultiLevelTemplateArgumentList(*DeducedArgumentList)));
0: branch 0 not taken
960: branch 1 taken
1293 960: if (!Specialization)
1294 0: return TDK_SubstitutionFailure;
1295 :
1296 : assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
0: branch 3 not taken
960: branch 4 taken
1297 960: FunctionTemplate->getCanonicalDecl());
1298 :
1299 : // If the template argument list is owned by the function template
1300 : // specialization, release it.
473: branch 1 taken
487: branch 2 taken
1301 960: if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList)
1302 473: Info.take();
1303 :
1304 : // There may have been an error that did not prevent us from constructing a
1305 : // declaration. Mark the declaration invalid and return with a substitution
1306 : // failure.
0: branch 1 not taken
960: branch 2 taken
1307 960: if (Trap.hasErrorOccurred()) {
1308 0: Specialization->setInvalidDecl(true);
1309 0: return TDK_SubstitutionFailure;
1310 : }
1311 :
1312 960: return TDK_Success;
1313 : }
1314 :
1315 : static QualType GetTypeOfFunction(ASTContext &Context,
1316 : bool isAddressOfOperand,
1317 19: FunctionDecl *Fn) {
2: branch 0 taken
17: branch 1 taken
1318 19: if (!isAddressOfOperand) return Fn->getType();
0: branch 1 not taken
17: branch 2 taken
1319 17: if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
0: branch 1 not taken
0: branch 2 not taken
1320 0: if (Method->isInstance())
1321 : return Context.getMemberPointerType(Fn->getType(),
1322 0: Context.getTypeDeclType(Method->getParent()).getTypePtr());
1323 17: return Context.getPointerType(Fn->getType());
1324 : }
1325 :
1326 : /// Apply the deduction rules for overload sets.
1327 : ///
1328 : /// \return the null type if this argument should be treated as an
1329 : /// undeduced context
1330 : static QualType
1331 : ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
1332 23: Expr *Arg, QualType ParamType) {
1333 23: llvm::PointerIntPair<OverloadExpr*,1> R = OverloadExpr::find(Arg);
1334 :
1335 23: bool isAddressOfOperand = bool(R.getInt());
1336 23: OverloadExpr *Ovl = R.getPointer();
1337 :
1338 : // If there were explicit template arguments, we can only find
1339 : // something via C++ [temp.arg.explicit]p3, i.e. if the arguments
1340 : // unambiguously name a full specialization.
14: branch 1 taken
9: branch 2 taken
1341 23: if (Ovl->hasExplicitTemplateArgs()) {
1342 : // But we can still look for an explicit specialization.
7: branch 0 taken
7: branch 1 taken
1343 14: if (FunctionDecl *ExplicitSpec
1344 14: = S.ResolveSingleFunctionTemplateSpecialization(Ovl))
1345 7: return GetTypeOfFunction(S.Context, isAddressOfOperand, ExplicitSpec);
1346 7: return QualType();
1347 : }
1348 :
1349 : // C++0x [temp.deduct.call]p6:
1350 : // When P is a function type, pointer to function type, or pointer
1351 : // to member function type:
1352 :
9: branch 2 taken
0: branch 3 not taken
0: branch 6 not taken
9: branch 7 taken
0: branch 10 not taken
0: branch 11 not taken
0: branch 12 not taken
9: branch 13 taken
1353 9: if (!ParamType->isFunctionType() &&
1354 : !ParamType->isFunctionPointerType() &&
1355 : !ParamType->isMemberFunctionPointerType())
1356 0: return QualType();
1357 :
1358 9: QualType Match;
5: branch 2 taken
5: branch 3 taken
2: branch 4 taken
5: branch 6 taken
5: branch 7 taken
2: branch 8 taken
16: branch 11 taken
3: branch 12 taken
1359 40: for (UnresolvedSetIterator I = Ovl->decls_begin(),
1360 9: E = Ovl->decls_end(); I != E; ++I) {
1361 16: NamedDecl *D = (*I)->getUnderlyingDecl();
1362 :
1363 : // - If the argument is an overload set containing one or more
1364 : // function templates, the parameter is treated as a
1365 : // non-deduced context.
4: branch 1 taken
12: branch 2 taken
1366 16: if (isa<FunctionTemplateDecl>(D))
1367 4: return QualType();
1368 :
1369 12: FunctionDecl *Fn = cast<FunctionDecl>(D);
1370 12: QualType ArgType = GetTypeOfFunction(S.Context, isAddressOfOperand, Fn);
1371 :
1372 : // - If the argument is an overload set (not containing function
1373 : // templates), trial argument deduction is attempted using each
1374 : // of the members of the set. If deduction succeeds for only one
1375 : // of the overload set members, that member is used as the
1376 : // argument value for the deduction. If deduction succeeds for
1377 : // more than one member of the overload set the parameter is
1378 : // treated as a non-deduced context.
1379 :
1380 : // We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
1381 : // Type deduction is done independently for each P/A pair, and
1382 : // the deduced template argument values are then combined.
1383 : // So we do not reject deductions which were made elsewhere.
1384 12: llvm::SmallVector<TemplateArgument, 8> Deduced(TemplateParams->size());
1385 12: Sema::TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc());
1386 12: unsigned TDF = 0;
1387 :
1388 : Sema::TemplateDeductionResult Result
1389 : = DeduceTemplateArguments(S, TemplateParams,
1390 : ParamType, ArgType,
1391 12: Info, Deduced, TDF);
5: branch 0 taken
7: branch 1 taken
1392 17: if (Result) continue;
2: branch 1 taken
5: branch 2 taken
1393 9: if (!Match.isNull()) return QualType();
1394 5: Match = ArgType;
1395 : }
1396 :
1397 3: return Match;
1398 : }
1399 :
1400 : /// \brief Perform template argument deduction from a function call
1401 : /// (C++ [temp.deduct.call]).
1402 : ///
1403 : /// \param FunctionTemplate the function template for which we are performing
1404 : /// template argument deduction.
1405 : ///
1406 : /// \param ExplicitTemplateArguments the explicit template arguments provided
1407 : /// for this call.
1408 : ///
1409 : /// \param Args the function call arguments
1410 : ///
1411 : /// \param NumArgs the number of arguments in Args
1412 : ///
1413 : /// \param Name the name of the function being called. This is only significant
1414 : /// when the function template is a conversion function template, in which
1415 : /// case this routine will also perform template argument deduction based on
1416 : /// the function to which
1417 : ///
1418 : /// \param Specialization if template argument deduction was successful,
1419 : /// this will be set to the function template specialization produced by
1420 : /// template argument deduction.
1421 : ///
1422 : /// \param Info the argument will be updated to provide additional information
1423 : /// about template argument deduction.
1424 : ///
1425 : /// \returns the result of template argument deduction.
1426 : Sema::TemplateDeductionResult
1427 : Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
1428 : const TemplateArgumentListInfo *ExplicitTemplateArgs,
1429 : Expr **Args, unsigned NumArgs,
1430 : FunctionDecl *&Specialization,
1431 474: TemplateDeductionInfo &Info) {
1432 474: FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
1433 :
1434 : // C++ [temp.deduct.call]p1:
1435 : // Template argument deduction is done by comparing each function template
1436 : // parameter type (call it P) with the type of the corresponding argument
1437 : // of the call (call it A) as described below.
1438 474: unsigned CheckArgs = NumArgs;
7: branch 1 taken
467: branch 2 taken
1439 474: if (NumArgs < Function->getMinRequiredArguments())
1440 7: return TDK_TooFewArguments;
16: branch 1 taken
451: branch 2 taken
1441 467: else if (NumArgs > Function->getNumParams()) {
1442 : const FunctionProtoType *Proto
1443 16: = Function->getType()->getAs<FunctionProtoType>();
13: branch 1 taken
3: branch 2 taken
1444 16: if (!Proto->isVariadic())
1445 13: return TDK_TooManyArguments;
1446 :
1447 3: CheckArgs = Function->getNumParams();
1448 : }
1449 :
1450 : // The types of the parameters from which we will perform template argument
1451 : // deduction.
1452 : TemplateParameterList *TemplateParams
1453 454: = FunctionTemplate->getTemplateParameters();
1454 454: llvm::SmallVector<TemplateArgument, 4> Deduced;
1455 454: llvm::SmallVector<QualType, 4> ParamTypes;
154: branch 0 taken
300: branch 1 taken
1456 454: if (ExplicitTemplateArgs) {
1457 : TemplateDeductionResult Result =
1458 : SubstituteExplicitTemplateArguments(FunctionTemplate,
1459 : *ExplicitTemplateArgs,
1460 : Deduced,
1461 : ParamTypes,
1462 : 0,
1463 154: Info);
16: branch 0 taken
138: branch 1 taken
1464 154: if (Result)
1465 16: return Result;
1466 : } else {
1467 : // Just fill in the parameter types from the function declaration.
402: branch 0 taken
300: branch 1 taken
1468 702: for (unsigned I = 0; I != CheckArgs; ++I)
1469 402: ParamTypes.push_back(Function->getParamDecl(I)->getType());
1470 : }
1471 :
1472 : // Deduce template arguments from the function parameters.
1473 438: Deduced.resize(TemplateParams->size());
493: branch 0 taken
420: branch 1 taken
1474 913: for (unsigned I = 0; I != CheckArgs; ++I) {
1475 493: QualType ParamType = ParamTypes[I];
1476 493: QualType ArgType = Args[I]->getType();
1477 :
1478 : // Overload sets usually make this parameter an undeduced
1479 : // context, but there are sometimes special circumstances.
23: branch 2 taken
470: branch 3 taken
1480 493: if (ArgType == Context.OverloadTy) {
1481 : ArgType = ResolveOverloadForDeduction(*this, TemplateParams,
1482 23: Args[I], ParamType);
10: branch 1 taken
13: branch 2 taken
1483 23: if (ArgType.isNull())
1484 13: continue;
1485 : }
1486 :
1487 : // C++ [temp.deduct.call]p2:
1488 : // If P is not a reference type:
1489 480: QualType CanonParamType = Context.getCanonicalType(ParamType);
1490 480: bool ParamWasReference = isa<ReferenceType>(CanonParamType);
353: branch 0 taken
127: branch 1 taken
1491 480: if (!ParamWasReference) {
1492 : // - If A is an array type, the pointer type produced by the
1493 : // array-to-pointer standard conversion (4.2) is used in place of
1494 : // A for type deduction; otherwise,
8: branch 2 taken
345: branch 3 taken
1495 353: if (ArgType->isArrayType())
1496 8: ArgType = Context.getArrayDecayedType(ArgType);
1497 : // - If A is a function type, the pointer type produced by the
1498 : // function-to-pointer standard conversion (4.3) is used in place
1499 : // of A for type deduction; otherwise,
4: branch 2 taken
341: branch 3 taken
1500 345: else if (ArgType->isFunctionType())
1501 4: ArgType = Context.getPointerType(ArgType);
1502 : else {
1503 : // - If A is a cv-qualified type, the top level cv-qualifiers of A’s
1504 : // type are ignored for type deduction.
1505 341: QualType CanonArgType = Context.getCanonicalType(ArgType);
2: branch 1 taken
339: branch 2 taken
1506 341: if (CanonArgType.getLocalCVRQualifiers())
1507 2: ArgType = CanonArgType.getLocalUnqualifiedType();
1508 : }
1509 : }
1510 :
1511 : // C++0x [temp.deduct.call]p3:
1512 : // If P is a cv-qualified type, the top level cv-qualifiers of P’s type
1513 : // are ignored for type deduction.
5: branch 1 taken
475: branch 2 taken
1514 480: if (CanonParamType.getLocalCVRQualifiers())
1515 5: ParamType = CanonParamType.getLocalUnqualifiedType();
127: branch 2 taken
353: branch 3 taken
1516 480: if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
1517 : // [...] If P is a reference type, the type referred to by P is used
1518 : // for type deduction.
1519 127: ParamType = ParamRefType->getPointeeType();
1520 :
1521 : // [...] If P is of the form T&&, where T is a template parameter, and
1522 : // the argument is an lvalue, the type A& is used in place of A for
1523 : // type deduction.
0: branch 1 not taken
127: branch 2 taken
0: branch 4 not taken
0: branch 5 not taken
0: branch 7 not taken
0: branch 8 not taken
0: branch 9 not taken
127: branch 10 taken
1524 127: if (isa<RValueReferenceType>(ParamRefType) &&
1525 : ParamRefType->getAs<TemplateTypeParmType>() &&
1526 : Args[I]->isLvalue(Context) == Expr::LV_Valid)
1527 0: ArgType = Context.getLValueReferenceType(ArgType);
1528 : }
1529 :
1530 : // C++0x [temp.deduct.call]p4:
1531 : // In general, the deduction process attempts to find template argument
1532 : // values that will make the deduced A identical to A (after the type A
1533 : // is transformed as described above). [...]
1534 480: unsigned TDF = TDF_SkipNonDependent;
1535 :
1536 : // - If the original P is a reference type, the deduced A (i.e., the
1537 : // type referred to by the reference) can be more cv-qualified than
1538 : // the transformed A.
127: branch 0 taken
353: branch 1 taken
1539 480: if (ParamWasReference)
1540 127: TDF |= TDF_ParamWithReferenceType;
1541 : // - The transformed A can be another pointer or pointer to member
1542 : // type that can be converted to the deduced A via a qualification
1543 : // conversion (4.4).
350: branch 2 taken
130: branch 3 taken
0: branch 6 not taken
350: branch 7 taken
130: branch 8 taken
350: branch 9 taken
1544 480: if (ArgType->isPointerType() || ArgType->isMemberPointerType())
1545 130: TDF |= TDF_IgnoreQualifiers;
1546 : // - If P is a class and P has the form simple-template-id, then the
1547 : // transformed A can be a derived class of the deduced A. Likewise,
1548 : // if P is a pointer to a class of the form simple-template-id, the
1549 : // transformed A can be a pointer to a derived class pointed to by
1550 : // the deduced A.
422: branch 1 taken
58: branch 2 taken
75: branch 4 taken
347: branch 5 taken
6: branch 10 taken
69: branch 11 taken
64: branch 12 taken
416: branch 13 taken
1551 480: if (isSimpleTemplateIdType(ParamType) ||
1552 : (isa<PointerType>(ParamType) &&
1553 : isSimpleTemplateIdType(
1554 : ParamType->getAs<PointerType>()->getPointeeType())))
1555 64: TDF |= TDF_DerivedClass;
1556 :
18: branch 0 taken
462: branch 1 taken
1557 480: if (TemplateDeductionResult Result
1558 : = ::DeduceTemplateArguments(*this, TemplateParams,
1559 : ParamType, ArgType, Info, Deduced,
1560 480: TDF))
1561 18: return Result;
1562 :
1563 : // FIXME: we need to check that the deduced A is the same as A,
1564 : // modulo the various allowed differences.
1565 : }
1566 :
1567 : return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
1568 420: Specialization, Info);
1569 : }
1570 :
1571 : /// \brief Deduce template arguments when taking the address of a function
1572 : /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
1573 : /// a template.
1574 : ///
1575 : /// \param FunctionTemplate the function template for which we are performing
1576 : /// template argument deduction.
1577 : ///
1578 : /// \param ExplicitTemplateArguments the explicitly-specified template
1579 : /// arguments.
1580 : ///
1581 : /// \param ArgFunctionType the function type that will be used as the
1582 : /// "argument" type (A) when performing template argument deduction from the
1583 : /// function template's function type. This type may be NULL, if there is no
1584 : /// argument type to compare against, in C++0x [temp.arg.explicit]p3.
1585 : ///
1586 : /// \param Specialization if template argument deduction was successful,
1587 : /// this will be set to the function template specialization produced by
1588 : /// template argument deduction.
1589 : ///
1590 : /// \param Info the argument will be updated to provide additional information
1591 : /// about template argument deduction.
1592 : ///
1593 : /// \returns the result of template argument deduction.
1594 : Sema::TemplateDeductionResult
1595 : Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
1596 : const TemplateArgumentListInfo *ExplicitTemplateArgs,
1597 : QualType ArgFunctionType,
1598 : FunctionDecl *&Specialization,
1599 512: TemplateDeductionInfo &Info) {
1600 512: FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
1601 : TemplateParameterList *TemplateParams
1602 512: = FunctionTemplate->getTemplateParameters();
1603 512: QualType FunctionType = Function->getType();
1604 :
1605 : // Substitute any explicit template arguments.
1606 512: llvm::SmallVector<TemplateArgument, 4> Deduced;
1607 512: llvm::SmallVector<QualType, 4> ParamTypes;
158: branch 0 taken
354: branch 1 taken
1608 512: if (ExplicitTemplateArgs) {
6: branch 0 taken
152: branch 1 taken
1609 158: if (TemplateDeductionResult Result
1610 : = SubstituteExplicitTemplateArguments(FunctionTemplate,
1611 : *ExplicitTemplateArgs,
1612 : Deduced, ParamTypes,
1613 158: &FunctionType, Info))
1614 6: return Result;
1615 : }
1616 :
1617 : // Template argument deduction for function templates in a SFINAE context.
1618 : // Trap any errors that might occur.
1619 506: SFINAETrap Trap(*this);
1620 :
1621 506: Deduced.resize(TemplateParams->size());
1622 :
488: branch 1 taken
18: branch 2 taken
1623 506: if (!ArgFunctionType.isNull()) {
1624 : // Deduce template arguments from the function type.
55: branch 0 taken
433: branch 1 taken
1625 488: if (TemplateDeductionResult Result
1626 : = ::DeduceTemplateArguments(*this, TemplateParams,
1627 : FunctionType, ArgFunctionType, Info,
1628 488: Deduced, 0))
1629 55: return Result;
1630 : }
1631 :
1632 : return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
1633 451: Specialization, Info);
1634 : }
1635 :
1636 : /// \brief Deduce template arguments for a templated conversion
1637 : /// function (C++ [temp.deduct.conv]) and, if successful, produce a
1638 : /// conversion function template specialization.
1639 : Sema::TemplateDeductionResult
1640 : Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
1641 : QualType ToType,
1642 : CXXConversionDecl *&Specialization,
1643 106: TemplateDeductionInfo &Info) {
1644 : CXXConversionDecl *Conv
1645 106: = cast<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl());
1646 106: QualType FromType = Conv->getConversionType();
1647 :
1648 : // Canonicalize the types for deduction.
1649 106: QualType P = Context.getCanonicalType(FromType);
1650 106: QualType A = Context.getCanonicalType(ToType);
1651 :
1652 : // C++0x [temp.deduct.conv]p3:
1653 : // If P is a reference type, the type referred to by P is used for
1654 : // type deduction.
3: branch 2 taken
103: branch 3 taken
1655 106: if (const ReferenceType *PRef = P->getAs<ReferenceType>())
1656 3: P = PRef->getPointeeType();
1657 :
1658 : // C++0x [temp.deduct.conv]p3:
1659 : // If A is a reference type, the type referred to by A is used
1660 : // for type deduction.
2: branch 2 taken
104: branch 3 taken
1661 106: if (const ReferenceType *ARef = A->getAs<ReferenceType>())
1662 2: A = ARef->getPointeeType();
1663 : // C++ [temp.deduct.conv]p2:
1664 : //
1665 : // If A is not a reference type:
1666 : else {
104: branch 2 taken
0: branch 3 not taken
1667 104: assert(!A->isReferenceType() && "Reference types were handled above");
1668 :
1669 : // - If P is an array type, the pointer type produced by the
1670 : // array-to-pointer standard conversion (4.2) is used in place
1671 : // of P for type deduction; otherwise,
0: branch 2 not taken
104: branch 3 taken
1672 104: if (P->isArrayType())
1673 0: P = Context.getArrayDecayedType(P);
1674 : // - If P is a function type, the pointer type produced by the
1675 : // function-to-pointer standard conversion (4.3) is used in
1676 : // place of P for type deduction; otherwise,
0: branch 2 not taken
104: branch 3 taken
1677 104: else if (P->isFunctionType())
1678 0: P = Context.getPointerType(P);
1679 : // - If P is a cv-qualified type, the top level cv-qualifiers of
1680 : // P’s type are ignored for type deduction.
1681 : else
1682 104: P = P.getUnqualifiedType();
1683 :
1684 : // C++0x [temp.deduct.conv]p3:
1685 : // If A is a cv-qualified type, the top level cv-qualifiers of A’s
1686 : // type are ignored for type deduction.
1687 104: A = A.getUnqualifiedType();
1688 : }
1689 :
1690 : // Template argument deduction for function templates in a SFINAE context.
1691 : // Trap any errors that might occur.
1692 106: SFINAETrap Trap(*this);
1693 :
1694 : // C++ [temp.deduct.conv]p1:
1695 : // Template argument deduction is done by comparing the return
1696 : // type of the template conversion function (call it P) with the
1697 : // type that is required as the result of the conversion (call it
1698 : // A) as described in 14.8.2.4.
1699 : TemplateParameterList *TemplateParams
1700 106: = FunctionTemplate->getTemplateParameters();
1701 106: llvm::SmallVector<TemplateArgument, 4> Deduced;
1702 106: Deduced.resize(TemplateParams->size());
1703 :
1704 : // C++0x [temp.deduct.conv]p4:
1705 : // In general, the deduction process attempts to find template
1706 : // argument values that will make the deduced A identical to
1707 : // A. However, there are two cases that allow a difference:
1708 106: unsigned TDF = 0;
1709 : // - If the original A is a reference type, A can be more
1710 : // cv-qualified than the deduced A (i.e., the type referred to
1711 : // by the reference)
2: branch 2 taken
104: branch 3 taken
1712 106: if (ToType->isReferenceType())
1713 2: TDF |= TDF_ParamWithReferenceType;
1714 : // - The deduced A can be another pointer or pointer to member
1715 : // type that can be converted to A via a qualification
1716 : // conversion.
1717 : //
1718 : // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
1719 : // both P and A are pointers or member pointers. In this case, we
1720 : // just ignore cv-qualifiers completely).
11: branch 2 taken
95: branch 3 taken
0: branch 6 not taken
11: branch 7 taken
1: branch 10 taken
94: branch 11 taken
1: branch 14 taken
0: branch 15 not taken
12: branch 16 taken
94: branch 17 taken
1721 106: if ((P->isPointerType() && A->isPointerType()) ||
1722 : (P->isMemberPointerType() && P->isMemberPointerType()))
1723 12: TDF |= TDF_IgnoreQualifiers;
2: branch 0 taken
104: branch 1 taken
1724 106: if (TemplateDeductionResult Result
1725 : = ::DeduceTemplateArguments(*this, TemplateParams,
1726 106: P, A, Info, Deduced, TDF))
1727 2: return Result;
1728 :
1729 : // FIXME: we need to check that the deduced A is the same as A,
1730 : // modulo the various allowed differences.
1731 :
1732 : // Finish template argument deduction.
1733 104: FunctionDecl *Spec = 0;
1734 : TemplateDeductionResult Result
1735 104: = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, Spec, Info);
1736 104: Specialization = cast_or_null<CXXConversionDecl>(Spec);
1737 104: return Result;
1738 : }
1739 :
1740 : /// \brief Deduce template arguments for a function template when there is
1741 : /// nothing to deduce against (C++0x [temp.arg.explicit]p3).
1742 : ///
1743 : /// \param FunctionTemplate the function template for which we are performing
1744 : /// template argument deduction.
1745 : ///
1746 : /// \param ExplicitTemplateArguments the explicitly-specified template
1747 : /// arguments.
1748 : ///
1749 : /// \param Specialization if template argument deduction was successful,
1750 : /// this will be set to the function template specialization produced by
1751 : /// template argument deduction.
1752 : ///
1753 : /// \param Info the argument will be updated to provide additional information
1754 : /// about template argument deduction.
1755 : ///
1756 : /// \returns the result of template argument deduction.
1757 : Sema::TemplateDeductionResult
1758 : Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
1759 : const TemplateArgumentListInfo *ExplicitTemplateArgs,
1760 : FunctionDecl *&Specialization,
1761 18: TemplateDeductionInfo &Info) {
1762 : return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
1763 18: QualType(), Specialization, Info);
1764 : }
1765 :
1766 : /// \brief Stores the result of comparing the qualifiers of two types.
1767 : enum DeductionQualifierComparison {
1768 : NeitherMoreQualified = 0,
1769 : ParamMoreQualified,
1770 : ArgMoreQualified
1771 : };
1772 :
1773 : /// \brief Deduce the template arguments during partial ordering by comparing
1774 : /// the parameter type and the argument type (C++0x [temp.deduct.partial]).
1775 : ///
1776 : /// \param S the semantic analysis object within which we are deducing
1777 : ///
1778 : /// \param TemplateParams the template parameters that we are deducing
1779 : ///
1780 : /// \param ParamIn the parameter type
1781 : ///
1782 : /// \param ArgIn the argument type
1783 : ///
1784 : /// \param Info information about the template argument deduction itself
1785 : ///
1786 : /// \param Deduced the deduced template arguments
1787 : ///
1788 : /// \returns the result of template argument deduction so far. Note that a
1789 : /// "success" result means that template argument deduction has not yet failed,
1790 : /// but it may still fail, later, for other reasons.
1791 : static Sema::TemplateDeductionResult
1792 : DeduceTemplateArgumentsDuringPartialOrdering(Sema &S,
1793 : TemplateParameterList *TemplateParams,
1794 : QualType ParamIn, QualType ArgIn,
1795 : Sema::TemplateDeductionInfo &Info,
1796 : llvm::SmallVectorImpl<TemplateArgument> &Deduced,
1797 186: llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) {
1798 186: CanQualType Param = S.Context.getCanonicalType(ParamIn);
1799 186: CanQualType Arg = S.Context.getCanonicalType(ArgIn);
1800 :
1801 : // C++0x [temp.deduct.partial]p5:
1802 : // Before the partial ordering is done, certain transformations are
1803 : // performed on the types used for partial ordering:
1804 : // - If P is a reference type, P is replaced by the type referred to.
1805 186: CanQual<ReferenceType> ParamRef = Param->getAs<ReferenceType>();
16: branch 1 taken
170: branch 2 taken
1806 186: if (!ParamRef.isNull())
1807 16: Param = ParamRef->getPointeeType();
1808 :
1809 : // - If A is a reference type, A is replaced by the type referred to.
1810 186: CanQual<ReferenceType> ArgRef = Arg->getAs<ReferenceType>();
16: branch 1 taken
170: branch 2 taken
1811 186: if (!ArgRef.isNull())
1812 16: Arg = ArgRef->getPointeeType();
1813 :
71: branch 0 taken
115: branch 1 taken
8: branch 3 taken
63: branch 4 taken
6: branch 6 taken
2: branch 7 taken
6: branch 8 taken
180: branch 9 taken
1814 186: if (QualifierComparisons && !ParamRef.isNull() && !ArgRef.isNull()) {
1815 : // C++0x [temp.deduct.partial]p6:
1816 : // If both P and A were reference types (before being replaced with the
1817 : // type referred to above), determine which of the two types (if any) is
1818 : // more cv-qualified than the other; otherwise the types are considered to
1819 : // be equally cv-qualified for partial ordering purposes. The result of this
1820 : // determination will be used below.
1821 : //
1822 : // We save this information for later, using it only when deduction
1823 : // succeeds in both directions.
1824 6: DeductionQualifierComparison QualifierResult = NeitherMoreQualified;
2: branch 1 taken
4: branch 2 taken
1825 6: if (Param.isMoreQualifiedThan(Arg))
1826 2: QualifierResult = ParamMoreQualified;
2: branch 1 taken
2: branch 2 taken
1827 4: else if (Arg.isMoreQualifiedThan(Param))
1828 2: QualifierResult = ArgMoreQualified;
1829 6: QualifierComparisons->push_back(QualifierResult);
1830 : }
1831 :
1832 : // C++0x [temp.deduct.partial]p7:
1833 : // Remove any top-level cv-qualifiers:
1834 : // - If P is a cv-qualified type, P is replaced by the cv-unqualified
1835 : // version of P.
1836 186: Param = Param.getUnqualifiedType();
1837 : // - If A is a cv-qualified type, A is replaced by the cv-unqualified
1838 : // version of A.
1839 186: Arg = Arg.getUnqualifiedType();
1840 :
1841 : // C++0x [temp.deduct.partial]p8:
1842 : // Using the resulting types P and A the deduction is then done as
1843 : // described in 14.9.2.5. If deduction succeeds for a given type, the type
1844 : // from the argument template is considered to be at least as specialized
1845 : // as the type from the parameter template.
1846 : return DeduceTemplateArguments(S, TemplateParams, Param, Arg, Info,
1847 186: Deduced, TDF_None);
1848 : }
1849 :
1850 : static void
1851 : MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
1852 : bool OnlyDeduced,
1853 : unsigned Level,
1854 : llvm::SmallVectorImpl<bool> &Deduced);
1855 :
1856 : /// \brief Determine whether the function template \p FT1 is at least as
1857 : /// specialized as \p FT2.
1858 : static bool isAtLeastAsSpecializedAs(Sema &S,
1859 : SourceLocation Loc,
1860 : FunctionTemplateDecl *FT1,
1861 : FunctionTemplateDecl *FT2,
1862 : TemplatePartialOrderingContext TPOC,
1863 130: llvm::SmallVectorImpl<DeductionQualifierComparison> *QualifierComparisons) {
1864 130: FunctionDecl *FD1 = FT1->getTemplatedDecl();
1865 130: FunctionDecl *FD2 = FT2->getTemplatedDecl();
1866 130: const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
1867 130: const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
1868 :
130: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
130: branch 3 taken
1869 130: assert(Proto1 && Proto2 && "Function templates must have prototypes");
1870 130: TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
1871 130: llvm::SmallVector<TemplateArgument, 4> Deduced;
1872 130: Deduced.resize(TemplateParams->size());
1873 :
1874 : // C++0x [temp.deduct.partial]p3:
1875 : // The types used to determine the ordering depend on the context in which
1876 : // the partial ordering is done:
1877 130: Sema::TemplateDeductionInfo Info(S.Context, Loc);
84: branch 0 taken
12: branch 1 taken
34: branch 2 taken
0: branch 3 not taken
1878 130: switch (TPOC) {
1879 : case TPOC_Call: {
1880 : // - In the context of a function call, the function parameter types are
1881 : // used.
1882 84: unsigned NumParams = std::min(Proto1->getNumArgs(), Proto2->getNumArgs());
96: branch 0 taken
50: branch 1 taken
1883 146: for (unsigned I = 0; I != NumParams; ++I)
34: branch 3 taken
62: branch 4 taken
1884 96: if (DeduceTemplateArgumentsDuringPartialOrdering(S,
1885 : TemplateParams,
1886 : Proto2->getArgType(I),
1887 : Proto1->getArgType(I),
1888 : Info,
1889 : Deduced,
1890 : QualifierComparisons))
1891 34: return false;
1892 :
1893 50: break;
1894 : }
1895 :
1896 : case TPOC_Conversion:
1897 : // - In the context of a call to a conversion operator, the return types
1898 : // of the conversion function templates are used.
6: branch 3 taken
6: branch 4 taken
1899 12: if (DeduceTemplateArgumentsDuringPartialOrdering(S,
1900 : TemplateParams,
1901 : Proto2->getResultType(),
1902 : Proto1->getResultType(),
1903 : Info,
1904 : Deduced,
1905 : QualifierComparisons))
1906 6: return false;
1907 6: break;
1908 :
1909 : case TPOC_Other:
1910 : // - In other contexts (14.6.6.2) the function template’s function type
1911 : // is used.
21: branch 3 taken
13: branch 4 taken
1912 34: if (DeduceTemplateArgumentsDuringPartialOrdering(S,
1913 : TemplateParams,
1914 : FD2->getType(),
1915 : FD1->getType(),
1916 : Info,
1917 : Deduced,
1918 : QualifierComparisons))
1919 21: return false;
1920 : break;
1921 : }
1922 :
1923 : // C++0x [temp.deduct.partial]p11:
1924 : // In most cases, all template parameters must have values in order for
1925 : // deduction to succeed, but for partial ordering purposes a template
1926 : // parameter may remain without a value provided it is not used in the
1927 : // types being used for partial ordering. [ Note: a template parameter used
1928 : // in a non-deduced context is considered used. -end note]
1929 69: unsigned ArgIdx = 0, NumArgs = Deduced.size();
94: branch 0 taken
55: branch 1 taken
1930 149: for (; ArgIdx != NumArgs; ++ArgIdx)
14: branch 2 taken
80: branch 3 taken
1931 94: if (Deduced[ArgIdx].isNull())
1932 14: break;
1933 :
55: branch 0 taken
14: branch 1 taken
1934 69: if (ArgIdx == NumArgs) {
1935 : // All template arguments were deduced. FT1 is at least as specialized
1936 : // as FT2.
1937 55: return true;
1938 : }
1939 :
1940 : // Figure out which template parameters were used.
1941 14: llvm::SmallVector<bool, 4> UsedParameters;
1942 14: UsedParameters.resize(TemplateParams->size());
14: branch 0 taken
0: branch 1 not taken
0: branch 2 not taken
0: branch 3 not taken
1943 14: switch (TPOC) {
1944 : case TPOC_Call: {
1945 14: unsigned NumParams = std::min(Proto1->getNumArgs(), Proto2->getNumArgs());
10: branch 0 taken
14: branch 1 taken
1946 24: for (unsigned I = 0; I != NumParams; ++I)
1947 : ::MarkUsedTemplateParameters(S, Proto2->getArgType(I), false,
1948 : TemplateParams->getDepth(),
1949 10: UsedParameters);
1950 14: break;
1951 : }
1952 :
1953 : case TPOC_Conversion:
1954 : ::MarkUsedTemplateParameters(S, Proto2->getResultType(), false,
1955 : TemplateParams->getDepth(),
1956 0: UsedParameters);
1957 0: break;
1958 :
1959 : case TPOC_Other:
1960 : ::MarkUsedTemplateParameters(S, FD2->getType(), false,
1961 : TemplateParams->getDepth(),
1962 0: UsedParameters);
1963 : break;
1964 : }
1965 :
16: branch 0 taken
10: branch 1 taken
1966 26: for (; ArgIdx != NumArgs; ++ArgIdx)
1967 : // If this argument had no value deduced but was used in one of the types
1968 : // used for partial ordering, then deduction fails.
14: branch 2 taken
2: branch 3 taken
4: branch 5 taken
10: branch 6 taken
4: branch 7 taken
12: branch 8 taken
1969 16: if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
1970 4: return false;
1971 :
1972 10: return true;
1973 : }
1974 :
1975 :
1976 : /// \brief Returns the more specialized function template according
1977 : /// to the rules of function template partial ordering (C++ [temp.func.order]).
1978 : ///
1979 : /// \param FT1 the first function template
1980 : ///
1981 : /// \param FT2 the second function template
1982 : ///
1983 : /// \param TPOC the context in which we are performing partial ordering of
1984 : /// function templates.
1985 : ///
1986 : /// \returns the more specialized function template. If neither
1987 : /// template is more specialized, returns NULL.
1988 : FunctionTemplateDecl *
1989 : Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
1990 : FunctionTemplateDecl *FT2,
1991 : SourceLocation Loc,
1992 65: TemplatePartialOrderingContext TPOC) {
1993 65: llvm::SmallVector<DeductionQualifierComparison, 4> QualifierComparisons;
1994 65: bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, 0);
1995 : bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
1996 65: &QualifierComparisons);
1997 :
41: branch 0 taken
24: branch 1 taken
1998 65: if (Better1 != Better2) // We have a clear winner
26: branch 0 taken
15: branch 1 taken
1999 41: return Better1? FT1 : FT2;
2000 :
12: branch 0 taken
12: branch 1 taken
12: branch 2 taken
0: branch 3 not taken
2001 24: if (!Better1 && !Better2) // Neither is better than the other
2002 12: return 0;
2003 :
2004 :
2005 : // C++0x [temp.deduct.partial]p10:
2006 : // If for each type being considered a given template is at least as
2007 : // specialized for all types and more specialized for some set of types and
2008 : // the other template is not more specialized for any types or is not at
2009 : // least as specialized for any types, then the given template is more
2010 : // specialized than the other template. Otherwise, neither template is more
2011 : // specialized than the other.
2012 12: Better1 = false;
2013 12: Better2 = false;
6: branch 1 taken
12: branch 2 taken
2014 18: for (unsigned I = 0, N = QualifierComparisons.size(); I != N; ++I) {
2015 : // C++0x [temp.deduct.partial]p9:
2016 : // If, for a given type, deduction succeeds in both directions (i.e., the
2017 : // types are identical after the transformations above) and if the type
2018 : // from the argument template is more cv-qualified than the type from the
2019 : // parameter template (as described above) that type is considered to be
2020 : // more specialized than the other. If neither type is more cv-qualified
2021 : // than the other then neither type is more specialized than the other.
2: branch 1 taken
2: branch 2 taken
2: branch 3 taken
0: branch 4 not taken
2022 6: switch (QualifierComparisons[I]) {
2023 : case NeitherMoreQualified:
2024 2: break;
2025 :
2026 : case ParamMoreQualified:
2027 2: Better1 = true;
0: branch 0 not taken
2: branch 1 taken
2028 2: if (Better2)
2029 0: return 0;
2030 2: break;
2031 :
2032 : case ArgMoreQualified:
2033 2: Better2 = true;
0: branch 0 not taken
2: branch 1 taken
2034 2: if (Better1)
2035 0: return 0;
2036 : break;
2037 : }
2038 : }
2039 :
2: branch 0 taken
10: branch 1 taken
0: branch 2 not taken
2: branch 3 taken
2040 12: assert(!(Better1 && Better2) && "Should have broken out in the loop above");
2: branch 0 taken
10: branch 1 taken
2041 12: if (Better1)
2042 2: return FT1;
2: branch 0 taken
8: branch 1 taken
2043 10: else if (Better2)
2044 2: return FT2;
2045 : else
2046 8: return 0;
2047 : }
2048 :
2049 : /// \brief Determine if the two templates are equivalent.
2050 17: static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2) {
11: branch 0 taken
6: branch 1 taken
2051 17: if (T1 == T2)
2052 11: return true;
2053 :
2: branch 0 taken
4: branch 1 taken
0: branch 2 not taken
2: branch 3 taken
2054 6: if (!T1 || !T2)
2055 4: return false;
2056 :
2057 2: return T1->getCanonicalDecl() == T2->getCanonicalDecl();
2058 : }
2059 :
2060 : /// \brief Retrieve the most specialized of the given function template
2061 : /// specializations.
2062 : ///
2063 : /// \param SpecBegin the start iterator of the function template
2064 : /// specializations that we will be comparing.
2065 : ///
2066 : /// \param SpecEnd the end iterator of the function template
2067 : /// specializations, paired with \p SpecBegin.
2068 : ///
2069 : /// \param TPOC the partial ordering context to use to compare the function
2070 : /// template specializations.
2071 : ///
2072 : /// \param Loc the location where the ambiguity or no-specializations
2073 : /// diagnostic should occur.
2074 : ///
2075 : /// \param NoneDiag partial diagnostic used to diagnose cases where there are
2076 : /// no matching candidates.
2077 : ///
2078 : /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
2079 : /// occurs.
2080 : ///
2081 : /// \param CandidateDiag partial diagnostic used for each function template
2082 : /// specialization that is a candidate in the ambiguous ordering. One parameter
2083 : /// in this diagnostic should be unbound, which will correspond to the string
2084 : /// describing the template arguments for the function template specialization.
2085 : ///
2086 : /// \param Index if non-NULL and the result of this function is non-nULL,
2087 : /// receives the index corresponding to the resulting function template
2088 : /// specialization.
2089 : ///
2090 : /// \returns the most specialized function template specialization, if
2091 : /// found. Otherwise, returns SpecEnd.
2092 : ///
2093 : /// \todo FIXME: Consider passing in the "also-ran" candidates that failed
2094 : /// template argument deduction.
2095 : UnresolvedSetIterator
2096 : Sema::getMostSpecialized(UnresolvedSetIterator SpecBegin,
2097 : UnresolvedSetIterator SpecEnd,
2098 : TemplatePartialOrderingContext TPOC,
2099 : SourceLocation Loc,
2100 : const PartialDiagnostic &NoneDiag,
2101 : const PartialDiagnostic &AmbigDiag,
2102 159: const PartialDiagnostic &CandidateDiag) {
7: branch 1 taken
152: branch 2 taken
2103 159: if (SpecBegin == SpecEnd) {
2104 7: Diag(Loc, NoneDiag);
2105 7: return SpecEnd;
2106 : }
2107 :
144: branch 2 taken
8: branch 3 taken
2108 152: if (SpecBegin + 1 == SpecEnd)
2109 144: return SpecBegin;
2110 :
2111 : // Find the function template that is better than all of the templates it
2112 : // has been compared to.
2113 8: UnresolvedSetIterator Best = SpecBegin;
2114 : FunctionTemplateDecl *BestTemplate
2115 8: = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
0: branch 0 not taken
8: branch 1 taken
2116 8: assert(BestTemplate && "Not a function template specialization?");
9: branch 3 taken
8: branch 4 taken
2117 17: for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
2118 : FunctionTemplateDecl *Challenger
2119 9: = cast<FunctionDecl>(*I)->getPrimaryTemplate();
0: branch 0 not taken
9: branch 1 taken
2120 9: assert(Challenger && "Not a function template specialization?");
5: branch 2 taken
4: branch 3 taken
2121 9: if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
2122 : Loc, TPOC),
2123 : Challenger)) {
2124 5: Best = I;
2125 5: BestTemplate = Challenger;
2126 : }
2127 : }
2128 :
2129 : // Make sure that the "best" function template is more specialized than all
2130 : // of the others.
2131 8: bool Ambiguous = false;
16: branch 2 taken
6: branch 3 taken
2132 22: for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
2133 : FunctionTemplateDecl *Challenger
2134 16: = cast<FunctionDecl>(*I)->getPrimaryTemplate();
8: branch 1 taken
8: branch 2 taken
2: branch 5 taken
6: branch 6 taken
2: branch 7 taken
14: branch 8 taken
2135 16: if (I != Best &&
2136 : !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
2137 : Loc, TPOC),
2138 : BestTemplate)) {
2139 2: Ambiguous = true;
2140 2: break;
2141 : }
2142 : }
2143 :
6: branch 0 taken
2: branch 1 taken
2144 8: if (!Ambiguous) {
2145 : // We found an answer. Return it.
2146 6: return Best;
2147 : }
2148 :
2149 : // Diagnose the ambiguity.
2150 2: Diag(Loc, AmbigDiag);
2151 :
2152 : // FIXME: Can we order the candidates in some sane way?
5: branch 2 taken
2: branch 3 taken
2153 7: for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I)
2154 : Diag((*I)->getLocation(), CandidateDiag)
2155 : << getTemplateArgumentBindingsText(
2156 : cast<FunctionDecl>(*I)->getPrimaryTemplate()->getTemplateParameters(),
2157 5: *cast<FunctionDecl>(*I)->getTemplateSpecializationArgs());
2158 :
2159 2: return SpecEnd;
2160 : }
2161 :
2162 : /// \brief Returns the more specialized class template partial specialization
2163 : /// according to the rules of partial ordering of class template partial
2164 : /// specializations (C++ [temp.class.order]).
2165 : ///
2166 : /// \param PS1 the first class template partial specialization
2167 : ///
2168 : /// \param PS2 the second class template partial specialization
2169 : ///
2170 : /// \returns the more specialized class template partial specialization. If
2171 : /// neither partial specialization is more specialized, returns NULL.
2172 : ClassTemplatePartialSpecializationDecl *
2173 : Sema::getMoreSpecializedPartialSpecialization(
2174 : ClassTemplatePartialSpecializationDecl *PS1,
2175 : ClassTemplatePartialSpecializationDecl *PS2,
2176 22: SourceLocation Loc) {
2177 : // C++ [temp.class.order]p1:
2178 : // For two class template partial specializations, the first is at least as
2179 : // specialized as the second if, given the following rewrite to two
2180 : // function templates, the first function template is at least as
2181 : // specialized as the second according to the ordering rules for function
2182 : // templates (14.6.6.2):
2183 : // - the first function template has the same template parameters as the
2184 : // first partial specialization and has a single function parameter
2185 : // whose type is a class template specialization with the template
2186 : // arguments of the first partial specialization, and
2187 : // - the second function template has the same template parameters as the
2188 : // second partial specialization and has a single function parameter
2189 : // whose type is a class template specialization with the template
2190 : // arguments of the second partial specialization.
2191 : //
2192 : // Rather than synthesize function templates, we merely perform the
2193 : // equivalent partial ordering by performing deduction directly on the
2194 : // template arguments of the class template partial specializations. This
2195 : // computation is slightly simpler than the general problem of function
2196 : // template partial ordering, because class template partial specializations
2197 : // are more constrained. We know that every template parameter is deduc
2198 22: llvm::SmallVector<TemplateArgument, 4> Deduced;
2199 22: Sema::TemplateDeductionInfo Info(Context, Loc);
2200 :
2201 : // Determine whether PS1 is at least as specialized as PS2
2202 22: Deduced.resize(PS2->getTemplateParameters()->size());
2203 : bool Better1 = !DeduceTemplateArgumentsDuringPartialOrdering(*this,
2204 : PS2->getTemplateParameters(),
2205 : Context.getTypeDeclType(PS2),
2206 : Context.getTypeDeclType(PS1),
2207 : Info,
2208 : Deduced,
2209 22: 0);
2210 :
2211 : // Determine whether PS2 is at least as specialized as PS1
2212 22: Deduced.clear();
2213 22: Deduced.resize(PS1->getTemplateParameters()->size());
2214 : bool Better2 = !DeduceTemplateArgumentsDuringPartialOrdering(*this,
2215 : PS1->getTemplateParameters(),
2216 : Context.getTypeDeclType(PS1),
2217 : Context.getTypeDeclType(PS2),
2218 : Info,
2219 : Deduced,
2220 22: 0);
2221 :
2: branch 0 taken
20: branch 1 taken
2222 22: if (Better1 == Better2)
2223 2: return 0;
2224 :
6: branch 0 taken
14: branch 1 taken
2225 20: return Better1? PS1 : PS2;
2226 : }
2227 :
2228 : static void
2229 : MarkUsedTemplateParameters(Sema &SemaRef,
2230 : const TemplateArgument &TemplateArg,
2231 : bool OnlyDeduced,
2232 : unsigned Depth,
2233 : llvm::SmallVectorImpl<bool> &Used);
2234 :
2235 : /// \brief Mark the template parameters that are used by the given
2236 : /// expression.
2237 : static void
2238 : MarkUsedTemplateParameters(Sema &SemaRef,
2239 : const Expr *E,
2240 : bool OnlyDeduced,
2241 : unsigned Depth,
2242 19: llvm::SmallVectorImpl<bool> &Used) {
2243 : // FIXME: if !OnlyDeduced, we have to walk the whole subexpression to
2244 : // find other occurrences of template parameters.
2245 19: const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
1: branch 0 taken
18: branch 1 taken
2246 19: if (!DRE)
2247 1: return;
2248 :
2249 : const NonTypeTemplateParmDecl *NTTP
2250 18: = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
0: branch 0 not taken
18: branch 1 taken
2251 18: if (!NTTP)
2252 0: return;
2253 :
18: branch 1 taken
0: branch 2 not taken
2254 18: if (NTTP->getDepth() == Depth)
2255 18: Used[NTTP->getIndex()] = true;
2256 : }
2257 :
2258 : /// \brief Mark the template parameters that are used by the given
2259 : /// nested name specifier.
2260 : static void
2261 : MarkUsedTemplateParameters(Sema &SemaRef,
2262 : NestedNameSpecifier *NNS,
2263 : bool OnlyDeduced,
2264 : unsigned Depth,
2265 8: llvm::SmallVectorImpl<bool> &Used) {
4: branch 0 taken
4: branch 1 taken
2266 8: if (!NNS)
2267 4: return;
2268 :
2269 : MarkUsedTemplateParameters(SemaRef, NNS->getPrefix(), OnlyDeduced, Depth,
2270 4: Used);
2271 : MarkUsedTemplateParameters(SemaRef, QualType(NNS->getAsType(), 0),
2272 4: OnlyDeduced, Depth, Used);
2273 : }
2274 :
2275 : /// \brief Mark the template parameters that are used by the given
2276 : /// template name.
2277 : static void
2278 : MarkUsedTemplateParameters(Sema &SemaRef,
2279 : TemplateName Name,
2280 : bool OnlyDeduced,
2281 : unsigned Depth,
2282 14: llvm::SmallVectorImpl<bool> &Used) {
14: branch 1 taken
0: branch 2 not taken
2283 14: if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
5: branch 0 taken
9: branch 1 taken
2284 14: if (TemplateTemplateParmDecl *TTP
2285 14: = dyn_cast<TemplateTemplateParmDecl>(Template)) {
5: branch 1 taken
0: branch 2 not taken
2286 5: if (TTP->getDepth() == Depth)
2287 5: Used[TTP->getIndex()] = true;
2288 : }
2289 14: return;
2290 : }
2291 :
0: branch 1 not taken
0: branch 2 not taken
2292 0: if (QualifiedTemplateName *QTN = Name.getAsQualifiedTemplateName())
2293 : MarkUsedTemplateParameters(SemaRef, QTN->getQualifier(), OnlyDeduced,
2294 0: Depth, Used);
0: branch 1 not taken
0: branch 2 not taken
2295 0: if (DependentTemplateName *DTN = Name.getAsDependentTemplateName())
2296 : MarkUsedTemplateParameters(SemaRef, DTN->getQualifier(), OnlyDeduced,
2297 0: Depth, Used);
2298 : }
2299 :
2300 : /// \brief Mark the template parameters that are used by the given
2301 : /// type.
2302 : static void
2303 : MarkUsedTemplateParameters(Sema &SemaRef, QualType T,
2304 : bool OnlyDeduced,
2305 : unsigned Depth,
2306 247: llvm::SmallVectorImpl<bool> &Used) {
0: branch 1 not taken
247: branch 2 taken
2307 247: if (T.isNull())
2308 0: return;
2309 :
2310 : // Non-dependent types have nothing deducible
14: branch 2 taken
233: branch 3 taken
2311 247: if (!T->isDependentType())
2312 14: return;
2313 :
2314 233: T = SemaRef.Context.getCanonicalType(T);
34: branch 2 taken
2: branch 3 taken
2: branch 4 taken
9: branch 5 taken
2: branch 6 taken
3: branch 7 taken
0: branch 8 not taken
0: branch 9 not taken
13: branch 10 taken
151: branch 11 taken
12: branch 12 taken
0: branch 13 not taken
5: branch 14 taken
0: branch 15 not taken
2315 233: switch (T->getTypeClass()) {
2316 : case Type::Pointer:
2317 : MarkUsedTemplateParameters(SemaRef,
2318 : cast<PointerType>(T)->getPointeeType(),
2319 : OnlyDeduced,
2320 : Depth,
2321 34: Used);
2322 34: break;
2323 :
2324 : case Type::BlockPointer:
2325 : MarkUsedTemplateParameters(SemaRef,
2326 : cast<BlockPointerType>(T)->getPointeeType(),
2327 : OnlyDeduced,
2328 : Depth,
2329 2: Used);
2330 2: break;
2331 :
2332 : case Type::LValueReference:
2333 : case Type::RValueReference:
2334 : MarkUsedTemplateParameters(SemaRef,
2335 : cast<ReferenceType>(T)->getPointeeType(),
2336 : OnlyDeduced,
2337 : Depth,
2338 2: Used);
2339 2: break;
2340 :
2341 : case Type::MemberPointer: {
2342 9: const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
2343 : MarkUsedTemplateParameters(SemaRef, MemPtr->getPointeeType(), OnlyDeduced,
2344 9: Depth, Used);
2345 : MarkUsedTemplateParameters(SemaRef, QualType(MemPtr->getClass(), 0),
2346 9: OnlyDeduced, Depth, Used);
2347 9: break;
2348 : }
2349 :
2350 : case Type::DependentSizedArray:
2351 : MarkUsedTemplateParameters(SemaRef,
2352 : cast<DependentSizedArrayType>(T)->getSizeExpr(),
2353 2: OnlyDeduced, Depth, Used);
2354 : // Fall through to check the element type
2355 :
2356 : case Type::ConstantArray:
2357 : case Type::IncompleteArray:
2358 : MarkUsedTemplateParameters(SemaRef,
2359 : cast<ArrayType>(T)->getElementType(),
2360 5: OnlyDeduced, Depth, Used);
2361 5: break;
2362 :
2363 : case Type::Vector:
2364 : case Type::ExtVector:
2365 : MarkUsedTemplateParameters(SemaRef,
2366 : cast<VectorType>(T)->getElementType(),
2367 0: OnlyDeduced, Depth, Used);
2368 0: break;
2369 :
2370 : case Type::DependentSizedExtVector: {
2371 : const DependentSizedExtVectorType *VecType
2372 0: = cast<DependentSizedExtVectorType>(T);
2373 : MarkUsedTemplateParameters(SemaRef, VecType->getElementType(), OnlyDeduced,
2374 0: Depth, Used);
2375 : MarkUsedTemplateParameters(SemaRef, VecType->getSizeExpr(), OnlyDeduced,
2376 0: Depth, Used);
2377 0: break;
2378 : }
2379 :
2380 : case Type::FunctionProto: {
2381 13: const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
2382 : MarkUsedTemplateParameters(SemaRef, Proto->getResultType(), OnlyDeduced,
2383 13: Depth, Used);
10: branch 1 taken
13: branch 2 taken
2384 23: for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I)
2385 : MarkUsedTemplateParameters(SemaRef, Proto->getArgType(I), OnlyDeduced,
2386 10: Depth, Used);
2387 13: break;
2388 : }
2389 :
2390 : case Type::TemplateTypeParm: {
2391 151: const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
149: branch 1 taken
2: branch 2 taken
2392 151: if (TTP->getDepth() == Depth)
2393 149: Used[TTP->getIndex()] = true;
2394 151: break;
2395 : }
2396 :
2397 : case Type::TemplateSpecialization: {
2398 : const TemplateSpecializationType *Spec
2399 12: = cast<TemplateSpecializationType>(T);
2400 : MarkUsedTemplateParameters(SemaRef, Spec->getTemplateName(), OnlyDeduced,
2401 12: Depth, Used);
17: branch 1 taken
12: branch 2 taken
2402 29: for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
2403 : MarkUsedTemplateParameters(SemaRef, Spec->getArg(I), OnlyDeduced, Depth,
2404 17: Used);
2405 12: break;
2406 : }
2407 :
2408 : case Type::Complex:
0: branch 0 not taken
0: branch 1 not taken
2409 0: if (!OnlyDeduced)
2410 : MarkUsedTemplateParameters(SemaRef,
2411 : cast<ComplexType>(T)->getElementType(),
2412 0: OnlyDeduced, Depth, Used);
2413 0: break;
2414 :
2415 : case Type::Typename:
4: branch 0 taken
1: branch 1 taken
2416 5: if (!OnlyDeduced)
2417 : MarkUsedTemplateParameters(SemaRef,
2418 : cast<TypenameType>(T)->getQualifier(),
2419 4: OnlyDeduced, Depth, Used);
2420 : break;
2421 :
2422 : // None of these types have any template parameters in them.
2423 : case Type::Builtin:
2424 : case Type::VariableArray:
2425 : case Type::FunctionNoProto:
2426 : case Type::Record:
2427 : case Type::Enum:
2428 : case Type::ObjCInterface:
2429 : case Type::ObjCObjectPointer:
2430 : case Type::UnresolvedUsing:
2431 : #define TYPE(Class, Base)
2432 : #define ABSTRACT_TYPE(Class, Base)
2433 : #define DEPENDENT_TYPE(Class, Base)
2434 : #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
2435 : #include "clang/AST/TypeNodes.def"
2436 : break;
2437 : }
2438 : }
2439 :
2440 : /// \brief Mark the template parameters that are used by this
2441 : /// template argument.
2442 : static void
2443 : MarkUsedTemplateParameters(Sema &SemaRef,
2444 : const TemplateArgument &TemplateArg,
2445 : bool OnlyDeduced,
2446 : unsigned Depth,
2447 173: llvm::SmallVectorImpl<bool> &Used) {
8: branch 1 taken
146: branch 2 taken
2: branch 3 taken
17: branch 4 taken
0: branch 5 not taken
0: branch 6 not taken
2448 173: switch (TemplateArg.getKind()) {
2449 : case TemplateArgument::Null:
2450 : case TemplateArgument::Integral:
2451 : case TemplateArgument::Declaration:
2452 8: break;
2453 :
2454 : case TemplateArgument::Type:
2455 : MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsType(), OnlyDeduced,
2456 146: Depth, Used);
2457 146: break;
2458 :
2459 : case TemplateArgument::Template:
2460 : MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsTemplate(),
2461 2: OnlyDeduced, Depth, Used);
2462 2: break;
2463 :
2464 : case TemplateArgument::Expression:
2465 : MarkUsedTemplateParameters(SemaRef, TemplateArg.getAsExpr(), OnlyDeduced,
2466 17: Depth, Used);
2467 17: break;
2468 :
2469 : case TemplateArgument::Pack:
0: branch 1 not taken
0: branch 2 not taken
2470 0: for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(),
2471 0: PEnd = TemplateArg.pack_end();
2472 : P != PEnd; ++P)
2473 0: MarkUsedTemplateParameters(SemaRef, *P, OnlyDeduced, Depth, Used);
2474 : break;
2475 : }
2476 173: }
2477 :
2478 : /// \brief Mark the template parameters can be deduced by the given
2479 : /// template argument list.
2480 : ///
2481 : /// \param TemplateArgs the template argument list from which template
2482 : /// parameters will be deduced.
2483 : ///
2484 : /// \param Deduced a bit vector whose elements will be set to \c true
2485 : /// to indicate when the corresponding template parameter will be
2486 : /// deduced.
2487 : void
2488 : Sema::MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
2489 : bool OnlyDeduced, unsigned Depth,
2490 89: llvm::SmallVectorImpl<bool> &Used) {
156: branch 1 taken
89: branch 2 taken
2491 245: for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
2492 : ::MarkUsedTemplateParameters(*this, TemplateArgs[I], OnlyDeduced,
2493 156: Depth, Used);
2494 89: }
2495 :
2496 : /// \brief Marks all of the template parameters that will be deduced by a
2497 : /// call to the given function template.
2498 : void Sema::MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate,
2499 3: llvm::SmallVectorImpl<bool> &Deduced) {
2500 : TemplateParameterList *TemplateParams
2501 3: = FunctionTemplate->getTemplateParameters();
2502 3: Deduced.clear();
2503 3: Deduced.resize(TemplateParams->size());
2504 :
2505 3: FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3: branch 1 taken
3: branch 2 taken
2506 6: for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
2507 : ::MarkUsedTemplateParameters(*this, Function->getParamDecl(I)->getType(),
2508 3: true, TemplateParams->getDepth(), Deduced);
2509 3: }
Generated: 2010-02-10 01:31 by zcov