File: | clang/lib/Sema/SemaTemplateDeduction.cpp |
Warning: | line 3666, column 31 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===// | ||||||
2 | // | ||||||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | ||||||
4 | // See https://llvm.org/LICENSE.txt for license information. | ||||||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | ||||||
6 | // | ||||||
7 | //===----------------------------------------------------------------------===// | ||||||
8 | // | ||||||
9 | // This file implements C++ template argument deduction. | ||||||
10 | // | ||||||
11 | //===----------------------------------------------------------------------===// | ||||||
12 | |||||||
13 | #include "clang/Sema/TemplateDeduction.h" | ||||||
14 | #include "TreeTransform.h" | ||||||
15 | #include "TypeLocBuilder.h" | ||||||
16 | #include "clang/AST/ASTContext.h" | ||||||
17 | #include "clang/AST/ASTLambda.h" | ||||||
18 | #include "clang/AST/Decl.h" | ||||||
19 | #include "clang/AST/DeclAccessPair.h" | ||||||
20 | #include "clang/AST/DeclBase.h" | ||||||
21 | #include "clang/AST/DeclCXX.h" | ||||||
22 | #include "clang/AST/DeclTemplate.h" | ||||||
23 | #include "clang/AST/DeclarationName.h" | ||||||
24 | #include "clang/AST/Expr.h" | ||||||
25 | #include "clang/AST/ExprCXX.h" | ||||||
26 | #include "clang/AST/NestedNameSpecifier.h" | ||||||
27 | #include "clang/AST/TemplateBase.h" | ||||||
28 | #include "clang/AST/TemplateName.h" | ||||||
29 | #include "clang/AST/Type.h" | ||||||
30 | #include "clang/AST/TypeLoc.h" | ||||||
31 | #include "clang/AST/UnresolvedSet.h" | ||||||
32 | #include "clang/Basic/AddressSpaces.h" | ||||||
33 | #include "clang/Basic/ExceptionSpecificationType.h" | ||||||
34 | #include "clang/Basic/LLVM.h" | ||||||
35 | #include "clang/Basic/LangOptions.h" | ||||||
36 | #include "clang/Basic/PartialDiagnostic.h" | ||||||
37 | #include "clang/Basic/SourceLocation.h" | ||||||
38 | #include "clang/Basic/Specifiers.h" | ||||||
39 | #include "clang/Sema/Ownership.h" | ||||||
40 | #include "clang/Sema/Sema.h" | ||||||
41 | #include "clang/Sema/Template.h" | ||||||
42 | #include "llvm/ADT/APInt.h" | ||||||
43 | #include "llvm/ADT/APSInt.h" | ||||||
44 | #include "llvm/ADT/ArrayRef.h" | ||||||
45 | #include "llvm/ADT/DenseMap.h" | ||||||
46 | #include "llvm/ADT/FoldingSet.h" | ||||||
47 | #include "llvm/ADT/Optional.h" | ||||||
48 | #include "llvm/ADT/SmallBitVector.h" | ||||||
49 | #include "llvm/ADT/SmallPtrSet.h" | ||||||
50 | #include "llvm/ADT/SmallVector.h" | ||||||
51 | #include "llvm/Support/Casting.h" | ||||||
52 | #include "llvm/Support/Compiler.h" | ||||||
53 | #include "llvm/Support/ErrorHandling.h" | ||||||
54 | #include <algorithm> | ||||||
55 | #include <cassert> | ||||||
56 | #include <tuple> | ||||||
57 | #include <utility> | ||||||
58 | |||||||
59 | namespace clang { | ||||||
60 | |||||||
61 | /// Various flags that control template argument deduction. | ||||||
62 | /// | ||||||
63 | /// These flags can be bitwise-OR'd together. | ||||||
64 | enum TemplateDeductionFlags { | ||||||
65 | /// No template argument deduction flags, which indicates the | ||||||
66 | /// strictest results for template argument deduction (as used for, e.g., | ||||||
67 | /// matching class template partial specializations). | ||||||
68 | TDF_None = 0, | ||||||
69 | |||||||
70 | /// Within template argument deduction from a function call, we are | ||||||
71 | /// matching with a parameter type for which the original parameter was | ||||||
72 | /// a reference. | ||||||
73 | TDF_ParamWithReferenceType = 0x1, | ||||||
74 | |||||||
75 | /// Within template argument deduction from a function call, we | ||||||
76 | /// are matching in a case where we ignore cv-qualifiers. | ||||||
77 | TDF_IgnoreQualifiers = 0x02, | ||||||
78 | |||||||
79 | /// Within template argument deduction from a function call, | ||||||
80 | /// we are matching in a case where we can perform template argument | ||||||
81 | /// deduction from a template-id of a derived class of the argument type. | ||||||
82 | TDF_DerivedClass = 0x04, | ||||||
83 | |||||||
84 | /// Allow non-dependent types to differ, e.g., when performing | ||||||
85 | /// template argument deduction from a function call where conversions | ||||||
86 | /// may apply. | ||||||
87 | TDF_SkipNonDependent = 0x08, | ||||||
88 | |||||||
89 | /// Whether we are performing template argument deduction for | ||||||
90 | /// parameters and arguments in a top-level template argument | ||||||
91 | TDF_TopLevelParameterTypeList = 0x10, | ||||||
92 | |||||||
93 | /// Within template argument deduction from overload resolution per | ||||||
94 | /// C++ [over.over] allow matching function types that are compatible in | ||||||
95 | /// terms of noreturn and default calling convention adjustments, or | ||||||
96 | /// similarly matching a declared template specialization against a | ||||||
97 | /// possible template, per C++ [temp.deduct.decl]. In either case, permit | ||||||
98 | /// deduction where the parameter is a function type that can be converted | ||||||
99 | /// to the argument type. | ||||||
100 | TDF_AllowCompatibleFunctionType = 0x20, | ||||||
101 | |||||||
102 | /// Within template argument deduction for a conversion function, we are | ||||||
103 | /// matching with an argument type for which the original argument was | ||||||
104 | /// a reference. | ||||||
105 | TDF_ArgWithReferenceType = 0x40, | ||||||
106 | }; | ||||||
107 | } | ||||||
108 | |||||||
109 | using namespace clang; | ||||||
110 | using namespace sema; | ||||||
111 | |||||||
112 | /// Compare two APSInts, extending and switching the sign as | ||||||
113 | /// necessary to compare their values regardless of underlying type. | ||||||
114 | static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) { | ||||||
115 | if (Y.getBitWidth() > X.getBitWidth()) | ||||||
116 | X = X.extend(Y.getBitWidth()); | ||||||
117 | else if (Y.getBitWidth() < X.getBitWidth()) | ||||||
118 | Y = Y.extend(X.getBitWidth()); | ||||||
119 | |||||||
120 | // If there is a signedness mismatch, correct it. | ||||||
121 | if (X.isSigned() != Y.isSigned()) { | ||||||
122 | // If the signed value is negative, then the values cannot be the same. | ||||||
123 | if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative())) | ||||||
124 | return false; | ||||||
125 | |||||||
126 | Y.setIsSigned(true); | ||||||
127 | X.setIsSigned(true); | ||||||
128 | } | ||||||
129 | |||||||
130 | return X == Y; | ||||||
131 | } | ||||||
132 | |||||||
133 | static Sema::TemplateDeductionResult | ||||||
134 | DeduceTemplateArguments(Sema &S, | ||||||
135 | TemplateParameterList *TemplateParams, | ||||||
136 | const TemplateArgument &Param, | ||||||
137 | TemplateArgument Arg, | ||||||
138 | TemplateDeductionInfo &Info, | ||||||
139 | SmallVectorImpl<DeducedTemplateArgument> &Deduced); | ||||||
140 | |||||||
141 | static Sema::TemplateDeductionResult | ||||||
142 | DeduceTemplateArgumentsByTypeMatch(Sema &S, | ||||||
143 | TemplateParameterList *TemplateParams, | ||||||
144 | QualType Param, | ||||||
145 | QualType Arg, | ||||||
146 | TemplateDeductionInfo &Info, | ||||||
147 | SmallVectorImpl<DeducedTemplateArgument> & | ||||||
148 | Deduced, | ||||||
149 | unsigned TDF, | ||||||
150 | bool PartialOrdering = false, | ||||||
151 | bool DeducedFromArrayBound = false); | ||||||
152 | |||||||
153 | static Sema::TemplateDeductionResult | ||||||
154 | DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, | ||||||
155 | ArrayRef<TemplateArgument> Params, | ||||||
156 | ArrayRef<TemplateArgument> Args, | ||||||
157 | TemplateDeductionInfo &Info, | ||||||
158 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
159 | bool NumberOfArgumentsMustMatch); | ||||||
160 | |||||||
161 | static void MarkUsedTemplateParameters(ASTContext &Ctx, | ||||||
162 | const TemplateArgument &TemplateArg, | ||||||
163 | bool OnlyDeduced, unsigned Depth, | ||||||
164 | llvm::SmallBitVector &Used); | ||||||
165 | |||||||
166 | static void MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, | ||||||
167 | bool OnlyDeduced, unsigned Level, | ||||||
168 | llvm::SmallBitVector &Deduced); | ||||||
169 | |||||||
170 | /// If the given expression is of a form that permits the deduction | ||||||
171 | /// of a non-type template parameter, return the declaration of that | ||||||
172 | /// non-type template parameter. | ||||||
173 | static NonTypeTemplateParmDecl * | ||||||
174 | getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E) { | ||||||
175 | // If we are within an alias template, the expression may have undergone | ||||||
176 | // any number of parameter substitutions already. | ||||||
177 | while (true) { | ||||||
178 | if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E)) | ||||||
179 | E = IC->getSubExpr(); | ||||||
180 | else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E)) | ||||||
181 | E = CE->getSubExpr(); | ||||||
182 | else if (SubstNonTypeTemplateParmExpr *Subst = | ||||||
183 | dyn_cast<SubstNonTypeTemplateParmExpr>(E)) | ||||||
184 | E = Subst->getReplacement(); | ||||||
185 | else | ||||||
186 | break; | ||||||
187 | } | ||||||
188 | |||||||
189 | if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) | ||||||
190 | if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) | ||||||
191 | if (NTTP->getDepth() == Info.getDeducedDepth()) | ||||||
192 | return NTTP; | ||||||
193 | |||||||
194 | return nullptr; | ||||||
195 | } | ||||||
196 | |||||||
197 | /// Determine whether two declaration pointers refer to the same | ||||||
198 | /// declaration. | ||||||
199 | static bool isSameDeclaration(Decl *X, Decl *Y) { | ||||||
200 | if (NamedDecl *NX = dyn_cast<NamedDecl>(X)) | ||||||
201 | X = NX->getUnderlyingDecl(); | ||||||
202 | if (NamedDecl *NY = dyn_cast<NamedDecl>(Y)) | ||||||
203 | Y = NY->getUnderlyingDecl(); | ||||||
204 | |||||||
205 | return X->getCanonicalDecl() == Y->getCanonicalDecl(); | ||||||
206 | } | ||||||
207 | |||||||
208 | /// Verify that the given, deduced template arguments are compatible. | ||||||
209 | /// | ||||||
210 | /// \returns The deduced template argument, or a NULL template argument if | ||||||
211 | /// the deduced template arguments were incompatible. | ||||||
212 | static DeducedTemplateArgument | ||||||
213 | checkDeducedTemplateArguments(ASTContext &Context, | ||||||
214 | const DeducedTemplateArgument &X, | ||||||
215 | const DeducedTemplateArgument &Y) { | ||||||
216 | // We have no deduction for one or both of the arguments; they're compatible. | ||||||
217 | if (X.isNull()) | ||||||
218 | return Y; | ||||||
219 | if (Y.isNull()) | ||||||
220 | return X; | ||||||
221 | |||||||
222 | // If we have two non-type template argument values deduced for the same | ||||||
223 | // parameter, they must both match the type of the parameter, and thus must | ||||||
224 | // match each other's type. As we're only keeping one of them, we must check | ||||||
225 | // for that now. The exception is that if either was deduced from an array | ||||||
226 | // bound, the type is permitted to differ. | ||||||
227 | if (!X.wasDeducedFromArrayBound() && !Y.wasDeducedFromArrayBound()) { | ||||||
228 | QualType XType = X.getNonTypeTemplateArgumentType(); | ||||||
229 | if (!XType.isNull()) { | ||||||
230 | QualType YType = Y.getNonTypeTemplateArgumentType(); | ||||||
231 | if (YType.isNull() || !Context.hasSameType(XType, YType)) | ||||||
232 | return DeducedTemplateArgument(); | ||||||
233 | } | ||||||
234 | } | ||||||
235 | |||||||
236 | switch (X.getKind()) { | ||||||
237 | case TemplateArgument::Null: | ||||||
238 | llvm_unreachable("Non-deduced template arguments handled above")::llvm::llvm_unreachable_internal("Non-deduced template arguments handled above" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 238); | ||||||
239 | |||||||
240 | case TemplateArgument::Type: | ||||||
241 | // If two template type arguments have the same type, they're compatible. | ||||||
242 | if (Y.getKind() == TemplateArgument::Type && | ||||||
243 | Context.hasSameType(X.getAsType(), Y.getAsType())) | ||||||
244 | return X; | ||||||
245 | |||||||
246 | // If one of the two arguments was deduced from an array bound, the other | ||||||
247 | // supersedes it. | ||||||
248 | if (X.wasDeducedFromArrayBound() != Y.wasDeducedFromArrayBound()) | ||||||
249 | return X.wasDeducedFromArrayBound() ? Y : X; | ||||||
250 | |||||||
251 | // The arguments are not compatible. | ||||||
252 | return DeducedTemplateArgument(); | ||||||
253 | |||||||
254 | case TemplateArgument::Integral: | ||||||
255 | // If we deduced a constant in one case and either a dependent expression or | ||||||
256 | // declaration in another case, keep the integral constant. | ||||||
257 | // If both are integral constants with the same value, keep that value. | ||||||
258 | if (Y.getKind() == TemplateArgument::Expression || | ||||||
259 | Y.getKind() == TemplateArgument::Declaration || | ||||||
260 | (Y.getKind() == TemplateArgument::Integral && | ||||||
261 | hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()))) | ||||||
262 | return X.wasDeducedFromArrayBound() ? Y : X; | ||||||
263 | |||||||
264 | // All other combinations are incompatible. | ||||||
265 | return DeducedTemplateArgument(); | ||||||
266 | |||||||
267 | case TemplateArgument::Template: | ||||||
268 | if (Y.getKind() == TemplateArgument::Template && | ||||||
269 | Context.hasSameTemplateName(X.getAsTemplate(), Y.getAsTemplate())) | ||||||
270 | return X; | ||||||
271 | |||||||
272 | // All other combinations are incompatible. | ||||||
273 | return DeducedTemplateArgument(); | ||||||
274 | |||||||
275 | case TemplateArgument::TemplateExpansion: | ||||||
276 | if (Y.getKind() == TemplateArgument::TemplateExpansion && | ||||||
277 | Context.hasSameTemplateName(X.getAsTemplateOrTemplatePattern(), | ||||||
278 | Y.getAsTemplateOrTemplatePattern())) | ||||||
279 | return X; | ||||||
280 | |||||||
281 | // All other combinations are incompatible. | ||||||
282 | return DeducedTemplateArgument(); | ||||||
283 | |||||||
284 | case TemplateArgument::Expression: { | ||||||
285 | if (Y.getKind() != TemplateArgument::Expression) | ||||||
286 | return checkDeducedTemplateArguments(Context, Y, X); | ||||||
287 | |||||||
288 | // Compare the expressions for equality | ||||||
289 | llvm::FoldingSetNodeID ID1, ID2; | ||||||
290 | X.getAsExpr()->Profile(ID1, Context, true); | ||||||
291 | Y.getAsExpr()->Profile(ID2, Context, true); | ||||||
292 | if (ID1 == ID2) | ||||||
293 | return X.wasDeducedFromArrayBound() ? Y : X; | ||||||
294 | |||||||
295 | // Differing dependent expressions are incompatible. | ||||||
296 | return DeducedTemplateArgument(); | ||||||
297 | } | ||||||
298 | |||||||
299 | case TemplateArgument::Declaration: | ||||||
300 | assert(!X.wasDeducedFromArrayBound())((!X.wasDeducedFromArrayBound()) ? static_cast<void> (0 ) : __assert_fail ("!X.wasDeducedFromArrayBound()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 300, __PRETTY_FUNCTION__)); | ||||||
301 | |||||||
302 | // If we deduced a declaration and a dependent expression, keep the | ||||||
303 | // declaration. | ||||||
304 | if (Y.getKind() == TemplateArgument::Expression) | ||||||
305 | return X; | ||||||
306 | |||||||
307 | // If we deduced a declaration and an integral constant, keep the | ||||||
308 | // integral constant and whichever type did not come from an array | ||||||
309 | // bound. | ||||||
310 | if (Y.getKind() == TemplateArgument::Integral) { | ||||||
311 | if (Y.wasDeducedFromArrayBound()) | ||||||
312 | return TemplateArgument(Context, Y.getAsIntegral(), | ||||||
313 | X.getParamTypeForDecl()); | ||||||
314 | return Y; | ||||||
315 | } | ||||||
316 | |||||||
317 | // If we deduced two declarations, make sure that they refer to the | ||||||
318 | // same declaration. | ||||||
319 | if (Y.getKind() == TemplateArgument::Declaration && | ||||||
320 | isSameDeclaration(X.getAsDecl(), Y.getAsDecl())) | ||||||
321 | return X; | ||||||
322 | |||||||
323 | // All other combinations are incompatible. | ||||||
324 | return DeducedTemplateArgument(); | ||||||
325 | |||||||
326 | case TemplateArgument::NullPtr: | ||||||
327 | // If we deduced a null pointer and a dependent expression, keep the | ||||||
328 | // null pointer. | ||||||
329 | if (Y.getKind() == TemplateArgument::Expression) | ||||||
330 | return X; | ||||||
331 | |||||||
332 | // If we deduced a null pointer and an integral constant, keep the | ||||||
333 | // integral constant. | ||||||
334 | if (Y.getKind() == TemplateArgument::Integral) | ||||||
335 | return Y; | ||||||
336 | |||||||
337 | // If we deduced two null pointers, they are the same. | ||||||
338 | if (Y.getKind() == TemplateArgument::NullPtr) | ||||||
339 | return X; | ||||||
340 | |||||||
341 | // All other combinations are incompatible. | ||||||
342 | return DeducedTemplateArgument(); | ||||||
343 | |||||||
344 | case TemplateArgument::Pack: { | ||||||
345 | if (Y.getKind() != TemplateArgument::Pack || | ||||||
346 | X.pack_size() != Y.pack_size()) | ||||||
347 | return DeducedTemplateArgument(); | ||||||
348 | |||||||
349 | llvm::SmallVector<TemplateArgument, 8> NewPack; | ||||||
350 | for (TemplateArgument::pack_iterator XA = X.pack_begin(), | ||||||
351 | XAEnd = X.pack_end(), | ||||||
352 | YA = Y.pack_begin(); | ||||||
353 | XA != XAEnd; ++XA, ++YA) { | ||||||
354 | TemplateArgument Merged = checkDeducedTemplateArguments( | ||||||
355 | Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), | ||||||
356 | DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())); | ||||||
357 | if (Merged.isNull()) | ||||||
358 | return DeducedTemplateArgument(); | ||||||
359 | NewPack.push_back(Merged); | ||||||
360 | } | ||||||
361 | |||||||
362 | return DeducedTemplateArgument( | ||||||
363 | TemplateArgument::CreatePackCopy(Context, NewPack), | ||||||
364 | X.wasDeducedFromArrayBound() && Y.wasDeducedFromArrayBound()); | ||||||
365 | } | ||||||
366 | } | ||||||
367 | |||||||
368 | llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 368); | ||||||
369 | } | ||||||
370 | |||||||
371 | /// Deduce the value of the given non-type template parameter | ||||||
372 | /// as the given deduced template argument. All non-type template parameter | ||||||
373 | /// deduction is funneled through here. | ||||||
374 | static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( | ||||||
375 | Sema &S, TemplateParameterList *TemplateParams, | ||||||
376 | NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced, | ||||||
377 | QualType ValueType, TemplateDeductionInfo &Info, | ||||||
378 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
379 | assert(NTTP->getDepth() == Info.getDeducedDepth() &&((NTTP->getDepth() == Info.getDeducedDepth() && "deducing non-type template argument with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"deducing non-type template argument with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 380, __PRETTY_FUNCTION__)) | ||||||
380 | "deducing non-type template argument with wrong depth")((NTTP->getDepth() == Info.getDeducedDepth() && "deducing non-type template argument with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"deducing non-type template argument with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 380, __PRETTY_FUNCTION__)); | ||||||
381 | |||||||
382 | DeducedTemplateArgument Result = checkDeducedTemplateArguments( | ||||||
383 | S.Context, Deduced[NTTP->getIndex()], NewDeduced); | ||||||
384 | if (Result.isNull()) { | ||||||
385 | Info.Param = NTTP; | ||||||
386 | Info.FirstArg = Deduced[NTTP->getIndex()]; | ||||||
387 | Info.SecondArg = NewDeduced; | ||||||
388 | return Sema::TDK_Inconsistent; | ||||||
389 | } | ||||||
390 | |||||||
391 | Deduced[NTTP->getIndex()] = Result; | ||||||
392 | if (!S.getLangOpts().CPlusPlus17) | ||||||
393 | return Sema::TDK_Success; | ||||||
394 | |||||||
395 | if (NTTP->isExpandedParameterPack()) | ||||||
396 | // FIXME: We may still need to deduce parts of the type here! But we | ||||||
397 | // don't have any way to find which slice of the type to use, and the | ||||||
398 | // type stored on the NTTP itself is nonsense. Perhaps the type of an | ||||||
399 | // expanded NTTP should be a pack expansion type? | ||||||
400 | return Sema::TDK_Success; | ||||||
401 | |||||||
402 | // Get the type of the parameter for deduction. If it's a (dependent) array | ||||||
403 | // or function type, we will not have decayed it yet, so do that now. | ||||||
404 | QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType()); | ||||||
405 | if (auto *Expansion = dyn_cast<PackExpansionType>(ParamType)) | ||||||
406 | ParamType = Expansion->getPattern(); | ||||||
407 | |||||||
408 | // FIXME: It's not clear how deduction of a parameter of reference | ||||||
409 | // type from an argument (of non-reference type) should be performed. | ||||||
410 | // For now, we just remove reference types from both sides and let | ||||||
411 | // the final check for matching types sort out the mess. | ||||||
412 | return DeduceTemplateArgumentsByTypeMatch( | ||||||
413 | S, TemplateParams, ParamType.getNonReferenceType(), | ||||||
414 | ValueType.getNonReferenceType(), Info, Deduced, TDF_SkipNonDependent, | ||||||
415 | /*PartialOrdering=*/false, | ||||||
416 | /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound()); | ||||||
417 | } | ||||||
418 | |||||||
419 | /// Deduce the value of the given non-type template parameter | ||||||
420 | /// from the given integral constant. | ||||||
421 | static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( | ||||||
422 | Sema &S, TemplateParameterList *TemplateParams, | ||||||
423 | NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value, | ||||||
424 | QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info, | ||||||
425 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
426 | return DeduceNonTypeTemplateArgument( | ||||||
427 | S, TemplateParams, NTTP, | ||||||
428 | DeducedTemplateArgument(S.Context, Value, ValueType, | ||||||
429 | DeducedFromArrayBound), | ||||||
430 | ValueType, Info, Deduced); | ||||||
431 | } | ||||||
432 | |||||||
433 | /// Deduce the value of the given non-type template parameter | ||||||
434 | /// from the given null pointer template argument type. | ||||||
435 | static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument( | ||||||
436 | Sema &S, TemplateParameterList *TemplateParams, | ||||||
437 | NonTypeTemplateParmDecl *NTTP, QualType NullPtrType, | ||||||
438 | TemplateDeductionInfo &Info, | ||||||
439 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
440 | Expr *Value = | ||||||
441 | S.ImpCastExprToType(new (S.Context) CXXNullPtrLiteralExpr( | ||||||
442 | S.Context.NullPtrTy, NTTP->getLocation()), | ||||||
443 | NullPtrType, CK_NullToPointer) | ||||||
444 | .get(); | ||||||
445 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
446 | DeducedTemplateArgument(Value), | ||||||
447 | Value->getType(), Info, Deduced); | ||||||
448 | } | ||||||
449 | |||||||
450 | /// Deduce the value of the given non-type template parameter | ||||||
451 | /// from the given type- or value-dependent expression. | ||||||
452 | /// | ||||||
453 | /// \returns true if deduction succeeded, false otherwise. | ||||||
454 | static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( | ||||||
455 | Sema &S, TemplateParameterList *TemplateParams, | ||||||
456 | NonTypeTemplateParmDecl *NTTP, Expr *Value, TemplateDeductionInfo &Info, | ||||||
457 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
458 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
459 | DeducedTemplateArgument(Value), | ||||||
460 | Value->getType(), Info, Deduced); | ||||||
461 | } | ||||||
462 | |||||||
463 | /// Deduce the value of the given non-type template parameter | ||||||
464 | /// from the given declaration. | ||||||
465 | /// | ||||||
466 | /// \returns true if deduction succeeded, false otherwise. | ||||||
467 | static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument( | ||||||
468 | Sema &S, TemplateParameterList *TemplateParams, | ||||||
469 | NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T, | ||||||
470 | TemplateDeductionInfo &Info, | ||||||
471 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
472 | D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr; | ||||||
473 | TemplateArgument New(D, T); | ||||||
474 | return DeduceNonTypeTemplateArgument( | ||||||
475 | S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced); | ||||||
476 | } | ||||||
477 | |||||||
478 | static Sema::TemplateDeductionResult | ||||||
479 | DeduceTemplateArguments(Sema &S, | ||||||
480 | TemplateParameterList *TemplateParams, | ||||||
481 | TemplateName Param, | ||||||
482 | TemplateName Arg, | ||||||
483 | TemplateDeductionInfo &Info, | ||||||
484 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
485 | TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); | ||||||
486 | if (!ParamDecl) { | ||||||
487 | // The parameter type is dependent and is not a template template parameter, | ||||||
488 | // so there is nothing that we can deduce. | ||||||
489 | return Sema::TDK_Success; | ||||||
490 | } | ||||||
491 | |||||||
492 | if (TemplateTemplateParmDecl *TempParam | ||||||
493 | = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { | ||||||
494 | // If we're not deducing at this depth, there's nothing to deduce. | ||||||
495 | if (TempParam->getDepth() != Info.getDeducedDepth()) | ||||||
496 | return Sema::TDK_Success; | ||||||
497 | |||||||
498 | DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); | ||||||
499 | DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, | ||||||
500 | Deduced[TempParam->getIndex()], | ||||||
501 | NewDeduced); | ||||||
502 | if (Result.isNull()) { | ||||||
503 | Info.Param = TempParam; | ||||||
504 | Info.FirstArg = Deduced[TempParam->getIndex()]; | ||||||
505 | Info.SecondArg = NewDeduced; | ||||||
506 | return Sema::TDK_Inconsistent; | ||||||
507 | } | ||||||
508 | |||||||
509 | Deduced[TempParam->getIndex()] = Result; | ||||||
510 | return Sema::TDK_Success; | ||||||
511 | } | ||||||
512 | |||||||
513 | // Verify that the two template names are equivalent. | ||||||
514 | if (S.Context.hasSameTemplateName(Param, Arg)) | ||||||
515 | return Sema::TDK_Success; | ||||||
516 | |||||||
517 | // Mismatch of non-dependent template parameter to argument. | ||||||
518 | Info.FirstArg = TemplateArgument(Param); | ||||||
519 | Info.SecondArg = TemplateArgument(Arg); | ||||||
520 | return Sema::TDK_NonDeducedMismatch; | ||||||
521 | } | ||||||
522 | |||||||
523 | /// Deduce the template arguments by comparing the template parameter | ||||||
524 | /// type (which is a template-id) with the template argument type. | ||||||
525 | /// | ||||||
526 | /// \param S the Sema | ||||||
527 | /// | ||||||
528 | /// \param TemplateParams the template parameters that we are deducing | ||||||
529 | /// | ||||||
530 | /// \param Param the parameter type | ||||||
531 | /// | ||||||
532 | /// \param Arg the argument type | ||||||
533 | /// | ||||||
534 | /// \param Info information about the template argument deduction itself | ||||||
535 | /// | ||||||
536 | /// \param Deduced the deduced template arguments | ||||||
537 | /// | ||||||
538 | /// \returns the result of template argument deduction so far. Note that a | ||||||
539 | /// "success" result means that template argument deduction has not yet failed, | ||||||
540 | /// but it may still fail, later, for other reasons. | ||||||
541 | static Sema::TemplateDeductionResult | ||||||
542 | DeduceTemplateArguments(Sema &S, | ||||||
543 | TemplateParameterList *TemplateParams, | ||||||
544 | const TemplateSpecializationType *Param, | ||||||
545 | QualType Arg, | ||||||
546 | TemplateDeductionInfo &Info, | ||||||
547 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
548 | assert(Arg.isCanonical() && "Argument type must be canonical")((Arg.isCanonical() && "Argument type must be canonical" ) ? static_cast<void> (0) : __assert_fail ("Arg.isCanonical() && \"Argument type must be canonical\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 548, __PRETTY_FUNCTION__)); | ||||||
549 | |||||||
550 | // Treat an injected-class-name as its underlying template-id. | ||||||
551 | if (auto *Injected = dyn_cast<InjectedClassNameType>(Arg)) | ||||||
552 | Arg = Injected->getInjectedSpecializationType(); | ||||||
553 | |||||||
554 | // Check whether the template argument is a dependent template-id. | ||||||
555 | if (const TemplateSpecializationType *SpecArg | ||||||
556 | = dyn_cast<TemplateSpecializationType>(Arg)) { | ||||||
557 | // Perform template argument deduction for the template name. | ||||||
558 | if (Sema::TemplateDeductionResult Result | ||||||
559 | = DeduceTemplateArguments(S, TemplateParams, | ||||||
560 | Param->getTemplateName(), | ||||||
561 | SpecArg->getTemplateName(), | ||||||
562 | Info, Deduced)) | ||||||
563 | return Result; | ||||||
564 | |||||||
565 | |||||||
566 | // Perform template argument deduction on each template | ||||||
567 | // argument. Ignore any missing/extra arguments, since they could be | ||||||
568 | // filled in by default arguments. | ||||||
569 | return DeduceTemplateArguments(S, TemplateParams, | ||||||
570 | Param->template_arguments(), | ||||||
571 | SpecArg->template_arguments(), Info, Deduced, | ||||||
572 | /*NumberOfArgumentsMustMatch=*/false); | ||||||
573 | } | ||||||
574 | |||||||
575 | // If the argument type is a class template specialization, we | ||||||
576 | // perform template argument deduction using its template | ||||||
577 | // arguments. | ||||||
578 | const RecordType *RecordArg = dyn_cast<RecordType>(Arg); | ||||||
579 | if (!RecordArg) { | ||||||
580 | Info.FirstArg = TemplateArgument(QualType(Param, 0)); | ||||||
581 | Info.SecondArg = TemplateArgument(Arg); | ||||||
582 | return Sema::TDK_NonDeducedMismatch; | ||||||
583 | } | ||||||
584 | |||||||
585 | ClassTemplateSpecializationDecl *SpecArg | ||||||
586 | = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl()); | ||||||
587 | if (!SpecArg) { | ||||||
588 | Info.FirstArg = TemplateArgument(QualType(Param, 0)); | ||||||
589 | Info.SecondArg = TemplateArgument(Arg); | ||||||
590 | return Sema::TDK_NonDeducedMismatch; | ||||||
591 | } | ||||||
592 | |||||||
593 | // Perform template argument deduction for the template name. | ||||||
594 | if (Sema::TemplateDeductionResult Result | ||||||
595 | = DeduceTemplateArguments(S, | ||||||
596 | TemplateParams, | ||||||
597 | Param->getTemplateName(), | ||||||
598 | TemplateName(SpecArg->getSpecializedTemplate()), | ||||||
599 | Info, Deduced)) | ||||||
600 | return Result; | ||||||
601 | |||||||
602 | // Perform template argument deduction for the template arguments. | ||||||
603 | return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(), | ||||||
604 | SpecArg->getTemplateArgs().asArray(), Info, | ||||||
605 | Deduced, /*NumberOfArgumentsMustMatch=*/true); | ||||||
606 | } | ||||||
607 | |||||||
608 | /// Determines whether the given type is an opaque type that | ||||||
609 | /// might be more qualified when instantiated. | ||||||
610 | static bool IsPossiblyOpaquelyQualifiedType(QualType T) { | ||||||
611 | switch (T->getTypeClass()) { | ||||||
612 | case Type::TypeOfExpr: | ||||||
613 | case Type::TypeOf: | ||||||
614 | case Type::DependentName: | ||||||
615 | case Type::Decltype: | ||||||
616 | case Type::UnresolvedUsing: | ||||||
617 | case Type::TemplateTypeParm: | ||||||
618 | return true; | ||||||
619 | |||||||
620 | case Type::ConstantArray: | ||||||
621 | case Type::IncompleteArray: | ||||||
622 | case Type::VariableArray: | ||||||
623 | case Type::DependentSizedArray: | ||||||
624 | return IsPossiblyOpaquelyQualifiedType( | ||||||
625 | cast<ArrayType>(T)->getElementType()); | ||||||
626 | |||||||
627 | default: | ||||||
628 | return false; | ||||||
629 | } | ||||||
630 | } | ||||||
631 | |||||||
632 | /// Helper function to build a TemplateParameter when we don't | ||||||
633 | /// know its type statically. | ||||||
634 | static TemplateParameter makeTemplateParameter(Decl *D) { | ||||||
635 | if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D)) | ||||||
636 | return TemplateParameter(TTP); | ||||||
637 | if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D)) | ||||||
638 | return TemplateParameter(NTTP); | ||||||
639 | |||||||
640 | return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); | ||||||
641 | } | ||||||
642 | |||||||
643 | /// If \p Param is an expanded parameter pack, get the number of expansions. | ||||||
644 | static Optional<unsigned> getExpandedPackSize(NamedDecl *Param) { | ||||||
645 | if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) | ||||||
646 | if (NTTP->isExpandedParameterPack()) | ||||||
647 | return NTTP->getNumExpansionTypes(); | ||||||
648 | |||||||
649 | if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) | ||||||
650 | if (TTP->isExpandedParameterPack()) | ||||||
651 | return TTP->getNumExpansionTemplateParameters(); | ||||||
652 | |||||||
653 | return None; | ||||||
654 | } | ||||||
655 | |||||||
656 | /// A pack that we're currently deducing. | ||||||
657 | struct clang::DeducedPack { | ||||||
658 | // The index of the pack. | ||||||
659 | unsigned Index; | ||||||
660 | |||||||
661 | // The old value of the pack before we started deducing it. | ||||||
662 | DeducedTemplateArgument Saved; | ||||||
663 | |||||||
664 | // A deferred value of this pack from an inner deduction, that couldn't be | ||||||
665 | // deduced because this deduction hadn't happened yet. | ||||||
666 | DeducedTemplateArgument DeferredDeduction; | ||||||
667 | |||||||
668 | // The new value of the pack. | ||||||
669 | SmallVector<DeducedTemplateArgument, 4> New; | ||||||
670 | |||||||
671 | // The outer deduction for this pack, if any. | ||||||
672 | DeducedPack *Outer = nullptr; | ||||||
673 | |||||||
674 | DeducedPack(unsigned Index) : Index(Index) {} | ||||||
675 | }; | ||||||
676 | |||||||
677 | namespace { | ||||||
678 | |||||||
679 | /// A scope in which we're performing pack deduction. | ||||||
680 | class PackDeductionScope { | ||||||
681 | public: | ||||||
682 | /// Prepare to deduce the packs named within Pattern. | ||||||
683 | PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, | ||||||
684 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
685 | TemplateDeductionInfo &Info, TemplateArgument Pattern) | ||||||
686 | : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { | ||||||
687 | unsigned NumNamedPacks = addPacks(Pattern); | ||||||
688 | finishConstruction(NumNamedPacks); | ||||||
689 | } | ||||||
690 | |||||||
691 | /// Prepare to directly deduce arguments of the parameter with index \p Index. | ||||||
692 | PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, | ||||||
693 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
694 | TemplateDeductionInfo &Info, unsigned Index) | ||||||
695 | : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { | ||||||
696 | addPack(Index); | ||||||
697 | finishConstruction(1); | ||||||
698 | } | ||||||
699 | |||||||
700 | private: | ||||||
701 | void addPack(unsigned Index) { | ||||||
702 | // Save the deduced template argument for the parameter pack expanded | ||||||
703 | // by this pack expansion, then clear out the deduction. | ||||||
704 | DeducedPack Pack(Index); | ||||||
705 | Pack.Saved = Deduced[Index]; | ||||||
706 | Deduced[Index] = TemplateArgument(); | ||||||
707 | |||||||
708 | // FIXME: What if we encounter multiple packs with different numbers of | ||||||
709 | // pre-expanded expansions? (This should already have been diagnosed | ||||||
710 | // during substitution.) | ||||||
711 | if (Optional<unsigned> ExpandedPackExpansions = | ||||||
712 | getExpandedPackSize(TemplateParams->getParam(Index))) | ||||||
713 | FixedNumExpansions = ExpandedPackExpansions; | ||||||
714 | |||||||
715 | Packs.push_back(Pack); | ||||||
716 | } | ||||||
717 | |||||||
718 | unsigned addPacks(TemplateArgument Pattern) { | ||||||
719 | // Compute the set of template parameter indices that correspond to | ||||||
720 | // parameter packs expanded by the pack expansion. | ||||||
721 | llvm::SmallBitVector SawIndices(TemplateParams->size()); | ||||||
722 | |||||||
723 | auto AddPack = [&](unsigned Index) { | ||||||
724 | if (SawIndices[Index]) | ||||||
725 | return; | ||||||
726 | SawIndices[Index] = true; | ||||||
727 | addPack(Index); | ||||||
728 | }; | ||||||
729 | |||||||
730 | // First look for unexpanded packs in the pattern. | ||||||
731 | SmallVector<UnexpandedParameterPack, 2> Unexpanded; | ||||||
732 | S.collectUnexpandedParameterPacks(Pattern, Unexpanded); | ||||||
733 | for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { | ||||||
734 | unsigned Depth, Index; | ||||||
735 | std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); | ||||||
736 | if (Depth == Info.getDeducedDepth()) | ||||||
737 | AddPack(Index); | ||||||
738 | } | ||||||
739 | assert(!Packs.empty() && "Pack expansion without unexpanded packs?")((!Packs.empty() && "Pack expansion without unexpanded packs?" ) ? static_cast<void> (0) : __assert_fail ("!Packs.empty() && \"Pack expansion without unexpanded packs?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 739, __PRETTY_FUNCTION__)); | ||||||
740 | |||||||
741 | unsigned NumNamedPacks = Packs.size(); | ||||||
742 | |||||||
743 | // We can also have deduced template parameters that do not actually | ||||||
744 | // appear in the pattern, but can be deduced by it (the type of a non-type | ||||||
745 | // template parameter pack, in particular). These won't have prevented us | ||||||
746 | // from partially expanding the pack. | ||||||
747 | llvm::SmallBitVector Used(TemplateParams->size()); | ||||||
748 | MarkUsedTemplateParameters(S.Context, Pattern, /*OnlyDeduced*/true, | ||||||
749 | Info.getDeducedDepth(), Used); | ||||||
750 | for (int Index = Used.find_first(); Index != -1; | ||||||
751 | Index = Used.find_next(Index)) | ||||||
752 | if (TemplateParams->getParam(Index)->isParameterPack()) | ||||||
753 | AddPack(Index); | ||||||
754 | |||||||
755 | return NumNamedPacks; | ||||||
756 | } | ||||||
757 | |||||||
758 | void finishConstruction(unsigned NumNamedPacks) { | ||||||
759 | // Dig out the partially-substituted pack, if there is one. | ||||||
760 | const TemplateArgument *PartialPackArgs = nullptr; | ||||||
761 | unsigned NumPartialPackArgs = 0; | ||||||
762 | std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u); | ||||||
763 | if (auto *Scope = S.CurrentInstantiationScope) | ||||||
764 | if (auto *Partial = Scope->getPartiallySubstitutedPack( | ||||||
765 | &PartialPackArgs, &NumPartialPackArgs)) | ||||||
766 | PartialPackDepthIndex = getDepthAndIndex(Partial); | ||||||
767 | |||||||
768 | // This pack expansion will have been partially or fully expanded if | ||||||
769 | // it only names explicitly-specified parameter packs (including the | ||||||
770 | // partially-substituted one, if any). | ||||||
771 | bool IsExpanded = true; | ||||||
772 | for (unsigned I = 0; I != NumNamedPacks; ++I) { | ||||||
773 | if (Packs[I].Index >= Info.getNumExplicitArgs()) { | ||||||
774 | IsExpanded = false; | ||||||
775 | IsPartiallyExpanded = false; | ||||||
776 | break; | ||||||
777 | } | ||||||
778 | if (PartialPackDepthIndex == | ||||||
779 | std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) { | ||||||
780 | IsPartiallyExpanded = true; | ||||||
781 | } | ||||||
782 | } | ||||||
783 | |||||||
784 | // Skip over the pack elements that were expanded into separate arguments. | ||||||
785 | // If we partially expanded, this is the number of partial arguments. | ||||||
786 | if (IsPartiallyExpanded) | ||||||
787 | PackElements += NumPartialPackArgs; | ||||||
788 | else if (IsExpanded) | ||||||
789 | PackElements += *FixedNumExpansions; | ||||||
790 | |||||||
791 | for (auto &Pack : Packs) { | ||||||
792 | if (Info.PendingDeducedPacks.size() > Pack.Index) | ||||||
793 | Pack.Outer = Info.PendingDeducedPacks[Pack.Index]; | ||||||
794 | else | ||||||
795 | Info.PendingDeducedPacks.resize(Pack.Index + 1); | ||||||
796 | Info.PendingDeducedPacks[Pack.Index] = &Pack; | ||||||
797 | |||||||
798 | if (PartialPackDepthIndex == | ||||||
799 | std::make_pair(Info.getDeducedDepth(), Pack.Index)) { | ||||||
800 | Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs); | ||||||
801 | // We pre-populate the deduced value of the partially-substituted | ||||||
802 | // pack with the specified value. This is not entirely correct: the | ||||||
803 | // value is supposed to have been substituted, not deduced, but the | ||||||
804 | // cases where this is observable require an exact type match anyway. | ||||||
805 | // | ||||||
806 | // FIXME: If we could represent a "depth i, index j, pack elem k" | ||||||
807 | // parameter, we could substitute the partially-substituted pack | ||||||
808 | // everywhere and avoid this. | ||||||
809 | if (!IsPartiallyExpanded) | ||||||
810 | Deduced[Pack.Index] = Pack.New[PackElements]; | ||||||
811 | } | ||||||
812 | } | ||||||
813 | } | ||||||
814 | |||||||
815 | public: | ||||||
816 | ~PackDeductionScope() { | ||||||
817 | for (auto &Pack : Packs) | ||||||
818 | Info.PendingDeducedPacks[Pack.Index] = Pack.Outer; | ||||||
819 | } | ||||||
820 | |||||||
821 | /// Determine whether this pack has already been partially expanded into a | ||||||
822 | /// sequence of (prior) function parameters / template arguments. | ||||||
823 | bool isPartiallyExpanded() { return IsPartiallyExpanded; } | ||||||
824 | |||||||
825 | /// Determine whether this pack expansion scope has a known, fixed arity. | ||||||
826 | /// This happens if it involves a pack from an outer template that has | ||||||
827 | /// (notionally) already been expanded. | ||||||
828 | bool hasFixedArity() { return FixedNumExpansions.hasValue(); } | ||||||
829 | |||||||
830 | /// Determine whether the next element of the argument is still part of this | ||||||
831 | /// pack. This is the case unless the pack is already expanded to a fixed | ||||||
832 | /// length. | ||||||
833 | bool hasNextElement() { | ||||||
834 | return !FixedNumExpansions || *FixedNumExpansions > PackElements; | ||||||
835 | } | ||||||
836 | |||||||
837 | /// Move to deducing the next element in each pack that is being deduced. | ||||||
838 | void nextPackElement() { | ||||||
839 | // Capture the deduced template arguments for each parameter pack expanded | ||||||
840 | // by this pack expansion, add them to the list of arguments we've deduced | ||||||
841 | // for that pack, then clear out the deduced argument. | ||||||
842 | for (auto &Pack : Packs) { | ||||||
843 | DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; | ||||||
844 | if (!Pack.New.empty() || !DeducedArg.isNull()) { | ||||||
845 | while (Pack.New.size() < PackElements) | ||||||
846 | Pack.New.push_back(DeducedTemplateArgument()); | ||||||
847 | if (Pack.New.size() == PackElements) | ||||||
848 | Pack.New.push_back(DeducedArg); | ||||||
849 | else | ||||||
850 | Pack.New[PackElements] = DeducedArg; | ||||||
851 | DeducedArg = Pack.New.size() > PackElements + 1 | ||||||
852 | ? Pack.New[PackElements + 1] | ||||||
853 | : DeducedTemplateArgument(); | ||||||
854 | } | ||||||
855 | } | ||||||
856 | ++PackElements; | ||||||
857 | } | ||||||
858 | |||||||
859 | /// Finish template argument deduction for a set of argument packs, | ||||||
860 | /// producing the argument packs and checking for consistency with prior | ||||||
861 | /// deductions. | ||||||
862 | Sema::TemplateDeductionResult | ||||||
863 | finish(bool TreatNoDeductionsAsNonDeduced = true) { | ||||||
864 | // Build argument packs for each of the parameter packs expanded by this | ||||||
865 | // pack expansion. | ||||||
866 | for (auto &Pack : Packs) { | ||||||
867 | // Put back the old value for this pack. | ||||||
868 | Deduced[Pack.Index] = Pack.Saved; | ||||||
869 | |||||||
870 | // If we are deducing the size of this pack even if we didn't deduce any | ||||||
871 | // values for it, then make sure we build a pack of the right size. | ||||||
872 | // FIXME: Should we always deduce the size, even if the pack appears in | ||||||
873 | // a non-deduced context? | ||||||
874 | if (!TreatNoDeductionsAsNonDeduced) | ||||||
875 | Pack.New.resize(PackElements); | ||||||
876 | |||||||
877 | // Build or find a new value for this pack. | ||||||
878 | DeducedTemplateArgument NewPack; | ||||||
879 | if (PackElements && Pack.New.empty()) { | ||||||
880 | if (Pack.DeferredDeduction.isNull()) { | ||||||
881 | // We were not able to deduce anything for this parameter pack | ||||||
882 | // (because it only appeared in non-deduced contexts), so just | ||||||
883 | // restore the saved argument pack. | ||||||
884 | continue; | ||||||
885 | } | ||||||
886 | |||||||
887 | NewPack = Pack.DeferredDeduction; | ||||||
888 | Pack.DeferredDeduction = TemplateArgument(); | ||||||
889 | } else if (Pack.New.empty()) { | ||||||
890 | // If we deduced an empty argument pack, create it now. | ||||||
891 | NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); | ||||||
892 | } else { | ||||||
893 | TemplateArgument *ArgumentPack = | ||||||
894 | new (S.Context) TemplateArgument[Pack.New.size()]; | ||||||
895 | std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); | ||||||
896 | NewPack = DeducedTemplateArgument( | ||||||
897 | TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())), | ||||||
898 | // FIXME: This is wrong, it's possible that some pack elements are | ||||||
899 | // deduced from an array bound and others are not: | ||||||
900 | // template<typename ...T, T ...V> void g(const T (&...p)[V]); | ||||||
901 | // g({1, 2, 3}, {{}, {}}); | ||||||
902 | // ... should deduce T = {int, size_t (from array bound)}. | ||||||
903 | Pack.New[0].wasDeducedFromArrayBound()); | ||||||
904 | } | ||||||
905 | |||||||
906 | // Pick where we're going to put the merged pack. | ||||||
907 | DeducedTemplateArgument *Loc; | ||||||
908 | if (Pack.Outer) { | ||||||
909 | if (Pack.Outer->DeferredDeduction.isNull()) { | ||||||
910 | // Defer checking this pack until we have a complete pack to compare | ||||||
911 | // it against. | ||||||
912 | Pack.Outer->DeferredDeduction = NewPack; | ||||||
913 | continue; | ||||||
914 | } | ||||||
915 | Loc = &Pack.Outer->DeferredDeduction; | ||||||
916 | } else { | ||||||
917 | Loc = &Deduced[Pack.Index]; | ||||||
918 | } | ||||||
919 | |||||||
920 | // Check the new pack matches any previous value. | ||||||
921 | DeducedTemplateArgument OldPack = *Loc; | ||||||
922 | DeducedTemplateArgument Result = | ||||||
923 | checkDeducedTemplateArguments(S.Context, OldPack, NewPack); | ||||||
924 | |||||||
925 | // If we deferred a deduction of this pack, check that one now too. | ||||||
926 | if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) { | ||||||
927 | OldPack = Result; | ||||||
928 | NewPack = Pack.DeferredDeduction; | ||||||
929 | Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); | ||||||
930 | } | ||||||
931 | |||||||
932 | NamedDecl *Param = TemplateParams->getParam(Pack.Index); | ||||||
933 | if (Result.isNull()) { | ||||||
934 | Info.Param = makeTemplateParameter(Param); | ||||||
935 | Info.FirstArg = OldPack; | ||||||
936 | Info.SecondArg = NewPack; | ||||||
937 | return Sema::TDK_Inconsistent; | ||||||
938 | } | ||||||
939 | |||||||
940 | // If we have a pre-expanded pack and we didn't deduce enough elements | ||||||
941 | // for it, fail deduction. | ||||||
942 | if (Optional<unsigned> Expansions = getExpandedPackSize(Param)) { | ||||||
943 | if (*Expansions != PackElements) { | ||||||
944 | Info.Param = makeTemplateParameter(Param); | ||||||
945 | Info.FirstArg = Result; | ||||||
946 | return Sema::TDK_IncompletePack; | ||||||
947 | } | ||||||
948 | } | ||||||
949 | |||||||
950 | *Loc = Result; | ||||||
951 | } | ||||||
952 | |||||||
953 | return Sema::TDK_Success; | ||||||
954 | } | ||||||
955 | |||||||
956 | private: | ||||||
957 | Sema &S; | ||||||
958 | TemplateParameterList *TemplateParams; | ||||||
959 | SmallVectorImpl<DeducedTemplateArgument> &Deduced; | ||||||
960 | TemplateDeductionInfo &Info; | ||||||
961 | unsigned PackElements = 0; | ||||||
962 | bool IsPartiallyExpanded = false; | ||||||
963 | /// The number of expansions, if we have a fully-expanded pack in this scope. | ||||||
964 | Optional<unsigned> FixedNumExpansions; | ||||||
965 | |||||||
966 | SmallVector<DeducedPack, 2> Packs; | ||||||
967 | }; | ||||||
968 | |||||||
969 | } // namespace | ||||||
970 | |||||||
971 | /// Deduce the template arguments by comparing the list of parameter | ||||||
972 | /// types to the list of argument types, as in the parameter-type-lists of | ||||||
973 | /// function types (C++ [temp.deduct.type]p10). | ||||||
974 | /// | ||||||
975 | /// \param S The semantic analysis object within which we are deducing | ||||||
976 | /// | ||||||
977 | /// \param TemplateParams The template parameters that we are deducing | ||||||
978 | /// | ||||||
979 | /// \param Params The list of parameter types | ||||||
980 | /// | ||||||
981 | /// \param NumParams The number of types in \c Params | ||||||
982 | /// | ||||||
983 | /// \param Args The list of argument types | ||||||
984 | /// | ||||||
985 | /// \param NumArgs The number of types in \c Args | ||||||
986 | /// | ||||||
987 | /// \param Info information about the template argument deduction itself | ||||||
988 | /// | ||||||
989 | /// \param Deduced the deduced template arguments | ||||||
990 | /// | ||||||
991 | /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe | ||||||
992 | /// how template argument deduction is performed. | ||||||
993 | /// | ||||||
994 | /// \param PartialOrdering If true, we are performing template argument | ||||||
995 | /// deduction for during partial ordering for a call | ||||||
996 | /// (C++0x [temp.deduct.partial]). | ||||||
997 | /// | ||||||
998 | /// \returns the result of template argument deduction so far. Note that a | ||||||
999 | /// "success" result means that template argument deduction has not yet failed, | ||||||
1000 | /// but it may still fail, later, for other reasons. | ||||||
1001 | static Sema::TemplateDeductionResult | ||||||
1002 | DeduceTemplateArguments(Sema &S, | ||||||
1003 | TemplateParameterList *TemplateParams, | ||||||
1004 | const QualType *Params, unsigned NumParams, | ||||||
1005 | const QualType *Args, unsigned NumArgs, | ||||||
1006 | TemplateDeductionInfo &Info, | ||||||
1007 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
1008 | unsigned TDF, | ||||||
1009 | bool PartialOrdering = false) { | ||||||
1010 | // C++0x [temp.deduct.type]p10: | ||||||
1011 | // Similarly, if P has a form that contains (T), then each parameter type | ||||||
1012 | // Pi of the respective parameter-type- list of P is compared with the | ||||||
1013 | // corresponding parameter type Ai of the corresponding parameter-type-list | ||||||
1014 | // of A. [...] | ||||||
1015 | unsigned ArgIdx = 0, ParamIdx = 0; | ||||||
1016 | for (; ParamIdx != NumParams; ++ParamIdx) { | ||||||
1017 | // Check argument types. | ||||||
1018 | const PackExpansionType *Expansion | ||||||
1019 | = dyn_cast<PackExpansionType>(Params[ParamIdx]); | ||||||
1020 | if (!Expansion) { | ||||||
1021 | // Simple case: compare the parameter and argument types at this point. | ||||||
1022 | |||||||
1023 | // Make sure we have an argument. | ||||||
1024 | if (ArgIdx >= NumArgs) | ||||||
1025 | return Sema::TDK_MiscellaneousDeductionFailure; | ||||||
1026 | |||||||
1027 | if (isa<PackExpansionType>(Args[ArgIdx])) { | ||||||
1028 | // C++0x [temp.deduct.type]p22: | ||||||
1029 | // If the original function parameter associated with A is a function | ||||||
1030 | // parameter pack and the function parameter associated with P is not | ||||||
1031 | // a function parameter pack, then template argument deduction fails. | ||||||
1032 | return Sema::TDK_MiscellaneousDeductionFailure; | ||||||
1033 | } | ||||||
1034 | |||||||
1035 | if (Sema::TemplateDeductionResult Result | ||||||
1036 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1037 | Params[ParamIdx], Args[ArgIdx], | ||||||
1038 | Info, Deduced, TDF, | ||||||
1039 | PartialOrdering)) | ||||||
1040 | return Result; | ||||||
1041 | |||||||
1042 | ++ArgIdx; | ||||||
1043 | continue; | ||||||
1044 | } | ||||||
1045 | |||||||
1046 | // C++0x [temp.deduct.type]p10: | ||||||
1047 | // If the parameter-declaration corresponding to Pi is a function | ||||||
1048 | // parameter pack, then the type of its declarator- id is compared with | ||||||
1049 | // each remaining parameter type in the parameter-type-list of A. Each | ||||||
1050 | // comparison deduces template arguments for subsequent positions in the | ||||||
1051 | // template parameter packs expanded by the function parameter pack. | ||||||
1052 | |||||||
1053 | QualType Pattern = Expansion->getPattern(); | ||||||
1054 | PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); | ||||||
1055 | |||||||
1056 | // A pack scope with fixed arity is not really a pack any more, so is not | ||||||
1057 | // a non-deduced context. | ||||||
1058 | if (ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) { | ||||||
1059 | for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) { | ||||||
1060 | // Deduce template arguments from the pattern. | ||||||
1061 | if (Sema::TemplateDeductionResult Result | ||||||
1062 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, | ||||||
1063 | Args[ArgIdx], Info, Deduced, | ||||||
1064 | TDF, PartialOrdering)) | ||||||
1065 | return Result; | ||||||
1066 | |||||||
1067 | PackScope.nextPackElement(); | ||||||
1068 | } | ||||||
1069 | } else { | ||||||
1070 | // C++0x [temp.deduct.type]p5: | ||||||
1071 | // The non-deduced contexts are: | ||||||
1072 | // - A function parameter pack that does not occur at the end of the | ||||||
1073 | // parameter-declaration-clause. | ||||||
1074 | // | ||||||
1075 | // FIXME: There is no wording to say what we should do in this case. We | ||||||
1076 | // choose to resolve this by applying the same rule that is applied for a | ||||||
1077 | // function call: that is, deduce all contained packs to their | ||||||
1078 | // explicitly-specified values (or to <> if there is no such value). | ||||||
1079 | // | ||||||
1080 | // This is seemingly-arbitrarily different from the case of a template-id | ||||||
1081 | // with a non-trailing pack-expansion in its arguments, which renders the | ||||||
1082 | // entire template-argument-list a non-deduced context. | ||||||
1083 | |||||||
1084 | // If the parameter type contains an explicitly-specified pack that we | ||||||
1085 | // could not expand, skip the number of parameters notionally created | ||||||
1086 | // by the expansion. | ||||||
1087 | Optional<unsigned> NumExpansions = Expansion->getNumExpansions(); | ||||||
1088 | if (NumExpansions && !PackScope.isPartiallyExpanded()) { | ||||||
1089 | for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs; | ||||||
1090 | ++I, ++ArgIdx) | ||||||
1091 | PackScope.nextPackElement(); | ||||||
1092 | } | ||||||
1093 | } | ||||||
1094 | |||||||
1095 | // Build argument packs for each of the parameter packs expanded by this | ||||||
1096 | // pack expansion. | ||||||
1097 | if (auto Result = PackScope.finish()) | ||||||
1098 | return Result; | ||||||
1099 | } | ||||||
1100 | |||||||
1101 | // Make sure we don't have any extra arguments. | ||||||
1102 | if (ArgIdx < NumArgs) | ||||||
1103 | return Sema::TDK_MiscellaneousDeductionFailure; | ||||||
1104 | |||||||
1105 | return Sema::TDK_Success; | ||||||
1106 | } | ||||||
1107 | |||||||
1108 | /// Determine whether the parameter has qualifiers that the argument | ||||||
1109 | /// lacks. Put another way, determine whether there is no way to add | ||||||
1110 | /// a deduced set of qualifiers to the ParamType that would result in | ||||||
1111 | /// its qualifiers matching those of the ArgType. | ||||||
1112 | static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, | ||||||
1113 | QualType ArgType) { | ||||||
1114 | Qualifiers ParamQs = ParamType.getQualifiers(); | ||||||
1115 | Qualifiers ArgQs = ArgType.getQualifiers(); | ||||||
1116 | |||||||
1117 | if (ParamQs == ArgQs) | ||||||
1118 | return false; | ||||||
1119 | |||||||
1120 | // Mismatched (but not missing) Objective-C GC attributes. | ||||||
1121 | if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() && | ||||||
1122 | ParamQs.hasObjCGCAttr()) | ||||||
1123 | return true; | ||||||
1124 | |||||||
1125 | // Mismatched (but not missing) address spaces. | ||||||
1126 | if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() && | ||||||
1127 | ParamQs.hasAddressSpace()) | ||||||
1128 | return true; | ||||||
1129 | |||||||
1130 | // Mismatched (but not missing) Objective-C lifetime qualifiers. | ||||||
1131 | if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() && | ||||||
1132 | ParamQs.hasObjCLifetime()) | ||||||
1133 | return true; | ||||||
1134 | |||||||
1135 | // CVR qualifiers inconsistent or a superset. | ||||||
1136 | return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0; | ||||||
1137 | } | ||||||
1138 | |||||||
1139 | /// Compare types for equality with respect to possibly compatible | ||||||
1140 | /// function types (noreturn adjustment, implicit calling conventions). If any | ||||||
1141 | /// of parameter and argument is not a function, just perform type comparison. | ||||||
1142 | /// | ||||||
1143 | /// \param Param the template parameter type. | ||||||
1144 | /// | ||||||
1145 | /// \param Arg the argument type. | ||||||
1146 | bool Sema::isSameOrCompatibleFunctionType(CanQualType Param, | ||||||
1147 | CanQualType Arg) { | ||||||
1148 | const FunctionType *ParamFunction = Param->getAs<FunctionType>(), | ||||||
1149 | *ArgFunction = Arg->getAs<FunctionType>(); | ||||||
1150 | |||||||
1151 | // Just compare if not functions. | ||||||
1152 | if (!ParamFunction || !ArgFunction) | ||||||
1153 | return Param == Arg; | ||||||
1154 | |||||||
1155 | // Noreturn and noexcept adjustment. | ||||||
1156 | QualType AdjustedParam; | ||||||
1157 | if (IsFunctionConversion(Param, Arg, AdjustedParam)) | ||||||
1158 | return Arg == Context.getCanonicalType(AdjustedParam); | ||||||
1159 | |||||||
1160 | // FIXME: Compatible calling conventions. | ||||||
1161 | |||||||
1162 | return Param == Arg; | ||||||
1163 | } | ||||||
1164 | |||||||
1165 | /// Get the index of the first template parameter that was originally from the | ||||||
1166 | /// innermost template-parameter-list. This is 0 except when we concatenate | ||||||
1167 | /// the template parameter lists of a class template and a constructor template | ||||||
1168 | /// when forming an implicit deduction guide. | ||||||
1169 | static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD) { | ||||||
1170 | auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl()); | ||||||
1171 | if (!Guide || !Guide->isImplicit()) | ||||||
1172 | return 0; | ||||||
1173 | return Guide->getDeducedTemplate()->getTemplateParameters()->size(); | ||||||
1174 | } | ||||||
1175 | |||||||
1176 | /// Determine whether a type denotes a forwarding reference. | ||||||
1177 | static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex) { | ||||||
1178 | // C++1z [temp.deduct.call]p3: | ||||||
1179 | // A forwarding reference is an rvalue reference to a cv-unqualified | ||||||
1180 | // template parameter that does not represent a template parameter of a | ||||||
1181 | // class template. | ||||||
1182 | if (auto *ParamRef = Param->getAs<RValueReferenceType>()) { | ||||||
1183 | if (ParamRef->getPointeeType().getQualifiers()) | ||||||
1184 | return false; | ||||||
1185 | auto *TypeParm = ParamRef->getPointeeType()->getAs<TemplateTypeParmType>(); | ||||||
1186 | return TypeParm && TypeParm->getIndex() >= FirstInnerIndex; | ||||||
1187 | } | ||||||
1188 | return false; | ||||||
1189 | } | ||||||
1190 | |||||||
1191 | /// Deduce the template arguments by comparing the parameter type and | ||||||
1192 | /// the argument type (C++ [temp.deduct.type]). | ||||||
1193 | /// | ||||||
1194 | /// \param S the semantic analysis object within which we are deducing | ||||||
1195 | /// | ||||||
1196 | /// \param TemplateParams the template parameters that we are deducing | ||||||
1197 | /// | ||||||
1198 | /// \param ParamIn the parameter type | ||||||
1199 | /// | ||||||
1200 | /// \param ArgIn the argument type | ||||||
1201 | /// | ||||||
1202 | /// \param Info information about the template argument deduction itself | ||||||
1203 | /// | ||||||
1204 | /// \param Deduced the deduced template arguments | ||||||
1205 | /// | ||||||
1206 | /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe | ||||||
1207 | /// how template argument deduction is performed. | ||||||
1208 | /// | ||||||
1209 | /// \param PartialOrdering Whether we're performing template argument deduction | ||||||
1210 | /// in the context of partial ordering (C++0x [temp.deduct.partial]). | ||||||
1211 | /// | ||||||
1212 | /// \returns the result of template argument deduction so far. Note that a | ||||||
1213 | /// "success" result means that template argument deduction has not yet failed, | ||||||
1214 | /// but it may still fail, later, for other reasons. | ||||||
1215 | static Sema::TemplateDeductionResult | ||||||
1216 | DeduceTemplateArgumentsByTypeMatch(Sema &S, | ||||||
1217 | TemplateParameterList *TemplateParams, | ||||||
1218 | QualType ParamIn, QualType ArgIn, | ||||||
1219 | TemplateDeductionInfo &Info, | ||||||
1220 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
1221 | unsigned TDF, | ||||||
1222 | bool PartialOrdering, | ||||||
1223 | bool DeducedFromArrayBound) { | ||||||
1224 | // We only want to look at the canonical types, since typedefs and | ||||||
1225 | // sugar are not part of template argument deduction. | ||||||
1226 | QualType Param = S.Context.getCanonicalType(ParamIn); | ||||||
1227 | QualType Arg = S.Context.getCanonicalType(ArgIn); | ||||||
1228 | |||||||
1229 | // If the argument type is a pack expansion, look at its pattern. | ||||||
1230 | // This isn't explicitly called out | ||||||
1231 | if (const PackExpansionType *ArgExpansion | ||||||
1232 | = dyn_cast<PackExpansionType>(Arg)) | ||||||
1233 | Arg = ArgExpansion->getPattern(); | ||||||
1234 | |||||||
1235 | if (PartialOrdering) { | ||||||
1236 | // C++11 [temp.deduct.partial]p5: | ||||||
1237 | // Before the partial ordering is done, certain transformations are | ||||||
1238 | // performed on the types used for partial ordering: | ||||||
1239 | // - If P is a reference type, P is replaced by the type referred to. | ||||||
1240 | const ReferenceType *ParamRef = Param->getAs<ReferenceType>(); | ||||||
1241 | if (ParamRef) | ||||||
1242 | Param = ParamRef->getPointeeType(); | ||||||
1243 | |||||||
1244 | // - If A is a reference type, A is replaced by the type referred to. | ||||||
1245 | const ReferenceType *ArgRef = Arg->getAs<ReferenceType>(); | ||||||
1246 | if (ArgRef) | ||||||
1247 | Arg = ArgRef->getPointeeType(); | ||||||
1248 | |||||||
1249 | if (ParamRef && ArgRef && S.Context.hasSameUnqualifiedType(Param, Arg)) { | ||||||
1250 | // C++11 [temp.deduct.partial]p9: | ||||||
1251 | // If, for a given type, deduction succeeds in both directions (i.e., | ||||||
1252 | // the types are identical after the transformations above) and both | ||||||
1253 | // P and A were reference types [...]: | ||||||
1254 | // - if [one type] was an lvalue reference and [the other type] was | ||||||
1255 | // not, [the other type] is not considered to be at least as | ||||||
1256 | // specialized as [the first type] | ||||||
1257 | // - if [one type] is more cv-qualified than [the other type], | ||||||
1258 | // [the other type] is not considered to be at least as specialized | ||||||
1259 | // as [the first type] | ||||||
1260 | // Objective-C ARC adds: | ||||||
1261 | // - [one type] has non-trivial lifetime, [the other type] has | ||||||
1262 | // __unsafe_unretained lifetime, and the types are otherwise | ||||||
1263 | // identical | ||||||
1264 | // | ||||||
1265 | // A is "considered to be at least as specialized" as P iff deduction | ||||||
1266 | // succeeds, so we model this as a deduction failure. Note that | ||||||
1267 | // [the first type] is P and [the other type] is A here; the standard | ||||||
1268 | // gets this backwards. | ||||||
1269 | Qualifiers ParamQuals = Param.getQualifiers(); | ||||||
1270 | Qualifiers ArgQuals = Arg.getQualifiers(); | ||||||
1271 | if ((ParamRef->isLValueReferenceType() && | ||||||
1272 | !ArgRef->isLValueReferenceType()) || | ||||||
1273 | ParamQuals.isStrictSupersetOf(ArgQuals) || | ||||||
1274 | (ParamQuals.hasNonTrivialObjCLifetime() && | ||||||
1275 | ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && | ||||||
1276 | ParamQuals.withoutObjCLifetime() == | ||||||
1277 | ArgQuals.withoutObjCLifetime())) { | ||||||
1278 | Info.FirstArg = TemplateArgument(ParamIn); | ||||||
1279 | Info.SecondArg = TemplateArgument(ArgIn); | ||||||
1280 | return Sema::TDK_NonDeducedMismatch; | ||||||
1281 | } | ||||||
1282 | } | ||||||
1283 | |||||||
1284 | // C++11 [temp.deduct.partial]p7: | ||||||
1285 | // Remove any top-level cv-qualifiers: | ||||||
1286 | // - If P is a cv-qualified type, P is replaced by the cv-unqualified | ||||||
1287 | // version of P. | ||||||
1288 | Param = Param.getUnqualifiedType(); | ||||||
1289 | // - If A is a cv-qualified type, A is replaced by the cv-unqualified | ||||||
1290 | // version of A. | ||||||
1291 | Arg = Arg.getUnqualifiedType(); | ||||||
1292 | } else { | ||||||
1293 | // C++0x [temp.deduct.call]p4 bullet 1: | ||||||
1294 | // - If the original P is a reference type, the deduced A (i.e., the type | ||||||
1295 | // referred to by the reference) can be more cv-qualified than the | ||||||
1296 | // transformed A. | ||||||
1297 | if (TDF & TDF_ParamWithReferenceType) { | ||||||
1298 | Qualifiers Quals; | ||||||
1299 | QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals); | ||||||
1300 | Quals.setCVRQualifiers(Quals.getCVRQualifiers() & | ||||||
1301 | Arg.getCVRQualifiers()); | ||||||
1302 | Param = S.Context.getQualifiedType(UnqualParam, Quals); | ||||||
1303 | } | ||||||
1304 | |||||||
1305 | if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) { | ||||||
1306 | // C++0x [temp.deduct.type]p10: | ||||||
1307 | // If P and A are function types that originated from deduction when | ||||||
1308 | // taking the address of a function template (14.8.2.2) or when deducing | ||||||
1309 | // template arguments from a function declaration (14.8.2.6) and Pi and | ||||||
1310 | // Ai are parameters of the top-level parameter-type-list of P and A, | ||||||
1311 | // respectively, Pi is adjusted if it is a forwarding reference and Ai | ||||||
1312 | // is an lvalue reference, in | ||||||
1313 | // which case the type of Pi is changed to be the template parameter | ||||||
1314 | // type (i.e., T&& is changed to simply T). [ Note: As a result, when | ||||||
1315 | // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be | ||||||
1316 | // deduced as X&. - end note ] | ||||||
1317 | TDF &= ~TDF_TopLevelParameterTypeList; | ||||||
1318 | if (isForwardingReference(Param, 0) && Arg->isLValueReferenceType()) | ||||||
1319 | Param = Param->getPointeeType(); | ||||||
1320 | } | ||||||
1321 | } | ||||||
1322 | |||||||
1323 | // C++ [temp.deduct.type]p9: | ||||||
1324 | // A template type argument T, a template template argument TT or a | ||||||
1325 | // template non-type argument i can be deduced if P and A have one of | ||||||
1326 | // the following forms: | ||||||
1327 | // | ||||||
1328 | // T | ||||||
1329 | // cv-list T | ||||||
1330 | if (const TemplateTypeParmType *TemplateTypeParm | ||||||
1331 | = Param->getAs<TemplateTypeParmType>()) { | ||||||
1332 | // Just skip any attempts to deduce from a placeholder type or a parameter | ||||||
1333 | // at a different depth. | ||||||
1334 | if (Arg->isPlaceholderType() || | ||||||
1335 | Info.getDeducedDepth() != TemplateTypeParm->getDepth()) | ||||||
1336 | return Sema::TDK_Success; | ||||||
1337 | |||||||
1338 | unsigned Index = TemplateTypeParm->getIndex(); | ||||||
1339 | bool RecanonicalizeArg = false; | ||||||
1340 | |||||||
1341 | // If the argument type is an array type, move the qualifiers up to the | ||||||
1342 | // top level, so they can be matched with the qualifiers on the parameter. | ||||||
1343 | if (isa<ArrayType>(Arg)) { | ||||||
1344 | Qualifiers Quals; | ||||||
1345 | Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); | ||||||
1346 | if (Quals) { | ||||||
1347 | Arg = S.Context.getQualifiedType(Arg, Quals); | ||||||
1348 | RecanonicalizeArg = true; | ||||||
1349 | } | ||||||
1350 | } | ||||||
1351 | |||||||
1352 | // The argument type can not be less qualified than the parameter | ||||||
1353 | // type. | ||||||
1354 | if (!(TDF & TDF_IgnoreQualifiers) && | ||||||
1355 | hasInconsistentOrSupersetQualifiersOf(Param, Arg)) { | ||||||
1356 | Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); | ||||||
1357 | Info.FirstArg = TemplateArgument(Param); | ||||||
1358 | Info.SecondArg = TemplateArgument(Arg); | ||||||
1359 | return Sema::TDK_Underqualified; | ||||||
1360 | } | ||||||
1361 | |||||||
1362 | // Do not match a function type with a cv-qualified type. | ||||||
1363 | // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584 | ||||||
1364 | if (Arg->isFunctionType() && Param.hasQualifiers()) { | ||||||
1365 | return Sema::TDK_NonDeducedMismatch; | ||||||
1366 | } | ||||||
1367 | |||||||
1368 | assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() &&((TemplateTypeParm->getDepth() == Info.getDeducedDepth() && "saw template type parameter with wrong depth") ? static_cast <void> (0) : __assert_fail ("TemplateTypeParm->getDepth() == Info.getDeducedDepth() && \"saw template type parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1369, __PRETTY_FUNCTION__)) | ||||||
1369 | "saw template type parameter with wrong depth")((TemplateTypeParm->getDepth() == Info.getDeducedDepth() && "saw template type parameter with wrong depth") ? static_cast <void> (0) : __assert_fail ("TemplateTypeParm->getDepth() == Info.getDeducedDepth() && \"saw template type parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1369, __PRETTY_FUNCTION__)); | ||||||
1370 | assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function")((Arg != S.Context.OverloadTy && "Unresolved overloaded function" ) ? static_cast<void> (0) : __assert_fail ("Arg != S.Context.OverloadTy && \"Unresolved overloaded function\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1370, __PRETTY_FUNCTION__)); | ||||||
1371 | QualType DeducedType = Arg; | ||||||
1372 | |||||||
1373 | // Remove any qualifiers on the parameter from the deduced type. | ||||||
1374 | // We checked the qualifiers for consistency above. | ||||||
1375 | Qualifiers DeducedQs = DeducedType.getQualifiers(); | ||||||
1376 | Qualifiers ParamQs = Param.getQualifiers(); | ||||||
1377 | DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers()); | ||||||
1378 | if (ParamQs.hasObjCGCAttr()) | ||||||
1379 | DeducedQs.removeObjCGCAttr(); | ||||||
1380 | if (ParamQs.hasAddressSpace()) | ||||||
1381 | DeducedQs.removeAddressSpace(); | ||||||
1382 | if (ParamQs.hasObjCLifetime()) | ||||||
1383 | DeducedQs.removeObjCLifetime(); | ||||||
1384 | |||||||
1385 | // Objective-C ARC: | ||||||
1386 | // If template deduction would produce a lifetime qualifier on a type | ||||||
1387 | // that is not a lifetime type, template argument deduction fails. | ||||||
1388 | if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && | ||||||
1389 | !DeducedType->isDependentType()) { | ||||||
1390 | Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); | ||||||
1391 | Info.FirstArg = TemplateArgument(Param); | ||||||
1392 | Info.SecondArg = TemplateArgument(Arg); | ||||||
1393 | return Sema::TDK_Underqualified; | ||||||
1394 | } | ||||||
1395 | |||||||
1396 | // Objective-C ARC: | ||||||
1397 | // If template deduction would produce an argument type with lifetime type | ||||||
1398 | // but no lifetime qualifier, the __strong lifetime qualifier is inferred. | ||||||
1399 | if (S.getLangOpts().ObjCAutoRefCount && | ||||||
1400 | DeducedType->isObjCLifetimeType() && | ||||||
1401 | !DeducedQs.hasObjCLifetime()) | ||||||
1402 | DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong); | ||||||
1403 | |||||||
1404 | DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), | ||||||
1405 | DeducedQs); | ||||||
1406 | |||||||
1407 | if (RecanonicalizeArg) | ||||||
1408 | DeducedType = S.Context.getCanonicalType(DeducedType); | ||||||
1409 | |||||||
1410 | DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound); | ||||||
1411 | DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, | ||||||
1412 | Deduced[Index], | ||||||
1413 | NewDeduced); | ||||||
1414 | if (Result.isNull()) { | ||||||
1415 | Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); | ||||||
1416 | Info.FirstArg = Deduced[Index]; | ||||||
1417 | Info.SecondArg = NewDeduced; | ||||||
1418 | return Sema::TDK_Inconsistent; | ||||||
1419 | } | ||||||
1420 | |||||||
1421 | Deduced[Index] = Result; | ||||||
1422 | return Sema::TDK_Success; | ||||||
1423 | } | ||||||
1424 | |||||||
1425 | // Set up the template argument deduction information for a failure. | ||||||
1426 | Info.FirstArg = TemplateArgument(ParamIn); | ||||||
1427 | Info.SecondArg = TemplateArgument(ArgIn); | ||||||
1428 | |||||||
1429 | // If the parameter is an already-substituted template parameter | ||||||
1430 | // pack, do nothing: we don't know which of its arguments to look | ||||||
1431 | // at, so we have to wait until all of the parameter packs in this | ||||||
1432 | // expansion have arguments. | ||||||
1433 | if (isa<SubstTemplateTypeParmPackType>(Param)) | ||||||
1434 | return Sema::TDK_Success; | ||||||
1435 | |||||||
1436 | // Check the cv-qualifiers on the parameter and argument types. | ||||||
1437 | CanQualType CanParam = S.Context.getCanonicalType(Param); | ||||||
1438 | CanQualType CanArg = S.Context.getCanonicalType(Arg); | ||||||
1439 | if (!(TDF & TDF_IgnoreQualifiers)) { | ||||||
1440 | if (TDF & TDF_ParamWithReferenceType) { | ||||||
1441 | if (hasInconsistentOrSupersetQualifiersOf(Param, Arg)) | ||||||
1442 | return Sema::TDK_NonDeducedMismatch; | ||||||
1443 | } else if (TDF & TDF_ArgWithReferenceType) { | ||||||
1444 | // C++ [temp.deduct.conv]p4: | ||||||
1445 | // If the original A is a reference type, A can be more cv-qualified | ||||||
1446 | // than the deduced A | ||||||
1447 | if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers())) | ||||||
1448 | return Sema::TDK_NonDeducedMismatch; | ||||||
1449 | |||||||
1450 | // Strip out all extra qualifiers from the argument to figure out the | ||||||
1451 | // type we're converting to, prior to the qualification conversion. | ||||||
1452 | Qualifiers Quals; | ||||||
1453 | Arg = S.Context.getUnqualifiedArrayType(Arg, Quals); | ||||||
1454 | Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers()); | ||||||
1455 | } else if (!IsPossiblyOpaquelyQualifiedType(Param)) { | ||||||
1456 | if (Param.getCVRQualifiers() != Arg.getCVRQualifiers()) | ||||||
1457 | return Sema::TDK_NonDeducedMismatch; | ||||||
1458 | } | ||||||
1459 | |||||||
1460 | // If the parameter type is not dependent, there is nothing to deduce. | ||||||
1461 | if (!Param->isDependentType()) { | ||||||
1462 | if (!(TDF & TDF_SkipNonDependent)) { | ||||||
1463 | bool NonDeduced = | ||||||
1464 | (TDF & TDF_AllowCompatibleFunctionType) | ||||||
1465 | ? !S.isSameOrCompatibleFunctionType(CanParam, CanArg) | ||||||
1466 | : Param != Arg; | ||||||
1467 | if (NonDeduced) { | ||||||
1468 | return Sema::TDK_NonDeducedMismatch; | ||||||
1469 | } | ||||||
1470 | } | ||||||
1471 | return Sema::TDK_Success; | ||||||
1472 | } | ||||||
1473 | } else if (!Param->isDependentType()) { | ||||||
1474 | CanQualType ParamUnqualType = CanParam.getUnqualifiedType(), | ||||||
1475 | ArgUnqualType = CanArg.getUnqualifiedType(); | ||||||
1476 | bool Success = | ||||||
1477 | (TDF & TDF_AllowCompatibleFunctionType) | ||||||
1478 | ? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType) | ||||||
1479 | : ParamUnqualType == ArgUnqualType; | ||||||
1480 | if (Success) | ||||||
1481 | return Sema::TDK_Success; | ||||||
1482 | } | ||||||
1483 | |||||||
1484 | switch (Param->getTypeClass()) { | ||||||
1485 | // Non-canonical types cannot appear here. | ||||||
1486 | #define NON_CANONICAL_TYPE(Class, Base) \ | ||||||
1487 | case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class)::llvm::llvm_unreachable_internal("deducing non-canonical type: " #Class, "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1487); | ||||||
1488 | #define TYPE(Class, Base) | ||||||
1489 | #include "clang/AST/TypeNodes.inc" | ||||||
1490 | |||||||
1491 | case Type::TemplateTypeParm: | ||||||
1492 | case Type::SubstTemplateTypeParmPack: | ||||||
1493 | llvm_unreachable("Type nodes handled above")::llvm::llvm_unreachable_internal("Type nodes handled above", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1493); | ||||||
1494 | |||||||
1495 | // These types cannot be dependent, so simply check whether the types are | ||||||
1496 | // the same. | ||||||
1497 | case Type::Builtin: | ||||||
1498 | case Type::VariableArray: | ||||||
1499 | case Type::Vector: | ||||||
1500 | case Type::FunctionNoProto: | ||||||
1501 | case Type::Record: | ||||||
1502 | case Type::Enum: | ||||||
1503 | case Type::ObjCObject: | ||||||
1504 | case Type::ObjCInterface: | ||||||
1505 | case Type::ObjCObjectPointer: | ||||||
1506 | if (TDF & TDF_SkipNonDependent) | ||||||
1507 | return Sema::TDK_Success; | ||||||
1508 | |||||||
1509 | if (TDF & TDF_IgnoreQualifiers) { | ||||||
1510 | Param = Param.getUnqualifiedType(); | ||||||
1511 | Arg = Arg.getUnqualifiedType(); | ||||||
1512 | } | ||||||
1513 | |||||||
1514 | return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch; | ||||||
1515 | |||||||
1516 | // _Complex T [placeholder extension] | ||||||
1517 | case Type::Complex: | ||||||
1518 | if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>()) | ||||||
1519 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1520 | cast<ComplexType>(Param)->getElementType(), | ||||||
1521 | ComplexArg->getElementType(), | ||||||
1522 | Info, Deduced, TDF); | ||||||
1523 | |||||||
1524 | return Sema::TDK_NonDeducedMismatch; | ||||||
1525 | |||||||
1526 | // _Atomic T [extension] | ||||||
1527 | case Type::Atomic: | ||||||
1528 | if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>()) | ||||||
1529 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1530 | cast<AtomicType>(Param)->getValueType(), | ||||||
1531 | AtomicArg->getValueType(), | ||||||
1532 | Info, Deduced, TDF); | ||||||
1533 | |||||||
1534 | return Sema::TDK_NonDeducedMismatch; | ||||||
1535 | |||||||
1536 | // T * | ||||||
1537 | case Type::Pointer: { | ||||||
1538 | QualType PointeeType; | ||||||
1539 | if (const PointerType *PointerArg = Arg->getAs<PointerType>()) { | ||||||
1540 | PointeeType = PointerArg->getPointeeType(); | ||||||
1541 | } else if (const ObjCObjectPointerType *PointerArg | ||||||
1542 | = Arg->getAs<ObjCObjectPointerType>()) { | ||||||
1543 | PointeeType = PointerArg->getPointeeType(); | ||||||
1544 | } else { | ||||||
1545 | return Sema::TDK_NonDeducedMismatch; | ||||||
1546 | } | ||||||
1547 | |||||||
1548 | unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); | ||||||
1549 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1550 | cast<PointerType>(Param)->getPointeeType(), | ||||||
1551 | PointeeType, | ||||||
1552 | Info, Deduced, SubTDF); | ||||||
1553 | } | ||||||
1554 | |||||||
1555 | // T & | ||||||
1556 | case Type::LValueReference: { | ||||||
1557 | const LValueReferenceType *ReferenceArg = | ||||||
1558 | Arg->getAs<LValueReferenceType>(); | ||||||
1559 | if (!ReferenceArg) | ||||||
1560 | return Sema::TDK_NonDeducedMismatch; | ||||||
1561 | |||||||
1562 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1563 | cast<LValueReferenceType>(Param)->getPointeeType(), | ||||||
1564 | ReferenceArg->getPointeeType(), Info, Deduced, 0); | ||||||
1565 | } | ||||||
1566 | |||||||
1567 | // T && [C++0x] | ||||||
1568 | case Type::RValueReference: { | ||||||
1569 | const RValueReferenceType *ReferenceArg = | ||||||
1570 | Arg->getAs<RValueReferenceType>(); | ||||||
1571 | if (!ReferenceArg) | ||||||
1572 | return Sema::TDK_NonDeducedMismatch; | ||||||
1573 | |||||||
1574 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1575 | cast<RValueReferenceType>(Param)->getPointeeType(), | ||||||
1576 | ReferenceArg->getPointeeType(), | ||||||
1577 | Info, Deduced, 0); | ||||||
1578 | } | ||||||
1579 | |||||||
1580 | // T [] (implied, but not stated explicitly) | ||||||
1581 | case Type::IncompleteArray: { | ||||||
1582 | const IncompleteArrayType *IncompleteArrayArg = | ||||||
1583 | S.Context.getAsIncompleteArrayType(Arg); | ||||||
1584 | if (!IncompleteArrayArg) | ||||||
1585 | return Sema::TDK_NonDeducedMismatch; | ||||||
1586 | |||||||
1587 | unsigned SubTDF = TDF & TDF_IgnoreQualifiers; | ||||||
1588 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1589 | S.Context.getAsIncompleteArrayType(Param)->getElementType(), | ||||||
1590 | IncompleteArrayArg->getElementType(), | ||||||
1591 | Info, Deduced, SubTDF); | ||||||
1592 | } | ||||||
1593 | |||||||
1594 | // T [integer-constant] | ||||||
1595 | case Type::ConstantArray: { | ||||||
1596 | const ConstantArrayType *ConstantArrayArg = | ||||||
1597 | S.Context.getAsConstantArrayType(Arg); | ||||||
1598 | if (!ConstantArrayArg) | ||||||
1599 | return Sema::TDK_NonDeducedMismatch; | ||||||
1600 | |||||||
1601 | const ConstantArrayType *ConstantArrayParm = | ||||||
1602 | S.Context.getAsConstantArrayType(Param); | ||||||
1603 | if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize()) | ||||||
1604 | return Sema::TDK_NonDeducedMismatch; | ||||||
1605 | |||||||
1606 | unsigned SubTDF = TDF & TDF_IgnoreQualifiers; | ||||||
1607 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1608 | ConstantArrayParm->getElementType(), | ||||||
1609 | ConstantArrayArg->getElementType(), | ||||||
1610 | Info, Deduced, SubTDF); | ||||||
1611 | } | ||||||
1612 | |||||||
1613 | // type [i] | ||||||
1614 | case Type::DependentSizedArray: { | ||||||
1615 | const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg); | ||||||
1616 | if (!ArrayArg) | ||||||
1617 | return Sema::TDK_NonDeducedMismatch; | ||||||
1618 | |||||||
1619 | unsigned SubTDF = TDF & TDF_IgnoreQualifiers; | ||||||
1620 | |||||||
1621 | // Check the element type of the arrays | ||||||
1622 | const DependentSizedArrayType *DependentArrayParm | ||||||
1623 | = S.Context.getAsDependentSizedArrayType(Param); | ||||||
1624 | if (Sema::TemplateDeductionResult Result | ||||||
1625 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1626 | DependentArrayParm->getElementType(), | ||||||
1627 | ArrayArg->getElementType(), | ||||||
1628 | Info, Deduced, SubTDF)) | ||||||
1629 | return Result; | ||||||
1630 | |||||||
1631 | // Determine the array bound is something we can deduce. | ||||||
1632 | NonTypeTemplateParmDecl *NTTP | ||||||
1633 | = getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr()); | ||||||
1634 | if (!NTTP) | ||||||
1635 | return Sema::TDK_Success; | ||||||
1636 | |||||||
1637 | // We can perform template argument deduction for the given non-type | ||||||
1638 | // template parameter. | ||||||
1639 | assert(NTTP->getDepth() == Info.getDeducedDepth() &&((NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"saw non-type template parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1640, __PRETTY_FUNCTION__)) | ||||||
1640 | "saw non-type template parameter with wrong depth")((NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"saw non-type template parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1640, __PRETTY_FUNCTION__)); | ||||||
1641 | if (const ConstantArrayType *ConstantArrayArg | ||||||
1642 | = dyn_cast<ConstantArrayType>(ArrayArg)) { | ||||||
1643 | llvm::APSInt Size(ConstantArrayArg->getSize()); | ||||||
1644 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size, | ||||||
1645 | S.Context.getSizeType(), | ||||||
1646 | /*ArrayBound=*/true, | ||||||
1647 | Info, Deduced); | ||||||
1648 | } | ||||||
1649 | if (const DependentSizedArrayType *DependentArrayArg | ||||||
1650 | = dyn_cast<DependentSizedArrayType>(ArrayArg)) | ||||||
1651 | if (DependentArrayArg->getSizeExpr()) | ||||||
1652 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
1653 | DependentArrayArg->getSizeExpr(), | ||||||
1654 | Info, Deduced); | ||||||
1655 | |||||||
1656 | // Incomplete type does not match a dependently-sized array type | ||||||
1657 | return Sema::TDK_NonDeducedMismatch; | ||||||
1658 | } | ||||||
1659 | |||||||
1660 | // type(*)(T) | ||||||
1661 | // T(*)() | ||||||
1662 | // T(*)(T) | ||||||
1663 | case Type::FunctionProto: { | ||||||
1664 | unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList; | ||||||
1665 | const FunctionProtoType *FunctionProtoArg = | ||||||
1666 | dyn_cast<FunctionProtoType>(Arg); | ||||||
1667 | if (!FunctionProtoArg) | ||||||
1668 | return Sema::TDK_NonDeducedMismatch; | ||||||
1669 | |||||||
1670 | const FunctionProtoType *FunctionProtoParam = | ||||||
1671 | cast<FunctionProtoType>(Param); | ||||||
1672 | |||||||
1673 | if (FunctionProtoParam->getMethodQuals() | ||||||
1674 | != FunctionProtoArg->getMethodQuals() || | ||||||
1675 | FunctionProtoParam->getRefQualifier() | ||||||
1676 | != FunctionProtoArg->getRefQualifier() || | ||||||
1677 | FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic()) | ||||||
1678 | return Sema::TDK_NonDeducedMismatch; | ||||||
1679 | |||||||
1680 | // Check return types. | ||||||
1681 | if (auto Result = DeduceTemplateArgumentsByTypeMatch( | ||||||
1682 | S, TemplateParams, FunctionProtoParam->getReturnType(), | ||||||
1683 | FunctionProtoArg->getReturnType(), Info, Deduced, 0)) | ||||||
1684 | return Result; | ||||||
1685 | |||||||
1686 | // Check parameter types. | ||||||
1687 | if (auto Result = DeduceTemplateArguments( | ||||||
1688 | S, TemplateParams, FunctionProtoParam->param_type_begin(), | ||||||
1689 | FunctionProtoParam->getNumParams(), | ||||||
1690 | FunctionProtoArg->param_type_begin(), | ||||||
1691 | FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF)) | ||||||
1692 | return Result; | ||||||
1693 | |||||||
1694 | if (TDF & TDF_AllowCompatibleFunctionType) | ||||||
1695 | return Sema::TDK_Success; | ||||||
1696 | |||||||
1697 | // FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit | ||||||
1698 | // deducing through the noexcept-specifier if it's part of the canonical | ||||||
1699 | // type. libstdc++ relies on this. | ||||||
1700 | Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr(); | ||||||
1701 | if (NonTypeTemplateParmDecl *NTTP = | ||||||
1702 | NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr) | ||||||
1703 | : nullptr) { | ||||||
1704 | assert(NTTP->getDepth() == Info.getDeducedDepth() &&((NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"saw non-type template parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1705, __PRETTY_FUNCTION__)) | ||||||
1705 | "saw non-type template parameter with wrong depth")((NTTP->getDepth() == Info.getDeducedDepth() && "saw non-type template parameter with wrong depth" ) ? static_cast<void> (0) : __assert_fail ("NTTP->getDepth() == Info.getDeducedDepth() && \"saw non-type template parameter with wrong depth\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1705, __PRETTY_FUNCTION__)); | ||||||
1706 | |||||||
1707 | llvm::APSInt Noexcept(1); | ||||||
1708 | switch (FunctionProtoArg->canThrow()) { | ||||||
1709 | case CT_Cannot: | ||||||
1710 | Noexcept = 1; | ||||||
1711 | LLVM_FALLTHROUGH[[gnu::fallthrough]]; | ||||||
1712 | |||||||
1713 | case CT_Can: | ||||||
1714 | // We give E in noexcept(E) the "deduced from array bound" treatment. | ||||||
1715 | // FIXME: Should we? | ||||||
1716 | return DeduceNonTypeTemplateArgument( | ||||||
1717 | S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy, | ||||||
1718 | /*ArrayBound*/true, Info, Deduced); | ||||||
1719 | |||||||
1720 | case CT_Dependent: | ||||||
1721 | if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr()) | ||||||
1722 | return DeduceNonTypeTemplateArgument( | ||||||
1723 | S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced); | ||||||
1724 | // Can't deduce anything from throw(T...). | ||||||
1725 | break; | ||||||
1726 | } | ||||||
1727 | } | ||||||
1728 | // FIXME: Detect non-deduced exception specification mismatches? | ||||||
1729 | // | ||||||
1730 | // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow | ||||||
1731 | // top-level differences in noexcept-specifications. | ||||||
1732 | |||||||
1733 | return Sema::TDK_Success; | ||||||
1734 | } | ||||||
1735 | |||||||
1736 | case Type::InjectedClassName: | ||||||
1737 | // Treat a template's injected-class-name as if the template | ||||||
1738 | // specialization type had been used. | ||||||
1739 | Param = cast<InjectedClassNameType>(Param) | ||||||
1740 | ->getInjectedSpecializationType(); | ||||||
1741 | assert(isa<TemplateSpecializationType>(Param) &&((isa<TemplateSpecializationType>(Param) && "injected class name is not a template specialization type" ) ? static_cast<void> (0) : __assert_fail ("isa<TemplateSpecializationType>(Param) && \"injected class name is not a template specialization type\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1742, __PRETTY_FUNCTION__)) | ||||||
1742 | "injected class name is not a template specialization type")((isa<TemplateSpecializationType>(Param) && "injected class name is not a template specialization type" ) ? static_cast<void> (0) : __assert_fail ("isa<TemplateSpecializationType>(Param) && \"injected class name is not a template specialization type\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1742, __PRETTY_FUNCTION__)); | ||||||
1743 | LLVM_FALLTHROUGH[[gnu::fallthrough]]; | ||||||
1744 | |||||||
1745 | // template-name<T> (where template-name refers to a class template) | ||||||
1746 | // template-name<i> | ||||||
1747 | // TT<T> | ||||||
1748 | // TT<i> | ||||||
1749 | // TT<> | ||||||
1750 | case Type::TemplateSpecialization: { | ||||||
1751 | const TemplateSpecializationType *SpecParam = | ||||||
1752 | cast<TemplateSpecializationType>(Param); | ||||||
1753 | |||||||
1754 | // When Arg cannot be a derived class, we can just try to deduce template | ||||||
1755 | // arguments from the template-id. | ||||||
1756 | const RecordType *RecordT = Arg->getAs<RecordType>(); | ||||||
1757 | if (!(TDF & TDF_DerivedClass) || !RecordT) | ||||||
1758 | return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info, | ||||||
1759 | Deduced); | ||||||
1760 | |||||||
1761 | SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(), | ||||||
1762 | Deduced.end()); | ||||||
1763 | |||||||
1764 | Sema::TemplateDeductionResult Result = DeduceTemplateArguments( | ||||||
1765 | S, TemplateParams, SpecParam, Arg, Info, Deduced); | ||||||
1766 | |||||||
1767 | if (Result == Sema::TDK_Success) | ||||||
1768 | return Result; | ||||||
1769 | |||||||
1770 | // We cannot inspect base classes as part of deduction when the type | ||||||
1771 | // is incomplete, so either instantiate any templates necessary to | ||||||
1772 | // complete the type, or skip over it if it cannot be completed. | ||||||
1773 | if (!S.isCompleteType(Info.getLocation(), Arg)) | ||||||
1774 | return Result; | ||||||
1775 | |||||||
1776 | // C++14 [temp.deduct.call] p4b3: | ||||||
1777 | // If P is a class and P has the form simple-template-id, then the | ||||||
1778 | // transformed A can be a derived class of the deduced A. Likewise if | ||||||
1779 | // P is a pointer to a class of the form simple-template-id, the | ||||||
1780 | // transformed A can be a pointer to a derived class pointed to by the | ||||||
1781 | // deduced A. | ||||||
1782 | // | ||||||
1783 | // These alternatives are considered only if type deduction would | ||||||
1784 | // otherwise fail. If they yield more than one possible deduced A, the | ||||||
1785 | // type deduction fails. | ||||||
1786 | |||||||
1787 | // Reset the incorrectly deduced argument from above. | ||||||
1788 | Deduced = DeducedOrig; | ||||||
1789 | |||||||
1790 | // Use data recursion to crawl through the list of base classes. | ||||||
1791 | // Visited contains the set of nodes we have already visited, while | ||||||
1792 | // ToVisit is our stack of records that we still need to visit. | ||||||
1793 | llvm::SmallPtrSet<const RecordType *, 8> Visited; | ||||||
1794 | SmallVector<const RecordType *, 8> ToVisit; | ||||||
1795 | ToVisit.push_back(RecordT); | ||||||
1796 | bool Successful = false; | ||||||
1797 | SmallVector<DeducedTemplateArgument, 8> SuccessfulDeduced; | ||||||
1798 | while (!ToVisit.empty()) { | ||||||
1799 | // Retrieve the next class in the inheritance hierarchy. | ||||||
1800 | const RecordType *NextT = ToVisit.pop_back_val(); | ||||||
1801 | |||||||
1802 | // If we have already seen this type, skip it. | ||||||
1803 | if (!Visited.insert(NextT).second) | ||||||
1804 | continue; | ||||||
1805 | |||||||
1806 | // If this is a base class, try to perform template argument | ||||||
1807 | // deduction from it. | ||||||
1808 | if (NextT != RecordT) { | ||||||
1809 | TemplateDeductionInfo BaseInfo(Info.getLocation()); | ||||||
1810 | Sema::TemplateDeductionResult BaseResult = | ||||||
1811 | DeduceTemplateArguments(S, TemplateParams, SpecParam, | ||||||
1812 | QualType(NextT, 0), BaseInfo, Deduced); | ||||||
1813 | |||||||
1814 | // If template argument deduction for this base was successful, | ||||||
1815 | // note that we had some success. Otherwise, ignore any deductions | ||||||
1816 | // from this base class. | ||||||
1817 | if (BaseResult == Sema::TDK_Success) { | ||||||
1818 | // If we've already seen some success, then deduction fails due to | ||||||
1819 | // an ambiguity (temp.deduct.call p5). | ||||||
1820 | if (Successful) | ||||||
1821 | return Sema::TDK_MiscellaneousDeductionFailure; | ||||||
1822 | |||||||
1823 | Successful = true; | ||||||
1824 | std::swap(SuccessfulDeduced, Deduced); | ||||||
1825 | |||||||
1826 | Info.Param = BaseInfo.Param; | ||||||
1827 | Info.FirstArg = BaseInfo.FirstArg; | ||||||
1828 | Info.SecondArg = BaseInfo.SecondArg; | ||||||
1829 | } | ||||||
1830 | |||||||
1831 | Deduced = DeducedOrig; | ||||||
1832 | } | ||||||
1833 | |||||||
1834 | // Visit base classes | ||||||
1835 | CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); | ||||||
1836 | for (const auto &Base : Next->bases()) { | ||||||
1837 | assert(Base.getType()->isRecordType() &&((Base.getType()->isRecordType() && "Base class that isn't a record?" ) ? static_cast<void> (0) : __assert_fail ("Base.getType()->isRecordType() && \"Base class that isn't a record?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1838, __PRETTY_FUNCTION__)) | ||||||
1838 | "Base class that isn't a record?")((Base.getType()->isRecordType() && "Base class that isn't a record?" ) ? static_cast<void> (0) : __assert_fail ("Base.getType()->isRecordType() && \"Base class that isn't a record?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 1838, __PRETTY_FUNCTION__)); | ||||||
1839 | ToVisit.push_back(Base.getType()->getAs<RecordType>()); | ||||||
1840 | } | ||||||
1841 | } | ||||||
1842 | |||||||
1843 | if (Successful) { | ||||||
1844 | std::swap(SuccessfulDeduced, Deduced); | ||||||
1845 | return Sema::TDK_Success; | ||||||
1846 | } | ||||||
1847 | |||||||
1848 | return Result; | ||||||
1849 | } | ||||||
1850 | |||||||
1851 | // T type::* | ||||||
1852 | // T T::* | ||||||
1853 | // T (type::*)() | ||||||
1854 | // type (T::*)() | ||||||
1855 | // type (type::*)(T) | ||||||
1856 | // type (T::*)(T) | ||||||
1857 | // T (type::*)(T) | ||||||
1858 | // T (T::*)() | ||||||
1859 | // T (T::*)(T) | ||||||
1860 | case Type::MemberPointer: { | ||||||
1861 | const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param); | ||||||
1862 | const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg); | ||||||
1863 | if (!MemPtrArg) | ||||||
1864 | return Sema::TDK_NonDeducedMismatch; | ||||||
1865 | |||||||
1866 | QualType ParamPointeeType = MemPtrParam->getPointeeType(); | ||||||
1867 | if (ParamPointeeType->isFunctionType()) | ||||||
1868 | S.adjustMemberFunctionCC(ParamPointeeType, /*IsStatic=*/true, | ||||||
1869 | /*IsCtorOrDtor=*/false, Info.getLocation()); | ||||||
1870 | QualType ArgPointeeType = MemPtrArg->getPointeeType(); | ||||||
1871 | if (ArgPointeeType->isFunctionType()) | ||||||
1872 | S.adjustMemberFunctionCC(ArgPointeeType, /*IsStatic=*/true, | ||||||
1873 | /*IsCtorOrDtor=*/false, Info.getLocation()); | ||||||
1874 | |||||||
1875 | if (Sema::TemplateDeductionResult Result | ||||||
1876 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1877 | ParamPointeeType, | ||||||
1878 | ArgPointeeType, | ||||||
1879 | Info, Deduced, | ||||||
1880 | TDF & TDF_IgnoreQualifiers)) | ||||||
1881 | return Result; | ||||||
1882 | |||||||
1883 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1884 | QualType(MemPtrParam->getClass(), 0), | ||||||
1885 | QualType(MemPtrArg->getClass(), 0), | ||||||
1886 | Info, Deduced, | ||||||
1887 | TDF & TDF_IgnoreQualifiers); | ||||||
1888 | } | ||||||
1889 | |||||||
1890 | // (clang extension) | ||||||
1891 | // | ||||||
1892 | // type(^)(T) | ||||||
1893 | // T(^)() | ||||||
1894 | // T(^)(T) | ||||||
1895 | case Type::BlockPointer: { | ||||||
1896 | const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param); | ||||||
1897 | const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg); | ||||||
1898 | |||||||
1899 | if (!BlockPtrArg) | ||||||
1900 | return Sema::TDK_NonDeducedMismatch; | ||||||
1901 | |||||||
1902 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1903 | BlockPtrParam->getPointeeType(), | ||||||
1904 | BlockPtrArg->getPointeeType(), | ||||||
1905 | Info, Deduced, 0); | ||||||
1906 | } | ||||||
1907 | |||||||
1908 | // (clang extension) | ||||||
1909 | // | ||||||
1910 | // T __attribute__(((ext_vector_type(<integral constant>)))) | ||||||
1911 | case Type::ExtVector: { | ||||||
1912 | const ExtVectorType *VectorParam = cast<ExtVectorType>(Param); | ||||||
1913 | if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { | ||||||
1914 | // Make sure that the vectors have the same number of elements. | ||||||
1915 | if (VectorParam->getNumElements() != VectorArg->getNumElements()) | ||||||
1916 | return Sema::TDK_NonDeducedMismatch; | ||||||
1917 | |||||||
1918 | // Perform deduction on the element types. | ||||||
1919 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1920 | VectorParam->getElementType(), | ||||||
1921 | VectorArg->getElementType(), | ||||||
1922 | Info, Deduced, TDF); | ||||||
1923 | } | ||||||
1924 | |||||||
1925 | if (const DependentSizedExtVectorType *VectorArg | ||||||
1926 | = dyn_cast<DependentSizedExtVectorType>(Arg)) { | ||||||
1927 | // We can't check the number of elements, since the argument has a | ||||||
1928 | // dependent number of elements. This can only occur during partial | ||||||
1929 | // ordering. | ||||||
1930 | |||||||
1931 | // Perform deduction on the element types. | ||||||
1932 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
1933 | VectorParam->getElementType(), | ||||||
1934 | VectorArg->getElementType(), | ||||||
1935 | Info, Deduced, TDF); | ||||||
1936 | } | ||||||
1937 | |||||||
1938 | return Sema::TDK_NonDeducedMismatch; | ||||||
1939 | } | ||||||
1940 | |||||||
1941 | case Type::DependentVector: { | ||||||
1942 | const auto *VectorParam = cast<DependentVectorType>(Param); | ||||||
1943 | |||||||
1944 | if (const auto *VectorArg = dyn_cast<VectorType>(Arg)) { | ||||||
1945 | // Perform deduction on the element types. | ||||||
1946 | if (Sema::TemplateDeductionResult Result = | ||||||
1947 | DeduceTemplateArgumentsByTypeMatch( | ||||||
1948 | S, TemplateParams, VectorParam->getElementType(), | ||||||
1949 | VectorArg->getElementType(), Info, Deduced, TDF)) | ||||||
1950 | return Result; | ||||||
1951 | |||||||
1952 | // Perform deduction on the vector size, if we can. | ||||||
1953 | NonTypeTemplateParmDecl *NTTP = | ||||||
1954 | getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); | ||||||
1955 | if (!NTTP) | ||||||
1956 | return Sema::TDK_Success; | ||||||
1957 | |||||||
1958 | llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); | ||||||
1959 | ArgSize = VectorArg->getNumElements(); | ||||||
1960 | // Note that we use the "array bound" rules here; just like in that | ||||||
1961 | // case, we don't have any particular type for the vector size, but | ||||||
1962 | // we can provide one if necessary. | ||||||
1963 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, | ||||||
1964 | S.Context.UnsignedIntTy, true, | ||||||
1965 | Info, Deduced); | ||||||
1966 | } | ||||||
1967 | |||||||
1968 | if (const auto *VectorArg = dyn_cast<DependentVectorType>(Arg)) { | ||||||
1969 | // Perform deduction on the element types. | ||||||
1970 | if (Sema::TemplateDeductionResult Result = | ||||||
1971 | DeduceTemplateArgumentsByTypeMatch( | ||||||
1972 | S, TemplateParams, VectorParam->getElementType(), | ||||||
1973 | VectorArg->getElementType(), Info, Deduced, TDF)) | ||||||
1974 | return Result; | ||||||
1975 | |||||||
1976 | // Perform deduction on the vector size, if we can. | ||||||
1977 | NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( | ||||||
1978 | Info, VectorParam->getSizeExpr()); | ||||||
1979 | if (!NTTP) | ||||||
1980 | return Sema::TDK_Success; | ||||||
1981 | |||||||
1982 | return DeduceNonTypeTemplateArgument( | ||||||
1983 | S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced); | ||||||
1984 | } | ||||||
1985 | |||||||
1986 | return Sema::TDK_NonDeducedMismatch; | ||||||
1987 | } | ||||||
1988 | |||||||
1989 | // (clang extension) | ||||||
1990 | // | ||||||
1991 | // T __attribute__(((ext_vector_type(N)))) | ||||||
1992 | case Type::DependentSizedExtVector: { | ||||||
1993 | const DependentSizedExtVectorType *VectorParam | ||||||
1994 | = cast<DependentSizedExtVectorType>(Param); | ||||||
1995 | |||||||
1996 | if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) { | ||||||
1997 | // Perform deduction on the element types. | ||||||
1998 | if (Sema::TemplateDeductionResult Result | ||||||
1999 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
2000 | VectorParam->getElementType(), | ||||||
2001 | VectorArg->getElementType(), | ||||||
2002 | Info, Deduced, TDF)) | ||||||
2003 | return Result; | ||||||
2004 | |||||||
2005 | // Perform deduction on the vector size, if we can. | ||||||
2006 | NonTypeTemplateParmDecl *NTTP | ||||||
2007 | = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); | ||||||
2008 | if (!NTTP) | ||||||
2009 | return Sema::TDK_Success; | ||||||
2010 | |||||||
2011 | llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false); | ||||||
2012 | ArgSize = VectorArg->getNumElements(); | ||||||
2013 | // Note that we use the "array bound" rules here; just like in that | ||||||
2014 | // case, we don't have any particular type for the vector size, but | ||||||
2015 | // we can provide one if necessary. | ||||||
2016 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize, | ||||||
2017 | S.Context.IntTy, true, Info, | ||||||
2018 | Deduced); | ||||||
2019 | } | ||||||
2020 | |||||||
2021 | if (const DependentSizedExtVectorType *VectorArg | ||||||
2022 | = dyn_cast<DependentSizedExtVectorType>(Arg)) { | ||||||
2023 | // Perform deduction on the element types. | ||||||
2024 | if (Sema::TemplateDeductionResult Result | ||||||
2025 | = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
2026 | VectorParam->getElementType(), | ||||||
2027 | VectorArg->getElementType(), | ||||||
2028 | Info, Deduced, TDF)) | ||||||
2029 | return Result; | ||||||
2030 | |||||||
2031 | // Perform deduction on the vector size, if we can. | ||||||
2032 | NonTypeTemplateParmDecl *NTTP | ||||||
2033 | = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr()); | ||||||
2034 | if (!NTTP) | ||||||
2035 | return Sema::TDK_Success; | ||||||
2036 | |||||||
2037 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
2038 | VectorArg->getSizeExpr(), | ||||||
2039 | Info, Deduced); | ||||||
2040 | } | ||||||
2041 | |||||||
2042 | return Sema::TDK_NonDeducedMismatch; | ||||||
2043 | } | ||||||
2044 | |||||||
2045 | // (clang extension) | ||||||
2046 | // | ||||||
2047 | // T __attribute__(((address_space(N)))) | ||||||
2048 | case Type::DependentAddressSpace: { | ||||||
2049 | const DependentAddressSpaceType *AddressSpaceParam = | ||||||
2050 | cast<DependentAddressSpaceType>(Param); | ||||||
2051 | |||||||
2052 | if (const DependentAddressSpaceType *AddressSpaceArg = | ||||||
2053 | dyn_cast<DependentAddressSpaceType>(Arg)) { | ||||||
2054 | // Perform deduction on the pointer type. | ||||||
2055 | if (Sema::TemplateDeductionResult Result = | ||||||
2056 | DeduceTemplateArgumentsByTypeMatch( | ||||||
2057 | S, TemplateParams, AddressSpaceParam->getPointeeType(), | ||||||
2058 | AddressSpaceArg->getPointeeType(), Info, Deduced, TDF)) | ||||||
2059 | return Result; | ||||||
2060 | |||||||
2061 | // Perform deduction on the address space, if we can. | ||||||
2062 | NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( | ||||||
2063 | Info, AddressSpaceParam->getAddrSpaceExpr()); | ||||||
2064 | if (!NTTP) | ||||||
2065 | return Sema::TDK_Success; | ||||||
2066 | |||||||
2067 | return DeduceNonTypeTemplateArgument( | ||||||
2068 | S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info, | ||||||
2069 | Deduced); | ||||||
2070 | } | ||||||
2071 | |||||||
2072 | if (isTargetAddressSpace(Arg.getAddressSpace())) { | ||||||
2073 | llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy), | ||||||
2074 | false); | ||||||
2075 | ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace()); | ||||||
2076 | |||||||
2077 | // Perform deduction on the pointer types. | ||||||
2078 | if (Sema::TemplateDeductionResult Result = | ||||||
2079 | DeduceTemplateArgumentsByTypeMatch( | ||||||
2080 | S, TemplateParams, AddressSpaceParam->getPointeeType(), | ||||||
2081 | S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF)) | ||||||
2082 | return Result; | ||||||
2083 | |||||||
2084 | // Perform deduction on the address space, if we can. | ||||||
2085 | NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr( | ||||||
2086 | Info, AddressSpaceParam->getAddrSpaceExpr()); | ||||||
2087 | if (!NTTP) | ||||||
2088 | return Sema::TDK_Success; | ||||||
2089 | |||||||
2090 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
2091 | ArgAddressSpace, S.Context.IntTy, | ||||||
2092 | true, Info, Deduced); | ||||||
2093 | } | ||||||
2094 | |||||||
2095 | return Sema::TDK_NonDeducedMismatch; | ||||||
2096 | } | ||||||
2097 | |||||||
2098 | case Type::TypeOfExpr: | ||||||
2099 | case Type::TypeOf: | ||||||
2100 | case Type::DependentName: | ||||||
2101 | case Type::UnresolvedUsing: | ||||||
2102 | case Type::Decltype: | ||||||
2103 | case Type::UnaryTransform: | ||||||
2104 | case Type::Auto: | ||||||
2105 | case Type::DeducedTemplateSpecialization: | ||||||
2106 | case Type::DependentTemplateSpecialization: | ||||||
2107 | case Type::PackExpansion: | ||||||
2108 | case Type::Pipe: | ||||||
2109 | // No template argument deduction for these types | ||||||
2110 | return Sema::TDK_Success; | ||||||
2111 | } | ||||||
2112 | |||||||
2113 | llvm_unreachable("Invalid Type Class!")::llvm::llvm_unreachable_internal("Invalid Type Class!", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2113); | ||||||
2114 | } | ||||||
2115 | |||||||
2116 | static Sema::TemplateDeductionResult | ||||||
2117 | DeduceTemplateArguments(Sema &S, | ||||||
2118 | TemplateParameterList *TemplateParams, | ||||||
2119 | const TemplateArgument &Param, | ||||||
2120 | TemplateArgument Arg, | ||||||
2121 | TemplateDeductionInfo &Info, | ||||||
2122 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
2123 | // If the template argument is a pack expansion, perform template argument | ||||||
2124 | // deduction against the pattern of that expansion. This only occurs during | ||||||
2125 | // partial ordering. | ||||||
2126 | if (Arg.isPackExpansion()) | ||||||
2127 | Arg = Arg.getPackExpansionPattern(); | ||||||
2128 | |||||||
2129 | switch (Param.getKind()) { | ||||||
2130 | case TemplateArgument::Null: | ||||||
2131 | llvm_unreachable("Null template argument in parameter list")::llvm::llvm_unreachable_internal("Null template argument in parameter list" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2131); | ||||||
2132 | |||||||
2133 | case TemplateArgument::Type: | ||||||
2134 | if (Arg.getKind() == TemplateArgument::Type) | ||||||
2135 | return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, | ||||||
2136 | Param.getAsType(), | ||||||
2137 | Arg.getAsType(), | ||||||
2138 | Info, Deduced, 0); | ||||||
2139 | Info.FirstArg = Param; | ||||||
2140 | Info.SecondArg = Arg; | ||||||
2141 | return Sema::TDK_NonDeducedMismatch; | ||||||
2142 | |||||||
2143 | case TemplateArgument::Template: | ||||||
2144 | if (Arg.getKind() == TemplateArgument::Template) | ||||||
2145 | return DeduceTemplateArguments(S, TemplateParams, | ||||||
2146 | Param.getAsTemplate(), | ||||||
2147 | Arg.getAsTemplate(), Info, Deduced); | ||||||
2148 | Info.FirstArg = Param; | ||||||
2149 | Info.SecondArg = Arg; | ||||||
2150 | return Sema::TDK_NonDeducedMismatch; | ||||||
2151 | |||||||
2152 | case TemplateArgument::TemplateExpansion: | ||||||
2153 | llvm_unreachable("caller should handle pack expansions")::llvm::llvm_unreachable_internal("caller should handle pack expansions" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2153); | ||||||
2154 | |||||||
2155 | case TemplateArgument::Declaration: | ||||||
2156 | if (Arg.getKind() == TemplateArgument::Declaration && | ||||||
2157 | isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl())) | ||||||
2158 | return Sema::TDK_Success; | ||||||
2159 | |||||||
2160 | Info.FirstArg = Param; | ||||||
2161 | Info.SecondArg = Arg; | ||||||
2162 | return Sema::TDK_NonDeducedMismatch; | ||||||
2163 | |||||||
2164 | case TemplateArgument::NullPtr: | ||||||
2165 | if (Arg.getKind() == TemplateArgument::NullPtr && | ||||||
2166 | S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType())) | ||||||
2167 | return Sema::TDK_Success; | ||||||
2168 | |||||||
2169 | Info.FirstArg = Param; | ||||||
2170 | Info.SecondArg = Arg; | ||||||
2171 | return Sema::TDK_NonDeducedMismatch; | ||||||
2172 | |||||||
2173 | case TemplateArgument::Integral: | ||||||
2174 | if (Arg.getKind() == TemplateArgument::Integral) { | ||||||
2175 | if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral())) | ||||||
2176 | return Sema::TDK_Success; | ||||||
2177 | |||||||
2178 | Info.FirstArg = Param; | ||||||
2179 | Info.SecondArg = Arg; | ||||||
2180 | return Sema::TDK_NonDeducedMismatch; | ||||||
2181 | } | ||||||
2182 | |||||||
2183 | if (Arg.getKind() == TemplateArgument::Expression) { | ||||||
2184 | Info.FirstArg = Param; | ||||||
2185 | Info.SecondArg = Arg; | ||||||
2186 | return Sema::TDK_NonDeducedMismatch; | ||||||
2187 | } | ||||||
2188 | |||||||
2189 | Info.FirstArg = Param; | ||||||
2190 | Info.SecondArg = Arg; | ||||||
2191 | return Sema::TDK_NonDeducedMismatch; | ||||||
2192 | |||||||
2193 | case TemplateArgument::Expression: | ||||||
2194 | if (NonTypeTemplateParmDecl *NTTP | ||||||
2195 | = getDeducedParameterFromExpr(Info, Param.getAsExpr())) { | ||||||
2196 | if (Arg.getKind() == TemplateArgument::Integral) | ||||||
2197 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
2198 | Arg.getAsIntegral(), | ||||||
2199 | Arg.getIntegralType(), | ||||||
2200 | /*ArrayBound=*/false, | ||||||
2201 | Info, Deduced); | ||||||
2202 | if (Arg.getKind() == TemplateArgument::NullPtr) | ||||||
2203 | return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP, | ||||||
2204 | Arg.getNullPtrType(), | ||||||
2205 | Info, Deduced); | ||||||
2206 | if (Arg.getKind() == TemplateArgument::Expression) | ||||||
2207 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
2208 | Arg.getAsExpr(), Info, Deduced); | ||||||
2209 | if (Arg.getKind() == TemplateArgument::Declaration) | ||||||
2210 | return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, | ||||||
2211 | Arg.getAsDecl(), | ||||||
2212 | Arg.getParamTypeForDecl(), | ||||||
2213 | Info, Deduced); | ||||||
2214 | |||||||
2215 | Info.FirstArg = Param; | ||||||
2216 | Info.SecondArg = Arg; | ||||||
2217 | return Sema::TDK_NonDeducedMismatch; | ||||||
2218 | } | ||||||
2219 | |||||||
2220 | // Can't deduce anything, but that's okay. | ||||||
2221 | return Sema::TDK_Success; | ||||||
2222 | |||||||
2223 | case TemplateArgument::Pack: | ||||||
2224 | llvm_unreachable("Argument packs should be expanded by the caller!")::llvm::llvm_unreachable_internal("Argument packs should be expanded by the caller!" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2224); | ||||||
2225 | } | ||||||
2226 | |||||||
2227 | llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2227); | ||||||
2228 | } | ||||||
2229 | |||||||
2230 | /// Determine whether there is a template argument to be used for | ||||||
2231 | /// deduction. | ||||||
2232 | /// | ||||||
2233 | /// This routine "expands" argument packs in-place, overriding its input | ||||||
2234 | /// parameters so that \c Args[ArgIdx] will be the available template argument. | ||||||
2235 | /// | ||||||
2236 | /// \returns true if there is another template argument (which will be at | ||||||
2237 | /// \c Args[ArgIdx]), false otherwise. | ||||||
2238 | static bool hasTemplateArgumentForDeduction(ArrayRef<TemplateArgument> &Args, | ||||||
2239 | unsigned &ArgIdx) { | ||||||
2240 | if (ArgIdx == Args.size()) | ||||||
2241 | return false; | ||||||
2242 | |||||||
2243 | const TemplateArgument &Arg = Args[ArgIdx]; | ||||||
2244 | if (Arg.getKind() != TemplateArgument::Pack) | ||||||
2245 | return true; | ||||||
2246 | |||||||
2247 | assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?")((ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?" ) ? static_cast<void> (0) : __assert_fail ("ArgIdx == Args.size() - 1 && \"Pack not at the end of argument list?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2247, __PRETTY_FUNCTION__)); | ||||||
2248 | Args = Arg.pack_elements(); | ||||||
2249 | ArgIdx = 0; | ||||||
2250 | return ArgIdx < Args.size(); | ||||||
2251 | } | ||||||
2252 | |||||||
2253 | /// Determine whether the given set of template arguments has a pack | ||||||
2254 | /// expansion that is not the last template argument. | ||||||
2255 | static bool hasPackExpansionBeforeEnd(ArrayRef<TemplateArgument> Args) { | ||||||
2256 | bool FoundPackExpansion = false; | ||||||
2257 | for (const auto &A : Args) { | ||||||
2258 | if (FoundPackExpansion) | ||||||
2259 | return true; | ||||||
2260 | |||||||
2261 | if (A.getKind() == TemplateArgument::Pack) | ||||||
2262 | return hasPackExpansionBeforeEnd(A.pack_elements()); | ||||||
2263 | |||||||
2264 | // FIXME: If this is a fixed-arity pack expansion from an outer level of | ||||||
2265 | // templates, it should not be treated as a pack expansion. | ||||||
2266 | if (A.isPackExpansion()) | ||||||
2267 | FoundPackExpansion = true; | ||||||
2268 | } | ||||||
2269 | |||||||
2270 | return false; | ||||||
2271 | } | ||||||
2272 | |||||||
2273 | static Sema::TemplateDeductionResult | ||||||
2274 | DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, | ||||||
2275 | ArrayRef<TemplateArgument> Params, | ||||||
2276 | ArrayRef<TemplateArgument> Args, | ||||||
2277 | TemplateDeductionInfo &Info, | ||||||
2278 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
2279 | bool NumberOfArgumentsMustMatch) { | ||||||
2280 | // C++0x [temp.deduct.type]p9: | ||||||
2281 | // If the template argument list of P contains a pack expansion that is not | ||||||
2282 | // the last template argument, the entire template argument list is a | ||||||
2283 | // non-deduced context. | ||||||
2284 | if (hasPackExpansionBeforeEnd(Params)) | ||||||
2285 | return Sema::TDK_Success; | ||||||
2286 | |||||||
2287 | // C++0x [temp.deduct.type]p9: | ||||||
2288 | // If P has a form that contains <T> or <i>, then each argument Pi of the | ||||||
2289 | // respective template argument list P is compared with the corresponding | ||||||
2290 | // argument Ai of the corresponding template argument list of A. | ||||||
2291 | unsigned ArgIdx = 0, ParamIdx = 0; | ||||||
2292 | for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) { | ||||||
2293 | if (!Params[ParamIdx].isPackExpansion()) { | ||||||
2294 | // The simple case: deduce template arguments by matching Pi and Ai. | ||||||
2295 | |||||||
2296 | // Check whether we have enough arguments. | ||||||
2297 | if (!hasTemplateArgumentForDeduction(Args, ArgIdx)) | ||||||
2298 | return NumberOfArgumentsMustMatch | ||||||
2299 | ? Sema::TDK_MiscellaneousDeductionFailure | ||||||
2300 | : Sema::TDK_Success; | ||||||
2301 | |||||||
2302 | // C++1z [temp.deduct.type]p9: | ||||||
2303 | // During partial ordering, if Ai was originally a pack expansion [and] | ||||||
2304 | // Pi is not a pack expansion, template argument deduction fails. | ||||||
2305 | if (Args[ArgIdx].isPackExpansion()) | ||||||
2306 | return Sema::TDK_MiscellaneousDeductionFailure; | ||||||
2307 | |||||||
2308 | // Perform deduction for this Pi/Ai pair. | ||||||
2309 | if (Sema::TemplateDeductionResult Result | ||||||
2310 | = DeduceTemplateArguments(S, TemplateParams, | ||||||
2311 | Params[ParamIdx], Args[ArgIdx], | ||||||
2312 | Info, Deduced)) | ||||||
2313 | return Result; | ||||||
2314 | |||||||
2315 | // Move to the next argument. | ||||||
2316 | ++ArgIdx; | ||||||
2317 | continue; | ||||||
2318 | } | ||||||
2319 | |||||||
2320 | // The parameter is a pack expansion. | ||||||
2321 | |||||||
2322 | // C++0x [temp.deduct.type]p9: | ||||||
2323 | // If Pi is a pack expansion, then the pattern of Pi is compared with | ||||||
2324 | // each remaining argument in the template argument list of A. Each | ||||||
2325 | // comparison deduces template arguments for subsequent positions in the | ||||||
2326 | // template parameter packs expanded by Pi. | ||||||
2327 | TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); | ||||||
2328 | |||||||
2329 | // Prepare to deduce the packs within the pattern. | ||||||
2330 | PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); | ||||||
2331 | |||||||
2332 | // Keep track of the deduced template arguments for each parameter pack | ||||||
2333 | // expanded by this pack expansion (the outer index) and for each | ||||||
2334 | // template argument (the inner SmallVectors). | ||||||
2335 | for (; hasTemplateArgumentForDeduction(Args, ArgIdx) && | ||||||
2336 | PackScope.hasNextElement(); | ||||||
2337 | ++ArgIdx) { | ||||||
2338 | // Deduce template arguments from the pattern. | ||||||
2339 | if (Sema::TemplateDeductionResult Result | ||||||
2340 | = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], | ||||||
2341 | Info, Deduced)) | ||||||
2342 | return Result; | ||||||
2343 | |||||||
2344 | PackScope.nextPackElement(); | ||||||
2345 | } | ||||||
2346 | |||||||
2347 | // Build argument packs for each of the parameter packs expanded by this | ||||||
2348 | // pack expansion. | ||||||
2349 | if (auto Result = PackScope.finish()) | ||||||
2350 | return Result; | ||||||
2351 | } | ||||||
2352 | |||||||
2353 | return Sema::TDK_Success; | ||||||
2354 | } | ||||||
2355 | |||||||
2356 | static Sema::TemplateDeductionResult | ||||||
2357 | DeduceTemplateArguments(Sema &S, | ||||||
2358 | TemplateParameterList *TemplateParams, | ||||||
2359 | const TemplateArgumentList &ParamList, | ||||||
2360 | const TemplateArgumentList &ArgList, | ||||||
2361 | TemplateDeductionInfo &Info, | ||||||
2362 | SmallVectorImpl<DeducedTemplateArgument> &Deduced) { | ||||||
2363 | return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(), | ||||||
2364 | ArgList.asArray(), Info, Deduced, | ||||||
2365 | /*NumberOfArgumentsMustMatch*/false); | ||||||
2366 | } | ||||||
2367 | |||||||
2368 | /// Determine whether two template arguments are the same. | ||||||
2369 | static bool isSameTemplateArg(ASTContext &Context, | ||||||
2370 | TemplateArgument X, | ||||||
2371 | const TemplateArgument &Y, | ||||||
2372 | bool PackExpansionMatchesPack = false) { | ||||||
2373 | // If we're checking deduced arguments (X) against original arguments (Y), | ||||||
2374 | // we will have flattened packs to non-expansions in X. | ||||||
2375 | if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion()) | ||||||
2376 | X = X.getPackExpansionPattern(); | ||||||
2377 | |||||||
2378 | if (X.getKind() != Y.getKind()) | ||||||
2379 | return false; | ||||||
2380 | |||||||
2381 | switch (X.getKind()) { | ||||||
2382 | case TemplateArgument::Null: | ||||||
2383 | llvm_unreachable("Comparing NULL template argument")::llvm::llvm_unreachable_internal("Comparing NULL template argument" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2383); | ||||||
2384 | |||||||
2385 | case TemplateArgument::Type: | ||||||
2386 | return Context.getCanonicalType(X.getAsType()) == | ||||||
2387 | Context.getCanonicalType(Y.getAsType()); | ||||||
2388 | |||||||
2389 | case TemplateArgument::Declaration: | ||||||
2390 | return isSameDeclaration(X.getAsDecl(), Y.getAsDecl()); | ||||||
2391 | |||||||
2392 | case TemplateArgument::NullPtr: | ||||||
2393 | return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType()); | ||||||
2394 | |||||||
2395 | case TemplateArgument::Template: | ||||||
2396 | case TemplateArgument::TemplateExpansion: | ||||||
2397 | return Context.getCanonicalTemplateName( | ||||||
2398 | X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() == | ||||||
2399 | Context.getCanonicalTemplateName( | ||||||
2400 | Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer(); | ||||||
2401 | |||||||
2402 | case TemplateArgument::Integral: | ||||||
2403 | return hasSameExtendedValue(X.getAsIntegral(), Y.getAsIntegral()); | ||||||
2404 | |||||||
2405 | case TemplateArgument::Expression: { | ||||||
2406 | llvm::FoldingSetNodeID XID, YID; | ||||||
2407 | X.getAsExpr()->Profile(XID, Context, true); | ||||||
2408 | Y.getAsExpr()->Profile(YID, Context, true); | ||||||
2409 | return XID == YID; | ||||||
2410 | } | ||||||
2411 | |||||||
2412 | case TemplateArgument::Pack: | ||||||
2413 | if (X.pack_size() != Y.pack_size()) | ||||||
2414 | return false; | ||||||
2415 | |||||||
2416 | for (TemplateArgument::pack_iterator XP = X.pack_begin(), | ||||||
2417 | XPEnd = X.pack_end(), | ||||||
2418 | YP = Y.pack_begin(); | ||||||
2419 | XP != XPEnd; ++XP, ++YP) | ||||||
2420 | if (!isSameTemplateArg(Context, *XP, *YP, PackExpansionMatchesPack)) | ||||||
2421 | return false; | ||||||
2422 | |||||||
2423 | return true; | ||||||
2424 | } | ||||||
2425 | |||||||
2426 | llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2426); | ||||||
2427 | } | ||||||
2428 | |||||||
2429 | /// Allocate a TemplateArgumentLoc where all locations have | ||||||
2430 | /// been initialized to the given location. | ||||||
2431 | /// | ||||||
2432 | /// \param Arg The template argument we are producing template argument | ||||||
2433 | /// location information for. | ||||||
2434 | /// | ||||||
2435 | /// \param NTTPType For a declaration template argument, the type of | ||||||
2436 | /// the non-type template parameter that corresponds to this template | ||||||
2437 | /// argument. Can be null if no type sugar is available to add to the | ||||||
2438 | /// type from the template argument. | ||||||
2439 | /// | ||||||
2440 | /// \param Loc The source location to use for the resulting template | ||||||
2441 | /// argument. | ||||||
2442 | TemplateArgumentLoc | ||||||
2443 | Sema::getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, | ||||||
2444 | QualType NTTPType, SourceLocation Loc) { | ||||||
2445 | switch (Arg.getKind()) { | ||||||
2446 | case TemplateArgument::Null: | ||||||
2447 | llvm_unreachable("Can't get a NULL template argument here")::llvm::llvm_unreachable_internal("Can't get a NULL template argument here" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2447); | ||||||
2448 | |||||||
2449 | case TemplateArgument::Type: | ||||||
2450 | return TemplateArgumentLoc( | ||||||
2451 | Arg, Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc)); | ||||||
2452 | |||||||
2453 | case TemplateArgument::Declaration: { | ||||||
2454 | if (NTTPType.isNull()) | ||||||
2455 | NTTPType = Arg.getParamTypeForDecl(); | ||||||
2456 | Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) | ||||||
2457 | .getAs<Expr>(); | ||||||
2458 | return TemplateArgumentLoc(TemplateArgument(E), E); | ||||||
2459 | } | ||||||
2460 | |||||||
2461 | case TemplateArgument::NullPtr: { | ||||||
2462 | if (NTTPType.isNull()) | ||||||
2463 | NTTPType = Arg.getNullPtrType(); | ||||||
2464 | Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) | ||||||
2465 | .getAs<Expr>(); | ||||||
2466 | return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), | ||||||
2467 | E); | ||||||
2468 | } | ||||||
2469 | |||||||
2470 | case TemplateArgument::Integral: { | ||||||
2471 | Expr *E = | ||||||
2472 | BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<Expr>(); | ||||||
2473 | return TemplateArgumentLoc(TemplateArgument(E), E); | ||||||
2474 | } | ||||||
2475 | |||||||
2476 | case TemplateArgument::Template: | ||||||
2477 | case TemplateArgument::TemplateExpansion: { | ||||||
2478 | NestedNameSpecifierLocBuilder Builder; | ||||||
2479 | TemplateName Template = Arg.getAsTemplate(); | ||||||
2480 | if (DependentTemplateName *DTN = Template.getAsDependentTemplateName()) | ||||||
2481 | Builder.MakeTrivial(Context, DTN->getQualifier(), Loc); | ||||||
2482 | else if (QualifiedTemplateName *QTN = | ||||||
2483 | Template.getAsQualifiedTemplateName()) | ||||||
2484 | Builder.MakeTrivial(Context, QTN->getQualifier(), Loc); | ||||||
2485 | |||||||
2486 | if (Arg.getKind() == TemplateArgument::Template) | ||||||
2487 | return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), | ||||||
2488 | Loc); | ||||||
2489 | |||||||
2490 | return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context), | ||||||
2491 | Loc, Loc); | ||||||
2492 | } | ||||||
2493 | |||||||
2494 | case TemplateArgument::Expression: | ||||||
2495 | return TemplateArgumentLoc(Arg, Arg.getAsExpr()); | ||||||
2496 | |||||||
2497 | case TemplateArgument::Pack: | ||||||
2498 | return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo()); | ||||||
2499 | } | ||||||
2500 | |||||||
2501 | llvm_unreachable("Invalid TemplateArgument Kind!")::llvm::llvm_unreachable_internal("Invalid TemplateArgument Kind!" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2501); | ||||||
2502 | } | ||||||
2503 | |||||||
2504 | /// Convert the given deduced template argument and add it to the set of | ||||||
2505 | /// fully-converted template arguments. | ||||||
2506 | static bool | ||||||
2507 | ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, | ||||||
2508 | DeducedTemplateArgument Arg, | ||||||
2509 | NamedDecl *Template, | ||||||
2510 | TemplateDeductionInfo &Info, | ||||||
2511 | bool IsDeduced, | ||||||
2512 | SmallVectorImpl<TemplateArgument> &Output) { | ||||||
2513 | auto ConvertArg = [&](DeducedTemplateArgument Arg, | ||||||
2514 | unsigned ArgumentPackIndex) { | ||||||
2515 | // Convert the deduced template argument into a template | ||||||
2516 | // argument that we can check, almost as if the user had written | ||||||
2517 | // the template argument explicitly. | ||||||
2518 | TemplateArgumentLoc ArgLoc = | ||||||
2519 | S.getTrivialTemplateArgumentLoc(Arg, QualType(), Info.getLocation()); | ||||||
2520 | |||||||
2521 | // Check the template argument, converting it as necessary. | ||||||
2522 | return S.CheckTemplateArgument( | ||||||
2523 | Param, ArgLoc, Template, Template->getLocation(), | ||||||
2524 | Template->getSourceRange().getEnd(), ArgumentPackIndex, Output, | ||||||
2525 | IsDeduced | ||||||
2526 | ? (Arg.wasDeducedFromArrayBound() ? Sema::CTAK_DeducedFromArrayBound | ||||||
2527 | : Sema::CTAK_Deduced) | ||||||
2528 | : Sema::CTAK_Specified); | ||||||
2529 | }; | ||||||
2530 | |||||||
2531 | if (Arg.getKind() == TemplateArgument::Pack) { | ||||||
2532 | // This is a template argument pack, so check each of its arguments against | ||||||
2533 | // the template parameter. | ||||||
2534 | SmallVector<TemplateArgument, 2> PackedArgsBuilder; | ||||||
2535 | for (const auto &P : Arg.pack_elements()) { | ||||||
2536 | // When converting the deduced template argument, append it to the | ||||||
2537 | // general output list. We need to do this so that the template argument | ||||||
2538 | // checking logic has all of the prior template arguments available. | ||||||
2539 | DeducedTemplateArgument InnerArg(P); | ||||||
2540 | InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); | ||||||
2541 | assert(InnerArg.getKind() != TemplateArgument::Pack &&((InnerArg.getKind() != TemplateArgument::Pack && "deduced nested pack" ) ? static_cast<void> (0) : __assert_fail ("InnerArg.getKind() != TemplateArgument::Pack && \"deduced nested pack\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2542, __PRETTY_FUNCTION__)) | ||||||
2542 | "deduced nested pack")((InnerArg.getKind() != TemplateArgument::Pack && "deduced nested pack" ) ? static_cast<void> (0) : __assert_fail ("InnerArg.getKind() != TemplateArgument::Pack && \"deduced nested pack\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2542, __PRETTY_FUNCTION__)); | ||||||
2543 | if (P.isNull()) { | ||||||
2544 | // We deduced arguments for some elements of this pack, but not for | ||||||
2545 | // all of them. This happens if we get a conditionally-non-deduced | ||||||
2546 | // context in a pack expansion (such as an overload set in one of the | ||||||
2547 | // arguments). | ||||||
2548 | S.Diag(Param->getLocation(), | ||||||
2549 | diag::err_template_arg_deduced_incomplete_pack) | ||||||
2550 | << Arg << Param; | ||||||
2551 | return true; | ||||||
2552 | } | ||||||
2553 | if (ConvertArg(InnerArg, PackedArgsBuilder.size())) | ||||||
2554 | return true; | ||||||
2555 | |||||||
2556 | // Move the converted template argument into our argument pack. | ||||||
2557 | PackedArgsBuilder.push_back(Output.pop_back_val()); | ||||||
2558 | } | ||||||
2559 | |||||||
2560 | // If the pack is empty, we still need to substitute into the parameter | ||||||
2561 | // itself, in case that substitution fails. | ||||||
2562 | if (PackedArgsBuilder.empty()) { | ||||||
2563 | LocalInstantiationScope Scope(S); | ||||||
2564 | TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Output); | ||||||
2565 | MultiLevelTemplateArgumentList Args(TemplateArgs); | ||||||
2566 | |||||||
2567 | if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) { | ||||||
2568 | Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, | ||||||
2569 | NTTP, Output, | ||||||
2570 | Template->getSourceRange()); | ||||||
2571 | if (Inst.isInvalid() || | ||||||
2572 | S.SubstType(NTTP->getType(), Args, NTTP->getLocation(), | ||||||
2573 | NTTP->getDeclName()).isNull()) | ||||||
2574 | return true; | ||||||
2575 | } else if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) { | ||||||
2576 | Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, | ||||||
2577 | TTP, Output, | ||||||
2578 | Template->getSourceRange()); | ||||||
2579 | if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args)) | ||||||
2580 | return true; | ||||||
2581 | } | ||||||
2582 | // For type parameters, no substitution is ever required. | ||||||
2583 | } | ||||||
2584 | |||||||
2585 | // Create the resulting argument pack. | ||||||
2586 | Output.push_back( | ||||||
2587 | TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder)); | ||||||
2588 | return false; | ||||||
2589 | } | ||||||
2590 | |||||||
2591 | return ConvertArg(Arg, 0); | ||||||
2592 | } | ||||||
2593 | |||||||
2594 | // FIXME: This should not be a template, but | ||||||
2595 | // ClassTemplatePartialSpecializationDecl sadly does not derive from | ||||||
2596 | // TemplateDecl. | ||||||
2597 | template<typename TemplateDeclT> | ||||||
2598 | static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments( | ||||||
2599 | Sema &S, TemplateDeclT *Template, bool IsDeduced, | ||||||
2600 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
2601 | TemplateDeductionInfo &Info, SmallVectorImpl<TemplateArgument> &Builder, | ||||||
2602 | LocalInstantiationScope *CurrentInstantiationScope = nullptr, | ||||||
2603 | unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) { | ||||||
2604 | TemplateParameterList *TemplateParams = Template->getTemplateParameters(); | ||||||
2605 | |||||||
2606 | for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { | ||||||
2607 | NamedDecl *Param = TemplateParams->getParam(I); | ||||||
2608 | |||||||
2609 | // C++0x [temp.arg.explicit]p3: | ||||||
2610 | // A trailing template parameter pack (14.5.3) not otherwise deduced will | ||||||
2611 | // be deduced to an empty sequence of template arguments. | ||||||
2612 | // FIXME: Where did the word "trailing" come from? | ||||||
2613 | if (Deduced[I].isNull() && Param->isTemplateParameterPack()) { | ||||||
2614 | if (auto Result = PackDeductionScope(S, TemplateParams, Deduced, Info, I) | ||||||
2615 | .finish(/*TreatNoDeductionsAsNonDeduced*/false)) | ||||||
2616 | return Result; | ||||||
2617 | } | ||||||
2618 | |||||||
2619 | if (!Deduced[I].isNull()) { | ||||||
2620 | if (I < NumAlreadyConverted) { | ||||||
2621 | // We may have had explicitly-specified template arguments for a | ||||||
2622 | // template parameter pack (that may or may not have been extended | ||||||
2623 | // via additional deduced arguments). | ||||||
2624 | if (Param->isParameterPack() && CurrentInstantiationScope && | ||||||
2625 | CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { | ||||||
2626 | // Forget the partially-substituted pack; its substitution is now | ||||||
2627 | // complete. | ||||||
2628 | CurrentInstantiationScope->ResetPartiallySubstitutedPack(); | ||||||
2629 | // We still need to check the argument in case it was extended by | ||||||
2630 | // deduction. | ||||||
2631 | } else { | ||||||
2632 | // We have already fully type-checked and converted this | ||||||
2633 | // argument, because it was explicitly-specified. Just record the | ||||||
2634 | // presence of this argument. | ||||||
2635 | Builder.push_back(Deduced[I]); | ||||||
2636 | continue; | ||||||
2637 | } | ||||||
2638 | } | ||||||
2639 | |||||||
2640 | // We may have deduced this argument, so it still needs to be | ||||||
2641 | // checked and converted. | ||||||
2642 | if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info, | ||||||
2643 | IsDeduced, Builder)) { | ||||||
2644 | Info.Param = makeTemplateParameter(Param); | ||||||
2645 | // FIXME: These template arguments are temporary. Free them! | ||||||
2646 | Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); | ||||||
2647 | return Sema::TDK_SubstitutionFailure; | ||||||
2648 | } | ||||||
2649 | |||||||
2650 | continue; | ||||||
2651 | } | ||||||
2652 | |||||||
2653 | // Substitute into the default template argument, if available. | ||||||
2654 | bool HasDefaultArg = false; | ||||||
2655 | TemplateDecl *TD = dyn_cast<TemplateDecl>(Template); | ||||||
2656 | if (!TD) { | ||||||
2657 | assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||((isa<ClassTemplatePartialSpecializationDecl>(Template) || isa<VarTemplatePartialSpecializationDecl>(Template) ) ? static_cast<void> (0) : __assert_fail ("isa<ClassTemplatePartialSpecializationDecl>(Template) || isa<VarTemplatePartialSpecializationDecl>(Template)" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2658, __PRETTY_FUNCTION__)) | ||||||
2658 | isa<VarTemplatePartialSpecializationDecl>(Template))((isa<ClassTemplatePartialSpecializationDecl>(Template) || isa<VarTemplatePartialSpecializationDecl>(Template) ) ? static_cast<void> (0) : __assert_fail ("isa<ClassTemplatePartialSpecializationDecl>(Template) || isa<VarTemplatePartialSpecializationDecl>(Template)" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaTemplateDeduction.cpp" , 2658, __PRETTY_FUNCTION__)); | ||||||
2659 | return Sema::TDK_Incomplete; | ||||||
2660 | } | ||||||
2661 | |||||||
2662 | TemplateArgumentLoc DefArg = S.SubstDefaultTemplateArgumentIfAvailable( | ||||||
2663 | TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder, | ||||||
2664 | HasDefaultArg); | ||||||
2665 | |||||||
2666 | // If there was no default argument, deduction is incomplete. | ||||||
2667 | if (DefArg.getArgument().isNull()) { | ||||||
2668 | Info.Param = makeTemplateParameter( | ||||||
2669 | const_cast<NamedDecl *>(TemplateParams->getParam(I))); | ||||||
2670 | Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); | ||||||
2671 | if (PartialOverloading) break; | ||||||
2672 | |||||||
2673 | return HasDefaultArg ? Sema::TDK_SubstitutionFailure | ||||||
2674 | : Sema::TDK_Incomplete; | ||||||
2675 | } | ||||||
2676 | |||||||
2677 | // Check whether we can actually use the default argument. | ||||||
2678 | if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(), | ||||||
2679 | TD->getSourceRange().getEnd(), 0, Builder, | ||||||
2680 | Sema::CTAK_Specified)) { | ||||||
2681 | Info.Param = makeTemplateParameter( | ||||||
2682 | const_cast<NamedDecl *>(TemplateParams->getParam(I))); | ||||||
2683 | // FIXME: These template arguments are temporary. Free them! | ||||||
2684 | Info.reset(TemplateArgumentList::CreateCopy(S.Context, Builder)); | ||||||
2685 | return Sema::TDK_SubstitutionFailure; | ||||||
2686 | } | ||||||
2687 | |||||||
2688 | // If we get here, we successfully used the default template argument. | ||||||
2689 | } | ||||||
2690 | |||||||
2691 | return Sema::TDK_Success; | ||||||
2692 | } | ||||||
2693 | |||||||
2694 | static DeclContext *getAsDeclContextOrEnclosing(Decl *D) { | ||||||
2695 | if (auto *DC = dyn_cast<DeclContext>(D)) | ||||||
2696 | return DC; | ||||||
2697 | return D->getDeclContext(); | ||||||
2698 | } | ||||||
2699 | |||||||
2700 | template<typename T> struct IsPartialSpecialization { | ||||||
2701 | static constexpr bool value = false; | ||||||
2702 | }; | ||||||
2703 | template<> | ||||||
2704 | struct IsPartialSpecialization<ClassTemplatePartialSpecializationDecl> { | ||||||
2705 | static constexpr bool value = true; | ||||||
2706 | }; | ||||||
2707 | template<> | ||||||
2708 | struct IsPartialSpecialization<VarTemplatePartialSpecializationDecl> { | ||||||
2709 | static constexpr bool value = true; | ||||||
2710 | }; | ||||||
2711 | |||||||
2712 | /// Complete template argument deduction for a partial specialization. | ||||||
2713 | template <typename T> | ||||||
2714 | static typename std::enable_if<IsPartialSpecialization<T>::value, | ||||||
2715 | Sema::TemplateDeductionResult>::type | ||||||
2716 | FinishTemplateArgumentDeduction( | ||||||
2717 | Sema &S, T *Partial, bool IsPartialOrdering, | ||||||
2718 | const TemplateArgumentList &TemplateArgs, | ||||||
2719 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
2720 | TemplateDeductionInfo &Info) { | ||||||
2721 | // Unevaluated SFINAE context. | ||||||
2722 | EnterExpressionEvaluationContext Unevaluated( | ||||||
2723 | S, Sema::ExpressionEvaluationContext::Unevaluated); | ||||||
2724 | Sema::SFINAETrap Trap(S); | ||||||
2725 | |||||||
2726 | Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Partial)); | ||||||
2727 | |||||||
2728 | // C++ [temp.deduct.type]p2: | ||||||
2729 | // [...] or if any template argument remains neither deduced nor | ||||||
2730 | // explicitly specified, template argument deduction fails. | ||||||
2731 | SmallVector<TemplateArgument, 4> Builder; | ||||||
2732 | if (auto Result = ConvertDeducedTemplateArguments( | ||||||
2733 | S, Partial, IsPartialOrdering, Deduced, Info, Builder)) | ||||||
2734 | return Result; | ||||||
2735 | |||||||
2736 | // Form the template argument list from the deduced template arguments. | ||||||
2737 | TemplateArgumentList *DeducedArgumentList | ||||||
2738 | = TemplateArgumentList::CreateCopy(S.Context, Builder); | ||||||
2739 | |||||||
2740 | Info.reset(DeducedArgumentList); | ||||||
2741 | |||||||
2742 | // Substitute the deduced template arguments into the template | ||||||
2743 | // arguments of the class template partial specialization, and | ||||||
2744 | // verify that the instantiated template arguments are both valid | ||||||
2745 | // and are equivalent to the template arguments originally provided | ||||||
2746 | // to the class template. | ||||||
2747 | LocalInstantiationScope InstScope(S); | ||||||
2748 | auto *Template = Partial->getSpecializedTemplate(); | ||||||
2749 | const ASTTemplateArgumentListInfo *PartialTemplArgInfo = | ||||||
2750 | Partial->getTemplateArgsAsWritten(); | ||||||
2751 | const TemplateArgumentLoc *PartialTemplateArgs = | ||||||
2752 | PartialTemplArgInfo->getTemplateArgs(); | ||||||
2753 | |||||||
2754 | TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, | ||||||
2755 | PartialTemplArgInfo->RAngleLoc); | ||||||
2756 | |||||||
2757 | if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs, | ||||||
2758 | InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) { | ||||||
2759 | unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx; | ||||||
2760 | if (ParamIdx >= Partial->getTemplateParameters()->size()) | ||||||
2761 | ParamIdx = Partial->getTemplateParameters()->size() - 1; | ||||||
2762 | |||||||
2763 | Decl *Param = const_cast<NamedDecl *>( | ||||||
2764 | Partial->getTemplateParameters()->getParam(ParamIdx)); | ||||||
2765 | Info.Param = makeTemplateParameter(Param); | ||||||
2766 | Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument(); | ||||||
2767 | return Sema::TDK_SubstitutionFailure; | ||||||
2768 | } | ||||||
2769 | |||||||
2770 | SmallVector<TemplateArgument, 4> ConvertedInstArgs; | ||||||
2771 | if (S.CheckTemplateArgumentList(Template, Partial->getLocation(), InstArgs, | ||||||
2772 | false, ConvertedInstArgs)) | ||||||
2773 | return Sema::TDK_SubstitutionFailure; | ||||||
2774 | |||||||
2775 | TemplateParameterList *TemplateParams = Template->getTemplateParameters(); | ||||||
2776 | for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { | ||||||
2777 | TemplateArgument InstArg = ConvertedInstArgs.data()[I]; | ||||||
2778 | if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) { | ||||||
2779 | Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); | ||||||
2780 | Info.FirstArg = TemplateArgs[I]; | ||||||
2781 | Info.SecondArg = InstArg; | ||||||
2782 | return Sema::TDK_NonDeducedMismatch; | ||||||
2783 | } | ||||||
2784 | } | ||||||
2785 | |||||||
2786 | if (Trap.hasErrorOccurred()) | ||||||
2787 | return Sema::TDK_SubstitutionFailure; | ||||||
2788 | |||||||
2789 | return Sema::TDK_Success; | ||||||
2790 | } | ||||||
2791 | |||||||
2792 | /// Complete template argument deduction for a class or variable template, | ||||||
2793 | /// when partial ordering against a partial specialization. | ||||||
2794 | // FIXME: Factor out duplication with partial specialization version above. | ||||||
2795 | static Sema::TemplateDeductionResult FinishTemplateArgumentDeduction( | ||||||
2796 | Sema &S, TemplateDecl *Template, bool PartialOrdering, | ||||||
2797 | const TemplateArgumentList &TemplateArgs, | ||||||
2798 | SmallVectorImpl<DeducedTemplateArgument> &Deduced, | ||||||
2799 | TemplateDeductionInfo &Info) { | ||||||
2800 | // Unevaluated SFINAE context. | ||||||
2801 | EnterExpressionEvaluationContext Unevaluated( | ||||||
2802 | S, Sema::ExpressionEvaluationContext::Unevaluated); | ||||||
2803 | Sema::SFINAETrap Trap(S); | ||||||
2804 | |||||||
2805 | Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template)); | ||||||
2806 | |||||||
2807 | // C++ [temp.deduct.type]p2: | ||||||
2808 | // [...] or if any template argument remains neither deduced nor | ||||||
2809 | // explicitly specified, template argument deduction fails. | ||||||
2810 | SmallVector<TemplateArgument, 4> Builder; | ||||||
2811 | if (auto Result = ConvertDeducedTemplateArguments( | ||||||
2812 | S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder)) | ||||||
2813 | return Result; | ||||||
2814 | |||||||
2815 | // Check that we produced the correct argument list. | ||||||
2816 | TemplateParameterList *TemplateParams = Template->getTemplateParameters(); | ||||||
2817 | for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { | ||||||
2818 | TemplateArgument InstArg = Builder[I]; | ||||||
2819 | if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg, | ||||||
2820 | /*PackExpansionMatchesPack*/true)) { | ||||||
2821 | Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); | ||||||
2822 | Info.FirstArg = TemplateArgs[I]; | ||||||
2823 | Info.SecondArg = InstArg; | ||||||
2824 | return Sema::TDK_NonDeducedMismatch; | ||||||
2825 | } | ||||||
2826 | } | ||||||
2827 | |||||||
2828 | if (Trap.hasErrorOccurred()) | ||||||
2829 | return Sema::TDK_SubstitutionFailure; | ||||||
2830 | |||||||
2831 | return Sema::TDK_Success; | ||||||
2832 | } | ||||||
2833 | |||||||
2834 | |||||||
2835 | /// Perform template argument deduction to determine whether | ||||||
2836 | /// the given template arguments match the given class template | ||||||
2837 | /// partial specialization per C++ [temp.class.spec.match]. | ||||||
2838 | Sema::TemplateDeductionResult | ||||||
2839 | Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, | ||||||
2840 | const TemplateArgumentList &TemplateArgs, | ||||||
2841 | TemplateDeductionInfo &Info) { | ||||||
2842 | if (Partial->isInvalidDecl()) | ||||||
2843 | return TDK_Invalid; | ||||||
2844 | |||||||
2845 | // C++ [temp.class.spec.match]p2: | ||||||
2846 | // A partial specialization matches a given actual template | ||||||
2847 | // argument list if the template arguments of the partial | ||||||
2848 | // specialization can be deduced from the actual template argument | ||||||
2849 | // list (14.8.2). | ||||||
2850 | |||||||
2851 | // Unevaluated SFINAE context. | ||||||
2852 | EnterExpressionEvaluationContext Unevaluated( | ||||||
2853 | *this, Sema::ExpressionEvaluationContext::Unevaluated); | ||||||
2854 | SFINAETrap Trap(*this); | ||||||
2855 | |||||||
2856 | SmallVector<DeducedTemplateArgument, 4> Deduced; | ||||||
2857 | Deduced.resize(Partial->getTemplateParameters()->size()); | ||||||
2858 | if (TemplateDeductionResult Result | ||||||
2859 | = ::DeduceTemplateArguments(*this, | ||||||
2860 | Partial->getTemplateParameters(), | ||||||
2861 | Partial->getTemplateArgs(), | ||||||
2862 | TemplateArgs, Info, Deduced)) | ||||||
2863 | return Result; | ||||||
2864 | |||||||
2865 | SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); | ||||||
2866 | InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, | ||||||
2867 | Info); | ||||||
2868 | if (Inst.isInvalid()) | ||||||
2869 | return TDK_InstantiationDepth; | ||||||
2870 | |||||||
2871 | if (Trap.hasErrorOccurred()) | ||||||
2872 | return Sema::TDK_SubstitutionFailure; | ||||||
2873 | |||||||
2874 | return ::FinishTemplateArgumentDeduction( | ||||||
2875 | *this, Partial, /*IsPartialOrdering=*/false, TemplateArgs, Deduced, Info); | ||||||
2876 | } | ||||||
2877 | |||||||
2878 | /// Perform template argument deduction to determine whether | ||||||
2879 | /// the given template arguments match the given variable template | ||||||
2880 | /// partial specialization per C++ [temp.class.spec.match]. | ||||||
2881 | Sema::TemplateDeductionResult | ||||||
2882 | Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, | ||||||
2883 | const TemplateArgumentList &TemplateArgs, | ||||||
2884 | TemplateDeductionInfo &Info) { | ||||||
2885 | if (Partial->isInvalidDecl()) | ||||||
2886 | return TDK_Invalid; | ||||||
2887 | |||||||
2888 | // C++ [temp.class.spec.match]p2: | ||||||
2889 | // A partial specialization matches a given actual template | ||||||
2890 | // argument list if the template arguments of the partial | ||||||
2891 | // specialization can be deduced from the actual template argument | ||||||
2892 | // list (14.8.2). | ||||||
2893 | |||||||
2894 | // Unevaluated SFINAE context. | ||||||
2895 | EnterExpressionEvaluationContext Unevaluated( | ||||||
2896 | *this, Sema::ExpressionEvaluationContext::Unevaluated); | ||||||
2897 | SFINAETrap Trap(*this); | ||||||
2898 | |||||||
2899 | SmallVector<DeducedTemplateArgument, 4> Deduced; | ||||||
2900 | Deduced.resize(Partial->getTemplateParameters()->size()); | ||||||
2901 | if (TemplateDeductionResult Result = ::DeduceTemplateArguments( | ||||||
2902 | *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(), | ||||||
2903 | TemplateArgs, Info, Deduced)) | ||||||
2904 | return Result; | ||||||
2905 | |||||||
2906 | SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); | ||||||
2907 | InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, | ||||||
2908 | Info); | ||||||
2909 | if (Inst.isInvalid()) | ||||||
2910 | return TDK_InstantiationDepth; | ||||||
2911 | |||||||
2912 | if (Trap.hasErrorOccurred()) | ||||||
2913 | return Sema::TDK_SubstitutionFailure; | ||||||
2914 | |||||||
2915 | return ::FinishTemplateArgumentDeduction( | ||||||
2916 | *this, Partial, /*IsPartialOrdering=*/false, TemplateArgs, Deduced, Info); | ||||||
2917 | } | ||||||
2918 | |||||||
2919 | /// Determine whether the given type T is a simple-template-id type. | ||||||
2920 | static bool isSimpleTemplateIdType(QualType T) { | ||||||
2921 | if (const TemplateSpecializationType *Spec
|
36.1 | 'Spec' is non-null |
20.1 | 'ParamRefType' is null |
20.1 | 'ParamRefType' is null |
20.1 | 'ParamRefType' is null |
29.1 | 'ParamRefType' is null |
29.1 | 'ParamRefType' is null |
29.1 | 'ParamRefType' is null |
32.1 | 'ParamRefType' is null |
32.1 | 'ParamRefType' is null |
32.1 | 'ParamRefType' is null |
43 | Called C++ object pointer is null |
1 | Assuming the condition is false |
10.1 | 'ParamExpansion' is null |
10.1 | 'ParamExpansion' is null |
10.1 | 'ParamExpansion' is null |
1 | //===- Type.h - C Language Family Type Representation -----------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | /// \file |
10 | /// C Language Family Type Representation |
11 | /// |
12 | /// This file defines the clang::Type interface and subclasses, used to |
13 | /// represent types for languages in the C family. |
14 | // |
15 | //===----------------------------------------------------------------------===// |
16 | |
17 | #ifndef LLVM_CLANG_AST_TYPE_H |
18 | #define LLVM_CLANG_AST_TYPE_H |
19 | |
20 | #include "clang/AST/NestedNameSpecifier.h" |
21 | #include "clang/AST/TemplateName.h" |
22 | #include "clang/Basic/AddressSpaces.h" |
23 | #include "clang/Basic/AttrKinds.h" |
24 | #include "clang/Basic/Diagnostic.h" |
25 | #include "clang/Basic/ExceptionSpecificationType.h" |
26 | #include "clang/Basic/LLVM.h" |
27 | #include "clang/Basic/Linkage.h" |
28 | #include "clang/Basic/PartialDiagnostic.h" |
29 | #include "clang/Basic/SourceLocation.h" |
30 | #include "clang/Basic/Specifiers.h" |
31 | #include "clang/Basic/Visibility.h" |
32 | #include "llvm/ADT/APInt.h" |
33 | #include "llvm/ADT/APSInt.h" |
34 | #include "llvm/ADT/ArrayRef.h" |
35 | #include "llvm/ADT/FoldingSet.h" |
36 | #include "llvm/ADT/None.h" |
37 | #include "llvm/ADT/Optional.h" |
38 | #include "llvm/ADT/PointerIntPair.h" |
39 | #include "llvm/ADT/PointerUnion.h" |
40 | #include "llvm/ADT/StringRef.h" |
41 | #include "llvm/ADT/Twine.h" |
42 | #include "llvm/ADT/iterator_range.h" |
43 | #include "llvm/Support/Casting.h" |
44 | #include "llvm/Support/Compiler.h" |
45 | #include "llvm/Support/ErrorHandling.h" |
46 | #include "llvm/Support/PointerLikeTypeTraits.h" |
47 | #include "llvm/Support/type_traits.h" |
48 | #include "llvm/Support/TrailingObjects.h" |
49 | #include <cassert> |
50 | #include <cstddef> |
51 | #include <cstdint> |
52 | #include <cstring> |
53 | #include <string> |
54 | #include <type_traits> |
55 | #include <utility> |
56 | |
57 | namespace clang { |
58 | |
59 | class ExtQuals; |
60 | class QualType; |
61 | class TagDecl; |
62 | class Type; |
63 | |
64 | enum { |
65 | TypeAlignmentInBits = 4, |
66 | TypeAlignment = 1 << TypeAlignmentInBits |
67 | }; |
68 | |
69 | } // namespace clang |
70 | |
71 | namespace llvm { |
72 | |
73 | template <typename T> |
74 | struct PointerLikeTypeTraits; |
75 | template<> |
76 | struct PointerLikeTypeTraits< ::clang::Type*> { |
77 | static inline void *getAsVoidPointer(::clang::Type *P) { return P; } |
78 | |
79 | static inline ::clang::Type *getFromVoidPointer(void *P) { |
80 | return static_cast< ::clang::Type*>(P); |
81 | } |
82 | |
83 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; |
84 | }; |
85 | |
86 | template<> |
87 | struct PointerLikeTypeTraits< ::clang::ExtQuals*> { |
88 | static inline void *getAsVoidPointer(::clang::ExtQuals *P) { return P; } |
89 | |
90 | static inline ::clang::ExtQuals *getFromVoidPointer(void *P) { |
91 | return static_cast< ::clang::ExtQuals*>(P); |
92 | } |
93 | |
94 | enum { NumLowBitsAvailable = clang::TypeAlignmentInBits }; |
95 | }; |
96 | |
97 | } // namespace llvm |
98 | |
99 | namespace clang { |
100 | |
101 | class ASTContext; |
102 | template <typename> class CanQual; |
103 | class CXXRecordDecl; |
104 | class DeclContext; |
105 | class EnumDecl; |
106 | class Expr; |
107 | class ExtQualsTypeCommonBase; |
108 | class FunctionDecl; |
109 | class IdentifierInfo; |
110 | class NamedDecl; |
111 | class ObjCInterfaceDecl; |
112 | class ObjCProtocolDecl; |
113 | class ObjCTypeParamDecl; |
114 | struct PrintingPolicy; |
115 | class RecordDecl; |
116 | class Stmt; |
117 | class TagDecl; |
118 | class TemplateArgument; |
119 | class TemplateArgumentListInfo; |
120 | class TemplateArgumentLoc; |
121 | class TemplateTypeParmDecl; |
122 | class TypedefNameDecl; |
123 | class UnresolvedUsingTypenameDecl; |
124 | |
125 | using CanQualType = CanQual<Type>; |
126 | |
127 | // Provide forward declarations for all of the *Type classes. |
128 | #define TYPE(Class, Base) class Class##Type; |
129 | #include "clang/AST/TypeNodes.inc" |
130 | |
131 | /// The collection of all-type qualifiers we support. |
132 | /// Clang supports five independent qualifiers: |
133 | /// * C99: const, volatile, and restrict |
134 | /// * MS: __unaligned |
135 | /// * Embedded C (TR18037): address spaces |
136 | /// * Objective C: the GC attributes (none, weak, or strong) |
137 | class Qualifiers { |
138 | public: |
139 | enum TQ { // NOTE: These flags must be kept in sync with DeclSpec::TQ. |
140 | Const = 0x1, |
141 | Restrict = 0x2, |
142 | Volatile = 0x4, |
143 | CVRMask = Const | Volatile | Restrict |
144 | }; |
145 | |
146 | enum GC { |
147 | GCNone = 0, |
148 | Weak, |
149 | Strong |
150 | }; |
151 | |
152 | enum ObjCLifetime { |
153 | /// There is no lifetime qualification on this type. |
154 | OCL_None, |
155 | |
156 | /// This object can be modified without requiring retains or |
157 | /// releases. |
158 | OCL_ExplicitNone, |
159 | |
160 | /// Assigning into this object requires the old value to be |
161 | /// released and the new value to be retained. The timing of the |
162 | /// release of the old value is inexact: it may be moved to |
163 | /// immediately after the last known point where the value is |
164 | /// live. |
165 | OCL_Strong, |
166 | |
167 | /// Reading or writing from this object requires a barrier call. |
168 | OCL_Weak, |
169 | |
170 | /// Assigning into this object requires a lifetime extension. |
171 | OCL_Autoreleasing |
172 | }; |
173 | |
174 | enum { |
175 | /// The maximum supported address space number. |
176 | /// 23 bits should be enough for anyone. |
177 | MaxAddressSpace = 0x7fffffu, |
178 | |
179 | /// The width of the "fast" qualifier mask. |
180 | FastWidth = 3, |
181 | |
182 | /// The fast qualifier mask. |
183 | FastMask = (1 << FastWidth) - 1 |
184 | }; |
185 | |
186 | /// Returns the common set of qualifiers while removing them from |
187 | /// the given sets. |
188 | static Qualifiers removeCommonQualifiers(Qualifiers &L, Qualifiers &R) { |
189 | // If both are only CVR-qualified, bit operations are sufficient. |
190 | if (!(L.Mask & ~CVRMask) && !(R.Mask & ~CVRMask)) { |
191 | Qualifiers Q; |
192 | Q.Mask = L.Mask & R.Mask; |
193 | L.Mask &= ~Q.Mask; |