clang  10.0.0git
SemaTemplateDeduction.cpp
Go to the documentation of this file.
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 
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"
20 #include "clang/AST/DeclBase.h"
21 #include "clang/AST/DeclCXX.h"
22 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
28 #include "clang/AST/TemplateBase.h"
29 #include "clang/AST/TemplateName.h"
30 #include "clang/AST/Type.h"
31 #include "clang/AST/TypeLoc.h"
35 #include "clang/Basic/LLVM.h"
39 #include "clang/Basic/Specifiers.h"
40 #include "clang/Sema/Ownership.h"
41 #include "clang/Sema/Sema.h"
42 #include "clang/Sema/Template.h"
43 #include "llvm/ADT/APInt.h"
44 #include "llvm/ADT/APSInt.h"
45 #include "llvm/ADT/ArrayRef.h"
46 #include "llvm/ADT/DenseMap.h"
47 #include "llvm/ADT/FoldingSet.h"
48 #include "llvm/ADT/Optional.h"
49 #include "llvm/ADT/SmallBitVector.h"
50 #include "llvm/ADT/SmallPtrSet.h"
51 #include "llvm/ADT/SmallVector.h"
52 #include "llvm/Support/Casting.h"
53 #include "llvm/Support/Compiler.h"
54 #include "llvm/Support/ErrorHandling.h"
55 #include <algorithm>
56 #include <cassert>
57 #include <tuple>
58 #include <utility>
59 
60 namespace clang {
61 
62  /// Various flags that control template argument deduction.
63  ///
64  /// These flags can be bitwise-OR'd together.
66  /// No template argument deduction flags, which indicates the
67  /// strictest results for template argument deduction (as used for, e.g.,
68  /// matching class template partial specializations).
69  TDF_None = 0,
70 
71  /// Within template argument deduction from a function call, we are
72  /// matching with a parameter type for which the original parameter was
73  /// a reference.
75 
76  /// Within template argument deduction from a function call, we
77  /// are matching in a case where we ignore cv-qualifiers.
79 
80  /// Within template argument deduction from a function call,
81  /// we are matching in a case where we can perform template argument
82  /// deduction from a template-id of a derived class of the argument type.
84 
85  /// Allow non-dependent types to differ, e.g., when performing
86  /// template argument deduction from a function call where conversions
87  /// may apply.
89 
90  /// Whether we are performing template argument deduction for
91  /// parameters and arguments in a top-level template argument
93 
94  /// Within template argument deduction from overload resolution per
95  /// C++ [over.over] allow matching function types that are compatible in
96  /// terms of noreturn and default calling convention adjustments, or
97  /// similarly matching a declared template specialization against a
98  /// possible template, per C++ [temp.deduct.decl]. In either case, permit
99  /// deduction where the parameter is a function type that can be converted
100  /// to the argument type.
102 
103  /// Within template argument deduction for a conversion function, we are
104  /// matching with an argument type for which the original argument was
105  /// a reference.
107  };
108 }
109 
110 using namespace clang;
111 using namespace sema;
112 
113 /// Compare two APSInts, extending and switching the sign as
114 /// necessary to compare their values regardless of underlying type.
116  if (Y.getBitWidth() > X.getBitWidth())
117  X = X.extend(Y.getBitWidth());
118  else if (Y.getBitWidth() < X.getBitWidth())
119  Y = Y.extend(X.getBitWidth());
120 
121  // If there is a signedness mismatch, correct it.
122  if (X.isSigned() != Y.isSigned()) {
123  // If the signed value is negative, then the values cannot be the same.
124  if ((Y.isSigned() && Y.isNegative()) || (X.isSigned() && X.isNegative()))
125  return false;
126 
127  Y.setIsSigned(true);
128  X.setIsSigned(true);
129  }
130 
131  return X == Y;
132 }
133 
136  TemplateParameterList *TemplateParams,
137  const TemplateArgument &Param,
138  TemplateArgument Arg,
139  TemplateDeductionInfo &Info,
140  SmallVectorImpl<DeducedTemplateArgument> &Deduced);
141 
144  TemplateParameterList *TemplateParams,
145  QualType Param,
146  QualType Arg,
147  TemplateDeductionInfo &Info,
148  SmallVectorImpl<DeducedTemplateArgument> &
149  Deduced,
150  unsigned TDF,
151  bool PartialOrdering = false,
152  bool DeducedFromArrayBound = false);
153 
156  ArrayRef<TemplateArgument> Params,
157  ArrayRef<TemplateArgument> Args,
158  TemplateDeductionInfo &Info,
159  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
160  bool NumberOfArgumentsMustMatch);
161 
162 static void MarkUsedTemplateParameters(ASTContext &Ctx,
163  const TemplateArgument &TemplateArg,
164  bool OnlyDeduced, unsigned Depth,
165  llvm::SmallBitVector &Used);
166 
168  bool OnlyDeduced, unsigned Level,
169  llvm::SmallBitVector &Deduced);
170 
171 /// If the given expression is of a form that permits the deduction
172 /// of a non-type template parameter, return the declaration of that
173 /// non-type template parameter.
176  // If we are within an alias template, the expression may have undergone
177  // any number of parameter substitutions already.
178  while (true) {
179  if (ImplicitCastExpr *IC = dyn_cast<ImplicitCastExpr>(E))
180  E = IC->getSubExpr();
181  else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(E))
182  E = CE->getSubExpr();
183  else if (SubstNonTypeTemplateParmExpr *Subst =
184  dyn_cast<SubstNonTypeTemplateParmExpr>(E))
185  E = Subst->getReplacement();
186  else
187  break;
188  }
189 
190  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
191  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()))
192  if (NTTP->getDepth() == Info.getDeducedDepth())
193  return NTTP;
194 
195  return nullptr;
196 }
197 
198 /// Determine whether two declaration pointers refer to the same
199 /// declaration.
200 static bool isSameDeclaration(Decl *X, Decl *Y) {
201  if (NamedDecl *NX = dyn_cast<NamedDecl>(X))
202  X = NX->getUnderlyingDecl();
203  if (NamedDecl *NY = dyn_cast<NamedDecl>(Y))
204  Y = NY->getUnderlyingDecl();
205 
206  return X->getCanonicalDecl() == Y->getCanonicalDecl();
207 }
208 
209 /// Verify that the given, deduced template arguments are compatible.
210 ///
211 /// \returns The deduced template argument, or a NULL template argument if
212 /// the deduced template arguments were incompatible.
215  const DeducedTemplateArgument &X,
216  const DeducedTemplateArgument &Y) {
217  // We have no deduction for one or both of the arguments; they're compatible.
218  if (X.isNull())
219  return Y;
220  if (Y.isNull())
221  return X;
222 
223  // If we have two non-type template argument values deduced for the same
224  // parameter, they must both match the type of the parameter, and thus must
225  // match each other's type. As we're only keeping one of them, we must check
226  // for that now. The exception is that if either was deduced from an array
227  // bound, the type is permitted to differ.
230  if (!XType.isNull()) {
232  if (YType.isNull() || !Context.hasSameType(XType, YType))
233  return DeducedTemplateArgument();
234  }
235  }
236 
237  switch (X.getKind()) {
239  llvm_unreachable("Non-deduced template arguments handled above");
240 
242  // If two template type arguments have the same type, they're compatible.
243  if (Y.getKind() == TemplateArgument::Type &&
244  Context.hasSameType(X.getAsType(), Y.getAsType()))
245  return X;
246 
247  // If one of the two arguments was deduced from an array bound, the other
248  // supersedes it.
250  return X.wasDeducedFromArrayBound() ? Y : X;
251 
252  // The arguments are not compatible.
253  return DeducedTemplateArgument();
254 
256  // If we deduced a constant in one case and either a dependent expression or
257  // declaration in another case, keep the integral constant.
258  // If both are integral constants with the same value, keep that value.
263  return X.wasDeducedFromArrayBound() ? Y : X;
264 
265  // All other combinations are incompatible.
266  return DeducedTemplateArgument();
267 
269  if (Y.getKind() == TemplateArgument::Template &&
271  return X;
272 
273  // All other combinations are incompatible.
274  return DeducedTemplateArgument();
275 
280  return X;
281 
282  // All other combinations are incompatible.
283  return DeducedTemplateArgument();
284 
287  return checkDeducedTemplateArguments(Context, Y, X);
288 
289  // Compare the expressions for equality
290  llvm::FoldingSetNodeID ID1, ID2;
291  X.getAsExpr()->Profile(ID1, Context, true);
292  Y.getAsExpr()->Profile(ID2, Context, true);
293  if (ID1 == ID2)
294  return X.wasDeducedFromArrayBound() ? Y : X;
295 
296  // Differing dependent expressions are incompatible.
297  return DeducedTemplateArgument();
298  }
299 
301  assert(!X.wasDeducedFromArrayBound());
302 
303  // If we deduced a declaration and a dependent expression, keep the
304  // declaration.
306  return X;
307 
308  // If we deduced a declaration and an integral constant, keep the
309  // integral constant and whichever type did not come from an array
310  // bound.
311  if (Y.getKind() == TemplateArgument::Integral) {
312  if (Y.wasDeducedFromArrayBound())
313  return TemplateArgument(Context, Y.getAsIntegral(),
314  X.getParamTypeForDecl());
315  return Y;
316  }
317 
318  // If we deduced two declarations, make sure that they refer to the
319  // same declaration.
322  return X;
323 
324  // All other combinations are incompatible.
325  return DeducedTemplateArgument();
326 
328  // If we deduced a null pointer and a dependent expression, keep the
329  // null pointer.
331  return X;
332 
333  // If we deduced a null pointer and an integral constant, keep the
334  // integral constant.
336  return Y;
337 
338  // If we deduced two null pointers, they are the same.
340  return X;
341 
342  // All other combinations are incompatible.
343  return DeducedTemplateArgument();
344 
345  case TemplateArgument::Pack: {
346  if (Y.getKind() != TemplateArgument::Pack ||
347  X.pack_size() != Y.pack_size())
348  return DeducedTemplateArgument();
349 
352  XAEnd = X.pack_end(),
353  YA = Y.pack_begin();
354  XA != XAEnd; ++XA, ++YA) {
358  if (Merged.isNull())
359  return DeducedTemplateArgument();
360  NewPack.push_back(Merged);
361  }
362 
364  TemplateArgument::CreatePackCopy(Context, NewPack),
366  }
367  }
368 
369  llvm_unreachable("Invalid TemplateArgument Kind!");
370 }
371 
372 /// Deduce the value of the given non-type template parameter
373 /// as the given deduced template argument. All non-type template parameter
374 /// deduction is funneled through here.
376  Sema &S, TemplateParameterList *TemplateParams,
377  NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced,
378  QualType ValueType, TemplateDeductionInfo &Info,
379  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
380  assert(NTTP->getDepth() == Info.getDeducedDepth() &&
381  "deducing non-type template argument with wrong depth");
382 
384  S.Context, Deduced[NTTP->getIndex()], NewDeduced);
385  if (Result.isNull()) {
386  Info.Param = NTTP;
387  Info.FirstArg = Deduced[NTTP->getIndex()];
388  Info.SecondArg = NewDeduced;
389  return Sema::TDK_Inconsistent;
390  }
391 
392  Deduced[NTTP->getIndex()] = Result;
393  if (!S.getLangOpts().CPlusPlus17)
394  return Sema::TDK_Success;
395 
396  if (NTTP->isExpandedParameterPack())
397  // FIXME: We may still need to deduce parts of the type here! But we
398  // don't have any way to find which slice of the type to use, and the
399  // type stored on the NTTP itself is nonsense. Perhaps the type of an
400  // expanded NTTP should be a pack expansion type?
401  return Sema::TDK_Success;
402 
403  // Get the type of the parameter for deduction. If it's a (dependent) array
404  // or function type, we will not have decayed it yet, so do that now.
405  QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType());
406  if (auto *Expansion = dyn_cast<PackExpansionType>(ParamType))
407  ParamType = Expansion->getPattern();
408 
409  // FIXME: It's not clear how deduction of a parameter of reference
410  // type from an argument (of non-reference type) should be performed.
411  // For now, we just remove reference types from both sides and let
412  // the final check for matching types sort out the mess.
414  S, TemplateParams, ParamType.getNonReferenceType(),
415  ValueType.getNonReferenceType(), Info, Deduced, TDF_SkipNonDependent,
416  /*PartialOrdering=*/false,
417  /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound());
418 }
419 
420 /// Deduce the value of the given non-type template parameter
421 /// from the given integral constant.
423  Sema &S, TemplateParameterList *TemplateParams,
425  QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
426  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
428  S, TemplateParams, NTTP,
429  DeducedTemplateArgument(S.Context, Value, ValueType,
430  DeducedFromArrayBound),
431  ValueType, Info, Deduced);
432 }
433 
434 /// Deduce the value of the given non-type template parameter
435 /// from the given null pointer template argument type.
437  Sema &S, TemplateParameterList *TemplateParams,
438  NonTypeTemplateParmDecl *NTTP, QualType NullPtrType,
439  TemplateDeductionInfo &Info,
440  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
441  Expr *Value =
443  S.Context.NullPtrTy, NTTP->getLocation()),
444  NullPtrType, CK_NullToPointer)
445  .get();
446  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
448  Value->getType(), Info, Deduced);
449 }
450 
451 /// Deduce the value of the given non-type template parameter
452 /// from the given type- or value-dependent expression.
453 ///
454 /// \returns true if deduction succeeded, false otherwise.
456  Sema &S, TemplateParameterList *TemplateParams,
458  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
459  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
461  Value->getType(), Info, Deduced);
462 }
463 
464 /// Deduce the value of the given non-type template parameter
465 /// from the given declaration.
466 ///
467 /// \returns true if deduction succeeded, false otherwise.
469  Sema &S, TemplateParameterList *TemplateParams,
471  TemplateDeductionInfo &Info,
472  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
473  D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
474  TemplateArgument New(D, T);
476  S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced);
477 }
478 
481  TemplateParameterList *TemplateParams,
482  TemplateName Param,
483  TemplateName Arg,
484  TemplateDeductionInfo &Info,
485  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
486  TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
487  if (!ParamDecl) {
488  // The parameter type is dependent and is not a template template parameter,
489  // so there is nothing that we can deduce.
490  return Sema::TDK_Success;
491  }
492 
493  if (TemplateTemplateParmDecl *TempParam
494  = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) {
495  // If we're not deducing at this depth, there's nothing to deduce.
496  if (TempParam->getDepth() != Info.getDeducedDepth())
497  return Sema::TDK_Success;
498 
501  Deduced[TempParam->getIndex()],
502  NewDeduced);
503  if (Result.isNull()) {
504  Info.Param = TempParam;
505  Info.FirstArg = Deduced[TempParam->getIndex()];
506  Info.SecondArg = NewDeduced;
507  return Sema::TDK_Inconsistent;
508  }
509 
510  Deduced[TempParam->getIndex()] = Result;
511  return Sema::TDK_Success;
512  }
513 
514  // Verify that the two template names are equivalent.
515  if (S.Context.hasSameTemplateName(Param, Arg))
516  return Sema::TDK_Success;
517 
518  // Mismatch of non-dependent template parameter to argument.
519  Info.FirstArg = TemplateArgument(Param);
520  Info.SecondArg = TemplateArgument(Arg);
522 }
523 
524 /// Deduce the template arguments by comparing the template parameter
525 /// type (which is a template-id) with the template argument type.
526 ///
527 /// \param S the Sema
528 ///
529 /// \param TemplateParams the template parameters that we are deducing
530 ///
531 /// \param Param the parameter type
532 ///
533 /// \param Arg the argument type
534 ///
535 /// \param Info information about the template argument deduction itself
536 ///
537 /// \param Deduced the deduced template arguments
538 ///
539 /// \returns the result of template argument deduction so far. Note that a
540 /// "success" result means that template argument deduction has not yet failed,
541 /// but it may still fail, later, for other reasons.
544  TemplateParameterList *TemplateParams,
545  const TemplateSpecializationType *Param,
546  QualType Arg,
547  TemplateDeductionInfo &Info,
548  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
549  assert(Arg.isCanonical() && "Argument type must be canonical");
550 
551  // Treat an injected-class-name as its underlying template-id.
552  if (auto *Injected = dyn_cast<InjectedClassNameType>(Arg))
553  Arg = Injected->getInjectedSpecializationType();
554 
555  // Check whether the template argument is a dependent template-id.
556  if (const TemplateSpecializationType *SpecArg
557  = dyn_cast<TemplateSpecializationType>(Arg)) {
558  // Perform template argument deduction for the template name.
560  = DeduceTemplateArguments(S, TemplateParams,
561  Param->getTemplateName(),
562  SpecArg->getTemplateName(),
563  Info, Deduced))
564  return Result;
565 
566 
567  // Perform template argument deduction on each template
568  // argument. Ignore any missing/extra arguments, since they could be
569  // filled in by default arguments.
570  return DeduceTemplateArguments(S, TemplateParams,
571  Param->template_arguments(),
572  SpecArg->template_arguments(), Info, Deduced,
573  /*NumberOfArgumentsMustMatch=*/false);
574  }
575 
576  // If the argument type is a class template specialization, we
577  // perform template argument deduction using its template
578  // arguments.
579  const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
580  if (!RecordArg) {
581  Info.FirstArg = TemplateArgument(QualType(Param, 0));
582  Info.SecondArg = TemplateArgument(Arg);
584  }
585 
587  = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
588  if (!SpecArg) {
589  Info.FirstArg = TemplateArgument(QualType(Param, 0));
590  Info.SecondArg = TemplateArgument(Arg);
592  }
593 
594  // Perform template argument deduction for the template name.
597  TemplateParams,
598  Param->getTemplateName(),
600  Info, Deduced))
601  return Result;
602 
603  // Perform template argument deduction for the template arguments.
604  return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(),
605  SpecArg->getTemplateArgs().asArray(), Info,
606  Deduced, /*NumberOfArgumentsMustMatch=*/true);
607 }
608 
609 /// Determines whether the given type is an opaque type that
610 /// might be more qualified when instantiated.
612  switch (T->getTypeClass()) {
613  case Type::TypeOfExpr:
614  case Type::TypeOf:
615  case Type::DependentName:
616  case Type::Decltype:
617  case Type::UnresolvedUsing:
618  case Type::TemplateTypeParm:
619  return true;
620 
621  case Type::ConstantArray:
622  case Type::IncompleteArray:
623  case Type::VariableArray:
624  case Type::DependentSizedArray:
626  cast<ArrayType>(T)->getElementType());
627 
628  default:
629  return false;
630  }
631 }
632 
633 /// Helper function to build a TemplateParameter when we don't
634 /// know its type statically.
636  if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
637  return TemplateParameter(TTP);
638  if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
639  return TemplateParameter(NTTP);
640 
641  return TemplateParameter(cast<TemplateTemplateParmDecl>(D));
642 }
643 
644 /// If \p Param is an expanded parameter pack, get the number of expansions.
646  if (auto *TTP = dyn_cast<TemplateTypeParmDecl>(Param))
647  if (TTP->isExpandedParameterPack())
648  return TTP->getNumExpansionParameters();
649 
650  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param))
651  if (NTTP->isExpandedParameterPack())
652  return NTTP->getNumExpansionTypes();
653 
654  if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param))
655  if (TTP->isExpandedParameterPack())
656  return TTP->getNumExpansionTemplateParameters();
657 
658  return None;
659 }
660 
661 /// A pack that we're currently deducing.
663  // The index of the pack.
664  unsigned Index;
665 
666  // The old value of the pack before we started deducing it.
668 
669  // A deferred value of this pack from an inner deduction, that couldn't be
670  // deduced because this deduction hadn't happened yet.
672 
673  // The new value of the pack.
675 
676  // The outer deduction for this pack, if any.
677  DeducedPack *Outer = nullptr;
678 
679  DeducedPack(unsigned Index) : Index(Index) {}
680 };
681 
682 namespace {
683 
684 /// A scope in which we're performing pack deduction.
685 class PackDeductionScope {
686 public:
687  /// Prepare to deduce the packs named within Pattern.
688  PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
691  : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
692  unsigned NumNamedPacks = addPacks(Pattern);
693  finishConstruction(NumNamedPacks);
694  }
695 
696  /// Prepare to directly deduce arguments of the parameter with index \p Index.
697  PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
699  TemplateDeductionInfo &Info, unsigned Index)
700  : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) {
701  addPack(Index);
702  finishConstruction(1);
703  }
704 
705 private:
706  void addPack(unsigned Index) {
707  // Save the deduced template argument for the parameter pack expanded
708  // by this pack expansion, then clear out the deduction.
709  DeducedPack Pack(Index);
710  Pack.Saved = Deduced[Index];
711  Deduced[Index] = TemplateArgument();
712 
713  // FIXME: What if we encounter multiple packs with different numbers of
714  // pre-expanded expansions? (This should already have been diagnosed
715  // during substitution.)
716  if (Optional<unsigned> ExpandedPackExpansions =
717  getExpandedPackSize(TemplateParams->getParam(Index)))
718  FixedNumExpansions = ExpandedPackExpansions;
719 
720  Packs.push_back(Pack);
721  }
722 
723  unsigned addPacks(TemplateArgument Pattern) {
724  // Compute the set of template parameter indices that correspond to
725  // parameter packs expanded by the pack expansion.
726  llvm::SmallBitVector SawIndices(TemplateParams->size());
728 
729  auto AddPack = [&](unsigned Index) {
730  if (SawIndices[Index])
731  return;
732  SawIndices[Index] = true;
733  addPack(Index);
734 
735  // Deducing a parameter pack that is a pack expansion also constrains the
736  // packs appearing in that parameter to have the same deduced arity. Also,
737  // in C++17 onwards, deducing a non-type template parameter deduces its
738  // type, so we need to collect the pending deduced values for those packs.
739  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(
740  TemplateParams->getParam(Index))) {
741  if (auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType()))
742  ExtraDeductions.push_back(Expansion->getPattern());
743  }
744  // FIXME: Also collect the unexpanded packs in any type and template
745  // parameter packs that are pack expansions.
746  };
747 
748  auto Collect = [&](TemplateArgument Pattern) {
750  S.collectUnexpandedParameterPacks(Pattern, Unexpanded);
751  for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) {
752  unsigned Depth, Index;
753  std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]);
754  if (Depth == Info.getDeducedDepth())
755  AddPack(Index);
756  }
757  };
758 
759  // Look for unexpanded packs in the pattern.
760  Collect(Pattern);
761  assert(!Packs.empty() && "Pack expansion without unexpanded packs?");
762 
763  unsigned NumNamedPacks = Packs.size();
764 
765  // Also look for unexpanded packs that are indirectly deduced by deducing
766  // the sizes of the packs in this pattern.
767  while (!ExtraDeductions.empty())
768  Collect(ExtraDeductions.pop_back_val());
769 
770  return NumNamedPacks;
771  }
772 
773  void finishConstruction(unsigned NumNamedPacks) {
774  // Dig out the partially-substituted pack, if there is one.
775  const TemplateArgument *PartialPackArgs = nullptr;
776  unsigned NumPartialPackArgs = 0;
777  std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u);
778  if (auto *Scope = S.CurrentInstantiationScope)
779  if (auto *Partial = Scope->getPartiallySubstitutedPack(
780  &PartialPackArgs, &NumPartialPackArgs))
781  PartialPackDepthIndex = getDepthAndIndex(Partial);
782 
783  // This pack expansion will have been partially or fully expanded if
784  // it only names explicitly-specified parameter packs (including the
785  // partially-substituted one, if any).
786  bool IsExpanded = true;
787  for (unsigned I = 0; I != NumNamedPacks; ++I) {
788  if (Packs[I].Index >= Info.getNumExplicitArgs()) {
789  IsExpanded = false;
790  IsPartiallyExpanded = false;
791  break;
792  }
793  if (PartialPackDepthIndex ==
794  std::make_pair(Info.getDeducedDepth(), Packs[I].Index)) {
795  IsPartiallyExpanded = true;
796  }
797  }
798 
799  // Skip over the pack elements that were expanded into separate arguments.
800  // If we partially expanded, this is the number of partial arguments.
801  if (IsPartiallyExpanded)
802  PackElements += NumPartialPackArgs;
803  else if (IsExpanded)
804  PackElements += *FixedNumExpansions;
805 
806  for (auto &Pack : Packs) {
807  if (Info.PendingDeducedPacks.size() > Pack.Index)
808  Pack.Outer = Info.PendingDeducedPacks[Pack.Index];
809  else
810  Info.PendingDeducedPacks.resize(Pack.Index + 1);
811  Info.PendingDeducedPacks[Pack.Index] = &Pack;
812 
813  if (PartialPackDepthIndex ==
814  std::make_pair(Info.getDeducedDepth(), Pack.Index)) {
815  Pack.New.append(PartialPackArgs, PartialPackArgs + NumPartialPackArgs);
816  // We pre-populate the deduced value of the partially-substituted
817  // pack with the specified value. This is not entirely correct: the
818  // value is supposed to have been substituted, not deduced, but the
819  // cases where this is observable require an exact type match anyway.
820  //
821  // FIXME: If we could represent a "depth i, index j, pack elem k"
822  // parameter, we could substitute the partially-substituted pack
823  // everywhere and avoid this.
824  if (!IsPartiallyExpanded)
825  Deduced[Pack.Index] = Pack.New[PackElements];
826  }
827  }
828  }
829 
830 public:
831  ~PackDeductionScope() {
832  for (auto &Pack : Packs)
833  Info.PendingDeducedPacks[Pack.Index] = Pack.Outer;
834  }
835 
836  /// Determine whether this pack has already been partially expanded into a
837  /// sequence of (prior) function parameters / template arguments.
838  bool isPartiallyExpanded() { return IsPartiallyExpanded; }
839 
840  /// Determine whether this pack expansion scope has a known, fixed arity.
841  /// This happens if it involves a pack from an outer template that has
842  /// (notionally) already been expanded.
843  bool hasFixedArity() { return FixedNumExpansions.hasValue(); }
844 
845  /// Determine whether the next element of the argument is still part of this
846  /// pack. This is the case unless the pack is already expanded to a fixed
847  /// length.
848  bool hasNextElement() {
849  return !FixedNumExpansions || *FixedNumExpansions > PackElements;
850  }
851 
852  /// Move to deducing the next element in each pack that is being deduced.
853  void nextPackElement() {
854  // Capture the deduced template arguments for each parameter pack expanded
855  // by this pack expansion, add them to the list of arguments we've deduced
856  // for that pack, then clear out the deduced argument.
857  for (auto &Pack : Packs) {
858  DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
859  if (!Pack.New.empty() || !DeducedArg.isNull()) {
860  while (Pack.New.size() < PackElements)
861  Pack.New.push_back(DeducedTemplateArgument());
862  if (Pack.New.size() == PackElements)
863  Pack.New.push_back(DeducedArg);
864  else
865  Pack.New[PackElements] = DeducedArg;
866  DeducedArg = Pack.New.size() > PackElements + 1
867  ? Pack.New[PackElements + 1]
869  }
870  }
871  ++PackElements;
872  }
873 
874  /// Finish template argument deduction for a set of argument packs,
875  /// producing the argument packs and checking for consistency with prior
876  /// deductions.
878  // Build argument packs for each of the parameter packs expanded by this
879  // pack expansion.
880  for (auto &Pack : Packs) {
881  // Put back the old value for this pack.
882  Deduced[Pack.Index] = Pack.Saved;
883 
884  // Always make sure the size of this pack is correct, even if we didn't
885  // deduce any values for it.
886  //
887  // FIXME: This isn't required by the normative wording, but substitution
888  // and post-substitution checking will always fail if the arity of any
889  // pack is not equal to the number of elements we processed. (Either that
890  // or something else has gone *very* wrong.) We're permitted to skip any
891  // hard errors from those follow-on steps by the intent (but not the
892  // wording) of C++ [temp.inst]p8:
893  //
894  // If the function selected by overload resolution can be determined
895  // without instantiating a class template definition, it is unspecified
896  // whether that instantiation actually takes place
897  Pack.New.resize(PackElements);
898 
899  // Build or find a new value for this pack.
900  DeducedTemplateArgument NewPack;
901  if (Pack.New.empty()) {
902  // If we deduced an empty argument pack, create it now.
904  } else {
905  TemplateArgument *ArgumentPack =
906  new (S.Context) TemplateArgument[Pack.New.size()];
907  std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack);
908  NewPack = DeducedTemplateArgument(
909  TemplateArgument(llvm::makeArrayRef(ArgumentPack, Pack.New.size())),
910  // FIXME: This is wrong, it's possible that some pack elements are
911  // deduced from an array bound and others are not:
912  // template<typename ...T, T ...V> void g(const T (&...p)[V]);
913  // g({1, 2, 3}, {{}, {}});
914  // ... should deduce T = {int, size_t (from array bound)}.
915  Pack.New[0].wasDeducedFromArrayBound());
916  }
917 
918  // Pick where we're going to put the merged pack.
920  if (Pack.Outer) {
921  if (Pack.Outer->DeferredDeduction.isNull()) {
922  // Defer checking this pack until we have a complete pack to compare
923  // it against.
924  Pack.Outer->DeferredDeduction = NewPack;
925  continue;
926  }
927  Loc = &Pack.Outer->DeferredDeduction;
928  } else {
929  Loc = &Deduced[Pack.Index];
930  }
931 
932  // Check the new pack matches any previous value.
933  DeducedTemplateArgument OldPack = *Loc;
934  DeducedTemplateArgument Result =
935  checkDeducedTemplateArguments(S.Context, OldPack, NewPack);
936 
937  // If we deferred a deduction of this pack, check that one now too.
938  if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) {
939  OldPack = Result;
940  NewPack = Pack.DeferredDeduction;
941  Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack);
942  }
943 
944  NamedDecl *Param = TemplateParams->getParam(Pack.Index);
945  if (Result.isNull()) {
946  Info.Param = makeTemplateParameter(Param);
947  Info.FirstArg = OldPack;
948  Info.SecondArg = NewPack;
949  return Sema::TDK_Inconsistent;
950  }
951 
952  // If we have a pre-expanded pack and we didn't deduce enough elements
953  // for it, fail deduction.
954  if (Optional<unsigned> Expansions = getExpandedPackSize(Param)) {
955  if (*Expansions != PackElements) {
956  Info.Param = makeTemplateParameter(Param);
957  Info.FirstArg = Result;
959  }
960  }
961 
962  *Loc = Result;
963  }
964 
965  return Sema::TDK_Success;
966  }
967 
968 private:
969  Sema &S;
970  TemplateParameterList *TemplateParams;
972  TemplateDeductionInfo &Info;
973  unsigned PackElements = 0;
974  bool IsPartiallyExpanded = false;
975  /// The number of expansions, if we have a fully-expanded pack in this scope.
976  Optional<unsigned> FixedNumExpansions;
977 
979 };
980 
981 } // namespace
982 
983 /// Deduce the template arguments by comparing the list of parameter
984 /// types to the list of argument types, as in the parameter-type-lists of
985 /// function types (C++ [temp.deduct.type]p10).
986 ///
987 /// \param S The semantic analysis object within which we are deducing
988 ///
989 /// \param TemplateParams The template parameters that we are deducing
990 ///
991 /// \param Params The list of parameter types
992 ///
993 /// \param NumParams The number of types in \c Params
994 ///
995 /// \param Args The list of argument types
996 ///
997 /// \param NumArgs The number of types in \c Args
998 ///
999 /// \param Info information about the template argument deduction itself
1000 ///
1001 /// \param Deduced the deduced template arguments
1002 ///
1003 /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
1004 /// how template argument deduction is performed.
1005 ///
1006 /// \param PartialOrdering If true, we are performing template argument
1007 /// deduction for during partial ordering for a call
1008 /// (C++0x [temp.deduct.partial]).
1009 ///
1010 /// \returns the result of template argument deduction so far. Note that a
1011 /// "success" result means that template argument deduction has not yet failed,
1012 /// but it may still fail, later, for other reasons.
1015  TemplateParameterList *TemplateParams,
1016  const QualType *Params, unsigned NumParams,
1017  const QualType *Args, unsigned NumArgs,
1018  TemplateDeductionInfo &Info,
1019  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
1020  unsigned TDF,
1021  bool PartialOrdering = false) {
1022  // C++0x [temp.deduct.type]p10:
1023  // Similarly, if P has a form that contains (T), then each parameter type
1024  // Pi of the respective parameter-type- list of P is compared with the
1025  // corresponding parameter type Ai of the corresponding parameter-type-list
1026  // of A. [...]
1027  unsigned ArgIdx = 0, ParamIdx = 0;
1028  for (; ParamIdx != NumParams; ++ParamIdx) {
1029  // Check argument types.
1030  const PackExpansionType *Expansion
1031  = dyn_cast<PackExpansionType>(Params[ParamIdx]);
1032  if (!Expansion) {
1033  // Simple case: compare the parameter and argument types at this point.
1034 
1035  // Make sure we have an argument.
1036  if (ArgIdx >= NumArgs)
1038 
1039  if (isa<PackExpansionType>(Args[ArgIdx])) {
1040  // C++0x [temp.deduct.type]p22:
1041  // If the original function parameter associated with A is a function
1042  // parameter pack and the function parameter associated with P is not
1043  // a function parameter pack, then template argument deduction fails.
1045  }
1046 
1048  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1049  Params[ParamIdx], Args[ArgIdx],
1050  Info, Deduced, TDF,
1051  PartialOrdering))
1052  return Result;
1053 
1054  ++ArgIdx;
1055  continue;
1056  }
1057 
1058  // C++0x [temp.deduct.type]p10:
1059  // If the parameter-declaration corresponding to Pi is a function
1060  // parameter pack, then the type of its declarator- id is compared with
1061  // each remaining parameter type in the parameter-type-list of A. Each
1062  // comparison deduces template arguments for subsequent positions in the
1063  // template parameter packs expanded by the function parameter pack.
1064 
1065  QualType Pattern = Expansion->getPattern();
1066  PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
1067 
1068  // A pack scope with fixed arity is not really a pack any more, so is not
1069  // a non-deduced context.
1070  if (ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
1071  for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
1072  // Deduce template arguments from the pattern.
1074  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
1075  Args[ArgIdx], Info, Deduced,
1076  TDF, PartialOrdering))
1077  return Result;
1078 
1079  PackScope.nextPackElement();
1080  }
1081  } else {
1082  // C++0x [temp.deduct.type]p5:
1083  // The non-deduced contexts are:
1084  // - A function parameter pack that does not occur at the end of the
1085  // parameter-declaration-clause.
1086  //
1087  // FIXME: There is no wording to say what we should do in this case. We
1088  // choose to resolve this by applying the same rule that is applied for a
1089  // function call: that is, deduce all contained packs to their
1090  // explicitly-specified values (or to <> if there is no such value).
1091  //
1092  // This is seemingly-arbitrarily different from the case of a template-id
1093  // with a non-trailing pack-expansion in its arguments, which renders the
1094  // entire template-argument-list a non-deduced context.
1095 
1096  // If the parameter type contains an explicitly-specified pack that we
1097  // could not expand, skip the number of parameters notionally created
1098  // by the expansion.
1099  Optional<unsigned> NumExpansions = Expansion->getNumExpansions();
1100  if (NumExpansions && !PackScope.isPartiallyExpanded()) {
1101  for (unsigned I = 0; I != *NumExpansions && ArgIdx < NumArgs;
1102  ++I, ++ArgIdx)
1103  PackScope.nextPackElement();
1104  }
1105  }
1106 
1107  // Build argument packs for each of the parameter packs expanded by this
1108  // pack expansion.
1109  if (auto Result = PackScope.finish())
1110  return Result;
1111  }
1112 
1113  // Make sure we don't have any extra arguments.
1114  if (ArgIdx < NumArgs)
1116 
1117  return Sema::TDK_Success;
1118 }
1119 
1120 /// Determine whether the parameter has qualifiers that the argument
1121 /// lacks. Put another way, determine whether there is no way to add
1122 /// a deduced set of qualifiers to the ParamType that would result in
1123 /// its qualifiers matching those of the ArgType.
1125  QualType ArgType) {
1126  Qualifiers ParamQs = ParamType.getQualifiers();
1127  Qualifiers ArgQs = ArgType.getQualifiers();
1128 
1129  if (ParamQs == ArgQs)
1130  return false;
1131 
1132  // Mismatched (but not missing) Objective-C GC attributes.
1133  if (ParamQs.getObjCGCAttr() != ArgQs.getObjCGCAttr() &&
1134  ParamQs.hasObjCGCAttr())
1135  return true;
1136 
1137  // Mismatched (but not missing) address spaces.
1138  if (ParamQs.getAddressSpace() != ArgQs.getAddressSpace() &&
1139  ParamQs.hasAddressSpace())
1140  return true;
1141 
1142  // Mismatched (but not missing) Objective-C lifetime qualifiers.
1143  if (ParamQs.getObjCLifetime() != ArgQs.getObjCLifetime() &&
1144  ParamQs.hasObjCLifetime())
1145  return true;
1146 
1147  // CVR qualifiers inconsistent or a superset.
1148  return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0;
1149 }
1150 
1151 /// Compare types for equality with respect to possibly compatible
1152 /// function types (noreturn adjustment, implicit calling conventions). If any
1153 /// of parameter and argument is not a function, just perform type comparison.
1154 ///
1155 /// \param Param the template parameter type.
1156 ///
1157 /// \param Arg the argument type.
1159  CanQualType Arg) {
1160  const FunctionType *ParamFunction = Param->getAs<FunctionType>(),
1161  *ArgFunction = Arg->getAs<FunctionType>();
1162 
1163  // Just compare if not functions.
1164  if (!ParamFunction || !ArgFunction)
1165  return Param == Arg;
1166 
1167  // Noreturn and noexcept adjustment.
1168  QualType AdjustedParam;
1169  if (IsFunctionConversion(Param, Arg, AdjustedParam))
1170  return Arg == Context.getCanonicalType(AdjustedParam);
1171 
1172  // FIXME: Compatible calling conventions.
1173 
1174  return Param == Arg;
1175 }
1176 
1177 /// Get the index of the first template parameter that was originally from the
1178 /// innermost template-parameter-list. This is 0 except when we concatenate
1179 /// the template parameter lists of a class template and a constructor template
1180 /// when forming an implicit deduction guide.
1182  auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl());
1183  if (!Guide || !Guide->isImplicit())
1184  return 0;
1185  return Guide->getDeducedTemplate()->getTemplateParameters()->size();
1186 }
1187 
1188 /// Determine whether a type denotes a forwarding reference.
1189 static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex) {
1190  // C++1z [temp.deduct.call]p3:
1191  // A forwarding reference is an rvalue reference to a cv-unqualified
1192  // template parameter that does not represent a template parameter of a
1193  // class template.
1194  if (auto *ParamRef = Param->getAs<RValueReferenceType>()) {
1195  if (ParamRef->getPointeeType().getQualifiers())
1196  return false;
1197  auto *TypeParm = ParamRef->getPointeeType()->getAs<TemplateTypeParmType>();
1198  return TypeParm && TypeParm->getIndex() >= FirstInnerIndex;
1199  }
1200  return false;
1201 }
1202 
1203 /// Deduce the template arguments by comparing the parameter type and
1204 /// the argument type (C++ [temp.deduct.type]).
1205 ///
1206 /// \param S the semantic analysis object within which we are deducing
1207 ///
1208 /// \param TemplateParams the template parameters that we are deducing
1209 ///
1210 /// \param ParamIn the parameter type
1211 ///
1212 /// \param ArgIn the argument type
1213 ///
1214 /// \param Info information about the template argument deduction itself
1215 ///
1216 /// \param Deduced the deduced template arguments
1217 ///
1218 /// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
1219 /// how template argument deduction is performed.
1220 ///
1221 /// \param PartialOrdering Whether we're performing template argument deduction
1222 /// in the context of partial ordering (C++0x [temp.deduct.partial]).
1223 ///
1224 /// \returns the result of template argument deduction so far. Note that a
1225 /// "success" result means that template argument deduction has not yet failed,
1226 /// but it may still fail, later, for other reasons.
1229  TemplateParameterList *TemplateParams,
1230  QualType ParamIn, QualType ArgIn,
1231  TemplateDeductionInfo &Info,
1232  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
1233  unsigned TDF,
1234  bool PartialOrdering,
1235  bool DeducedFromArrayBound) {
1236  // We only want to look at the canonical types, since typedefs and
1237  // sugar are not part of template argument deduction.
1238  QualType Param = S.Context.getCanonicalType(ParamIn);
1239  QualType Arg = S.Context.getCanonicalType(ArgIn);
1240 
1241  // If the argument type is a pack expansion, look at its pattern.
1242  // This isn't explicitly called out
1243  if (const PackExpansionType *ArgExpansion
1244  = dyn_cast<PackExpansionType>(Arg))
1245  Arg = ArgExpansion->getPattern();
1246 
1247  if (PartialOrdering) {
1248  // C++11 [temp.deduct.partial]p5:
1249  // Before the partial ordering is done, certain transformations are
1250  // performed on the types used for partial ordering:
1251  // - If P is a reference type, P is replaced by the type referred to.
1252  const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
1253  if (ParamRef)
1254  Param = ParamRef->getPointeeType();
1255 
1256  // - If A is a reference type, A is replaced by the type referred to.
1257  const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
1258  if (ArgRef)
1259  Arg = ArgRef->getPointeeType();
1260 
1261  if (ParamRef && ArgRef && S.Context.hasSameUnqualifiedType(Param, Arg)) {
1262  // C++11 [temp.deduct.partial]p9:
1263  // If, for a given type, deduction succeeds in both directions (i.e.,
1264  // the types are identical after the transformations above) and both
1265  // P and A were reference types [...]:
1266  // - if [one type] was an lvalue reference and [the other type] was
1267  // not, [the other type] is not considered to be at least as
1268  // specialized as [the first type]
1269  // - if [one type] is more cv-qualified than [the other type],
1270  // [the other type] is not considered to be at least as specialized
1271  // as [the first type]
1272  // Objective-C ARC adds:
1273  // - [one type] has non-trivial lifetime, [the other type] has
1274  // __unsafe_unretained lifetime, and the types are otherwise
1275  // identical
1276  //
1277  // A is "considered to be at least as specialized" as P iff deduction
1278  // succeeds, so we model this as a deduction failure. Note that
1279  // [the first type] is P and [the other type] is A here; the standard
1280  // gets this backwards.
1281  Qualifiers ParamQuals = Param.getQualifiers();
1282  Qualifiers ArgQuals = Arg.getQualifiers();
1283  if ((ParamRef->isLValueReferenceType() &&
1284  !ArgRef->isLValueReferenceType()) ||
1285  ParamQuals.isStrictSupersetOf(ArgQuals) ||
1286  (ParamQuals.hasNonTrivialObjCLifetime() &&
1288  ParamQuals.withoutObjCLifetime() ==
1289  ArgQuals.withoutObjCLifetime())) {
1290  Info.FirstArg = TemplateArgument(ParamIn);
1291  Info.SecondArg = TemplateArgument(ArgIn);
1293  }
1294  }
1295 
1296  // C++11 [temp.deduct.partial]p7:
1297  // Remove any top-level cv-qualifiers:
1298  // - If P is a cv-qualified type, P is replaced by the cv-unqualified
1299  // version of P.
1300  Param = Param.getUnqualifiedType();
1301  // - If A is a cv-qualified type, A is replaced by the cv-unqualified
1302  // version of A.
1303  Arg = Arg.getUnqualifiedType();
1304  } else {
1305  // C++0x [temp.deduct.call]p4 bullet 1:
1306  // - If the original P is a reference type, the deduced A (i.e., the type
1307  // referred to by the reference) can be more cv-qualified than the
1308  // transformed A.
1309  if (TDF & TDF_ParamWithReferenceType) {
1310  Qualifiers Quals;
1311  QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
1312  Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
1313  Arg.getCVRQualifiers());
1314  Param = S.Context.getQualifiedType(UnqualParam, Quals);
1315  }
1316 
1317  if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
1318  // C++0x [temp.deduct.type]p10:
1319  // If P and A are function types that originated from deduction when
1320  // taking the address of a function template (14.8.2.2) or when deducing
1321  // template arguments from a function declaration (14.8.2.6) and Pi and
1322  // Ai are parameters of the top-level parameter-type-list of P and A,
1323  // respectively, Pi is adjusted if it is a forwarding reference and Ai
1324  // is an lvalue reference, in
1325  // which case the type of Pi is changed to be the template parameter
1326  // type (i.e., T&& is changed to simply T). [ Note: As a result, when
1327  // Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
1328  // deduced as X&. - end note ]
1329  TDF &= ~TDF_TopLevelParameterTypeList;
1330  if (isForwardingReference(Param, 0) && Arg->isLValueReferenceType())
1331  Param = Param->getPointeeType();
1332  }
1333  }
1334 
1335  // C++ [temp.deduct.type]p9:
1336  // A template type argument T, a template template argument TT or a
1337  // template non-type argument i can be deduced if P and A have one of
1338  // the following forms:
1339  //
1340  // T
1341  // cv-list T
1342  if (const TemplateTypeParmType *TemplateTypeParm
1343  = Param->getAs<TemplateTypeParmType>()) {
1344  // Just skip any attempts to deduce from a placeholder type or a parameter
1345  // at a different depth.
1346  if (Arg->isPlaceholderType() ||
1347  Info.getDeducedDepth() != TemplateTypeParm->getDepth())
1348  return Sema::TDK_Success;
1349 
1350  unsigned Index = TemplateTypeParm->getIndex();
1351  bool RecanonicalizeArg = false;
1352 
1353  // If the argument type is an array type, move the qualifiers up to the
1354  // top level, so they can be matched with the qualifiers on the parameter.
1355  if (isa<ArrayType>(Arg)) {
1356  Qualifiers Quals;
1357  Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
1358  if (Quals) {
1359  Arg = S.Context.getQualifiedType(Arg, Quals);
1360  RecanonicalizeArg = true;
1361  }
1362  }
1363 
1364  // The argument type can not be less qualified than the parameter
1365  // type.
1366  if (!(TDF & TDF_IgnoreQualifiers) &&
1368  Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1369  Info.FirstArg = TemplateArgument(Param);
1370  Info.SecondArg = TemplateArgument(Arg);
1371  return Sema::TDK_Underqualified;
1372  }
1373 
1374  // Do not match a function type with a cv-qualified type.
1375  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584
1376  if (Arg->isFunctionType() && Param.hasQualifiers()) {
1378  }
1379 
1380  assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() &&
1381  "saw template type parameter with wrong depth");
1382  assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
1383  QualType DeducedType = Arg;
1384 
1385  // Remove any qualifiers on the parameter from the deduced type.
1386  // We checked the qualifiers for consistency above.
1387  Qualifiers DeducedQs = DeducedType.getQualifiers();
1388  Qualifiers ParamQs = Param.getQualifiers();
1389  DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
1390  if (ParamQs.hasObjCGCAttr())
1391  DeducedQs.removeObjCGCAttr();
1392  if (ParamQs.hasAddressSpace())
1393  DeducedQs.removeAddressSpace();
1394  if (ParamQs.hasObjCLifetime())
1395  DeducedQs.removeObjCLifetime();
1396 
1397  // Objective-C ARC:
1398  // If template deduction would produce a lifetime qualifier on a type
1399  // that is not a lifetime type, template argument deduction fails.
1400  if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
1401  !DeducedType->isDependentType()) {
1402  Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1403  Info.FirstArg = TemplateArgument(Param);
1404  Info.SecondArg = TemplateArgument(Arg);
1405  return Sema::TDK_Underqualified;
1406  }
1407 
1408  // Objective-C ARC:
1409  // If template deduction would produce an argument type with lifetime type
1410  // but no lifetime qualifier, the __strong lifetime qualifier is inferred.
1411  if (S.getLangOpts().ObjCAutoRefCount &&
1412  DeducedType->isObjCLifetimeType() &&
1413  !DeducedQs.hasObjCLifetime())
1415 
1416  DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
1417  DeducedQs);
1418 
1419  if (RecanonicalizeArg)
1420  DeducedType = S.Context.getCanonicalType(DeducedType);
1421 
1422  DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound);
1424  Deduced[Index],
1425  NewDeduced);
1426  if (Result.isNull()) {
1427  Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
1428  Info.FirstArg = Deduced[Index];
1429  Info.SecondArg = NewDeduced;
1430  return Sema::TDK_Inconsistent;
1431  }
1432 
1433  Deduced[Index] = Result;
1434  return Sema::TDK_Success;
1435  }
1436 
1437  // Set up the template argument deduction information for a failure.
1438  Info.FirstArg = TemplateArgument(ParamIn);
1439  Info.SecondArg = TemplateArgument(ArgIn);
1440 
1441  // If the parameter is an already-substituted template parameter
1442  // pack, do nothing: we don't know which of its arguments to look
1443  // at, so we have to wait until all of the parameter packs in this
1444  // expansion have arguments.
1445  if (isa<SubstTemplateTypeParmPackType>(Param))
1446  return Sema::TDK_Success;
1447 
1448  // Check the cv-qualifiers on the parameter and argument types.
1449  CanQualType CanParam = S.Context.getCanonicalType(Param);
1450  CanQualType CanArg = S.Context.getCanonicalType(Arg);
1451  if (!(TDF & TDF_IgnoreQualifiers)) {
1452  if (TDF & TDF_ParamWithReferenceType) {
1453  if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
1455  } else if (TDF & TDF_ArgWithReferenceType) {
1456  // C++ [temp.deduct.conv]p4:
1457  // If the original A is a reference type, A can be more cv-qualified
1458  // than the deduced A
1459  if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers()))
1461 
1462  // Strip out all extra qualifiers from the argument to figure out the
1463  // type we're converting to, prior to the qualification conversion.
1464  Qualifiers Quals;
1465  Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
1466  Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers());
1467  } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
1468  if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
1470  }
1471 
1472  // If the parameter type is not dependent, there is nothing to deduce.
1473  if (!Param->isDependentType()) {
1474  if (!(TDF & TDF_SkipNonDependent)) {
1475  bool NonDeduced =
1477  ? !S.isSameOrCompatibleFunctionType(CanParam, CanArg)
1478  : Param != Arg;
1479  if (NonDeduced) {
1481  }
1482  }
1483  return Sema::TDK_Success;
1484  }
1485  } else if (!Param->isDependentType()) {
1486  CanQualType ParamUnqualType = CanParam.getUnqualifiedType(),
1487  ArgUnqualType = CanArg.getUnqualifiedType();
1488  bool Success =
1490  ? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType)
1491  : ParamUnqualType == ArgUnqualType;
1492  if (Success)
1493  return Sema::TDK_Success;
1494  }
1495 
1496  switch (Param->getTypeClass()) {
1497  // Non-canonical types cannot appear here.
1498 #define NON_CANONICAL_TYPE(Class, Base) \
1499  case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
1500 #define TYPE(Class, Base)
1501 #include "clang/AST/TypeNodes.inc"
1502 
1503  case Type::TemplateTypeParm:
1504  case Type::SubstTemplateTypeParmPack:
1505  llvm_unreachable("Type nodes handled above");
1506 
1507  // These types cannot be dependent, so simply check whether the types are
1508  // the same.
1509  case Type::Builtin:
1510  case Type::VariableArray:
1511  case Type::Vector:
1512  case Type::FunctionNoProto:
1513  case Type::Record:
1514  case Type::Enum:
1515  case Type::ObjCObject:
1516  case Type::ObjCInterface:
1517  case Type::ObjCObjectPointer:
1518  if (TDF & TDF_SkipNonDependent)
1519  return Sema::TDK_Success;
1520 
1521  if (TDF & TDF_IgnoreQualifiers) {
1522  Param = Param.getUnqualifiedType();
1523  Arg = Arg.getUnqualifiedType();
1524  }
1525 
1526  return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
1527 
1528  // _Complex T [placeholder extension]
1529  case Type::Complex:
1530  if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
1531  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1532  cast<ComplexType>(Param)->getElementType(),
1533  ComplexArg->getElementType(),
1534  Info, Deduced, TDF);
1535 
1537 
1538  // _Atomic T [extension]
1539  case Type::Atomic:
1540  if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
1541  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1542  cast<AtomicType>(Param)->getValueType(),
1543  AtomicArg->getValueType(),
1544  Info, Deduced, TDF);
1545 
1547 
1548  // T *
1549  case Type::Pointer: {
1550  QualType PointeeType;
1551  if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
1552  PointeeType = PointerArg->getPointeeType();
1553  } else if (const ObjCObjectPointerType *PointerArg
1554  = Arg->getAs<ObjCObjectPointerType>()) {
1555  PointeeType = PointerArg->getPointeeType();
1556  } else {
1558  }
1559 
1560  unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
1561  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1562  cast<PointerType>(Param)->getPointeeType(),
1563  PointeeType,
1564  Info, Deduced, SubTDF);
1565  }
1566 
1567  // T &
1568  case Type::LValueReference: {
1569  const LValueReferenceType *ReferenceArg =
1570  Arg->getAs<LValueReferenceType>();
1571  if (!ReferenceArg)
1573 
1574  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1575  cast<LValueReferenceType>(Param)->getPointeeType(),
1576  ReferenceArg->getPointeeType(), Info, Deduced, 0);
1577  }
1578 
1579  // T && [C++0x]
1580  case Type::RValueReference: {
1581  const RValueReferenceType *ReferenceArg =
1582  Arg->getAs<RValueReferenceType>();
1583  if (!ReferenceArg)
1585 
1586  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1587  cast<RValueReferenceType>(Param)->getPointeeType(),
1588  ReferenceArg->getPointeeType(),
1589  Info, Deduced, 0);
1590  }
1591 
1592  // T [] (implied, but not stated explicitly)
1593  case Type::IncompleteArray: {
1594  const IncompleteArrayType *IncompleteArrayArg =
1596  if (!IncompleteArrayArg)
1598 
1599  unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1600  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1602  IncompleteArrayArg->getElementType(),
1603  Info, Deduced, SubTDF);
1604  }
1605 
1606  // T [integer-constant]
1607  case Type::ConstantArray: {
1608  const ConstantArrayType *ConstantArrayArg =
1610  if (!ConstantArrayArg)
1612 
1613  const ConstantArrayType *ConstantArrayParm =
1615  if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
1616  return Sema::TDK_NonDeducedMismatch;
1617 
1618  unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1619  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1620  ConstantArrayParm->getElementType(),
1621  ConstantArrayArg->getElementType(),
1622  Info, Deduced, SubTDF);
1623  }
1624 
1625  // type [i]
1626  case Type::DependentSizedArray: {
1627  const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
1628  if (!ArrayArg)
1630 
1631  unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
1632 
1633  // Check the element type of the arrays
1634  const DependentSizedArrayType *DependentArrayParm
1637  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1638  DependentArrayParm->getElementType(),
1639  ArrayArg->getElementType(),
1640  Info, Deduced, SubTDF))
1641  return Result;
1642 
1643  // Determine the array bound is something we can deduce.
1645  = getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr());
1646  if (!NTTP)
1647  return Sema::TDK_Success;
1648 
1649  // We can perform template argument deduction for the given non-type
1650  // template parameter.
1651  assert(NTTP->getDepth() == Info.getDeducedDepth() &&
1652  "saw non-type template parameter with wrong depth");
1653  if (const ConstantArrayType *ConstantArrayArg
1654  = dyn_cast<ConstantArrayType>(ArrayArg)) {
1655  llvm::APSInt Size(ConstantArrayArg->getSize());
1656  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size,
1657  S.Context.getSizeType(),
1658  /*ArrayBound=*/true,
1659  Info, Deduced);
1660  }
1661  if (const DependentSizedArrayType *DependentArrayArg
1662  = dyn_cast<DependentSizedArrayType>(ArrayArg))
1663  if (DependentArrayArg->getSizeExpr())
1664  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
1665  DependentArrayArg->getSizeExpr(),
1666  Info, Deduced);
1667 
1668  // Incomplete type does not match a dependently-sized array type
1670  }
1671 
1672  // type(*)(T)
1673  // T(*)()
1674  // T(*)(T)
1675  case Type::FunctionProto: {
1676  unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
1677  const FunctionProtoType *FunctionProtoArg =
1678  dyn_cast<FunctionProtoType>(Arg);
1679  if (!FunctionProtoArg)
1681 
1682  const FunctionProtoType *FunctionProtoParam =
1683  cast<FunctionProtoType>(Param);
1684 
1685  if (FunctionProtoParam->getMethodQuals()
1686  != FunctionProtoArg->getMethodQuals() ||
1687  FunctionProtoParam->getRefQualifier()
1688  != FunctionProtoArg->getRefQualifier() ||
1689  FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
1690  return Sema::TDK_NonDeducedMismatch;
1691 
1692  // Check return types.
1693  if (auto Result = DeduceTemplateArgumentsByTypeMatch(
1694  S, TemplateParams, FunctionProtoParam->getReturnType(),
1695  FunctionProtoArg->getReturnType(), Info, Deduced, 0))
1696  return Result;
1697 
1698  // Check parameter types.
1699  if (auto Result = DeduceTemplateArguments(
1700  S, TemplateParams, FunctionProtoParam->param_type_begin(),
1701  FunctionProtoParam->getNumParams(),
1702  FunctionProtoArg->param_type_begin(),
1703  FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF))
1704  return Result;
1705 
1707  return Sema::TDK_Success;
1708 
1709  // FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit
1710  // deducing through the noexcept-specifier if it's part of the canonical
1711  // type. libstdc++ relies on this.
1712  Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr();
1713  if (NonTypeTemplateParmDecl *NTTP =
1714  NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr)
1715  : nullptr) {
1716  assert(NTTP->getDepth() == Info.getDeducedDepth() &&
1717  "saw non-type template parameter with wrong depth");
1718 
1719  llvm::APSInt Noexcept(1);
1720  switch (FunctionProtoArg->canThrow()) {
1721  case CT_Cannot:
1722  Noexcept = 1;
1723  LLVM_FALLTHROUGH;
1724 
1725  case CT_Can:
1726  // We give E in noexcept(E) the "deduced from array bound" treatment.
1727  // FIXME: Should we?
1729  S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
1730  /*ArrayBound*/true, Info, Deduced);
1731 
1732  case CT_Dependent:
1733  if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr())
1735  S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
1736  // Can't deduce anything from throw(T...).
1737  break;
1738  }
1739  }
1740  // FIXME: Detect non-deduced exception specification mismatches?
1741  //
1742  // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow
1743  // top-level differences in noexcept-specifications.
1744 
1745  return Sema::TDK_Success;
1746  }
1747 
1748  case Type::InjectedClassName:
1749  // Treat a template's injected-class-name as if the template
1750  // specialization type had been used.
1751  Param = cast<InjectedClassNameType>(Param)
1752  ->getInjectedSpecializationType();
1753  assert(isa<TemplateSpecializationType>(Param) &&
1754  "injected class name is not a template specialization type");
1755  LLVM_FALLTHROUGH;
1756 
1757  // template-name<T> (where template-name refers to a class template)
1758  // template-name<i>
1759  // TT<T>
1760  // TT<i>
1761  // TT<>
1762  case Type::TemplateSpecialization: {
1763  const TemplateSpecializationType *SpecParam =
1764  cast<TemplateSpecializationType>(Param);
1765 
1766  // When Arg cannot be a derived class, we can just try to deduce template
1767  // arguments from the template-id.
1768  const RecordType *RecordT = Arg->getAs<RecordType>();
1769  if (!(TDF & TDF_DerivedClass) || !RecordT)
1770  return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info,
1771  Deduced);
1772 
1773  SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
1774  Deduced.end());
1775 
1777  S, TemplateParams, SpecParam, Arg, Info, Deduced);
1778 
1779  if (Result == Sema::TDK_Success)
1780  return Result;
1781 
1782  // We cannot inspect base classes as part of deduction when the type
1783  // is incomplete, so either instantiate any templates necessary to
1784  // complete the type, or skip over it if it cannot be completed.
1785  if (!S.isCompleteType(Info.getLocation(), Arg))
1786  return Result;
1787 
1788  // C++14 [temp.deduct.call] p4b3:
1789  // If P is a class and P has the form simple-template-id, then the
1790  // transformed A can be a derived class of the deduced A. Likewise if
1791  // P is a pointer to a class of the form simple-template-id, the
1792  // transformed A can be a pointer to a derived class pointed to by the
1793  // deduced A.
1794  //
1795  // These alternatives are considered only if type deduction would
1796  // otherwise fail. If they yield more than one possible deduced A, the
1797  // type deduction fails.
1798 
1799  // Reset the incorrectly deduced argument from above.
1800  Deduced = DeducedOrig;
1801 
1802  // Use data recursion to crawl through the list of base classes.
1803  // Visited contains the set of nodes we have already visited, while
1804  // ToVisit is our stack of records that we still need to visit.
1805  llvm::SmallPtrSet<const RecordType *, 8> Visited;
1807  ToVisit.push_back(RecordT);
1808  bool Successful = false;
1809  SmallVector<DeducedTemplateArgument, 8> SuccessfulDeduced;
1810  while (!ToVisit.empty()) {
1811  // Retrieve the next class in the inheritance hierarchy.
1812  const RecordType *NextT = ToVisit.pop_back_val();
1813 
1814  // If we have already seen this type, skip it.
1815  if (!Visited.insert(NextT).second)
1816  continue;
1817 
1818  // If this is a base class, try to perform template argument
1819  // deduction from it.
1820  if (NextT != RecordT) {
1821  TemplateDeductionInfo BaseInfo(Info.getLocation());
1823  DeduceTemplateArguments(S, TemplateParams, SpecParam,
1824  QualType(NextT, 0), BaseInfo, Deduced);
1825 
1826  // If template argument deduction for this base was successful,
1827  // note that we had some success. Otherwise, ignore any deductions
1828  // from this base class.
1829  if (BaseResult == Sema::TDK_Success) {
1830  // If we've already seen some success, then deduction fails due to
1831  // an ambiguity (temp.deduct.call p5).
1832  if (Successful)
1834 
1835  Successful = true;
1836  std::swap(SuccessfulDeduced, Deduced);
1837 
1838  Info.Param = BaseInfo.Param;
1839  Info.FirstArg = BaseInfo.FirstArg;
1840  Info.SecondArg = BaseInfo.SecondArg;
1841  }
1842 
1843  Deduced = DeducedOrig;
1844  }
1845 
1846  // Visit base classes
1847  CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl());
1848  for (const auto &Base : Next->bases()) {
1849  assert(Base.getType()->isRecordType() &&
1850  "Base class that isn't a record?");
1851  ToVisit.push_back(Base.getType()->getAs<RecordType>());
1852  }
1853  }
1854 
1855  if (Successful) {
1856  std::swap(SuccessfulDeduced, Deduced);
1857  return Sema::TDK_Success;
1858  }
1859 
1860  return Result;
1861  }
1862 
1863  // T type::*
1864  // T T::*
1865  // T (type::*)()
1866  // type (T::*)()
1867  // type (type::*)(T)
1868  // type (T::*)(T)
1869  // T (type::*)(T)
1870  // T (T::*)()
1871  // T (T::*)(T)
1872  case Type::MemberPointer: {
1873  const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
1874  const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
1875  if (!MemPtrArg)
1877 
1878  QualType ParamPointeeType = MemPtrParam->getPointeeType();
1879  if (ParamPointeeType->isFunctionType())
1880  S.adjustMemberFunctionCC(ParamPointeeType, /*IsStatic=*/true,
1881  /*IsCtorOrDtor=*/false, Info.getLocation());
1882  QualType ArgPointeeType = MemPtrArg->getPointeeType();
1883  if (ArgPointeeType->isFunctionType())
1884  S.adjustMemberFunctionCC(ArgPointeeType, /*IsStatic=*/true,
1885  /*IsCtorOrDtor=*/false, Info.getLocation());
1886 
1888  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1889  ParamPointeeType,
1890  ArgPointeeType,
1891  Info, Deduced,
1892  TDF & TDF_IgnoreQualifiers))
1893  return Result;
1894 
1895  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1896  QualType(MemPtrParam->getClass(), 0),
1897  QualType(MemPtrArg->getClass(), 0),
1898  Info, Deduced,
1899  TDF & TDF_IgnoreQualifiers);
1900  }
1901 
1902  // (clang extension)
1903  //
1904  // type(^)(T)
1905  // T(^)()
1906  // T(^)(T)
1907  case Type::BlockPointer: {
1908  const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
1909  const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
1910 
1911  if (!BlockPtrArg)
1913 
1914  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1915  BlockPtrParam->getPointeeType(),
1916  BlockPtrArg->getPointeeType(),
1917  Info, Deduced, 0);
1918  }
1919 
1920  // (clang extension)
1921  //
1922  // T __attribute__(((ext_vector_type(<integral constant>))))
1923  case Type::ExtVector: {
1924  const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
1925  if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
1926  // Make sure that the vectors have the same number of elements.
1927  if (VectorParam->getNumElements() != VectorArg->getNumElements())
1928  return Sema::TDK_NonDeducedMismatch;
1929 
1930  // Perform deduction on the element types.
1931  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1932  VectorParam->getElementType(),
1933  VectorArg->getElementType(),
1934  Info, Deduced, TDF);
1935  }
1936 
1937  if (const DependentSizedExtVectorType *VectorArg
1938  = dyn_cast<DependentSizedExtVectorType>(Arg)) {
1939  // We can't check the number of elements, since the argument has a
1940  // dependent number of elements. This can only occur during partial
1941  // ordering.
1942 
1943  // Perform deduction on the element types.
1944  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
1945  VectorParam->getElementType(),
1946  VectorArg->getElementType(),
1947  Info, Deduced, TDF);
1948  }
1949 
1951  }
1952 
1953  case Type::DependentVector: {
1954  const auto *VectorParam = cast<DependentVectorType>(Param);
1955 
1956  if (const auto *VectorArg = dyn_cast<VectorType>(Arg)) {
1957  // Perform deduction on the element types.
1958  if (Sema::TemplateDeductionResult Result =
1960  S, TemplateParams, VectorParam->getElementType(),
1961  VectorArg->getElementType(), Info, Deduced, TDF))
1962  return Result;
1963 
1964  // Perform deduction on the vector size, if we can.
1965  NonTypeTemplateParmDecl *NTTP =
1966  getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
1967  if (!NTTP)
1968  return Sema::TDK_Success;
1969 
1970  llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
1971  ArgSize = VectorArg->getNumElements();
1972  // Note that we use the "array bound" rules here; just like in that
1973  // case, we don't have any particular type for the vector size, but
1974  // we can provide one if necessary.
1975  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
1976  S.Context.UnsignedIntTy, true,
1977  Info, Deduced);
1978  }
1979 
1980  if (const auto *VectorArg = dyn_cast<DependentVectorType>(Arg)) {
1981  // Perform deduction on the element types.
1982  if (Sema::TemplateDeductionResult Result =
1984  S, TemplateParams, VectorParam->getElementType(),
1985  VectorArg->getElementType(), Info, Deduced, TDF))
1986  return Result;
1987 
1988  // Perform deduction on the vector size, if we can.
1990  Info, VectorParam->getSizeExpr());
1991  if (!NTTP)
1992  return Sema::TDK_Success;
1993 
1995  S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced);
1996  }
1997 
1999  }
2000 
2001  // (clang extension)
2002  //
2003  // T __attribute__(((ext_vector_type(N))))
2004  case Type::DependentSizedExtVector: {
2005  const DependentSizedExtVectorType *VectorParam
2006  = cast<DependentSizedExtVectorType>(Param);
2007 
2008  if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
2009  // Perform deduction on the element types.
2011  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
2012  VectorParam->getElementType(),
2013  VectorArg->getElementType(),
2014  Info, Deduced, TDF))
2015  return Result;
2016 
2017  // Perform deduction on the vector size, if we can.
2019  = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
2020  if (!NTTP)
2021  return Sema::TDK_Success;
2022 
2023  llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
2024  ArgSize = VectorArg->getNumElements();
2025  // Note that we use the "array bound" rules here; just like in that
2026  // case, we don't have any particular type for the vector size, but
2027  // we can provide one if necessary.
2028  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
2029  S.Context.IntTy, true, Info,
2030  Deduced);
2031  }
2032 
2033  if (const DependentSizedExtVectorType *VectorArg
2034  = dyn_cast<DependentSizedExtVectorType>(Arg)) {
2035  // Perform deduction on the element types.
2037  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
2038  VectorParam->getElementType(),
2039  VectorArg->getElementType(),
2040  Info, Deduced, TDF))
2041  return Result;
2042 
2043  // Perform deduction on the vector size, if we can.
2045  = getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
2046  if (!NTTP)
2047  return Sema::TDK_Success;
2048 
2049  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
2050  VectorArg->getSizeExpr(),
2051  Info, Deduced);
2052  }
2053 
2055  }
2056 
2057  // (clang extension)
2058  //
2059  // T __attribute__(((address_space(N))))
2060  case Type::DependentAddressSpace: {
2061  const DependentAddressSpaceType *AddressSpaceParam =
2062  cast<DependentAddressSpaceType>(Param);
2063 
2064  if (const DependentAddressSpaceType *AddressSpaceArg =
2065  dyn_cast<DependentAddressSpaceType>(Arg)) {
2066  // Perform deduction on the pointer type.
2067  if (Sema::TemplateDeductionResult Result =
2069  S, TemplateParams, AddressSpaceParam->getPointeeType(),
2070  AddressSpaceArg->getPointeeType(), Info, Deduced, TDF))
2071  return Result;
2072 
2073  // Perform deduction on the address space, if we can.
2075  Info, AddressSpaceParam->getAddrSpaceExpr());
2076  if (!NTTP)
2077  return Sema::TDK_Success;
2078 
2080  S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info,
2081  Deduced);
2082  }
2083 
2085  llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy),
2086  false);
2087  ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace());
2088 
2089  // Perform deduction on the pointer types.
2090  if (Sema::TemplateDeductionResult Result =
2092  S, TemplateParams, AddressSpaceParam->getPointeeType(),
2093  S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF))
2094  return Result;
2095 
2096  // Perform deduction on the address space, if we can.
2098  Info, AddressSpaceParam->getAddrSpaceExpr());
2099  if (!NTTP)
2100  return Sema::TDK_Success;
2101 
2102  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
2103  ArgAddressSpace, S.Context.IntTy,
2104  true, Info, Deduced);
2105  }
2106 
2108  }
2109 
2110  case Type::TypeOfExpr:
2111  case Type::TypeOf:
2112  case Type::DependentName:
2113  case Type::UnresolvedUsing:
2114  case Type::Decltype:
2115  case Type::UnaryTransform:
2116  case Type::Auto:
2117  case Type::DeducedTemplateSpecialization:
2118  case Type::DependentTemplateSpecialization:
2119  case Type::PackExpansion:
2120  case Type::Pipe:
2121  // No template argument deduction for these types
2122  return Sema::TDK_Success;
2123  }
2124 
2125  llvm_unreachable("Invalid Type Class!");
2126 }
2127 
2130  TemplateParameterList *TemplateParams,
2131  const TemplateArgument &Param,
2132  TemplateArgument Arg,
2133  TemplateDeductionInfo &Info,
2134  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
2135  // If the template argument is a pack expansion, perform template argument
2136  // deduction against the pattern of that expansion. This only occurs during
2137  // partial ordering.
2138  if (Arg.isPackExpansion())
2139  Arg = Arg.getPackExpansionPattern();
2140 
2141  switch (Param.getKind()) {
2143  llvm_unreachable("Null template argument in parameter list");
2144 
2146  if (Arg.getKind() == TemplateArgument::Type)
2147  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
2148  Param.getAsType(),
2149  Arg.getAsType(),
2150  Info, Deduced, 0);
2151  Info.FirstArg = Param;
2152  Info.SecondArg = Arg;
2154 
2156  if (Arg.getKind() == TemplateArgument::Template)
2157  return DeduceTemplateArguments(S, TemplateParams,
2158  Param.getAsTemplate(),
2159  Arg.getAsTemplate(), Info, Deduced);
2160  Info.FirstArg = Param;
2161  Info.SecondArg = Arg;
2163 
2165  llvm_unreachable("caller should handle pack expansions");
2166 
2168  if (Arg.getKind() == TemplateArgument::Declaration &&
2169  isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()))
2170  return Sema::TDK_Success;
2171 
2172  Info.FirstArg = Param;
2173  Info.SecondArg = Arg;
2175 
2177  if (Arg.getKind() == TemplateArgument::NullPtr &&
2179  return Sema::TDK_Success;
2180 
2181  Info.FirstArg = Param;
2182  Info.SecondArg = Arg;
2184 
2186  if (Arg.getKind() == TemplateArgument::Integral) {
2187  if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
2188  return Sema::TDK_Success;
2189 
2190  Info.FirstArg = Param;
2191  Info.SecondArg = Arg;
2193  }
2194 
2195  if (Arg.getKind() == TemplateArgument::Expression) {
2196  Info.FirstArg = Param;
2197  Info.SecondArg = Arg;
2199  }
2200 
2201  Info.FirstArg = Param;
2202  Info.SecondArg = Arg;
2204 
2206  if (NonTypeTemplateParmDecl *NTTP
2207  = getDeducedParameterFromExpr(Info, Param.getAsExpr())) {
2208  if (Arg.getKind() == TemplateArgument::Integral)
2209  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
2210  Arg.getAsIntegral(),
2211  Arg.getIntegralType(),
2212  /*ArrayBound=*/false,
2213  Info, Deduced);
2214  if (Arg.getKind() == TemplateArgument::NullPtr)
2215  return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
2216  Arg.getNullPtrType(),
2217  Info, Deduced);
2219  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
2220  Arg.getAsExpr(), Info, Deduced);
2222  return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
2223  Arg.getAsDecl(),
2224  Arg.getParamTypeForDecl(),
2225  Info, Deduced);
2226 
2227  Info.FirstArg = Param;
2228  Info.SecondArg = Arg;
2230  }
2231 
2232  // Can't deduce anything, but that's okay.
2233  return Sema::TDK_Success;
2234 
2236  llvm_unreachable("Argument packs should be expanded by the caller!");
2237  }
2238 
2239  llvm_unreachable("Invalid TemplateArgument Kind!");
2240 }
2241 
2242 /// Determine whether there is a template argument to be used for
2243 /// deduction.
2244 ///
2245 /// This routine "expands" argument packs in-place, overriding its input
2246 /// parameters so that \c Args[ArgIdx] will be the available template argument.
2247 ///
2248 /// \returns true if there is another template argument (which will be at
2249 /// \c Args[ArgIdx]), false otherwise.
2250 static bool hasTemplateArgumentForDeduction(ArrayRef<TemplateArgument> &Args,
2251  unsigned &ArgIdx) {
2252  if (ArgIdx == Args.size())
2253  return false;
2254 
2255  const TemplateArgument &Arg = Args[ArgIdx];
2256  if (Arg.getKind() != TemplateArgument::Pack)
2257  return true;
2258 
2259  assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?");
2260  Args = Arg.pack_elements();
2261  ArgIdx = 0;
2262  return ArgIdx < Args.size();
2263 }
2264 
2265 /// Determine whether the given set of template arguments has a pack
2266 /// expansion that is not the last template argument.
2267 static bool hasPackExpansionBeforeEnd(ArrayRef<TemplateArgument> Args) {
2268  bool FoundPackExpansion = false;
2269  for (const auto &A : Args) {
2270  if (FoundPackExpansion)
2271  return true;
2272 
2273  if (A.getKind() == TemplateArgument::Pack)
2274  return hasPackExpansionBeforeEnd(A.pack_elements());
2275 
2276  // FIXME: If this is a fixed-arity pack expansion from an outer level of
2277  // templates, it should not be treated as a pack expansion.
2278  if (A.isPackExpansion())
2279  FoundPackExpansion = true;
2280  }
2281 
2282  return false;
2283 }
2284 
2287  ArrayRef<TemplateArgument> Params,
2288  ArrayRef<TemplateArgument> Args,
2289  TemplateDeductionInfo &Info,
2290  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2291  bool NumberOfArgumentsMustMatch) {
2292  // C++0x [temp.deduct.type]p9:
2293  // If the template argument list of P contains a pack expansion that is not
2294  // the last template argument, the entire template argument list is a
2295  // non-deduced context.
2296  if (hasPackExpansionBeforeEnd(Params))
2297  return Sema::TDK_Success;
2298 
2299  // C++0x [temp.deduct.type]p9:
2300  // If P has a form that contains <T> or <i>, then each argument Pi of the
2301  // respective template argument list P is compared with the corresponding
2302  // argument Ai of the corresponding template argument list of A.
2303  unsigned ArgIdx = 0, ParamIdx = 0;
2304  for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) {
2305  if (!Params[ParamIdx].isPackExpansion()) {
2306  // The simple case: deduce template arguments by matching Pi and Ai.
2307 
2308  // Check whether we have enough arguments.
2309  if (!hasTemplateArgumentForDeduction(Args, ArgIdx))
2310  return NumberOfArgumentsMustMatch
2313 
2314  // C++1z [temp.deduct.type]p9:
2315  // During partial ordering, if Ai was originally a pack expansion [and]
2316  // Pi is not a pack expansion, template argument deduction fails.
2317  if (Args[ArgIdx].isPackExpansion())
2319 
2320  // Perform deduction for this Pi/Ai pair.
2322  = DeduceTemplateArguments(S, TemplateParams,
2323  Params[ParamIdx], Args[ArgIdx],
2324  Info, Deduced))
2325  return Result;
2326 
2327  // Move to the next argument.
2328  ++ArgIdx;
2329  continue;
2330  }
2331 
2332  // The parameter is a pack expansion.
2333 
2334  // C++0x [temp.deduct.type]p9:
2335  // If Pi is a pack expansion, then the pattern of Pi is compared with
2336  // each remaining argument in the template argument list of A. Each
2337  // comparison deduces template arguments for subsequent positions in the
2338  // template parameter packs expanded by Pi.
2340 
2341  // Prepare to deduce the packs within the pattern.
2342  PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
2343 
2344  // Keep track of the deduced template arguments for each parameter pack
2345  // expanded by this pack expansion (the outer index) and for each
2346  // template argument (the inner SmallVectors).
2347  for (; hasTemplateArgumentForDeduction(Args, ArgIdx) &&
2348  PackScope.hasNextElement();
2349  ++ArgIdx) {
2350  // Deduce template arguments from the pattern.
2352  = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
2353  Info, Deduced))
2354  return Result;
2355 
2356  PackScope.nextPackElement();
2357  }
2358 
2359  // Build argument packs for each of the parameter packs expanded by this
2360  // pack expansion.
2361  if (auto Result = PackScope.finish())
2362  return Result;
2363  }
2364 
2365  return Sema::TDK_Success;
2366 }
2367 
2370  TemplateParameterList *TemplateParams,
2371  const TemplateArgumentList &ParamList,
2372  const TemplateArgumentList &ArgList,
2373  TemplateDeductionInfo &Info,
2374  SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
2375  return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(),
2376  ArgList.asArray(), Info, Deduced,
2377  /*NumberOfArgumentsMustMatch*/false);
2378 }
2379 
2380 /// Determine whether two template arguments are the same.
2381 static bool isSameTemplateArg(ASTContext &Context,
2383  const TemplateArgument &Y,
2384  bool PackExpansionMatchesPack = false) {
2385  // If we're checking deduced arguments (X) against original arguments (Y),
2386  // we will have flattened packs to non-expansions in X.
2387  if (PackExpansionMatchesPack && X.isPackExpansion() && !Y.isPackExpansion())
2388  X = X.getPackExpansionPattern();
2389 
2390  if (X.getKind() != Y.getKind())
2391  return false;
2392 
2393  switch (X.getKind()) {
2395  llvm_unreachable("Comparing NULL template argument");
2396 
2398  return Context.getCanonicalType(X.getAsType()) ==
2399  Context.getCanonicalType(Y.getAsType());
2400 
2402  return isSameDeclaration(X.getAsDecl(), Y.getAsDecl());
2403 
2405  return Context.hasSameType(X.getNullPtrType(), Y.getNullPtrType());
2406 
2409  return Context.getCanonicalTemplateName(
2410  X.getAsTemplateOrTemplatePattern()).getAsVoidPointer() ==
2411  Context.getCanonicalTemplateName(
2412  Y.getAsTemplateOrTemplatePattern()).getAsVoidPointer();
2413 
2416 
2418  llvm::FoldingSetNodeID XID, YID;
2419  X.getAsExpr()->Profile(XID, Context, true);
2420  Y.getAsExpr()->Profile(YID, Context, true);
2421  return XID == YID;
2422  }
2423 
2425  if (X.pack_size() != Y.pack_size())
2426  return false;
2427 
2429  XPEnd = X.pack_end(),
2430  YP = Y.pack_begin();
2431  XP != XPEnd; ++XP, ++YP)
2432  if (!isSameTemplateArg(Context, *XP, *YP, PackExpansionMatchesPack))
2433  return false;
2434 
2435  return true;
2436  }
2437 
2438  llvm_unreachable("Invalid TemplateArgument Kind!");
2439 }
2440 
2441 /// Allocate a TemplateArgumentLoc where all locations have
2442 /// been initialized to the given location.
2443 ///
2444 /// \param Arg The template argument we are producing template argument
2445 /// location information for.
2446 ///
2447 /// \param NTTPType For a declaration template argument, the type of
2448 /// the non-type template parameter that corresponds to this template
2449 /// argument. Can be null if no type sugar is available to add to the
2450 /// type from the template argument.
2451 ///
2452 /// \param Loc The source location to use for the resulting template
2453 /// argument.
2456  QualType NTTPType, SourceLocation Loc) {
2457  switch (Arg.getKind()) {
2459  llvm_unreachable("Can't get a NULL template argument here");
2460 
2462  return TemplateArgumentLoc(
2463  Arg, Context.getTrivialTypeSourceInfo(Arg.getAsType(), Loc));
2464 
2466  if (NTTPType.isNull())
2467  NTTPType = Arg.getParamTypeForDecl();
2468  Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2469  .getAs<Expr>();
2470  return TemplateArgumentLoc(TemplateArgument(E), E);
2471  }
2472 
2474  if (NTTPType.isNull())
2475  NTTPType = Arg.getNullPtrType();
2476  Expr *E = BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc)
2477  .getAs<Expr>();
2478  return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true),
2479  E);
2480  }
2481 
2483  Expr *E =
2484  BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<Expr>();
2485  return TemplateArgumentLoc(TemplateArgument(E), E);
2486  }
2487 
2492  if (DependentTemplateName *DTN = Template.getAsDependentTemplateName())
2493  Builder.MakeTrivial(Context, DTN->getQualifier(), Loc);
2494  else if (QualifiedTemplateName *QTN =
2495  Template.getAsQualifiedTemplateName())
2496  Builder.MakeTrivial(Context, QTN->getQualifier(), Loc);
2497 
2498  if (Arg.getKind() == TemplateArgument::Template)
2499  return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
2500  Loc);
2501 
2502  return TemplateArgumentLoc(Arg, Builder.getWithLocInContext(Context),
2503  Loc, Loc);
2504  }
2505 
2507  return TemplateArgumentLoc(Arg, Arg.getAsExpr());
2508 
2511  }
2512 
2513  llvm_unreachable("Invalid TemplateArgument Kind!");
2514 }
2515 
2518  SourceLocation Location) {
2519  return getTrivialTemplateArgumentLoc(
2520  Context.getInjectedTemplateArg(TemplateParm), QualType(), Location);
2521 }
2522 
2523 /// Convert the given deduced template argument and add it to the set of
2524 /// fully-converted template arguments.
2525 static bool
2528  NamedDecl *Template,
2529  TemplateDeductionInfo &Info,
2530  bool IsDeduced,
2531  SmallVectorImpl<TemplateArgument> &Output) {
2532  auto ConvertArg = [&](DeducedTemplateArgument Arg,
2533  unsigned ArgumentPackIndex) {
2534  // Convert the deduced template argument into a template
2535  // argument that we can check, almost as if the user had written
2536  // the template argument explicitly.
2537  TemplateArgumentLoc ArgLoc =
2539 
2540  // Check the template argument, converting it as necessary.
2541  return S.CheckTemplateArgument(
2542  Param, ArgLoc, Template, Template->getLocation(),
2543  Template->getSourceRange().getEnd(), ArgumentPackIndex, Output,
2544  IsDeduced
2548  };
2549 
2550  if (Arg.getKind() == TemplateArgument::Pack) {
2551  // This is a template argument pack, so check each of its arguments against
2552  // the template parameter.
2553  SmallVector<TemplateArgument, 2> PackedArgsBuilder;
2554  for (const auto &P : Arg.pack_elements()) {
2555  // When converting the deduced template argument, append it to the
2556  // general output list. We need to do this so that the template argument
2557  // checking logic has all of the prior template arguments available.
2558  DeducedTemplateArgument InnerArg(P);
2560  assert(InnerArg.getKind() != TemplateArgument::Pack &&
2561  "deduced nested pack");
2562  if (P.isNull()) {
2563  // We deduced arguments for some elements of this pack, but not for
2564  // all of them. This happens if we get a conditionally-non-deduced
2565  // context in a pack expansion (such as an overload set in one of the
2566  // arguments).
2567  S.Diag(Param->getLocation(),
2568  diag::err_template_arg_deduced_incomplete_pack)
2569  << Arg << Param;
2570  return true;
2571  }
2572  if (ConvertArg(InnerArg, PackedArgsBuilder.size()))
2573  return true;
2574 
2575  // Move the converted template argument into our argument pack.
2576  PackedArgsBuilder.push_back(Output.pop_back_val());
2577  }
2578 
2579  // If the pack is empty, we still need to substitute into the parameter
2580  // itself, in case that substitution fails.
2581  if (PackedArgsBuilder.empty()) {
2584  MultiLevelTemplateArgumentList Args(TemplateArgs);
2585 
2586  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
2587  Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
2588  NTTP, Output,
2589  Template->getSourceRange());
2590  if (Inst.isInvalid() ||
2591  S.SubstType(NTTP->getType(), Args, NTTP->getLocation(),
2592  NTTP->getDeclName()).isNull())
2593  return true;
2594  } else if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Param)) {
2595  Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template,
2596  TTP, Output,
2597  Template->getSourceRange());
2598  if (Inst.isInvalid() || !S.SubstDecl(TTP, S.CurContext, Args))
2599  return true;
2600  }
2601  // For type parameters, no substitution is ever required.
2602  }
2603 
2604  // Create the resulting argument pack.
2605  Output.push_back(
2606  TemplateArgument::CreatePackCopy(S.Context, PackedArgsBuilder));
2607  return false;
2608  }
2609 
2610  return ConvertArg(Arg, 0);
2611 }
2612 
2613 // FIXME: This should not be a template, but
2614 // ClassTemplatePartialSpecializationDecl sadly does not derive from
2615 // TemplateDecl.
2616 template<typename TemplateDeclT>
2618  Sema &S, TemplateDeclT *Template, bool IsDeduced,
2619  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2620  TemplateDeductionInfo &Info, SmallVectorImpl<TemplateArgument> &Builder,
2621  LocalInstantiationScope *CurrentInstantiationScope = nullptr,
2622  unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) {
2623  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
2624 
2625  for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
2626  NamedDecl *Param = TemplateParams->getParam(I);
2627 
2628  // C++0x [temp.arg.explicit]p3:
2629  // A trailing template parameter pack (14.5.3) not otherwise deduced will
2630  // be deduced to an empty sequence of template arguments.
2631  // FIXME: Where did the word "trailing" come from?
2632  if (Deduced[I].isNull() && Param->isTemplateParameterPack()) {
2633  if (auto Result =
2634  PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish())
2635  return Result;
2636  }
2637 
2638  if (!Deduced[I].isNull()) {
2639  if (I < NumAlreadyConverted) {
2640  // We may have had explicitly-specified template arguments for a
2641  // template parameter pack (that may or may not have been extended
2642  // via additional deduced arguments).
2643  if (Param->isParameterPack() && CurrentInstantiationScope &&
2644  CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) {
2645  // Forget the partially-substituted pack; its substitution is now
2646  // complete.
2647  CurrentInstantiationScope->ResetPartiallySubstitutedPack();
2648  // We still need to check the argument in case it was extended by
2649  // deduction.
2650  } else {
2651  // We have already fully type-checked and converted this
2652  // argument, because it was explicitly-specified. Just record the
2653  // presence of this argument.
2654  Builder.push_back(Deduced[I]);
2655  continue;
2656  }
2657  }
2658 
2659  // We may have deduced this argument, so it still needs to be
2660  // checked and converted.
2661  if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info,
2662  IsDeduced, Builder)) {
2663  Info.Param = makeTemplateParameter(Param);
2664  // FIXME: These template arguments are temporary. Free them!
2667  }
2668 
2669  continue;
2670  }
2671 
2672  // Substitute into the default template argument, if available.
2673  bool HasDefaultArg = false;
2674  TemplateDecl *TD = dyn_cast<TemplateDecl>(Template);
2675  if (!TD) {
2676  assert(isa<ClassTemplatePartialSpecializationDecl>(Template) ||
2677  isa<VarTemplatePartialSpecializationDecl>(Template));
2678  return Sema::TDK_Incomplete;
2679  }
2680 
2682  TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, Builder,
2683  HasDefaultArg);
2684 
2685  // If there was no default argument, deduction is incomplete.
2686  if (DefArg.getArgument().isNull()) {
2688  const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2690  if (PartialOverloading) break;
2691 
2692  return HasDefaultArg ? Sema::TDK_SubstitutionFailure
2694  }
2695 
2696  // Check whether we can actually use the default argument.
2697  if (S.CheckTemplateArgument(Param, DefArg, TD, TD->getLocation(),
2698  TD->getSourceRange().getEnd(), 0, Builder,
2701  const_cast<NamedDecl *>(TemplateParams->getParam(I)));
2702  // FIXME: These template arguments are temporary. Free them!
2705  }
2706 
2707  // If we get here, we successfully used the default template argument.
2708  }
2709 
2710  return Sema::TDK_Success;
2711 }
2712 
2714  if (auto *DC = dyn_cast<DeclContext>(D))
2715  return DC;
2716  return D->getDeclContext();
2717 }
2718 
2719 template<typename T> struct IsPartialSpecialization {
2720  static constexpr bool value = false;
2721 };
2722 template<>
2724  static constexpr bool value = true;
2725 };
2726 template<>
2728  static constexpr bool value = true;
2729 };
2730 
2731 template<typename TemplateDeclT>
2733 CheckDeducedArgumentConstraints(Sema& S, TemplateDeclT *Template,
2734  ArrayRef<TemplateArgument> DeducedArgs,
2735  TemplateDeductionInfo& Info) {
2736  llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
2737  Template->getAssociatedConstraints(AssociatedConstraints);
2738  if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints,
2739  DeducedArgs, Info.getLocation(),
2742  Info.reset(TemplateArgumentList::CreateCopy(S.Context, DeducedArgs));
2744  }
2745  return Sema::TDK_Success;
2746 }
2747 
2748 /// Complete template argument deduction for a partial specialization.
2749 template <typename T>
2750 static typename std::enable_if<IsPartialSpecialization<T>::value,
2753  Sema &S, T *Partial, bool IsPartialOrdering,
2754  const TemplateArgumentList &TemplateArgs,
2755  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2756  TemplateDeductionInfo &Info) {
2757  // Unevaluated SFINAE context.
2760  Sema::SFINAETrap Trap(S);
2761 
2762  Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Partial));
2763 
2764  // C++ [temp.deduct.type]p2:
2765  // [...] or if any template argument remains neither deduced nor
2766  // explicitly specified, template argument deduction fails.
2768  if (auto Result = ConvertDeducedTemplateArguments(
2769  S, Partial, IsPartialOrdering, Deduced, Info, Builder))
2770  return Result;
2771 
2772  // Form the template argument list from the deduced template arguments.
2773  TemplateArgumentList *DeducedArgumentList
2775 
2776  Info.reset(DeducedArgumentList);
2777 
2778  // Substitute the deduced template arguments into the template
2779  // arguments of the class template partial specialization, and
2780  // verify that the instantiated template arguments are both valid
2781  // and are equivalent to the template arguments originally provided
2782  // to the class template.
2783  LocalInstantiationScope InstScope(S);
2784  auto *Template = Partial->getSpecializedTemplate();
2785  const ASTTemplateArgumentListInfo *PartialTemplArgInfo =
2786  Partial->getTemplateArgsAsWritten();
2787  const TemplateArgumentLoc *PartialTemplateArgs =
2788  PartialTemplArgInfo->getTemplateArgs();
2789 
2790  TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc,
2791  PartialTemplArgInfo->RAngleLoc);
2792 
2793  if (S.Subst(PartialTemplateArgs, PartialTemplArgInfo->NumTemplateArgs,
2794  InstArgs, MultiLevelTemplateArgumentList(*DeducedArgumentList))) {
2795  unsigned ArgIdx = InstArgs.size(), ParamIdx = ArgIdx;
2796  if (ParamIdx >= Partial->getTemplateParameters()->size())
2797  ParamIdx = Partial->getTemplateParameters()->size() - 1;
2798 
2799  Decl *Param = const_cast<NamedDecl *>(
2800  Partial->getTemplateParameters()->getParam(ParamIdx));
2801  Info.Param = makeTemplateParameter(Param);
2802  Info.FirstArg = PartialTemplateArgs[ArgIdx].getArgument();
2804  }
2805 
2806  bool ConstraintsNotSatisfied;
2807  SmallVector<TemplateArgument, 4> ConvertedInstArgs;
2808  if (S.CheckTemplateArgumentList(Template, Partial->getLocation(), InstArgs,
2809  false, ConvertedInstArgs,
2810  /*UpdateArgsWithConversions=*/true,
2811  &ConstraintsNotSatisfied))
2812  return ConstraintsNotSatisfied ? Sema::TDK_ConstraintsNotSatisfied :
2814 
2815  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
2816  for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
2817  TemplateArgument InstArg = ConvertedInstArgs.data()[I];
2818  if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg)) {
2819  Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
2820  Info.FirstArg = TemplateArgs[I];
2821  Info.SecondArg = InstArg;
2823  }
2824  }
2825 
2826  if (Trap.hasErrorOccurred())
2828 
2829  if (auto Result = CheckDeducedArgumentConstraints(S, Partial, Builder, Info))
2830  return Result;
2831 
2832  return Sema::TDK_Success;
2833 }
2834 
2835 /// Complete template argument deduction for a class or variable template,
2836 /// when partial ordering against a partial specialization.
2837 // FIXME: Factor out duplication with partial specialization version above.
2839  Sema &S, TemplateDecl *Template, bool PartialOrdering,
2840  const TemplateArgumentList &TemplateArgs,
2841  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2842  TemplateDeductionInfo &Info) {
2843  // Unevaluated SFINAE context.
2846  Sema::SFINAETrap Trap(S);
2847 
2848  Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(Template));
2849 
2850  // C++ [temp.deduct.type]p2:
2851  // [...] or if any template argument remains neither deduced nor
2852  // explicitly specified, template argument deduction fails.
2854  if (auto Result = ConvertDeducedTemplateArguments(
2855  S, Template, /*IsDeduced*/PartialOrdering, Deduced, Info, Builder))
2856  return Result;
2857 
2858  // Check that we produced the correct argument list.
2859  TemplateParameterList *TemplateParams = Template->getTemplateParameters();
2860  for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) {
2861  TemplateArgument InstArg = Builder[I];
2862  if (!isSameTemplateArg(S.Context, TemplateArgs[I], InstArg,
2863  /*PackExpansionMatchesPack*/true)) {
2864  Info.Param = makeTemplateParameter(TemplateParams->getParam(I));
2865  Info.FirstArg = TemplateArgs[I];
2866  Info.SecondArg = InstArg;
2868  }
2869  }
2870 
2871  if (Trap.hasErrorOccurred())
2873 
2874  if (auto Result = CheckDeducedArgumentConstraints(S, Template, Builder,
2875  Info))
2876  return Result;
2877 
2878  return Sema::TDK_Success;
2879 }
2880 
2881 /// Perform template argument deduction to determine whether
2882 /// the given template arguments match the given class template
2883 /// partial specialization per C++ [temp.class.spec.match].
2886  const TemplateArgumentList &TemplateArgs,
2887  TemplateDeductionInfo &Info) {
2888  if (Partial->isInvalidDecl())
2889  return TDK_Invalid;
2890 
2891  // C++ [temp.class.spec.match]p2:
2892  // A partial specialization matches a given actual template
2893  // argument list if the template arguments of the partial
2894  // specialization can be deduced from the actual template argument
2895  // list (14.8.2).
2896 
2897  // Unevaluated SFINAE context.
2900  SFINAETrap Trap(*this);
2901 
2903  Deduced.resize(Partial->getTemplateParameters()->size());
2904  if (TemplateDeductionResult Result
2905  = ::DeduceTemplateArguments(*this,
2906  Partial->getTemplateParameters(),
2907  Partial->getTemplateArgs(),
2908  TemplateArgs, Info, Deduced))
2909  return Result;
2910 
2911  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2912  InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
2913  Info);
2914  if (Inst.isInvalid())
2915  return TDK_InstantiationDepth;
2916 
2917  if (Trap.hasErrorOccurred())
2919 
2921  *this, Partial, /*IsPartialOrdering=*/false, TemplateArgs, Deduced, Info);
2922 }
2923 
2924 /// Perform template argument deduction to determine whether
2925 /// the given template arguments match the given variable template
2926 /// partial specialization per C++ [temp.class.spec.match].
2929  const TemplateArgumentList &TemplateArgs,
2930  TemplateDeductionInfo &Info) {
2931  if (Partial->isInvalidDecl())
2932  return TDK_Invalid;
2933 
2934  // C++ [temp.class.spec.match]p2:
2935  // A partial specialization matches a given actual template
2936  // argument list if the template arguments of the partial
2937  // specialization can be deduced from the actual template argument
2938  // list (14.8.2).
2939 
2940  // Unevaluated SFINAE context.
2943  SFINAETrap Trap(*this);
2944 
2946  Deduced.resize(Partial->getTemplateParameters()->size());
2948  *this, Partial->getTemplateParameters(), Partial->getTemplateArgs(),
2949  TemplateArgs, Info, Deduced))
2950  return Result;
2951 
2952  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2953  InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs,
2954  Info);
2955  if (Inst.isInvalid())
2956  return TDK_InstantiationDepth;
2957 
2958  if (Trap.hasErrorOccurred())
2960 
2962  *this, Partial, /*IsPartialOrdering=*/false, TemplateArgs, Deduced, Info);
2963 }
2964 
2965 /// Determine whether the given type T is a simple-template-id type.
2967  if (const TemplateSpecializationType *Spec
2969  return Spec->getTemplateName().getAsTemplateDecl() != nullptr;
2970 
2971  // C++17 [temp.local]p2:
2972  // the injected-class-name [...] is equivalent to the template-name followed
2973  // by the template-arguments of the class template specialization or partial
2974  // specialization enclosed in <>
2975  // ... which means it's equivalent to a simple-template-id.
2976  //
2977  // This only arises during class template argument deduction for a copy
2978  // deduction candidate, where it permits slicing.
2979  if (T->getAs<InjectedClassNameType>())
2980  return true;
2981 
2982  return false;
2983 }
2984 
2985 /// Substitute the explicitly-provided template arguments into the
2986 /// given function template according to C++ [temp.arg.explicit].
2987 ///
2988 /// \param FunctionTemplate the function template into which the explicit
2989 /// template arguments will be substituted.
2990 ///
2991 /// \param ExplicitTemplateArgs the explicitly-specified template
2992 /// arguments.
2993 ///
2994 /// \param Deduced the deduced template arguments, which will be populated
2995 /// with the converted and checked explicit template arguments.
2996 ///
2997 /// \param ParamTypes will be populated with the instantiated function
2998 /// parameters.
2999 ///
3000 /// \param FunctionType if non-NULL, the result type of the function template
3001 /// will also be instantiated and the pointed-to value will be updated with
3002 /// the instantiated function type.
3003 ///
3004 /// \param Info if substitution fails for any reason, this object will be
3005 /// populated with more information about the failure.
3006 ///
3007 /// \returns TDK_Success if substitution was successful, or some failure
3008 /// condition.
3011  FunctionTemplateDecl *FunctionTemplate,
3012  TemplateArgumentListInfo &ExplicitTemplateArgs,
3014  SmallVectorImpl<QualType> &ParamTypes,
3016  TemplateDeductionInfo &Info) {
3017  FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3018  TemplateParameterList *TemplateParams
3019  = FunctionTemplate->getTemplateParameters();
3020 
3021  if (ExplicitTemplateArgs.size() == 0) {
3022  // No arguments to substitute; just copy over the parameter types and
3023  // fill in the function type.
3024  for (auto P : Function->parameters())
3025  ParamTypes.push_back(P->getType());
3026 
3027  if (FunctionType)
3028  *FunctionType = Function->getType();
3029  return TDK_Success;
3030  }
3031 
3032  // Unevaluated SFINAE context.
3035  SFINAETrap Trap(*this);
3036 
3037  // C++ [temp.arg.explicit]p3:
3038  // Template arguments that are present shall be specified in the
3039  // declaration order of their corresponding template-parameters. The
3040  // template argument list shall not specify more template-arguments than
3041  // there are corresponding template-parameters.
3043 
3044  // Enter a new template instantiation context where we check the
3045  // explicitly-specified template arguments against this function template,
3046  // and then substitute them into the function parameter types.
3048  InstantiatingTemplate Inst(
3049  *this, Info.getLocation(), FunctionTemplate, DeducedArgs,
3050  CodeSynthesisContext::ExplicitTemplateArgumentSubstitution, Info);
3051  if (Inst.isInvalid())
3052  return TDK_InstantiationDepth;
3053 
3054  if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(),
3055  ExplicitTemplateArgs, true, Builder, false) ||
3056  Trap.hasErrorOccurred()) {
3057  unsigned Index = Builder.size();
3058  if (Index >= TemplateParams->size())
3059  return TDK_SubstitutionFailure;
3060  Info.Param = makeTemplateParameter(TemplateParams->getParam(Index));
3061  return TDK_InvalidExplicitArguments;
3062  }
3063 
3064  // Form the template argument list from the explicitly-specified
3065  // template arguments.
3066  TemplateArgumentList *ExplicitArgumentList
3067  = TemplateArgumentList::CreateCopy(Context, Builder);
3068  Info.setExplicitArgs(ExplicitArgumentList);
3069 
3070  // Template argument deduction and the final substitution should be
3071  // done in the context of the templated declaration. Explicit
3072  // argument substitution, on the other hand, needs to happen in the
3073  // calling context.
3074  ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
3075 
3076  // If we deduced template arguments for a template parameter pack,
3077  // note that the template argument pack is partially substituted and record
3078  // the explicit template arguments. They'll be used as part of deduction
3079  // for this template parameter pack.
3080  unsigned PartiallySubstitutedPackIndex = -1u;
3081  if (!Builder.empty()) {
3082  const TemplateArgument &Arg = Builder.back();
3083  if (Arg.getKind() == TemplateArgument::Pack) {
3084  auto *Param = TemplateParams->getParam(Builder.size() - 1);
3085  // If this is a fully-saturated fixed-size pack, it should be
3086  // fully-substituted, not partially-substituted.
3087  Optional<unsigned> Expansions = getExpandedPackSize(Param);
3088  if (!Expansions || Arg.pack_size() < *Expansions) {
3089  PartiallySubstitutedPackIndex = Builder.size() - 1;
3090  CurrentInstantiationScope->SetPartiallySubstitutedPack(
3091  Param, Arg.pack_begin(), Arg.pack_size());
3092  }
3093  }
3094  }
3095 
3096  const FunctionProtoType *Proto
3097  = Function->getType()->getAs<FunctionProtoType>();
3098  assert(Proto && "Function template does not have a prototype?");
3099 
3100  // Isolate our substituted parameters from our caller.
3101  LocalInstantiationScope InstScope(*this, /*MergeWithOuterScope*/true);
3102 
3103  ExtParameterInfoBuilder ExtParamInfos;
3104 
3105  // Instantiate the types of each of the function parameters given the
3106  // explicitly-specified template arguments. If the function has a trailing
3107  // return type, substitute it after the arguments to ensure we substitute
3108  // in lexical order.
3109  if (Proto->hasTrailingReturn()) {
3110  if (SubstParmTypes(Function->getLocation(), Function->parameters(),
3111  Proto->getExtParameterInfosOrNull(),
3112  MultiLevelTemplateArgumentList(*ExplicitArgumentList),
3113  ParamTypes, /*params*/ nullptr, ExtParamInfos))
3114  return TDK_SubstitutionFailure;
3115  }
3116 
3117  // Instantiate the return type.
3118  QualType ResultType;
3119  {
3120  // C++11 [expr.prim.general]p3:
3121  // If a declaration declares a member function or member function
3122  // template of a class X, the expression this is a prvalue of type
3123  // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq
3124  // and the end of the function-definition, member-declarator, or
3125  // declarator.
3126  Qualifiers ThisTypeQuals;
3127  CXXRecordDecl *ThisContext = nullptr;
3128  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
3129  ThisContext = Method->getParent();
3130  ThisTypeQuals = Method->getMethodQualifiers();
3131  }
3132 
3133  CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals,
3134  getLangOpts().CPlusPlus11);
3135 
3136  ResultType =
3137  SubstType(Proto->getReturnType(),
3138  MultiLevelTemplateArgumentList(*ExplicitArgumentList),
3139  Function->getTypeSpecStartLoc(), Function->getDeclName());
3140  if (ResultType.isNull() || Trap.hasErrorOccurred())
3141  return TDK_SubstitutionFailure;
3142  // CUDA: Kernel function must have 'void' return type.
3143  if (getLangOpts().CUDA)
3144  if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->isVoidType()) {
3145  Diag(Function->getLocation(), diag::err_kern_type_not_void_return)
3146  << Function->getType() << Function->getSourceRange();
3147  return TDK_SubstitutionFailure;
3148  }
3149  }
3150 
3151  // Instantiate the types of each of the function parameters given the
3152  // explicitly-specified template arguments if we didn't do so earlier.
3153  if (!Proto->hasTrailingReturn() &&
3154  SubstParmTypes(Function->getLocation(), Function->parameters(),
3155  Proto->getExtParameterInfosOrNull(),
3156  MultiLevelTemplateArgumentList(*ExplicitArgumentList),
3157  ParamTypes, /*params*/ nullptr, ExtParamInfos))
3158  return TDK_SubstitutionFailure;
3159 
3160  if (FunctionType) {
3161  auto EPI = Proto->getExtProtoInfo();
3162  EPI.ExtParameterInfos = ExtParamInfos.getPointerOrNull(ParamTypes.size());
3163 
3164  // In C++1z onwards, exception specifications are part of the function type,
3165  // so substitution into the type must also substitute into the exception
3166  // specification.
3167  SmallVector<QualType, 4> ExceptionStorage;
3168  if (getLangOpts().CPlusPlus17 &&
3169  SubstExceptionSpec(
3170  Function->getLocation(), EPI.ExceptionSpec, ExceptionStorage,
3171  MultiLevelTemplateArgumentList(*ExplicitArgumentList)))
3172  return TDK_SubstitutionFailure;
3173 
3174  *FunctionType = BuildFunctionType(ResultType, ParamTypes,
3175  Function->getLocation(),
3176  Function->getDeclName(),
3177  EPI);
3178  if (FunctionType->isNull() || Trap.hasErrorOccurred())
3179  return TDK_SubstitutionFailure;
3180  }
3181 
3182  // C++ [temp.arg.explicit]p2:
3183  // Trailing template arguments that can be deduced (14.8.2) may be
3184  // omitted from the list of explicit template-arguments. If all of the
3185  // template arguments can be deduced, they may all be omitted; in this
3186  // case, the empty template argument list <> itself may also be omitted.
3187  //
3188  // Take all of the explicitly-specified arguments and put them into
3189  // the set of deduced template arguments. The partially-substituted
3190  // parameter pack, however, will be set to NULL since the deduction
3191  // mechanism handles the partially-substituted argument pack directly.
3192  Deduced.reserve(TemplateParams->size());
3193  for (unsigned I = 0, N = ExplicitArgumentList->size(); I != N; ++I) {
3194  const TemplateArgument &Arg = ExplicitArgumentList->get(I);
3195  if (I == PartiallySubstitutedPackIndex)
3196  Deduced.push_back(DeducedTemplateArgument());
3197  else
3198  Deduced.push_back(Arg);
3199  }
3200 
3201  return TDK_Success;
3202 }
3203 
3204 /// Check whether the deduced argument type for a call to a function
3205 /// template matches the actual argument type per C++ [temp.deduct.call]p4.
3208  Sema::OriginalCallArg OriginalArg,
3209  QualType DeducedA) {
3210  ASTContext &Context = S.Context;
3211 
3212  auto Failed = [&]() -> Sema::TemplateDeductionResult {
3213  Info.FirstArg = TemplateArgument(DeducedA);
3214  Info.SecondArg = TemplateArgument(OriginalArg.OriginalArgType);
3215  Info.CallArgIndex = OriginalArg.ArgIdx;
3218  };
3219 
3220  QualType A = OriginalArg.OriginalArgType;
3221  QualType OriginalParamType = OriginalArg.OriginalParamType;
3222 
3223  // Check for type equality (top-level cv-qualifiers are ignored).
3224  if (Context.hasSameUnqualifiedType(A, DeducedA))
3225  return Sema::TDK_Success;
3226 
3227  // Strip off references on the argument types; they aren't needed for
3228  // the following checks.
3229  if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>())
3230  DeducedA = DeducedARef->getPointeeType();
3231  if (const ReferenceType *ARef = A->getAs<ReferenceType>())
3232  A = ARef->getPointeeType();
3233 
3234  // C++ [temp.deduct.call]p4:
3235  // [...] However, there are three cases that allow a difference:
3236  // - If the original P is a reference type, the deduced A (i.e., the
3237  // type referred to by the reference) can be more cv-qualified than
3238  // the transformed A.
3239  if (const ReferenceType *OriginalParamRef
3240  = OriginalParamType->getAs<ReferenceType>()) {
3241  // We don't want to keep the reference around any more.
3242  OriginalParamType = OriginalParamRef->getPointeeType();
3243 
3244  // FIXME: Resolve core issue (no number yet): if the original P is a
3245  // reference type and the transformed A is function type "noexcept F",
3246  // the deduced A can be F.
3247  QualType Tmp;
3248  if (A->isFunctionType() && S.IsFunctionConversion(A, DeducedA, Tmp))
3249  return Sema::TDK_Success;
3250 
3251  Qualifiers AQuals = A.getQualifiers();
3252  Qualifiers DeducedAQuals = DeducedA.getQualifiers();
3253 
3254  // Under Objective-C++ ARC, the deduced type may have implicitly
3255  // been given strong or (when dealing with a const reference)
3256  // unsafe_unretained lifetime. If so, update the original
3257  // qualifiers to include this lifetime.
3258  if (S.getLangOpts().ObjCAutoRefCount &&
3259  ((DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_Strong &&
3260  AQuals.getObjCLifetime() == Qualifiers::OCL_None) ||
3261  (DeducedAQuals.hasConst() &&
3262  DeducedAQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone))) {
3263  AQuals.setObjCLifetime(DeducedAQuals.getObjCLifetime());
3264  }
3265 
3266  if (AQuals == DeducedAQuals) {
3267  // Qualifiers match; there's nothing to do.
3268  } else if (!DeducedAQuals.compatiblyIncludes(AQuals)) {
3269  return Failed();
3270  } else {
3271  // Qualifiers are compatible, so have the argument type adopt the
3272  // deduced argument type's qualifiers as if we had performed the
3273  // qualification conversion.
3274  A = Context.getQualifiedType(A.getUnqualifiedType(), DeducedAQuals);
3275  }
3276  }
3277 
3278  // - The transformed A can be another pointer or pointer to member
3279  // type that can be converted to the deduced A via a function pointer
3280  // conversion and/or a qualification conversion.
3281  //
3282  // Also allow conversions which merely strip __attribute__((noreturn)) from
3283  // function types (recursively).
3284  bool ObjCLifetimeConversion = false;
3285  QualType ResultTy;
3286  if ((A->isAnyPointerType() || A->isMemberPointerType()) &&
3287  (S.IsQualificationConversion(A, DeducedA, false,
3288  ObjCLifetimeConversion) ||
3289  S.IsFunctionConversion(A, DeducedA, ResultTy)))
3290  return Sema::TDK_Success;
3291 
3292  // - If P is a class and P has the form simple-template-id, then the
3293  // transformed A can be a derived class of the deduced A. [...]
3294  // [...] Likewise, if P is a pointer to a class of the form
3295  // simple-template-id, the transformed A can be a pointer to a
3296  // derived class pointed to by the deduced A.
3297  if (const PointerType *OriginalParamPtr
3298  = OriginalParamType->getAs<PointerType>()) {
3299  if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) {
3300  if (const PointerType *APtr = A->getAs<PointerType>()) {
3301  if (A->getPointeeType()->isRecordType()) {
3302  OriginalParamType = OriginalParamPtr->getPointeeType();
3303  DeducedA = DeducedAPtr->getPointeeType();
3304  A = APtr->getPointeeType();
3305  }
3306  }
3307  }
3308  }
3309 
3310  if (Context.hasSameUnqualifiedType(A, DeducedA))
3311  return Sema::TDK_Success;
3312 
3313  if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) &&
3314  S.IsDerivedFrom(Info.getLocation(), A, DeducedA))
3315  return Sema::TDK_Success;
3316 
3317  return Failed();
3318 }
3319 
3320 /// Find the pack index for a particular parameter index in an instantiation of
3321 /// a function template with specific arguments.
3322 ///
3323 /// \return The pack index for whichever pack produced this parameter, or -1
3324 /// if this was not produced by a parameter. Intended to be used as the
3325 /// ArgumentPackSubstitutionIndex for further substitutions.
3326 // FIXME: We should track this in OriginalCallArgs so we don't need to
3327 // reconstruct it here.
3328 static unsigned getPackIndexForParam(Sema &S,
3329  FunctionTemplateDecl *FunctionTemplate,
3330  const MultiLevelTemplateArgumentList &Args,
3331  unsigned ParamIdx) {
3332  unsigned Idx = 0;
3333  for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) {
3334  if (PD->isParameterPack()) {
3335  unsigned NumExpansions =
3336  S.getNumArgumentsInExpansion(PD->getType(), Args).getValueOr(1);
3337  if (Idx + NumExpansions > ParamIdx)
3338  return ParamIdx - Idx;
3339  Idx += NumExpansions;
3340  } else {
3341  if (Idx == ParamIdx)
3342  return -1; // Not a pack expansion
3343  ++Idx;
3344  }
3345  }
3346 
3347  llvm_unreachable("parameter index would not be produced from template");
3348 }
3349 
3350 /// Finish template argument deduction for a function template,
3351 /// checking the deduced template arguments for completeness and forming
3352 /// the function template specialization.
3353 ///
3354 /// \param OriginalCallArgs If non-NULL, the original call arguments against
3355 /// which the deduced argument types should be compared.
3357  FunctionTemplateDecl *FunctionTemplate,
3359  unsigned NumExplicitlySpecified, FunctionDecl *&Specialization,
3360  TemplateDeductionInfo &Info,
3361  SmallVectorImpl<OriginalCallArg> const *OriginalCallArgs,
3362  bool PartialOverloading, llvm::function_ref<bool()> CheckNonDependent) {
3363  // Unevaluated SFINAE context.
3366  SFINAETrap Trap(*this);
3367 
3368  // Enter a new template instantiation context while we instantiate the
3369  // actual function declaration.
3370  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
3371  InstantiatingTemplate Inst(
3372  *this, Info.getLocation(), FunctionTemplate, DeducedArgs,
3373  CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
3374  if (Inst.isInvalid())
3375  return TDK_InstantiationDepth;
3376 
3377  ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl());
3378 
3379  // C++ [temp.deduct.type]p2:
3380  // [...] or if any template argument remains neither deduced nor
3381  // explicitly specified, template argument deduction fails.
3383  if (auto Result = ConvertDeducedTemplateArguments(
3384  *this, FunctionTemplate, /*IsDeduced*/true, Deduced, Info, Builder,
3385  CurrentInstantiationScope, NumExplicitlySpecified,
3386  PartialOverloading))
3387  return Result;
3388 
3389  // C++ [temp.deduct.call]p10: [DR1391]
3390  // If deduction succeeds for all parameters that contain
3391  // template-parameters that participate in template argument deduction,
3392  // and all template arguments are explicitly specified, deduced, or
3393  // obtained from default template arguments, remaining parameters are then
3394  // compared with the corresponding arguments. For each remaining parameter
3395  // P with a type that was non-dependent before substitution of any
3396  // explicitly-specified template arguments, if the corresponding argument
3397  // A cannot be implicitly converted to P, deduction fails.
3398  if (CheckNonDependent())
3399  return TDK_NonDependentConversionFailure;
3400 
3401  // Form the template argument list from the deduced template arguments.
3402  TemplateArgumentList *DeducedArgumentList
3403  = TemplateArgumentList::CreateCopy(Context, Builder);
3404  Info.reset(DeducedArgumentList);
3405 
3406  // Substitute the deduced template arguments into the function template
3407  // declaration to produce the function template specialization.
3408  DeclContext *Owner = FunctionTemplate->getDeclContext();
3409  if (FunctionTemplate->getFriendObjectKind())
3410  Owner = FunctionTemplate->getLexicalDeclContext();
3411  MultiLevelTemplateArgumentList SubstArgs(*DeducedArgumentList);
3412  Specialization = cast_or_null<FunctionDecl>(
3413  SubstDecl(FunctionTemplate->getTemplatedDecl(), Owner, SubstArgs));
3414  if (!Specialization || Specialization->isInvalidDecl())
3415  return TDK_SubstitutionFailure;
3416 
3417  assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() ==
3418  FunctionTemplate->getCanonicalDecl());
3419 
3420  // If the template argument list is owned by the function template
3421  // specialization, release it.
3422  if (Specialization->getTemplateSpecializationArgs() == DeducedArgumentList &&
3423  !Trap.hasErrorOccurred())
3424  Info.take();
3425 
3426  // There may have been an error that did not prevent us from constructing a
3427  // declaration. Mark the declaration invalid and return with a substitution
3428  // failure.
3429  if (Trap.hasErrorOccurred()) {
3430  Specialization->setInvalidDecl(true);
3431  return TDK_SubstitutionFailure;
3432  }
3433 
3434  // C++2a [temp.deduct]p5
3435  // [...] When all template arguments have been deduced [...] all uses of
3436  // template parameters [...] are replaced with the corresponding deduced
3437  // or default argument values.
3438  // [...] If the function template has associated constraints
3439  // ([temp.constr.decl]), those constraints are checked for satisfaction
3440  // ([temp.constr.constr]). If the constraints are not satisfied, type
3441  // deduction fails.
3442  if (!PartialOverloading ||
3443  (Builder.size() == FunctionTemplate->getTemplateParameters()->size())) {
3444  if (CheckInstantiatedFunctionTemplateConstraints(Info.getLocation(),
3445  Specialization, Builder, Info.AssociatedConstraintsSatisfaction))
3446  return TDK_MiscellaneousDeductionFailure;
3447 
3449  Info.reset(TemplateArgumentList::CreateCopy(Context, Builder));
3450  return TDK_ConstraintsNotSatisfied;
3451  }
3452  }
3453 
3454  if (OriginalCallArgs) {
3455  // C++ [temp.deduct.call]p4:
3456  // In general, the deduction process attempts to find template argument
3457  // values that will make the deduced A identical to A (after the type A
3458  // is transformed as described above). [...]
3459  llvm::SmallDenseMap<std::pair<unsigned, QualType>, QualType> DeducedATypes;
3460  for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) {
3461  OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
3462 
3463  auto ParamIdx = OriginalArg.ArgIdx;
3464  if (ParamIdx >= Specialization->getNumParams())
3465  // FIXME: This presumably means a pack ended up smaller than we
3466  // expected while deducing. Should this not result in deduction
3467  // failure? Can it even happen?
3468  continue;
3469 
3470  QualType DeducedA;
3471  if (!OriginalArg.DecomposedParam) {
3472  // P is one of the function parameters, just look up its substituted
3473  // type.
3474  DeducedA = Specialization->getParamDecl(ParamIdx)->getType();
3475  } else {
3476  // P is a decomposed element of a parameter corresponding to a
3477  // braced-init-list argument. Substitute back into P to find the
3478  // deduced A.
3479  QualType &CacheEntry =
3480  DeducedATypes[{ParamIdx, OriginalArg.OriginalParamType}];
3481  if (CacheEntry.isNull()) {
3483  *this, getPackIndexForParam(*this, FunctionTemplate, SubstArgs,
3484  ParamIdx));
3485  CacheEntry =
3486  SubstType(OriginalArg.OriginalParamType, SubstArgs,
3487  Specialization->getTypeSpecStartLoc(),
3488  Specialization->getDeclName());
3489  }
3490  DeducedA = CacheEntry;
3491  }
3492 
3493  if (auto TDK =
3494  CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA))
3495  return TDK;
3496  }
3497  }
3498 
3499  // If we suppressed any diagnostics while performing template argument
3500  // deduction, and if we haven't already instantiated this declaration,
3501  // keep track of these diagnostics. They'll be emitted if this specialization
3502  // is actually used.
3503  if (Info.diag_begin() != Info.diag_end()) {
3504  SuppressedDiagnosticsMap::iterator
3505  Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl());
3506  if (Pos == SuppressedDiagnostics.end())
3507  SuppressedDiagnostics[Specialization->getCanonicalDecl()]
3508  .append(Info.diag_begin(), Info.diag_end());
3509  }
3510 
3511  return TDK_Success;
3512 }
3513 
3514 /// Gets the type of a function for template-argument-deducton
3515 /// purposes when it's considered as part of an overload set.
3517  FunctionDecl *Fn) {
3518  // We may need to deduce the return type of the function now.
3519  if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
3520  S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false))
3521  return {};
3522 
3523  if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
3524  if (Method->isInstance()) {
3525  // An instance method that's referenced in a form that doesn't
3526  // look like a member pointer is just invalid.
3527  if (!R.HasFormOfMemberPointer)
3528  return {};
3529 
3530  return S.Context.getMemberPointerType(Fn->getType(),
3531  S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
3532  }
3533 
3534  if (!R.IsAddressOfOperand) return Fn->getType();
3535  return S.Context.getPointerType(Fn->getType());
3536 }
3537 
3538 /// Apply the deduction rules for overload sets.
3539 ///
3540 /// \return the null type if this argument should be treated as an
3541 /// undeduced context
3542 static QualType
3544  Expr *Arg, QualType ParamType,
3545  bool ParamWasReference) {
3546 
3548 
3549  OverloadExpr *Ovl = R.Expression;
3550 
3551  // C++0x [temp.deduct.call]p4
3552  unsigned TDF = 0;
3553  if (ParamWasReference)
3555  if (R.IsAddressOfOperand)
3556  TDF |= TDF_IgnoreQualifiers;
3557 
3558  // C++0x [temp.deduct.call]p6:
3559  // When P is a function type, pointer to function type, or pointer
3560  // to member function type:
3561 
3562  if (!ParamType->isFunctionType() &&
3563  !ParamType->isFunctionPointerType() &&
3564  !ParamType->isMemberFunctionPointerType()) {
3565  if (Ovl->hasExplicitTemplateArgs()) {
3566  // But we can still look for an explicit specialization.
3567  if (FunctionDecl *ExplicitSpec
3569  return GetTypeOfFunction(S, R, ExplicitSpec);
3570  }
3571 
3572  DeclAccessPair DAP;
3573  if (FunctionDecl *Viable =
3575  return GetTypeOfFunction(S, R, Viable);
3576 
3577  return {};
3578  }
3579 
3580  // Gather the explicit template arguments, if any.
3581  TemplateArgumentListInfo ExplicitTemplateArgs;
3582  if (Ovl->hasExplicitTemplateArgs())
3583  Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
3584  QualType Match;
3585  for (UnresolvedSetIterator I = Ovl->decls_begin(),
3586  E = Ovl->decls_end(); I != E; ++I) {
3587  NamedDecl *D = (*I)->getUnderlyingDecl();
3588 
3589  if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D)) {
3590  // - If the argument is an overload set containing one or more
3591  // function templates, the parameter is treated as a
3592  // non-deduced context.
3593  if (!Ovl->hasExplicitTemplateArgs())
3594  return {};
3595 
3596  // Otherwise, see if we can resolve a function type
3597  FunctionDecl *Specialization = nullptr;
3598  TemplateDeductionInfo Info(Ovl->getNameLoc());
3599  if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs,
3600  Specialization, Info))
3601  continue;
3602 
3603  D = Specialization;
3604  }
3605 
3606  FunctionDecl *Fn = cast<FunctionDecl>(D);
3607  QualType ArgType = GetTypeOfFunction(S, R, Fn);
3608  if (ArgType.isNull()) continue;
3609 
3610  // Function-to-pointer conversion.
3611  if (!ParamWasReference && ParamType->isPointerType() &&
3612  ArgType->isFunctionType())
3613  ArgType = S.Context.getPointerType(ArgType);
3614 
3615  // - If the argument is an overload set (not containing function
3616  // templates), trial argument deduction is attempted using each
3617  // of the members of the set. If deduction succeeds for only one
3618  // of the overload set members, that member is used as the
3619  // argument value for the deduction. If deduction succeeds for
3620  // more than one member of the overload set the parameter is
3621  // treated as a non-deduced context.
3622 
3623  // We do all of this in a fresh context per C++0x [temp.deduct.type]p2:
3624  // Type deduction is done independently for each P/A pair, and
3625  // the deduced template argument values are then combined.
3626  // So we do not reject deductions which were made elsewhere.
3628  Deduced(TemplateParams->size());
3629  TemplateDeductionInfo Info(Ovl->getNameLoc());
3631  = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
3632  ArgType, Info, Deduced, TDF);
3633  if (Result) continue;
3634  if (!Match.isNull())
3635  return {};
3636  Match = ArgType;
3637  }
3638 
3639  return Match;
3640 }
3641 
3642 /// Perform the adjustments to the parameter and argument types
3643 /// described in C++ [temp.deduct.call].
3644 ///
3645 /// \returns true if the caller should not attempt to perform any template
3646 /// argument deduction based on this P/A pair because the argument is an
3647 /// overloaded function set that could not be resolved.
3649  Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
3650  QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF) {
3651  // C++0x [temp.deduct.call]p3:
3652  // If P is a cv-qualified type, the top level cv-qualifiers of P's type
3653  // are ignored for type deduction.
3654  if (ParamType.hasQualifiers())
3655  ParamType = ParamType.getUnqualifiedType();
3656 
3657  // [...] If P is a reference type, the type referred to by P is
3658  // used for type deduction.
3659  const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>();
3660  if (ParamRefType)
3661  ParamType = ParamRefType->getPointeeType();
3662 
3663  // Overload sets usually make this parameter an undeduced context,
3664  // but there are sometimes special circumstances. Typically
3665  // involving a template-id-expr.
3666  if (ArgType == S.Context.OverloadTy) {
3667  ArgType = ResolveOverloadForDeduction(S, TemplateParams,
3668  Arg, ParamType,
3669  ParamRefType != nullptr);
3670  if (ArgType.isNull())
3671  return true;
3672  }
3673 
3674  if (ParamRefType) {
3675  // If the argument has incomplete array type, try to complete its type.
3676  if (ArgType->isIncompleteArrayType()) {
3677  S.completeExprArrayBound(Arg);
3678  ArgType = Arg->getType();
3679  }
3680 
3681  // C++1z [temp.deduct.call]p3:
3682  // If P is a forwarding reference and the argument is an lvalue, the type
3683  // "lvalue reference to A" is used in place of A for type deduction.
3684  if (isForwardingReference(QualType(ParamRefType, 0), FirstInnerIndex) &&
3685  Arg->isLValue())
3686  ArgType = S.Context.getLValueReferenceType(ArgType);
3687  } else {
3688  // C++ [temp.deduct.call]p2:
3689  // If P is not a reference type:
3690  // - If A is an array type, the pointer type produced by the
3691  // array-to-pointer standard conversion (4.2) is used in place of
3692  // A for type deduction; otherwise,
3693  if (ArgType->isArrayType())
3694  ArgType = S.Context.getArrayDecayedType(ArgType);
3695  // - If A is a function type, the pointer type produced by the
3696  // function-to-pointer standard conversion (4.3) is used in place
3697  // of A for type deduction; otherwise,
3698  else if (ArgType->isFunctionType())
3699  ArgType = S.Context.getPointerType(ArgType);
3700  else {
3701  // - If A is a cv-qualified type, the top level cv-qualifiers of A's
3702  // type are ignored for type deduction.
3703  ArgType = ArgType.getUnqualifiedType();
3704  }
3705  }
3706 
3707  // C++0x [temp.deduct.call]p4:
3708  // In general, the deduction process attempts to find template argument
3709  // values that will make the deduced A identical to A (after the type A
3710  // is transformed as described above). [...]
3711  TDF = TDF_SkipNonDependent;
3712 
3713  // - If the original P is a reference type, the deduced A (i.e., the
3714  // type referred to by the reference) can be more cv-qualified than
3715  // the transformed A.
3716  if (ParamRefType)
3718  // - The transformed A can be another pointer or pointer to member
3719  // type that can be converted to the deduced A via a qualification
3720  // conversion (4.4).
3721  if (ArgType->isPointerType() || ArgType->isMemberPointerType() ||
3722  ArgType->isObjCObjectPointerType())
3723  TDF |= TDF_IgnoreQualifiers;
3724  // - If P is a class and P has the form simple-template-id, then the
3725  // transformed A can be a derived class of the deduced A. Likewise,
3726  // if P is a pointer to a class of the form simple-template-id, the
3727  // transformed A can be a pointer to a derived class pointed to by
3728  // the deduced A.
3729  if (isSimpleTemplateIdType(ParamType) ||
3730  (isa<PointerType>(ParamType) &&
3732  ParamType->getAs<PointerType>()->getPointeeType())))
3733  TDF |= TDF_DerivedClass;
3734 
3735  return false;
3736 }
3737 
3738 static bool
3740  QualType T);
3741 
3743  Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
3744  QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
3745  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3746  SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
3747  bool DecomposedParam, unsigned ArgIdx, unsigned TDF);
3748 
3749 /// Attempt template argument deduction from an initializer list
3750 /// deemed to be an argument in a function call.
3752  Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType,
3753  InitListExpr *ILE, TemplateDeductionInfo &Info,
3754  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3755  SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs, unsigned ArgIdx,
3756  unsigned TDF) {
3757  // C++ [temp.deduct.call]p1: (CWG 1591)
3758  // If removing references and cv-qualifiers from P gives
3759  // std::initializer_list<P0> or P0[N] for some P0 and N and the argument is
3760  // a non-empty initializer list, then deduction is performed instead for
3761  // each element of the initializer list, taking P0 as a function template
3762  // parameter type and the initializer element as its argument
3763  //
3764  // We've already removed references and cv-qualifiers here.
3765  if (!ILE->getNumInits())
3766  return Sema::TDK_Success;
3767 
3768  QualType ElTy;
3769  auto *ArrTy = S.Context.getAsArrayType(AdjustedParamType);
3770  if (ArrTy)
3771  ElTy = ArrTy->getElementType();
3772  else if (!S.isStdInitializerList(AdjustedParamType, &ElTy)) {
3773  // Otherwise, an initializer list argument causes the parameter to be
3774  // considered a non-deduced context
3775  return Sema::TDK_Success;
3776  }
3777 
3778  // Resolving a core issue: a braced-init-list containing any designators is
3779  // a non-deduced context.
3780  for (Expr *E : ILE->inits())
3781  if (isa<DesignatedInitExpr>(E))
3782  return Sema::TDK_Success;
3783 
3784  // Deduction only needs to be done for dependent types.
3785  if (ElTy->isDependentType()) {
3786  for (Expr *E : ILE->inits()) {
3787  if (auto Result = DeduceTemplateArgumentsFromCallArgument(
3788  S, TemplateParams, 0, ElTy, E, Info, Deduced, OriginalCallArgs, true,
3789  ArgIdx, TDF))
3790  return Result;
3791  }
3792  }
3793 
3794  // in the P0[N] case, if N is a non-type template parameter, N is deduced
3795  // from the length of the initializer list.
3796  if (auto *DependentArrTy = dyn_cast_or_null<DependentSizedArrayType>(ArrTy)) {
3797  // Determine the array bound is something we can deduce.
3798  if (NonTypeTemplateParmDecl *NTTP =
3799  getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) {
3800  // We can perform template argument deduction for the given non-type
3801  // template parameter.
3802  // C++ [temp.deduct.type]p13:
3803  // The type of N in the type T[N] is std::size_t.
3804  QualType T = S.Context.getSizeType();
3805  llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits());
3806  if (auto Result = DeduceNonTypeTemplateArgument(
3807  S, TemplateParams, NTTP, llvm::APSInt(Size), T,
3808  /*ArrayBound=*/true, Info, Deduced))
3809  return Result;
3810  }
3811  }
3812 
3813  return Sema::TDK_Success;
3814 }
3815 
3816 /// Perform template argument deduction per [temp.deduct.call] for a
3817 /// single parameter / argument pair.
3819  Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex,
3820  QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info,
3821  SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3822  SmallVectorImpl<Sema::OriginalCallArg> &OriginalCallArgs,
3823  bool DecomposedParam, unsigned ArgIdx, unsigned TDF) {
3824  QualType ArgType = Arg->getType();
3825  QualType OrigParamType = ParamType;
3826 
3827  // If P is a reference type [...]
3828  // If P is a cv-qualified type [...]
3830  S, TemplateParams, FirstInnerIndex, ParamType, ArgType, Arg, TDF))
3831  return Sema::TDK_Success;
3832 
3833  // If [...] the argument is a non-empty initializer list [...]
3834  if (InitListExpr *ILE = dyn_cast<InitListExpr>(Arg))
3835  return DeduceFromInitializerList(S, TemplateParams, ParamType, ILE, Info,
3836  Deduced, OriginalCallArgs, ArgIdx, TDF);
3837 
3838  // [...] the deduction process attempts to find template argument values
3839  // that will make the deduced A identical to A
3840  //
3841  // Keep track of the argument type and corresponding parameter index,
3842  // so we can check for compatibility between the deduced A and A.
3843  OriginalCallArgs.push_back(
3844  Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType));
3845  return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
3846  ArgType, Info, Deduced, TDF);
3847 }
3848 
3849 /// Perform template argument deduction from a function call
3850 /// (C++ [temp.deduct.call]).
3851 ///
3852 /// \param FunctionTemplate the function template for which we are performing
3853 /// template argument deduction.
3854 ///
3855 /// \param ExplicitTemplateArgs the explicit template arguments provided
3856 /// for this call.
3857 ///
3858 /// \param Args the function call arguments
3859 ///
3860 /// \param Specialization if template argument deduction was successful,
3861 /// this will be set to the function template specialization produced by
3862 /// template argument deduction.
3863 ///
3864 /// \param Info the argument will be updated to provide additional information
3865 /// about template argument deduction.
3866 ///
3867 /// \param CheckNonDependent A callback to invoke to check conversions for
3868 /// non-dependent parameters, between deduction and substitution, per DR1391.
3869 /// If this returns true, substitution will be skipped and we return
3870 /// TDK_NonDependentConversionFailure. The callback is passed the parameter
3871 /// types (after substituting explicit template arguments).
3872 ///
3873 /// \returns the result of template argument deduction.
3875  FunctionTemplateDecl *FunctionTemplate,
3876  TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
3877  FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
3878  bool PartialOverloading,
3879  llvm::function_ref<bool(ArrayRef<QualType>)> CheckNonDependent) {
3880  if (FunctionTemplate->isInvalidDecl())
3881  return TDK_Invalid;
3882 
3883  FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
3884  unsigned NumParams = Function->getNumParams();
3885 
3886  unsigned FirstInnerIndex = getFirstInnerIndex(FunctionTemplate);
3887 
3888  // C++ [temp.deduct.call]p1:
3889  // Template argument deduction is done by comparing each function template
3890  // parameter type (call it P) with the type of the corresponding argument
3891  // of the call (call it A) as described below.
3892  if (Args.size() < Function->getMinRequiredArguments() && !PartialOverloading)
3893  return TDK_TooFewArguments;
3894  else if (TooManyArguments(NumParams, Args.size(), PartialOverloading)) {
3895  const auto *Proto = Function->getType()->castAs<FunctionProtoType>();
3896  if (Proto->isTemplateVariadic())
3897  /* Do nothing */;
3898  else if (!Proto->isVariadic())
3899  return TDK_TooManyArguments;
3900  }
3901 
3902  // The types of the parameters from which we will perform template argument
3903  // deduction.
3904  LocalInstantiationScope InstScope(*this);
3905  TemplateParameterList *TemplateParams
3906  = FunctionTemplate->getTemplateParameters();
3908  SmallVector<QualType, 8> ParamTypes;
3909  unsigned NumExplicitlySpecified = 0;
3910  if (ExplicitTemplateArgs) {
3911  TemplateDeductionResult Result =
3912  SubstituteExplicitTemplateArguments(FunctionTemplate,
3913  *ExplicitTemplateArgs,
3914  Deduced,
3915  ParamTypes,
3916  nullptr,
3917  Info);
3918  if (Result)
3919  return Result;
3920 
3921  NumExplicitlySpecified = Deduced.size();
3922  } else {
3923  // Just fill in the parameter types from the function declaration.
3924  for (unsigned I = 0; I != NumParams; ++I)
3925  ParamTypes.push_back(Function->getParamDecl(I)->getType());
3926  }
3927 
3928  SmallVector<OriginalCallArg, 8> OriginalCallArgs;
3929 
3930  // Deduce an argument of type ParamType from an expression with index ArgIdx.
3931  auto DeduceCallArgument = [&](QualType ParamType, unsigned ArgIdx) {
3932  // C++ [demp.deduct.call]p1: (DR1391)
3933  // Template argument deduction is done by comparing each function template
3934  // parameter that contains template-parameters that participate in
3935  // template argument deduction ...
3936  if (!hasDeducibleTemplateParameters(*this, FunctionTemplate, ParamType))
3937  return Sema::TDK_Success;
3938 
3939  // ... with the type of the corresponding argument
3941  *this, TemplateParams, FirstInnerIndex, ParamType, Args[ArgIdx], Info, Deduced,
3942  OriginalCallArgs, /*Decomposed*/false, ArgIdx, /*TDF*/ 0);
3943  };
3944 
3945  // Deduce template arguments from the function parameters.
3946  Deduced.resize(TemplateParams->size());
3947  SmallVector<QualType, 8> ParamTypesForArgChecking;
3948  for (unsigned ParamIdx = 0, NumParamTypes = ParamTypes.size(), ArgIdx = 0;
3949  ParamIdx != NumParamTypes; ++ParamIdx) {
3950  QualType ParamType = ParamTypes[ParamIdx];
3951 
3952  const PackExpansionType *ParamExpansion =
3953  dyn_cast<PackExpansionType>(ParamType);
3954  if (!ParamExpansion) {
3955  // Simple case: matching a function parameter to a function argument.
3956  if (ArgIdx >= Args.size())
3957  break;
3958 
3959  ParamTypesForArgChecking.push_back(ParamType);
3960  if (auto Result = DeduceCallArgument(ParamType, ArgIdx++))
3961  return Result;
3962 
3963  continue;
3964  }
3965 
3966  QualType ParamPattern = ParamExpansion->getPattern();
3967  PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info,
3968  ParamPattern);
3969 
3970  // C++0x [temp.deduct.call]p1:
3971  // For a function parameter pack that occurs at the end of the
3972  // parameter-declaration-list, the type A of each remaining argument of
3973  // the call is compared with the type P of the declarator-id of the
3974  // function parameter pack. Each comparison deduces template arguments
3975  // for subsequent positions in the template parameter packs expanded by
3976  // the function parameter pack. When a function parameter pack appears
3977  // in a non-deduced context [not at the end of the list], the type of
3978  // that parameter pack is never deduced.
3979  //
3980  // FIXME: The above rule allows the size of the parameter pack to change
3981  // after we skip it (in the non-deduced case). That makes no sense, so
3982  // we instead notionally deduce the pack against N arguments, where N is
3983  // the length of the explicitly-specified pack if it's expanded by the
3984  // parameter pack and 0 otherwise, and we treat each deduction as a
3985  // non-deduced context.
3986  if (ParamIdx + 1 == NumParamTypes || PackScope.hasFixedArity()) {
3987  for (; ArgIdx < Args.size() && PackScope.hasNextElement();
3988  PackScope.nextPackElement(), ++ArgIdx) {
3989  ParamTypesForArgChecking.push_back(ParamPattern);
3990  if (auto Result = DeduceCallArgument(ParamPattern, ArgIdx))
3991  return Result;
3992  }
3993  } else {
3994  // If the parameter type contains an explicitly-specified pack that we
3995  // could not expand, skip the number of parameters notionally created
3996  // by the expansion.
3997  Optional<unsigned> NumExpansions = ParamExpansion->getNumExpansions();
3998  if (NumExpansions && !PackScope.isPartiallyExpanded()) {
3999  for (unsigned I = 0; I != *NumExpansions && ArgIdx < Args.size();
4000  ++I, ++ArgIdx) {
4001  ParamTypesForArgChecking.push_back(ParamPattern);
4002  // FIXME: Should we add OriginalCallArgs for these? What if the
4003  // corresponding argument is a list?
4004  PackScope.nextPackElement();
4005  }
4006  }
4007  }
4008 
4009  // Build argument packs for each of the parameter packs expanded by this
4010  // pack expansion.
4011  if (auto Result = PackScope.finish())
4012  return Result;
4013  }
4014 
4015  // Capture the context in which the function call is made. This is the context
4016  // that is needed when the accessibility of template arguments is checked.
4017  DeclContext *CallingCtx = CurContext;
4018 
4020  FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info,
4021  &OriginalCallArgs, PartialOverloading, [&, CallingCtx]() {
4022  ContextRAII SavedContext(*this, CallingCtx);
4023  return CheckNonDependent(ParamTypesForArgChecking);
4024  });
4025 }
4026 
4029  bool AdjustExceptionSpec) {
4030  if (ArgFunctionType.isNull())
4031  return ArgFunctionType;
4032 
4033  const auto *FunctionTypeP = FunctionType->castAs<FunctionProtoType>();
4034  const auto *ArgFunctionTypeP = ArgFunctionType->castAs<FunctionProtoType>();
4035  FunctionProtoType::ExtProtoInfo EPI = ArgFunctionTypeP->getExtProtoInfo();
4036  bool Rebuild = false;
4037 
4038  CallingConv CC = FunctionTypeP->getCallConv();
4039  if (EPI.ExtInfo.getCC() != CC) {
4040  EPI.ExtInfo = EPI.ExtInfo.withCallingConv(CC);
4041  Rebuild = true;
4042  }
4043 
4044  bool NoReturn = FunctionTypeP->getNoReturnAttr();
4045  if (EPI.ExtInfo.getNoReturn() != NoReturn) {
4046  EPI.ExtInfo = EPI.ExtInfo.withNoReturn(NoReturn);
4047  Rebuild = true;
4048  }
4049 
4050  if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() ||
4051  ArgFunctionTypeP->hasExceptionSpec())) {
4052  EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec;
4053  Rebuild = true;
4054  }
4055 
4056  if (!Rebuild)
4057  return ArgFunctionType;
4058 
4059  return Context.getFunctionType(ArgFunctionTypeP->getReturnType(),
4060  ArgFunctionTypeP->getParamTypes(), EPI);
4061 }
4062 
4063 /// Deduce template arguments when taking the address of a function
4064 /// template (C++ [temp.deduct.funcaddr]) or matching a specialization to
4065 /// a template.
4066 ///
4067 /// \param FunctionTemplate the function template for which we are performing
4068 /// template argument deduction.
4069 ///
4070 /// \param ExplicitTemplateArgs the explicitly-specified template
4071 /// arguments.
4072 ///
4073 /// \param ArgFunctionType the function type that will be used as the
4074 /// "argument" type (A) when performing template argument deduction from the
4075 /// function template's function type. This type may be NULL, if there is no
4076 /// argument type to compare against, in C++0x [temp.arg.explicit]p3.
4077 ///
4078 /// \param Specialization if template argument deduction was successful,
4079 /// this will be set to the function template specialization produced by
4080 /// template argument deduction.
4081 ///
4082 /// \param Info the argument will be updated to provide additional information
4083 /// about template argument deduction.
4084 ///
4085 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking
4086 /// the address of a function template per [temp.deduct.funcaddr] and
4087 /// [over.over]. If \c false, we are looking up a function template
4088 /// specialization based on its signature, per [temp.deduct.decl].
4089 ///
4090 /// \returns the result of template argument deduction.
4092  FunctionTemplateDecl *FunctionTemplate,
4093  TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ArgFunctionType,
4094  FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
4095  bool IsAddressOfFunction) {
4096  if (FunctionTemplate->isInvalidDecl())
4097  return TDK_Invalid;
4098 
4099  FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
4100  TemplateParameterList *TemplateParams
4101  = FunctionTemplate->getTemplateParameters();
4102  QualType FunctionType = Function->getType();
4103 
4104  // Substitute any explicit template arguments.
4105  LocalInstantiationScope InstScope(*this);
4107  unsigned NumExplicitlySpecified = 0;
4108  SmallVector<QualType, 4> ParamTypes;
4109  if (ExplicitTemplateArgs) {
4110  if (TemplateDeductionResult Result
4111  = SubstituteExplicitTemplateArguments(FunctionTemplate,
4112  *ExplicitTemplateArgs,
4113  Deduced, ParamTypes,
4114  &FunctionType, Info))
4115  return Result;
4116 
4117  NumExplicitlySpecified = Deduced.size();
4118  }
4119 
4120  // When taking the address of a function, we require convertibility of
4121  // the resulting function type. Otherwise, we allow arbitrary mismatches
4122  // of calling convention and noreturn.
4123  if (!IsAddressOfFunction)
4124  ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, FunctionType,
4125  /*AdjustExceptionSpec*/false);
4126 
4127  // Unevaluated SFINAE context.
4130  SFINAETrap Trap(*this);
4131 
4132  Deduced.resize(TemplateParams->size());
4133 
4134  // If the function has a deduced return type, substitute it for a dependent
4135  // type so that we treat it as a non-deduced context in what follows. If we
4136  // are looking up by signature, the signature type should also have a deduced
4137  // return type, which we instead expect to exactly match.
4138  bool HasDeducedReturnType = false;
4139  if (getLangOpts().CPlusPlus14 && IsAddressOfFunction &&
4140  Function->getReturnType()->getContainedAutoType()) {
4141  FunctionType = SubstAutoType(FunctionType, Context.DependentTy);
4142  HasDeducedReturnType = true;
4143  }
4144 
4145  if (!ArgFunctionType.isNull()) {
4146  unsigned TDF =
4148  // Deduce template arguments from the function type.
4149  if (TemplateDeductionResult Result
4150  = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
4151  FunctionType, ArgFunctionType,
4152  Info, Deduced, TDF))
4153  return Result;
4154  }
4155 
4156  if (TemplateDeductionResult Result
4157  = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
4158  NumExplicitlySpecified,
4159  Specialization, Info))
4160  return Result;
4161 
4162  // If the function has a deduced return type, deduce it now, so we can check
4163  // that the deduced function type matches the requested type.
4164  if (HasDeducedReturnType &&
4165  Specialization->getReturnType()->isUndeducedType() &&
4166  DeduceReturnType(Specialization, Info.getLocation(), false))
4167  return TDK_MiscellaneousDeductionFailure;
4168 
4169  // If the function has a dependent exception specification, resolve it now,
4170  // so we can check that the exception specification matches.
4171  auto *SpecializationFPT =
4172  Specialization->getType()->castAs<FunctionProtoType>();
4173  if (getLangOpts().CPlusPlus17 &&
4174  isUnresolvedExceptionSpec(SpecializationFPT->getExceptionSpecType()) &&
4175  !ResolveExceptionSpec(Info.getLocation(), SpecializationFPT))
4176  return TDK_MiscellaneousDeductionFailure;
4177 
4178  // Adjust the exception specification of the argument to match the
4179  // substituted and resolved type we just formed. (Calling convention and
4180  // noreturn can't be dependent, so we don't actually need this for them
4181  // right now.)
4182  QualType SpecializationType = Specialization->getType();
4183  if (!IsAddressOfFunction)
4184  ArgFunctionType = adjustCCAndNoReturn(ArgFunctionType, SpecializationType,
4185  /*AdjustExceptionSpec*/true);
4186 
4187  // If the requested function type does not match the actual type of the
4188  // specialization with respect to arguments of compatible pointer to function
4189  // types, template argument deduction fails.
4190  if (!ArgFunctionType.isNull()) {
4191  if (IsAddressOfFunction &&
4192  !isSameOrCompatibleFunctionType(
4193  Context.getCanonicalType(SpecializationType),
4194  Context.getCanonicalType(ArgFunctionType)))
4195  return TDK_MiscellaneousDeductionFailure;
4196 
4197  if (!IsAddressOfFunction &&
4198  !Context.hasSameType(SpecializationType, ArgFunctionType))
4199  return TDK_MiscellaneousDeductionFailure;
4200  }
4201 
4202  return TDK_Success;
4203 }
4204 
4205 /// Deduce template arguments for a templated conversion
4206 /// function (C++ [temp.deduct.conv]) and, if successful, produce a
4207 /// conversion function template specialization.
4210  QualType ToType,
4211  CXXConversionDecl *&Specialization,
4212  TemplateDeductionInfo &Info) {
4213  if (ConversionTemplate->isInvalidDecl())
4214  return TDK_Invalid;
4215 
4216  CXXConversionDecl *ConversionGeneric
4217  = cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl());
4218 
4219  QualType FromType = ConversionGeneric->getConversionType();
4220 
4221  // Canonicalize the types for deduction.
4222  QualType P = Context.getCanonicalType(FromType);
4223  QualType A = Context.getCanonicalType(ToType);
4224 
4225  // C++0x [temp.deduct.conv]p2:
4226  // If P is a reference type, the type referred to by P is used for
4227  // type deduction.
4228  if (const ReferenceType *PRef = P->getAs<ReferenceType>())
4229  P = PRef->getPointeeType();
4230 
4231  // C++0x [temp.deduct.conv]p4:
4232  // [...] If A is a reference type, the type referred to by A is used
4233  // for type deduction.
4234  if (const ReferenceType *ARef = A->getAs<ReferenceType>()) {
4235  A = ARef->getPointeeType();
4236  // We work around a defect in the standard here: cv-qualifiers are also
4237  // removed from P and A in this case, unless P was a reference type. This
4238  // seems to mostly match what other compilers are doing.
4239  if (!FromType->getAs<ReferenceType>()) {
4240  A = A.getUnqualifiedType();
4241  P = P.getUnqualifiedType();
4242  }
4243 
4244  // C++ [temp.deduct.conv]p3:
4245  //
4246  // If A is not a reference type:
4247  } else {
4248  assert(!A->isReferenceType() && "Reference types were handled above");
4249 
4250  // - If P is an array type, the pointer type produced by the
4251  // array-to-pointer standard conversion (4.2) is used in place
4252  // of P for type deduction; otherwise,
4253  if (P->isArrayType())
4254  P = Context.getArrayDecayedType(P);
4255  // - If P is a function type, the pointer type produced by the
4256  // function-to-pointer standard conversion (4.3) is used in
4257  // place of P for type deduction; otherwise,
4258  else if (P->isFunctionType())
4259  P = Context.getPointerType(P);
4260  // - If P is a cv-qualified type, the top level cv-qualifiers of
4261  // P's type are ignored for type deduction.
4262  else
4263  P = P.getUnqualifiedType();
4264 
4265  // C++0x [temp.deduct.conv]p4:
4266  // If A is a cv-qualified type, the top level cv-qualifiers of A's
4267  // type are ignored for type deduction. If A is a reference type, the type
4268  // referred to by A is used for type deduction.
4269  A = A.getUnqualifiedType();
4270  }
4271 
4272  // Unevaluated SFINAE context.
4275  SFINAETrap Trap(*this);
4276 
4277  // C++ [temp.deduct.conv]p1:
4278  // Template argument deduction is done by comparing the return
4279  // type of the template conversion function (call it P) with the
4280  // type that is required as the result of the conversion (call it
4281  // A) as described in 14.8.2.4.
4282  TemplateParameterList *TemplateParams
4283  = ConversionTemplate->getTemplateParameters();
4285  Deduced.resize(TemplateParams->size());
4286 
4287  // C++0x [temp.deduct.conv]p4:
4288  // In general, the deduction process attempts to find template
4289  // argument values that will make the deduced A identical to
4290  // A. However, there are two cases that allow a difference:
4291  unsigned TDF = 0;
4292  // - If the original A is a reference type, A can be more
4293  // cv-qualified than the deduced A (i.e., the type referred to
4294  // by the reference)
4295  if (ToType->isReferenceType())
4296  TDF |= TDF_ArgWithReferenceType;
4297  // - The deduced A can be another pointer or pointer to member
4298  // type that can be converted to A via a qualification
4299  // conversion.
4300  //
4301  // (C++0x [temp.deduct.conv]p6 clarifies that this only happens when
4302  // both P and A are pointers or member pointers. In this case, we
4303  // just ignore cv-qualifiers completely).
4304  if ((P->isPointerType() && A->isPointerType()) ||
4306  TDF |= TDF_IgnoreQualifiers;
4307  if (TemplateDeductionResult Result
4308  = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams,
4309  P, A, Info, Deduced, TDF))
4310  return Result;
4311 
4312  // Create an Instantiation Scope for finalizing the operator.
4313  LocalInstantiationScope InstScope(*this);
4314  // Finish template argument deduction.
4315  FunctionDecl *ConversionSpecialized = nullptr;
4317  = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0,
4318  ConversionSpecialized, Info);
4319  Specialization = cast_or_null<CXXConversionDecl>(ConversionSpecialized);
4320  return Result;
4321 }
4322 
4323 /// Deduce template arguments for a function template when there is
4324 /// nothing to deduce against (C++0x [temp.arg.explicit]p3).
4325 ///
4326 /// \param FunctionTemplate the function template for which we are performing
4327 /// template argument deduction.
4328 ///
4329 /// \param ExplicitTemplateArgs the explicitly-specified template
4330 /// arguments.
4331 ///
4332 /// \param Specialization if template argument deduction was successful,
4333 /// this will be set to the function template specialization produced by
4334 /// template argument deduction.
4335 ///
4336 /// \param Info the argument will be updated to provide additional information
4337 /// about template argument deduction.
4338 ///
4339 /// \param IsAddressOfFunction If \c true, we are deducing as part of taking
4340 /// the address of a function template in a context where we do not have a
4341 /// target type, per [over.over]. If \c false, we are looking up a function
4342 /// template specialization based on its signature, which only happens when
4343 /// deducing a function parameter type from an argument that is a template-id
4344 /// naming a function template specialization.
4345 ///
4346 /// \returns the result of template argument deduction.
4348  FunctionTemplateDecl *FunctionTemplate,
4349  TemplateArgumentListInfo *ExplicitTemplateArgs,
4350  FunctionDecl *&Specialization, TemplateDeductionInfo &Info,
4351  bool IsAddressOfFunction) {
4352  return DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs,
4353  QualType(), Specialization, Info,
4354  IsAddressOfFunction);
4355 }
4356 
4357 namespace {
4358  struct DependentAuto { bool IsPack; };
4359 
4360  /// Substitute the 'auto' specifier or deduced template specialization type
4361  /// specifier within a type for a given replacement type.
4362  class SubstituteDeducedTypeTransform :
4363  public TreeTransform<SubstituteDeducedTypeTransform> {
4364  QualType Replacement;
4365  bool ReplacementIsPack;
4366  bool UseTypeSugar;
4367 
4368  public:
4369  SubstituteDeducedTypeTransform(Sema &SemaRef, DependentAuto DA)
4370  : TreeTransform<SubstituteDeducedTypeTransform>(SemaRef), Replacement(),
4371  ReplacementIsPack(DA.IsPack), UseTypeSugar(true) {}
4372 
4373  SubstituteDeducedTypeTransform(Sema &SemaRef, QualType Replacement,
4374  bool UseTypeSugar = true)
4376  Replacement(Replacement), ReplacementIsPack(false),
4377  UseTypeSugar(UseTypeSugar) {}
4378 
4379  QualType TransformDesugared(TypeLocBuilder &TLB, DeducedTypeLoc TL) {
4380  assert(isa<TemplateTypeParmType>(Replacement) &&
4381  "unexpected unsugared replacement kind");
4382  QualType Result = Replacement;
4384  NewTL.setNameLoc(TL.getNameLoc());
4385  return Result;
4386  }
4387 
4388  QualType TransformAutoType(TypeLocBuilder &TLB, AutoTypeLoc TL) {
4389  // If we're building the type pattern to deduce against, don't wrap the
4390  // substituted type in an AutoType. Certain template deduction rules
4391  // apply only when a template type parameter appears directly (and not if
4392  // the parameter is found through desugaring). For instance:
4393  // auto &&lref = lvalue;
4394  // must transform into "rvalue reference to T" not "rvalue reference to
4395  // auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
4396  //
4397  // FIXME: Is this still necessary?
4398  if (!UseTypeSugar)
4399  return TransformDesugared(TLB, TL);
4400 
4401  QualType Result = SemaRef.Context.getAutoType(
4402  Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull(),
4403  ReplacementIsPack, TL.getTypePtr()->getTypeConstraintConcept(),
4405  auto NewTL = TLB.push<AutoTypeLoc>(Result);
4406  NewTL.copy(TL);
4407  return Result;
4408  }
4409 
4410  QualType TransformDeducedTemplateSpecializationType(
4412  if (!UseTypeSugar)
4413  return TransformDesugared(TLB, TL);
4414 
4416  TL.getTypePtr()->getTemplateName(),
4417  Replacement, Replacement.isNull());
4418  auto NewTL = TLB.push<DeducedTemplateSpecializationTypeLoc>(Result);
4419  NewTL.setNameLoc(TL.getNameLoc());
4420  return Result;
4421  }
4422 
4423  ExprResult TransformLambdaExpr(LambdaExpr *E) {
4424  // Lambdas never need to be transformed.
4425  return E;
4426  }
4427 
4428  QualType Apply(TypeLoc TL) {
4429  // Create some scratch storage for the transformed type locations.
4430  // FIXME: We're just going to throw this information away. Don't build it.
4431  TypeLocBuilder TLB;
4432  TLB.reserve(TL.getFullDataSize());
4433  return TransformType(TLB, TL);
4434  }
4435  };
4436 
4437 } // namespace
4438 
4441  Optional<unsigned> DependentDeductionDepth,
4442  bool IgnoreConstraints) {
4443  return DeduceAutoType(Type->getTypeLoc(), Init, Result,
4444  DependentDeductionDepth, IgnoreConstraints);
4445 }
4446 
4447 /// Attempt to produce an informative diagostic explaining why auto deduction
4448 /// failed.
4449 /// \return \c true if diagnosed, \c false if not.
4452  TemplateDeductionInfo &Info,
4453  ArrayRef<SourceRange> Ranges) {
4454  switch (TDK) {
4455  case Sema::TDK_Inconsistent: {
4456  // Inconsistent deduction means we were deducing from an initializer list.
4457  auto D = S.Diag(Info.getLocation(), diag::err_auto_inconsistent_deduction);
4458  D << Info.FirstArg << Info.SecondArg;
4459  for (auto R : Ranges)
4460  D << R;
4461  return true;
4462  }
4463 
4464  // FIXME: Are there other cases for which a custom diagnostic is more useful
4465  // than the basic "types don't match" diagnostic?
4466 
4467  default:
4468  return false;
4469  }
4470 }
4471 
4474  AutoTypeLoc TypeLoc, QualType Deduced) {
4475  ConstraintSatisfaction Satisfaction;
4476  ConceptDecl *Concept = Type.getTypeConstraintConcept();
4477  TemplateArgumentListInfo TemplateArgs(TypeLoc.getLAngleLoc(),
4478  TypeLoc.getRAngleLoc());
4479  TemplateArgs.addArgument(
4482  Deduced, TypeLoc.getNameLoc())));
4483  for (unsigned I = 0, C = TypeLoc.getNumArgs(); I != C; ++I)
4484  TemplateArgs.addArgument(TypeLoc.getArgLoc(I));
4485 
4487  if (S.CheckTemplateArgumentList(Concept, SourceLocation(), TemplateArgs,
4488  /*PartialTemplateArgs=*/false, Converted))
4490  if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()},
4491  Converted, TypeLoc.getLocalSourceRange(),
4492  Satisfaction))
4494  if (!Satisfaction.IsSatisfied) {
4495  std::string Buf;
4496  llvm::raw_string_ostream OS(Buf);
4497  OS << "'" << Concept->getName();
4498  if (TypeLoc.hasExplicitTemplateArgs()) {
4499  OS << "<";
4500  for (const auto &Arg : Type.getTypeConstraintArguments())
4501  Arg.print(S.getPrintingPolicy(), OS);
4502  OS << ">";
4503  }
4504  OS << "'";
4505  OS.flush();
4506  S.Diag(TypeLoc.getConceptNameLoc(),
4507  diag::err_placeholder_constraints_not_satisfied)
4508  << Deduced << Buf << TypeLoc.getLocalSourceRange();
4509  S.DiagnoseUnsatisfiedConstraint(Satisfaction);
4511  }
4512  return Sema::DAR_Succeeded;
4513 }
4514 
4515 /// Deduce the type for an auto type-specifier (C++11 [dcl.spec.auto]p6)
4516 ///
4517 /// Note that this is done even if the initializer is dependent. (This is
4518 /// necessary to support partial ordering of templates using 'auto'.)
4519 /// A dependent type will be produced when deducing from a dependent type.
4520 ///
4521 /// \param Type the type pattern using the auto type-specifier.
4522 /// \param Init the initializer for the variable whose type is to be deduced.
4523 /// \param Result if type deduction was successful, this will be set to the
4524 /// deduced type.
4525 /// \param DependentDeductionDepth Set if we should permit deduction in
4526 /// dependent cases. This is necessary for template partial ordering with
4527 /// 'auto' template parameters. The value specified is the template
4528 /// parameter depth at which we should perform 'auto' deduction.
4529 /// \param IgnoreConstraints Set if we should not fail if the deduced type does
4530 /// not satisfy the type-constraint in the auto type.
4533  Optional<unsigned> DependentDeductionDepth,
4534  bool IgnoreConstraints) {
4535  if (Init->getType()->isNonOverloadPlaceholderType()) {
4536  ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
4537  if (NonPlaceholder.isInvalid())
4538  return DAR_FailedAlreadyDiagnosed;
4539  Init = NonPlaceholder.get();
4540  }
4541 
4542  DependentAuto DependentResult = {
4543  /*.IsPack = */ (bool)Type.getAs<PackExpansionTypeLoc>()};
4544 
4545  if (!DependentDeductionDepth &&
4546  (Type.getType()->isDependentType() || Init->isTypeDependent() ||
4548  Result = SubstituteDeducedTypeTransform(*this, DependentResult).Apply(Type);
4549  assert(!Result.isNull() && "substituting DependentTy can't fail");
4550  return DAR_Succeeded;
4551  }
4552 
4553  // Find the depth of template parameter to synthesize.
4554  unsigned Depth = DependentDeductionDepth.getValueOr(0);
4555 
4556  // If this is a 'decltype(auto)' specifier, do the decltype dance.
4557  // Since 'decltype(auto)' can only occur at the top of the type, we
4558  // don't need to go digging for it.
4559  if (const AutoType *AT = Type.getType()->getAs<AutoType>()) {
4560  if (AT->isDecltypeAuto()) {
4561  if (isa<InitListExpr>(Init)) {
4562  Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
4563  return DAR_FailedAlreadyDiagnosed;
4564  }
4565 
4566  ExprResult ER = CheckPlaceholderExpr(Init);
4567  if (ER.isInvalid())
4568  return DAR_FailedAlreadyDiagnosed;
4569  Init = ER.get();
4570  QualType Deduced = BuildDecltypeType(Init, Init->getBeginLoc(), false);
4571  if (Deduced.isNull())
4572  return DAR_FailedAlreadyDiagnosed;
4573  // FIXME: Support a non-canonical deduced type for 'auto'.
4574  Deduced = Context.getCanonicalType(Deduced);
4575  if (AT->isConstrained() && !IgnoreConstraints) {
4576  auto ConstraintsResult =
4578  Type.getContainedAutoTypeLoc(),
4579  Deduced);
4580  if (ConstraintsResult != DAR_Succeeded)
4581  return ConstraintsResult;
4582  }
4583  Result = SubstituteDeducedTypeTransform(*this, Deduced).Apply(Type);
4584  if (Result.isNull())
4585  return DAR_FailedAlreadyDiagnosed;
4586  return DAR_Succeeded;
4587  } else if (!getLangOpts().CPlusPlus) {
4588  if (isa<InitListExpr>(Init)) {
4589  Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c);
4590  return DAR_FailedAlreadyDiagnosed;
4591  }
4592  }
4593  }
4594 
4595  SourceLocation Loc = Init->getExprLoc();
4596 
4597  LocalInstantiationScope InstScope(*this);
4598 
4599  // Build template<class TemplParam> void Func(FuncParam);
4601  Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false,
4602  false);
4603  QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
4604  NamedDecl *TemplParamPtr = TemplParam;
4606  Context, Loc, Loc, TemplParamPtr, Loc, nullptr);
4607 
4608  QualType FuncParam =
4609  SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
4610  .Apply(Type);
4611  assert(!FuncParam.isNull() &&
4612  "substituting template parameter for 'auto' failed");
4613 
4614  // Deduce type of TemplParam in Func(Init)
4616  Deduced.resize(1);
4617 
4618  TemplateDeductionInfo Info(Loc, Depth);
4619 
4620  // If deduction failed, don't diagnose if the initializer is dependent; it
4621  // might acquire a matching type in the instantiation.
4622  auto DeductionFailed = [&](TemplateDeductionResult TDK,
4624  if (Init->isTypeDependent()) {
4625  Result =
4626  SubstituteDeducedTypeTransform(*this, DependentResult).Apply(Type);
4627  assert(!Result.isNull() && "substituting DependentTy can't fail");
4628  return DAR_Succeeded;
4629  }
4630  if (diagnoseAutoDeductionFailure(*this, TDK, Info, Ranges))
4631  return DAR_FailedAlreadyDiagnosed;
4632  return DAR_Failed;
4633  };
4634 
4635  SmallVector<OriginalCallArg, 4> OriginalCallArgs;
4636 
4637  InitListExpr *InitList = dyn_cast<InitListExpr>(Init);
4638  if (InitList) {
4639  // Notionally, we substitute std::initializer_list<T> for 'auto' and deduce
4640  // against that. Such deduction only succeeds if removing cv-qualifiers and
4641  // references results in std::initializer_list<T>.
4642  if (!Type.getType().getNonReferenceType()->getAs<AutoType>())
4643  return DAR_Failed;
4644 
4645  // Resolving a core issue: a braced-init-list containing any designators is
4646  // a non-deduced context.
4647  for (Expr *E : InitList->inits())
4648  if (isa<DesignatedInitExpr>(E))
4649  return DAR_Failed;
4650 
4651  SourceRange DeducedFromInitRange;
4652  for (unsigned i = 0, e = InitList->getNumInits(); i < e; ++i) {
4653  Expr *Init = InitList->getInit(i);
4654 
4656  *this, TemplateParamsSt.get(), 0, TemplArg, Init,
4657  Info, Deduced, OriginalCallArgs, /*Decomposed*/ true,
4658  /*ArgIdx*/ 0, /*TDF*/ 0))
4659  return DeductionFailed(TDK, {DeducedFromInitRange,
4660  Init->getSourceRange()});
4661 
4662  if (DeducedFromInitRange.isInvalid() &&
4663  Deduced[0].getKind() != TemplateArgument::Null)
4664  DeducedFromInitRange = Init->getSourceRange();
4665  }
4666  } else {
4667  if (!getLangOpts().CPlusPlus && Init->refersToBitField()) {
4668  Diag(Loc, diag::err_auto_bitfield);
4669  return DAR_FailedAlreadyDiagnosed;
4670  }
4671 
4673  *this, TemplateParamsSt.get(), 0, FuncParam, Init, Info, Deduced,
4674  OriginalCallArgs, /*Decomposed*/ false, /*ArgIdx*/ 0, /*TDF*/ 0))
4675  return DeductionFailed(TDK, {});
4676  }
4677 
4678  // Could be null if somehow 'auto' appears in a non-deduced context.
4679  if (Deduced[0].getKind() != TemplateArgument::Type)
4680  return DeductionFailed(TDK_Incomplete, {});
4681 
4682  QualType DeducedType = Deduced[0].getAsType();
4683 
4684  if (InitList) {
4685  DeducedType = BuildStdInitializerList(DeducedType, Loc);
4686  if (DeducedType.isNull())
4687  return DAR_FailedAlreadyDiagnosed;
4688  }
4689 
4690  if (const auto *AT = Type.getType()->getAs<AutoType>()) {
4691  if (AT->isConstrained() && !IgnoreConstraints) {
4692  auto ConstraintsResult =
4694  Type.getContainedAutoTypeLoc(),
4695  DeducedType);
4696  if (ConstraintsResult != DAR_Succeeded)
4697  return ConstraintsResult;
4698  }
4699  }
4700 
4701  Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type);
4702  if (Result.isNull())
4703  return DAR_FailedAlreadyDiagnosed;
4704 
4705  // Check that the deduced argument type is compatible with the original
4706  // argument type per C++ [temp.deduct.call]p4.
4707  QualType DeducedA = InitList ? Deduced[0].getAsType() : Result;
4708  for (const OriginalCallArg &OriginalArg : OriginalCallArgs) {
4709  assert((bool)InitList == OriginalArg.DecomposedParam &&
4710  "decomposed non-init-list in auto deduction?");
4711  if (auto TDK =
4712  CheckOriginalCallArgDeduction(*this, Info, OriginalArg, DeducedA)) {
4713  Result = QualType();
4714  return DeductionFailed(TDK, {});
4715  }
4716  }
4717 
4718  return DAR_Succeeded;
4719 }
4720 
4722  QualType TypeToReplaceAuto) {
4723  if (TypeToReplaceAuto->isDependentType())
4724  return SubstituteDeducedTypeTransform(
4725  *this, DependentAuto{
4726  TypeToReplaceAuto->containsUnexpandedParameterPack()})
4727  .TransformType(TypeWithAuto);
4728  return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
4729  .TransformType(TypeWithAuto);
4730 }
4731 
4733  QualType TypeToReplaceAuto) {
4734  if (TypeToReplaceAuto->isDependentType())
4735  return SubstituteDeducedTypeTransform(
4736  *this,
4737  DependentAuto{
4738  TypeToReplaceAuto->containsUnexpandedParameterPack()})
4739  .TransformType(TypeWithAuto);
4740  return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
4741  .TransformType(TypeWithAuto);
4742 }
4743 
4745  QualType TypeToReplaceAuto) {
4746  return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto,
4747  /*UseTypeSugar*/ false)
4748  .TransformType(TypeWithAuto);
4749 }
4750 
4752  if (isa<InitListExpr>(Init))
4753  Diag(VDecl->getLocation(),
4754  VDecl->isInitCapture()
4755  ? diag::err_init_capture_deduction_failure_from_init_list
4756  : diag::err_auto_var_deduction_failure_from_init_list)
4757  << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange();
4758  else
4759  Diag(VDecl->getLocation(),
4760  VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure
4761  : diag::err_auto_var_deduction_failure)
4762  << VDecl->getDeclName() << VDecl->getType() << Init->getType()
4763  << Init->getSourceRange();
4764 }
4765 
4767  bool Diagnose) {
4768  assert(FD->getReturnType()->isUndeducedType());
4769 
4770  // For a lambda's conversion operator, deduce any 'auto' or 'decltype(auto)'
4771  // within the return type from the call operator's type.
4772  if (isLambdaConversionOperator(FD)) {
4773  CXXRecordDecl *Lambda = cast<CXXMethodDecl>(FD)->getParent();
4774  FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
4775 
4776  // For a generic lambda, instantiate the call operator if needed.
4777  if (auto *Args = FD->getTemplateSpecializationArgs()) {
4778  CallOp = InstantiateFunctionDeclaration(
4779  CallOp->getDescribedFunctionTemplate(), Args, Loc);
4780  if (!CallOp || CallOp->isInvalidDecl())
4781  return true;
4782 
4783  // We might need to deduce the return type by instantiating the definition
4784  // of the operator() function.
4785  if (CallOp->getReturnType()->isUndeducedType()) {
4786  runWithSufficientStackSpace(Loc, [&] {
4787  InstantiateFunctionDefinition(Loc, CallOp);
4788  });
4789  }
4790  }
4791 
4792  if (CallOp->isInvalidDecl())
4793  return true;
4794  assert(!CallOp->getReturnType()->isUndeducedType() &&
4795  "failed to deduce lambda return type");
4796 
4797  // Build the new return type from scratch.
4798  QualType RetType = getLambdaConversionFunctionResultType(
4799  CallOp->getType()->castAs<FunctionProtoType>());
4800  if (FD->getReturnType()->getAs<PointerType>())
4801  RetType = Context.getPointerType(RetType);
4802  else {
4803  assert(FD->getReturnType()->getAs<BlockPointerType>());
4804  RetType = Context.getBlockPointerType(RetType);
4805  }
4806  Context.adjustDeducedFunctionResultType(FD, RetType);
4807  return false;
4808  }
4809 
4810  if (FD->getTemplateInstantiationPattern()) {
4811  runWithSufficientStackSpace(Loc, [&] {
4812  InstantiateFunctionDefinition(Loc, FD);
4813  });
4814  }
4815 
4816  bool StillUndeduced = FD->getReturnType()->isUndeducedType();
4817  if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) {
4818  Diag(Loc, diag::err_auto_fn_used_before_defined) << FD;
4819  Diag(FD->getLocation(), diag::note_callee_decl) << FD;
4820  }
4821 
4822  return StillUndeduced;
4823 }
4824 
4825 /// If this is a non-static member function,
4826 static void
4828  CXXMethodDecl *Method,
4829  SmallVectorImpl<QualType> &ArgTypes) {
4830  // C++11 [temp.func.order]p3:
4831  // [...] The new parameter is of type "reference to cv A," where cv are
4832  // the cv-qualifiers of the function template (if any) and A is
4833  // the class of which the function template is a member.
4834  //
4835  // The standard doesn't say explicitly, but we pick the appropriate kind of
4836  // reference type based on [over.match.funcs]p4.
4837  QualType ArgTy = Context.getTypeDeclType(Method->getParent());
4838  ArgTy = Context.getQualifiedType(ArgTy, Method->getMethodQualifiers());
4839  if (Method->getRefQualifier() == RQ_RValue)
4840  ArgTy = Context.getRValueReferenceType(ArgTy);
4841  else
4842  ArgTy = Context.getLValueReferenceType(ArgTy);
4843  ArgTypes.push_back(ArgTy);
4844 }
4845 
4846 /// Determine whether the function template \p FT1 is at least as
4847 /// specialized as \p FT2.
4849  SourceLocation Loc,
4850  FunctionTemplateDecl *FT1,
4851  FunctionTemplateDecl *FT2,
4853  unsigned NumCallArguments1) {
4854  FunctionDecl *FD1 = FT1->getTemplatedDecl();
4855  FunctionDecl *FD2 = FT2->getTemplatedDecl();
4856  const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>();
4857  const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>();
4858 
4859  assert(Proto1 && Proto2 && "Function templates must have prototypes");
4860  TemplateParameterList *TemplateParams = FT2->getTemplateParameters();
4862  Deduced.resize(TemplateParams->size());
4863 
4864  // C++0x [temp.deduct.partial]p3:
4865  // The types used to determine the ordering depend on the context in which
4866  // the partial ordering is done:
4867  TemplateDeductionInfo Info(Loc);
4869  switch (TPOC) {
4870  case TPOC_Call: {
4871  // - In the context of a function call, the function parameter types are
4872  // used.
4873  CXXMethodDecl *Method1 = dyn_cast<CXXMethodDecl>(FD1);
4874  CXXMethodDecl *Method2 = dyn_cast<CXXMethodDecl>(FD2);
4875 
4876  // C++11 [temp.func.order]p3:
4877  // [...] If only one of the function templates is a non-static
4878  // member, that function template is considered to have a new
4879  // first parameter inserted in its function parameter list. The
4880  // new parameter is of type "reference to cv A," where cv are
4881  // the cv-qualifiers of the function template (if any) and A is
4882  // the class of which the function template is a member.
4883  //
4884  // Note that we interpret this to mean "if one of the function
4885  // templates is a non-static member and the other is a non-member";
4886  // otherwise, the ordering rules for static functions against non-static
4887  // functions don't make any sense.
4888  //
4889  // C++98/03 doesn't have this provision but we've extended DR532 to cover
4890  // it as wording was broken prior to it.
4892 
4893  unsigned NumComparedArguments = NumCallArguments1;
4894 
4895  if (!Method2 && Method1 && !Method1->isStatic()) {
4896  // Compare 'this' from Method1 against first parameter from Method2.
4897  AddImplicitObjectParameterType(S.Context, Method1, Args1);
4898  ++NumComparedArguments;
4899  } else if (!Method1 && Method2 && !Method2->isStatic()) {
4900  // Compare 'this' from Method2 against first parameter from Method1.
4901  AddImplicitObjectParameterType(S.Context, Method2, Args2);
4902  }
4903 
4904  Args1.insert(Args1.end(), Proto1->param_type_begin(),
4905  Proto1->param_type_end());
4906  Args2.insert(Args2.end(), Proto2->param_type_begin(),
4907  Proto2->param_type_end());
4908 
4909  // C++ [temp.func.order]p5:
4910  // The presence of unused ellipsis and default arguments has no effect on
4911  // the partial ordering of function templates.
4912  if (Args1.size() > NumComparedArguments)
4913  Args1.resize(NumComparedArguments);
4914  if (Args2.size() > NumComparedArguments)
4915  Args2.resize(NumComparedArguments);
4916  if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
4917  Args1.data(), Args1.size(), Info, Deduced,
4918  TDF_None, /*PartialOrdering=*/true))
4919  return false;
4920 
4921  break;
4922  }
4923 
4924  case TPOC_Conversion:
4925  // - In the context of a call to a conversion operator, the return types
4926  // of the conversion function templates are used.
4928  S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(),
4929  Info, Deduced, TDF_None,
4930  /*PartialOrdering=*/true))
4931  return false;
4932  break;
4933 
4934  case TPOC_Other:
4935  // - In other contexts (14.6.6.2) the function template's function type
4936  // is used.
4937  if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
4938  FD2->getType(), FD1->getType(),
4939  Info, Deduced, TDF_None,
4940  /*PartialOrdering=*/true))
4941  return false;
4942  break;
4943  }
4944 
4945  // C++0x [temp.deduct.partial]p11:
4946  // In most cases, all template parameters must have values in order for
4947  // deduction to succeed, but for partial ordering purposes a template
4948  // parameter may remain without a value provided it is not used in the
4949  // types being used for partial ordering. [ Note: a template parameter used
4950  // in a non-deduced context is considered used. -end note]
4951  unsigned ArgIdx = 0, NumArgs = Deduced.size();
4952  for (; ArgIdx != NumArgs; ++ArgIdx)
4953  if (Deduced[ArgIdx].isNull())
4954  break;
4955 
4956  // FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need
4957  // to substitute the deduced arguments back into the template and check that
4958  // we get the right type.
4959 
4960  if (ArgIdx == NumArgs) {
4961  // All template arguments were deduced. FT1 is at least as specialized
4962  // as FT2.
4963  return true;
4964  }
4965 
4966  // Figure out which template parameters were used.
4967  llvm::SmallBitVector UsedParameters(TemplateParams->size());
4968  switch (TPOC) {
4969  case TPOC_Call:
4970  for (unsigned I = 0, N = Args2.size(); I != N; ++I)
4971  ::MarkUsedTemplateParameters(S.Context, Args2[I], false,
4972  TemplateParams->getDepth(),
4973  UsedParameters);
4974  break;
4975 
4976  case TPOC_Conversion:
4977  ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false,
4978  TemplateParams->getDepth(), UsedParameters);
4979  break;
4980 
4981  case TPOC_Other:
4982  ::MarkUsedTemplateParameters(S.Context, FD2->getType(), false,
4983  TemplateParams->getDepth(),
4984  UsedParameters);
4985  break;
4986  }
4987 
4988  for (; ArgIdx != NumArgs; ++ArgIdx)
4989  // If this argument had no value deduced but was used in one of the types
4990  // used for partial ordering, then deduction fails.
4991  if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
4992  return false;
4993 
4994  return true;
4995 }
4996 
4997 /// Determine whether this a function template whose parameter-type-list
4998 /// ends with a function parameter pack.
5000  FunctionDecl *Function = FunTmpl->getTemplatedDecl();
5001  unsigned NumParams = Function->getNumParams();
5002  if (NumParams == 0)
5003  return false;
5004 
5005  ParmVarDecl *Last = Function->getParamDecl(NumParams - 1);
5006  if (!Last->isParameterPack())
5007  return false;
5008 
5009  // Make sure that no previous parameter is a parameter pack.
5010  while (--NumParams > 0) {
5011  if (Function->getParamDecl(NumParams - 1)->isParameterPack())
5012  return false;
5013  }
5014 
5015  return true;
5016 }
5017 
5018 /// Returns the more specialized function template according
5019 /// to the rules of function template partial ordering (C++ [temp.func.order]).
5020 ///
5021 /// \param FT1 the first function template
5022 ///
5023 /// \param FT2 the second function template
5024 ///
5025 /// \param TPOC the context in which we are performing partial ordering of
5026 /// function templates.
5027 ///
5028 /// \param NumCallArguments1 The number of arguments in the call to FT1, used
5029 /// only when \c TPOC is \c TPOC_Call.
5030 ///
5031 /// \param NumCallArguments2 The number of arguments in the call to FT2, used
5032 /// only when \c TPOC is \c TPOC_Call.
5033 ///
5034 /// \returns the more specialized function template. If neither
5035 /// template is more specialized, returns NULL.
5038  FunctionTemplateDecl *FT2,
5039  SourceLocation Loc,
5041  unsigned NumCallArguments1,
5042  unsigned NumCallArguments2) {
5043 
5044  auto JudgeByConstraints = [&] () -> FunctionTemplateDecl * {
5046  FT1->getAssociatedConstraints(AC1);
5047  FT2->getAssociatedConstraints(AC2);
5048  bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5049  if (IsAtLeastAsConstrained(FT1, AC1, FT2, AC2, AtLeastAsConstrained1))
5050  return nullptr;
5051  if (IsAtLeastAsConstrained(FT2, AC2, FT1, AC1, AtLeastAsConstrained2))
5052  return nullptr;
5053  if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5054  return nullptr;
5055  return AtLeastAsConstrained1 ? FT1 : FT2;
5056  };
5057 
5058  bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC,
5059  NumCallArguments1);
5060  bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC,
5061  NumCallArguments2);
5062 
5063  if (Better1 != Better2) // We have a clear winner
5064  return Better1 ? FT1 : FT2;
5065 
5066  if (!Better1 && !Better2) // Neither is better than the other
5067  return JudgeByConstraints();
5068 
5069  // FIXME: This mimics what GCC implements, but doesn't match up with the
5070  // proposed resolution for core issue 692. This area needs to be sorted out,
5071  // but for now we attempt to maintain compatibility.
5072  bool Variadic1 = isVariadicFunctionTemplate(FT1);
5073  bool Variadic2 = isVariadicFunctionTemplate(FT2);
5074  if (Variadic1 != Variadic2)
5075  return Variadic1? FT2 : FT1;
5076 
5077  return JudgeByConstraints();
5078 }
5079 
5080 /// Determine if the two templates are equivalent.
5082  if (T1 == T2)
5083  return true;
5084 
5085  if (!T1 || !T2)
5086  return false;
5087 
5088  return T1->getCanonicalDecl() == T2->getCanonicalDecl();
5089 }
5090 
5091 /// Retrieve the most specialized of the given function template
5092 /// specializations.
5093 ///
5094 /// \param SpecBegin the start iterator of the function template
5095 /// specializations that we will be comparing.
5096 ///
5097 /// \param SpecEnd the end iterator of the function template
5098 /// specializations, paired with \p SpecBegin.
5099 ///
5100 /// \param Loc the location where the ambiguity or no-specializations
5101 /// diagnostic should occur.
5102 ///
5103 /// \param NoneDiag partial diagnostic used to diagnose cases where there are
5104 /// no matching candidates.
5105 ///
5106 /// \param AmbigDiag partial diagnostic used to diagnose an ambiguity, if one
5107 /// occurs.
5108 ///
5109 /// \param CandidateDiag partial diagnostic used for each function template
5110 /// specialization that is a candidate in the ambiguous ordering. One parameter
5111 /// in this diagnostic should be unbound, which will correspond to the string
5112 /// describing the template arguments for the function template specialization.
5113 ///
5114 /// \returns the most specialized function template specialization, if
5115 /// found. Otherwise, returns SpecEnd.
5117  UnresolvedSetIterator SpecBegin, UnresolvedSetIterator SpecEnd,
5118  TemplateSpecCandidateSet &FailedCandidates,
5119  SourceLocation Loc, const PartialDiagnostic &NoneDiag,
5120  const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag,
5121  bool Complain, QualType TargetType) {
5122  if (SpecBegin == SpecEnd) {
5123  if (Complain) {
5124  Diag(Loc, NoneDiag);
5125  FailedCandidates.NoteCandidates(*this, Loc);
5126  }
5127  return SpecEnd;
5128  }
5129 
5130  if (SpecBegin + 1 == SpecEnd)
5131  return SpecBegin;
5132 
5133  // Find the function template that is better than all of the templates it
5134  // has been compared to.
5135  UnresolvedSetIterator Best = SpecBegin;
5136  FunctionTemplateDecl *BestTemplate
5137  = cast<FunctionDecl>(*Best)->getPrimaryTemplate();
5138  assert(BestTemplate && "Not a function template specialization?");
5139  for (UnresolvedSetIterator I = SpecBegin + 1; I != SpecEnd; ++I) {
5140  FunctionTemplateDecl *Challenger
5141  = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5142  assert(Challenger && "Not a function template specialization?");
5143  if (isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
5144  Loc, TPOC_Other, 0, 0),
5145  Challenger)) {
5146  Best = I;
5147  BestTemplate = Challenger;
5148  }
5149  }
5150 
5151  // Make sure that the "best" function template is more specialized than all
5152  // of the others.
5153  bool Ambiguous = false;
5154  for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
5155  FunctionTemplateDecl *Challenger
5156  = cast<FunctionDecl>(*I)->getPrimaryTemplate();
5157  if (I != Best &&
5158  !isSameTemplate(getMoreSpecializedTemplate(BestTemplate, Challenger,
5159  Loc, TPOC_Other, 0, 0),
5160  BestTemplate)) {
5161  Ambiguous = true;
5162  break;
5163  }
5164  }
5165 
5166  if (!Ambiguous) {
5167  // We found an answer. Return it.
5168  return Best;
5169  }
5170 
5171  // Diagnose the ambiguity.
5172  if (Complain) {
5173  Diag(Loc, AmbigDiag);
5174 
5175  // FIXME: Can we order the candidates in some sane way?
5176  for (UnresolvedSetIterator I = SpecBegin; I != SpecEnd; ++I) {
5177  PartialDiagnostic PD = CandidateDiag;
5178  const auto *FD = cast<FunctionDecl>(*I);
5179  PD << FD << getTemplateArgumentBindingsText(
5180  FD->getPrimaryTemplate()->getTemplateParameters(),
5181  *FD->getTemplateSpecializationArgs());
5182  if (!TargetType.isNull())
5183  HandleFunctionTypeMismatch(PD, FD->getType(), TargetType);
5184  Diag((*I)->getLocation(), PD);
5185  }
5186  }
5187 
5188  return SpecEnd;
5189 }
5190 
5191 /// Determine whether one partial specialization, P1, is at least as
5192 /// specialized than another, P2.
5193 ///
5194 /// \tparam TemplateLikeDecl The kind of P2, which must be a
5195 /// TemplateDecl or {Class,Var}TemplatePartialSpecializationDecl.
5196 /// \param T1 The injected-class-name of P1 (faked for a variable template).
5197 /// \param T2 The injected-class-name of P2 (faked for a variable template).
5198 template<typename TemplateLikeDecl>
5200  TemplateLikeDecl *P2,
5201  TemplateDeductionInfo &Info) {
5202  // C++ [temp.class.order]p1:
5203  // For two class template partial specializations, the first is at least as
5204  // specialized as the second if, given the following rewrite to two
5205  // function templates, the first function template is at least as
5206  // specialized as the second according to the ordering rules for function
5207  // templates (14.6.6.2):
5208  // - the first function template has the same template parameters as the
5209  // first partial specialization and has a single function parameter
5210  // whose type is a class template specialization with the template
5211  // arguments of the first partial specialization, and
5212  // - the second function template has the same template parameters as the
5213  // second partial specialization and has a single function parameter
5214  // whose type is a class template specialization with the template
5215  // arguments of the second partial specialization.
5216  //
5217  // Rather than synthesize function templates, we merely perform the
5218  // equivalent partial ordering by performing deduction directly on
5219  // the template arguments of the class template partial
5220  // specializations. This computation is slightly simpler than the
5221  // general problem of function template partial ordering, because
5222  // class template partial specializations are more constrained. We
5223  // know that every template parameter is deducible from the class
5224  // template partial specialization's template arguments, for
5225  // example.
5227 
5228  // Determine whether P1 is at least as specialized as P2.
5229  Deduced.resize(P2->getTemplateParameters()->size());
5230  if (DeduceTemplateArgumentsByTypeMatch(S, P2->getTemplateParameters(),
5231  T2, T1, Info, Deduced, TDF_None,
5232  /*PartialOrdering=*/true))
5233  return false;
5234 
5235  SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
5236  Deduced.end());
5237  Sema::InstantiatingTemplate Inst(S, Info.getLocation(), P2, DeducedArgs,
5238  Info);
5239  auto *TST1 = T1->castAs<TemplateSpecializationType>();
5241  S, P2, /*IsPartialOrdering=*/true,
5243  TST1->template_arguments()),
5244  Deduced, Info))
5245  return false;
5246 
5247  return true;
5248 }
5249 
5250 /// Returns the more specialized class template partial specialization
5251 /// according to the rules of partial ordering of class template partial
5252 /// specializations (C++ [temp.class.order]).
5253 ///
5254 /// \param PS1 the first class template partial specialization
5255 ///
5256 /// \param PS2 the second class template partial specialization
5257 ///
5258 /// \returns the more specialized class template partial specialization. If
5259 /// neither partial specialization is more specialized, returns NULL.
5264  SourceLocation Loc) {
5267 
5268  TemplateDeductionInfo Info(Loc);
5269  bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
5270  bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
5271 
5272  if (!Better1 && !Better2)
5273  return nullptr;
5274  if (Better1 && Better2) {
5276  PS1->getAssociatedConstraints(AC1);
5277  PS2->getAssociatedConstraints(AC2);
5278  bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5279  if (IsAtLeastAsConstrained(PS1, AC1, PS2, AC2, AtLeastAsConstrained1))
5280  return nullptr;
5281  if (IsAtLeastAsConstrained(PS2, AC2, PS1, AC1, AtLeastAsConstrained2))
5282  return nullptr;
5283  if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5284  return nullptr;
5285  return AtLeastAsConstrained1 ? PS1 : PS2;
5286  }
5287 
5288  return Better1 ? PS1 : PS2;
5289 }
5290 
5293  ClassTemplateDecl *Primary = Spec->getSpecializedTemplate();
5294  QualType PrimaryT = Primary->getInjectedClassNameSpecialization();
5295  QualType PartialT = Spec->getInjectedSpecializationType();
5296  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
5297  return false;
5298  if (!isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info))
5299  return true;
5300  Info.clearSFINAEDiagnostic();
5301  llvm::SmallVector<const Expr *, 3> PrimaryAC, SpecAC;
5302  Primary->getAssociatedConstraints(PrimaryAC);
5303  Spec->getAssociatedConstraints(SpecAC);
5304  bool AtLeastAsConstrainedPrimary, AtLeastAsConstrainedSpec;
5305  if (IsAtLeastAsConstrained(Spec, SpecAC, Primary, PrimaryAC,
5306  AtLeastAsConstrainedSpec))
5307  return false;
5308  if (!AtLeastAsConstrainedSpec)
5309  return false;
5310  if (IsAtLeastAsConstrained(Primary, PrimaryAC, Spec, SpecAC,
5311  AtLeastAsConstrainedPrimary))
5312  return false;
5313  return !AtLeastAsConstrainedPrimary;
5314 }
5315 
5320  // Pretend the variable template specializations are class template
5321  // specializations and form a fake injected class name type for comparison.
5322  assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() &&
5323  "the partial specializations being compared should specialize"
5324  " the same template.");
5325  TemplateName Name(PS1->getSpecializedTemplate());
5326  TemplateName CanonTemplate = Context.getCanonicalTemplateName(Name);
5328  CanonTemplate, PS1->getTemplateArgs().asArray());
5330  CanonTemplate, PS2->getTemplateArgs().asArray());
5331 
5332  TemplateDeductionInfo Info(Loc);
5333  bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
5334  bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
5335 
5336  if (!Better1 && !Better2)
5337  return nullptr;
5338  if (Better1 && Better2) {
5340  PS1->getAssociatedConstraints(AC1);
5341  PS2->getAssociatedConstraints(AC2);
5342  bool AtLeastAsConstrained1, AtLeastAsConstrained2;
5343  if (IsAtLeastAsConstrained(PS1, AC1, PS2, AC2, AtLeastAsConstrained1))
5344  return nullptr;
5345  if (IsAtLeastAsConstrained(PS2, AC2, PS1, AC1, AtLeastAsConstrained2))
5346  return nullptr;
5347  if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
5348  return nullptr;
5349  return AtLeastAsConstrained1 ? PS1 : PS2;
5350  }
5351 
5352  return Better1 ? PS1 : PS2;
5353 }
5354 
5357  TemplateDecl *Primary = Spec->getSpecializedTemplate();
5358  // FIXME: Cache the injected template arguments rather than recomputing
5359  // them for each partial specialization.
5362  PrimaryArgs);
5363 
5364  TemplateName CanonTemplate =
5365  Context.getCanonicalTemplateName(TemplateName(Primary));
5366  QualType PrimaryT = Context.getTemplateSpecializationType(
5367  CanonTemplate, PrimaryArgs);
5368  QualType PartialT = Context.getTemplateSpecializationType(
5369  CanonTemplate, Spec->getTemplateArgs().asArray());
5370 
5371  if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
5372  return false;
5373  if (!isAtLeastAsSpecializedAs(*this, PrimaryT, PartialT, Spec, Info))
5374  return true;
5375  Info.clearSFINAEDiagnostic();
5376  llvm::SmallVector<const Expr *, 3> PrimaryAC, SpecAC;
5377  Primary->getAssociatedConstraints(PrimaryAC);
5378  Spec->getAssociatedConstraints(SpecAC);
5379  bool AtLeastAsConstrainedPrimary, AtLeastAsConstrainedSpec;
5380  if (IsAtLeastAsConstrained(Spec, SpecAC, Primary, PrimaryAC,
5381  AtLeastAsConstrainedSpec))
5382  return false;
5383  if (!AtLeastAsConstrainedSpec)
5384  return false;
5385  if (IsAtLeastAsConstrained(Primary, PrimaryAC, Spec, SpecAC,
5386  AtLeastAsConstrainedPrimary))
5387  return false;
5388  return !AtLeastAsConstrainedPrimary;
5389 }
5390 
5393  // C++1z [temp.arg.template]p4: (DR 150)
5394  // A template template-parameter P is at least as specialized as a
5395  // template template-argument A if, given the following rewrite to two
5396  // function templates...
5397 
5398  // Rather than synthesize function templates, we merely perform the
5399  // equivalent partial ordering by performing deduction directly on
5400  // the template parameter lists of the template template parameters.
5401  //
5402  // Given an invented class template X with the template parameter list of
5403  // A (including default arguments):
5406 
5407  // - Each function template has a single function parameter whose type is
5408  // a specialization of X with template arguments corresponding to the
5409  // template parameters from the respective function template
5411  Context.getInjectedTemplateArgs(A, AArgs);
5412 
5413  // Check P's arguments against A's parameter list. This will fill in default
5414  // template arguments as needed. AArgs are already correct by construction.
5415  // We can't just use CheckTemplateIdType because that will expand alias
5416  // templates.
5418  {
5419  SFINAETrap Trap(*this);
5420 
5421  Context.getInjectedTemplateArgs(P, PArgs);
5422  TemplateArgumentListInfo PArgList(P->getLAngleLoc(),
5423  P->getRAngleLoc());
5424  for (unsigned I = 0, N = P->size(); I != N; ++I) {
5425  // Unwrap packs that getInjectedTemplateArgs wrapped around pack
5426  // expansions, to form an "as written" argument list.
5427  TemplateArgument Arg = PArgs[I];
5428  if (Arg.getKind() == TemplateArgument::Pack) {
5429  assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion());
5430  Arg = *Arg.pack_begin();
5431  }
5432  PArgList.addArgument(getTrivialTemplateArgumentLoc(
5433  Arg, QualType(), P->getParam(I)->getLocation()));
5434  }
5435  PArgs.clear();
5436 
5437  // C++1z [temp.arg.template]p3:
5438  // If the rewrite produces an invalid type, then P is not at least as
5439  // specialized as A.
5440  if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, PArgs) ||
5441  Trap.hasErrorOccurred())
5442  return false;
5443  }
5444 
5445  QualType AType = Context.getTemplateSpecializationType(X, AArgs);
5446  QualType PType = Context.getTemplateSpecializationType(X, PArgs);
5447 
5448  // ... the function template corresponding to P is at least as specialized
5449  // as the function template corresponding to A according to the partial
5450  // ordering rules for function templates.
5451  TemplateDeductionInfo Info(Loc, A->getDepth());
5452  return isAtLeastAsSpecializedAs(*this, PType, AType, AArg, Info);
5453 }
5454 
5455 namespace {
5456 struct MarkUsedTemplateParameterVisitor :
5457  RecursiveASTVisitor<MarkUsedTemplateParameterVisitor> {
5458  llvm::SmallBitVector &Used;
5459  unsigned Depth;
5460 
5461  MarkUsedTemplateParameterVisitor(llvm::SmallBitVector &Used,
5462  unsigned Depth)
5463  : Used(Used), Depth(Depth) { }
5464 
5465  bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
5466  if (T->getDepth() == Depth)
5467  Used[T->getIndex()] = true;
5468  return true;
5469  }
5470 
5471  bool TraverseTemplateName(TemplateName Template) {
5472  if (auto *TTP =
5473  dyn_cast<TemplateTemplateParmDecl>(Template.getAsTemplateDecl()))
5474  if (TTP->getDepth() == Depth)
5475  Used[TTP->getIndex()] = true;
5477  TraverseTemplateName(Template);
5478  return true;
5479  }
5480 
5481  bool VisitDeclRefExpr(DeclRefExpr *E) {
5482  if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(E->getDecl()))
5483  if (NTTP->getDepth() == Depth)
5484  Used[NTTP->getIndex()] = true;
5485  return true;
5486  }
5487 };
5488 }
5489 
5490 /// Mark the template parameters that are used by the given
5491 /// expression.
5492 static void
5494  const Expr *E,
5495  bool OnlyDeduced,
5496  unsigned Depth,
5497  llvm::SmallBitVector &Used) {
5498  if (!OnlyDeduced) {
5499  MarkUsedTemplateParameterVisitor(Used, Depth)
5500  .TraverseStmt(const_cast<Expr *>(E));
5501  return;
5502  }
5503 
5504  // We can deduce from a pack expansion.
5505  if (const PackExpansionExpr *Expansion = dyn_cast<PackExpansionExpr>(E))
5506  E = Expansion->getPattern();
5507 
5508  // Skip through any implicit casts we added while type-checking, and any
5509  // substitutions performed by template alias expansion.
5510  while (true) {
5511  if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
5512  E = ICE->getSubExpr();
5513  else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(E))
5514  E = CE->getSubExpr();
5515  else if (const SubstNonTypeTemplateParmExpr *Subst =
5516  dyn_cast<SubstNonTypeTemplateParmExpr>(E))
5517  E = Subst->getReplacement();
5518  else
5519  break;
5520  }
5521 
5522  const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E);
5523  if (!DRE)
5524  return;
5525 
5526  const NonTypeTemplateParmDecl *NTTP
5527  = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl());
5528  if (!NTTP)
5529  return;
5530 
5531  if (NTTP->getDepth() == Depth)
5532  Used[NTTP->getIndex()] = true;
5533 
5534  // In C++17 mode, additional arguments may be deduced from the type of a
5535  // non-type argument.
5536  if (Ctx.getLangOpts().CPlusPlus17)
5537  MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used);
5538 }
5539 
5540 /// Mark the template parameters that are used by the given
5541 /// nested name specifier.
5542 static void
5544  NestedNameSpecifier *NNS,
5545  bool OnlyDeduced,
5546  unsigned Depth,
5547  llvm::SmallBitVector &Used) {
5548  if (!NNS)
5549  return;
5550 
5551  MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth,
5552  Used);
5554  OnlyDeduced, Depth, Used);
5555 }
5556 
5557 /// Mark the template parameters that are used by the given
5558 /// template name.
5559 static void
5561  TemplateName Name,
5562  bool OnlyDeduced,
5563  unsigned Depth,
5564  llvm::SmallBitVector &Used) {
5565  if (TemplateDecl *Template = Name.getAsTemplateDecl()) {
5566  if (TemplateTemplateParmDecl *TTP
5567  = dyn_cast<TemplateTemplateParmDecl>(Template)) {
5568  if (TTP->getDepth() == Depth)
5569  Used[TTP->getIndex()] = true;
5570  }
5571  return;
5572  }
5573 
5575  MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced,
5576  Depth, Used);
5578  MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced,
5579  Depth, Used);
5580 }
5581 
5582 /// Mark the template parameters that are used by the given
5583 /// type.
5584 static void
5586  bool OnlyDeduced,
5587  unsigned Depth,
5588  llvm::SmallBitVector &Used) {
5589  if (T.isNull())
5590  return;
5591 
5592  // Non-dependent types have nothing deducible
5593  if (!T->isDependentType())
5594  return;
5595 
5596  T = Ctx.getCanonicalType(T);
5597  switch (T->getTypeClass()) {
5598  case Type::Pointer:
5600  cast<PointerType>(T)->getPointeeType(),
5601  OnlyDeduced,
5602  Depth,
5603  Used);
5604  break;
5605 
5606  case Type::BlockPointer:
5608  cast<BlockPointerType>(T)->getPointeeType(),
5609  OnlyDeduced,
5610  Depth,
5611  Used);
5612  break;
5613 
5614  case Type::LValueReference:
5615  case Type::RValueReference:
5617  cast<ReferenceType>(T)->getPointeeType(),
5618  OnlyDeduced,
5619  Depth,
5620  Used);
5621  break;
5622 
5623  case Type::MemberPointer: {
5624  const MemberPointerType *MemPtr = cast<MemberPointerType>(T.getTypePtr());
5625  MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced,
5626  Depth, Used);
5627  MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0),
5628  OnlyDeduced, Depth, Used);
5629  break;
5630  }
5631 
5632  case Type::DependentSizedArray:
5634  cast<DependentSizedArrayType>(T)->getSizeExpr(),
5635  OnlyDeduced, Depth, Used);
5636  // Fall through to check the element type
5637  LLVM_FALLTHROUGH;
5638 
5639  case Type::ConstantArray:
5640  case Type::IncompleteArray:
5642  cast<ArrayType>(T)->getElementType(),
5643  OnlyDeduced, Depth, Used);
5644  break;
5645 
5646  case Type::Vector:
5647  case Type::ExtVector:
5649  cast<VectorType>(T)->getElementType(),
5650  OnlyDeduced, Depth, Used);
5651  break;
5652 
5653  case Type::DependentVector: {
5654  const auto *VecType = cast<DependentVectorType>(T);
5655  MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
5656  Depth, Used);
5657  MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth,
5658  Used);
5659  break;
5660  }
5661  case Type::DependentSizedExtVector: {
5662  const DependentSizedExtVectorType *VecType
5663  = cast<DependentSizedExtVectorType>(T);
5664  MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced,
5665  Depth, Used);
5666  MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced,
5667  Depth, Used);
5668  break;
5669  }
5670 
5671  case Type::DependentAddressSpace: {
5672  const DependentAddressSpaceType *DependentASType =
5673  cast<DependentAddressSpaceType>(T);
5674  MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(),
5675  OnlyDeduced, Depth, Used);
5677  DependentASType->getAddrSpaceExpr(),
5678  OnlyDeduced, Depth, Used);
5679  break;
5680  }
5681 
5682  case Type::FunctionProto: {
5683  const FunctionProtoType *Proto = cast<FunctionProtoType>(T);
5684  MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth,
5685  Used);
5686  for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) {
5687  // C++17 [temp.deduct.type]p5:
5688  // The non-deduced contexts are: [...]
5689  // -- A function parameter pack that does not occur at the end of the
5690  // parameter-declaration-list.
5691  if (!OnlyDeduced || I + 1 == N ||
5692  !Proto->getParamType(I)->getAs<PackExpansionType>()) {
5693  MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced,
5694  Depth, Used);
5695  } else {
5696  // FIXME: C++17 [temp.deduct.call]p1:
5697  // When a function parameter pack appears in a non-deduced context,
5698  // the type of that pack is never deduced.
5699  //
5700  // We should also track a set of "never deduced" parameters, and
5701  // subtract that from the list of deduced parameters after marking.
5702  }
5703  }
5704  if (auto *E = Proto->getNoexceptExpr())
5705  MarkUsedTemplateParameters(Ctx, E, OnlyDeduced, Depth, Used);
5706  break;
5707  }
5708 
5709  case Type::TemplateTypeParm: {
5710  const TemplateTypeParmType *TTP = cast<TemplateTypeParmType>(T);
5711  if (TTP->getDepth() == Depth)
5712  Used[TTP->getIndex()] = true;
5713  break;
5714  }
5715 
5716  case Type::SubstTemplateTypeParmPack: {
5717  const SubstTemplateTypeParmPackType *Subst
5718  = cast<SubstTemplateTypeParmPackType>(T);
5720  QualType(Subst->getReplacedParameter(), 0),
5721  OnlyDeduced, Depth, Used);
5723  OnlyDeduced, Depth, Used);
5724  break;
5725  }
5726 
5727  case Type::InjectedClassName:
5728  T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType();
5729  LLVM_FALLTHROUGH;
5730 
5731  case Type::TemplateSpecialization: {
5732  const TemplateSpecializationType *Spec
5733  = cast<TemplateSpecializationType>(T);
5734  MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced,
5735  Depth, Used);
5736 
5737  // C++0x [temp.deduct.type]p9:
5738  // If the template argument list of P contains a pack expansion that is
5739  // not the last template argument, the entire template argument list is a
5740  // non-deduced context.
5741  if (OnlyDeduced &&
5743  break;
5744 
5745  for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
5746  MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
5747  Used);
5748  break;
5749  }
5750 
5751  case Type::Complex:
5752  if (!OnlyDeduced)
5754  cast<ComplexType>(T)->getElementType(),
5755  OnlyDeduced, Depth, Used);
5756  break;
5757 
5758  case Type::Atomic:
5759  if (!OnlyDeduced)
5761  cast<AtomicType>(T)->getValueType(),
5762  OnlyDeduced, Depth, Used);
5763  break;
5764 
5765  case Type::DependentName:
5766  if (!OnlyDeduced)
5768  cast<DependentNameType>(T)->getQualifier(),
5769  OnlyDeduced, Depth, Used);
5770  break;
5771 
5772  case Type::DependentTemplateSpecialization: {
5773  // C++14 [temp.deduct.type]p5:
5774  // The non-deduced contexts are:
5775  // -- The nested-name-specifier of a type that was specified using a
5776  // qualified-id
5777  //
5778  // C++14 [temp.deduct.type]p6:
5779  // When a type name is specified in a way that includes a non-deduced
5780  // context, all of the types that comprise that type name are also
5781  // non-deduced.
5782  if (OnlyDeduced)
5783  break;
5784 
5786  = cast<DependentTemplateSpecializationType>(T);
5787 
5789  OnlyDeduced, Depth, Used);
5790 
5791  for (unsigned I = 0, N = Spec->getNumArgs(); I != N; ++I)
5792  MarkUsedTemplateParameters(Ctx, Spec->getArg(I), OnlyDeduced, Depth,
5793  Used);
5794  break;
5795  }
5796 
5797  case Type::TypeOf:
5798  if (!OnlyDeduced)
5800  cast<TypeOfType>(T)->getUnderlyingType(),
5801  OnlyDeduced, Depth, Used);
5802  break;
5803 
5804  case Type::TypeOfExpr:
5805  if (!OnlyDeduced)
5807  cast<TypeOfExprType>(T)->getUnderlyingExpr(),
5808  OnlyDeduced, Depth, Used);
5809  break;
5810 
5811  case Type::Decltype:
5812  if (!OnlyDeduced)
5814  cast<DecltypeType>(T)->getUnderlyingExpr(),
5815  OnlyDeduced, Depth, Used);
5816  break;
5817 
5818  case Type::UnaryTransform:
5819  if (!OnlyDeduced)
5821  cast<UnaryTransformType>(T)->getUnderlyingType(),
5822  OnlyDeduced, Depth, Used);
5823  break;
5824 
5825  case Type::PackExpansion:
5827  cast<PackExpansionType>(T)->getPattern(),
5828  OnlyDeduced, Depth, Used);
5829  break;
5830 
5831  case Type::Auto:
5832  case Type::DeducedTemplateSpecialization:
5834  cast<DeducedType>(T)->getDeducedType(),
5835  OnlyDeduced, Depth, Used);
5836  break;
5837 
5838  // None of these types have any template parameters in them.
5839  case Type::Builtin:
5840  case Type::VariableArray:
5841  case Type::FunctionNoProto:
5842  case Type::Record:
5843  case Type::Enum:
5844  case Type::ObjCInterface:
5845  case Type::ObjCObject:
5846  case Type::ObjCObjectPointer:
5847  case Type::UnresolvedUsing:
5848  case Type::Pipe:
5849 #define TYPE(Class, Base)
5850 #define ABSTRACT_TYPE(Class, Base)
5851 #define DEPENDENT_TYPE(Class, Base)
5852 #define NON_CANONICAL_TYPE(Class, Base) case Type::Class:
5853 #include "clang/AST/TypeNodes.inc"
5854  break;
5855  }
5856 }
5857 
5858 /// Mark the template parameters that are used by this
5859 /// template argument.
5860 static void
5862  const TemplateArgument &TemplateArg,
5863  bool OnlyDeduced,
5864  unsigned Depth,
5865  llvm::SmallBitVector &Used) {
5866  switch (TemplateArg.getKind()) {
5870  break;
5871 
5873  MarkUsedTemplateParameters(Ctx, TemplateArg.getNullPtrType(), OnlyDeduced,
5874  Depth, Used);
5875  break;
5876 
5878  MarkUsedTemplateParameters(Ctx, TemplateArg.getAsType(), OnlyDeduced,
5879  Depth, Used);
5880  break;
5881 
5885  TemplateArg.getAsTemplateOrTemplatePattern(),
5886  OnlyDeduced, Depth, Used);
5887  break;
5888 
5890  MarkUsedTemplateParameters(Ctx, TemplateArg.getAsExpr(), OnlyDeduced,
5891  Depth, Used);
5892  break;
5893 
5895  for (const auto &P : TemplateArg.pack_elements())
5896  MarkUsedTemplateParameters(Ctx, P, OnlyDeduced, Depth, Used);
5897  break;
5898  }
5899 }
5900 
5901 /// Mark which template parameters are used in a given expression.
5902 ///
5903 /// \param E the expression from which template parameters will be deduced.
5904 ///
5905 /// \param Used a bit vector whose elements will be set to \c true
5906 /// to indicate when the corresponding template parameter will be
5907 /// deduced.
5908 void
5909 Sema::MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced,
5910  unsigned Depth,
5911  llvm::SmallBitVector &Used) {
5912  ::MarkUsedTemplateParameters(Context, E, OnlyDeduced, Depth, Used);
5913 }
5914 
5915 /// Mark which template parameters can be deduced from a given
5916 /// template argument list.
5917 ///
5918 /// \param TemplateArgs the template argument list from which template
5919 /// parameters will be deduced.
5920 ///
5921 /// \param Used a bit vector whose elements will be set to \c true
5922 /// to indicate when the corresponding template parameter will be
5923 /// deduced.
5924 void
5926  bool OnlyDeduced, unsigned Depth,
5927  llvm::SmallBitVector &Used) {
5928  // C++0x [temp.deduct.type]p9:
5929  // If the template argument list of P contains a pack expansion that is not
5930  // the last template argument, the entire template argument list is a
5931  // non-deduced context.
5932  if (OnlyDeduced &&
5933  hasPackExpansionBeforeEnd(TemplateArgs.asArray()))
5934  return;
5935 
5936  for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
5937  ::MarkUsedTemplateParameters(Context, TemplateArgs[I], OnlyDeduced,
5938  Depth, Used);
5939 }
5940 
5941 /// Marks all of the template parameters that will be deduced by a
5942 /// call to the given function template.
5944  ASTContext &Ctx, const FunctionTemplateDecl *FunctionTemplate,
5945  llvm::SmallBitVector &Deduced) {
5946  TemplateParameterList *TemplateParams
5947  = FunctionTemplate->getTemplateParameters();
5948  Deduced.clear();
5949  Deduced.resize(TemplateParams->size());
5950 
5951  FunctionDecl *Function = FunctionTemplate->getTemplatedDecl();
5952  for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I)
5953  ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(),
5954  true, TemplateParams->getDepth(), Deduced);
5955 }
5956 
5958  FunctionTemplateDecl *FunctionTemplate,
5959  QualType T) {
5960  if (!T->isDependentType())
5961  return false;
5962 
5963  TemplateParameterList *TemplateParams
5964  = FunctionTemplate->getTemplateParameters();
5965  llvm::SmallBitVector Deduced(TemplateParams->size());
5966  ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(),
5967  Deduced);
5968 
5969  return Deduced.any();
5970 }
const IncompleteArrayType * getAsIncompleteArrayType(QualType T) const
Definition: ASTContext.h:2472
QualType getPattern() const
Retrieve the pattern of this pack expansion, which is the type that will be repeatedly instantiated w...
Definition: Type.h:5532
Defines the clang::ASTContext interface.
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:683
Represents a function declaration or definition.
Definition: Decl.h:1783
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
All associated constraints of this partial specialization, including the requires clause and any cons...
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2995
bool isStrictSupersetOf(Qualifiers Other) const
Determine whether this set of qualifiers is a strict superset of another set of qualifiers, not considering qualifier compatibility.
Definition: Type.cpp:57
static DeducedTemplateArgument checkDeducedTemplateArguments(ASTContext &Context, const DeducedTemplateArgument &X, const DeducedTemplateArgument &Y)
Verify that the given, deduced template arguments are compatible.
QualType getAdjustedParameterType(QualType T) const
Perform adjustment on the parameter type of a function.
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:502
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this function type.
Definition: Type.h:4112
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
QualType getPointeeType() const
Definition: Type.h:2627
A (possibly-)qualified type.
Definition: Type.h:654
TemplateDeductionResult
Describes the result of template argument deduction.
Definition: Sema.h:7752
base_class_range bases()
Definition: DeclCXX.h:587
bool isArrayType() const
Definition: Type.h:6570
void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, SourceRange R)
Make a new nested-name-specifier from incomplete source-location information.
bool isMemberPointerType() const
Definition: Type.h:6552
bool isLambdaConversionOperator(CXXConversionDecl *C)
Definition: ASTLambda.h:47
void DiagnoseUnsatisfiedConstraint(const ConstraintSatisfaction &Satisfaction, bool First=true)
Emit diagnostics explaining why a constraint expression was deemed unsatisfied.
A stack-allocated class that identifies which local variable declaration instantiations are present i...
Definition: Template.h:227
const TypeClass * getTypePtr() const
Definition: TypeLoc.h:409
Template argument deduction was successful.
Definition: Sema.h:7754
UnresolvedSetIterator getMostSpecialized(UnresolvedSetIterator SBegin, UnresolvedSetIterator SEnd, TemplateSpecCandidateSet &FailedCandidates, SourceLocation Loc, const PartialDiagnostic &NoneDiag, const PartialDiagnostic &AmbigDiag, const PartialDiagnostic &CandidateDiag, bool Complain=true, QualType TargetType=QualType())
Retrieve the most specialized of the given function template specializations.
unsigned getNumArgs() const
Definition: TypeLoc.h:2014
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4451
ArrayRef< TemplateArgument > getTypeConstraintArguments() const
Definition: Type.h:4904
static Sema::TemplateDeductionResult ConvertDeducedTemplateArguments(Sema &S, TemplateDeclT *Template, bool IsDeduced, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info, SmallVectorImpl< TemplateArgument > &Builder, LocalInstantiationScope *CurrentInstantiationScope=nullptr, unsigned NumAlreadyConverted=0, bool PartialOverloading=false)
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
static Sema::TemplateDeductionResult CheckOriginalCallArgDeduction(Sema &S, TemplateDeductionInfo &Info, Sema::OriginalCallArg OriginalArg, QualType DeducedA)
Check whether the deduced argument type for a call to a function template matches the actual argument...
Provides information about an attempted template argument deduction, whose success or failure was des...
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
C Language Family Type Representation.
void setObjCLifetime(ObjCLifetime type)
Definition: Type.h:336
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:86
bool isRecordType() const
Definition: Type.h:6594
unsigned size() const
Retrieve the number of template arguments in this template argument list.
Definition: DeclTemplate.h:299
static TemplateTypeParmDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation KeyLoc, SourceLocation NameLoc, unsigned D, unsigned P, IdentifierInfo *Id, bool Typename, bool ParameterPack, bool HasTypeConstraint=false, Optional< unsigned > NumExpanded=None)
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1958
QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const
Return the uniqued reference to the type for an lvalue reference to the specified type...
const Type * getTypeForDecl() const
Definition: Decl.h:3053
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
static bool IsPossiblyOpaquelyQualifiedType(QualType T)
Determines whether the given type is an opaque type that might be more qualified when instantiated...
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4086
NestedNameSpecifier * getPrefix() const
Return the prefix of this nested name specifier.
QualType getDeducedTemplateSpecializationType(TemplateName Template, QualType DeducedType, bool IsDependent) const
C++17 deduced class template specialization type.
Defines the C++ template declaration subclasses.
StringRef P
Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained by a type-constraint.
Definition: Type.h:4874
QualType getNonReferenceType() const
If Type is a reference type (e.g., const int&), returns the type that the reference refers to ("const...
Definition: Type.h:6452
QualType getBlockPointerType(QualType T) const
Return the uniqued reference to the type for a block of the specified type.
The base class of the type hierarchy.
Definition: Type.h:1450
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2889
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:63
Template argument deduction produced inconsistent deduced values for the given template parameter...
Definition: Sema.h:7768
NamedDecl * getParam(unsigned Idx)
Definition: DeclTemplate.h:138
A container of type source information.
Definition: Type.h:6227
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2752
Partial ordering of function templates for a call to a conversion function.
Definition: Template.h:166
bool TraverseTemplateName(TemplateName Template)
Recursively visit a template name and dispatch to the appropriate method.
void copy(AutoTypeLoc Loc)
Definition: TypeLoc.h:2044
TemplateDeductionResult FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned NumExplicitlySpecified, FunctionDecl *&Specialization, sema::TemplateDeductionInfo &Info, SmallVectorImpl< OriginalCallArg > const *OriginalCallArgs=nullptr, bool PartialOverloading=false, llvm::function_ref< bool()> CheckNonDependent=[]{ return false;})
Finish template argument deduction for a function template, checking the deduced template arguments f...
QualType getElementType() const
Definition: Type.h:2910
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
SourceRange getLocalSourceRange() const
Definition: TypeLoc.h:2031
static void MarkUsedTemplateParameters(ASTContext &Ctx, const TemplateArgument &TemplateArg, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark the template parameters that are used by this template argument.
TemplateName getTemplateName() const
Retrieve the name of the template that we are deducing.
Definition: Type.h:4958
This file provides some common utility functions for processing Lambda related AST Constructs...
unsigned getDepth() const
Get the nesting depth of the template parameter.
RAII object that enters a new expression evaluation context.
Definition: Sema.h:12029
Represents a variable declaration or definition.
Definition: Decl.h:820
void removeObjCLifetime()
Definition: Type.h:339
QualType getReturnType() const
Definition: Decl.h:2445
unsigned getNumParams() const
Definition: Type.h:3964
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
PrintingPolicy getPrintingPolicy() const
Retrieve a suitable printing policy for diagnostics.
Definition: Sema.h:2487
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:56
Extra information about a function prototype.
Definition: Type.h:3837
TemplateDeductionFlags
Various flags that control template argument deduction.
void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context, bool Canonical) const
Produce a unique representation of the given statement.
QualifiedTemplateName * getAsQualifiedTemplateName() const
Retrieve the underlying qualified template name structure, if any.
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
SourceLocation getLAngleLoc() const
Definition: DeclTemplate.h:196
RAII object used to temporarily allow the C++ &#39;this&#39; expression to be used, with the given qualifiers...
Definition: Sema.h:5616
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
bool isInvalidDecl() const
Definition: DeclBase.h:553
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
void clearSFINAEDiagnostic()
Discard any SFINAE diagnostics.
TemplateArgumentLoc SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, Decl *Param, SmallVectorImpl< TemplateArgument > &Converted, bool &HasDefaultArg)
If the given template parameter has a default template argument, substitute into that default templat...
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:211
bool isStatic() const
Definition: DeclCXX.cpp:1983
Whether we are performing template argument deduction for parameters and arguments in a top-level tem...
Represents a parameter to a function.
Definition: Decl.h:1595
Defines the clang::Expr interface and subclasses for C++ expressions.
TemplateParameter Param
The template parameter to which a template argument deduction failure refers.
QualType getIntegralType() const
Retrieve the type of the integral value.
Definition: TemplateBase.h:314
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclTemplate.h:443
The collection of all-type qualifiers we support.
Definition: Type.h:143
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
A semantic tree transformation that allows one to transform one abstract syntax tree into another...
Definition: TreeTransform.h:99
QualType adjustCCAndNoReturn(QualType ArgFunctionType, QualType FunctionType, bool AdjustExceptionSpec=false)
Adjust the type ArgFunctionType to match the calling convention, noreturn, and optionally the excepti...
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
FunctionType::ExtInfo ExtInfo
Definition: Type.h:3838
Represents a class template specialization, which refers to a class template with a given set of temp...
LocalInstantiationScope * CurrentInstantiationScope
The current instantiation scope used to store local variables.
Definition: Sema.h:8508
void setDeducedFromArrayBound(bool Deduced)
Specify whether the given non-type template argument was deduced from an array bound.
Definition: Template.h:216
TemplateArgument getPackExpansionPattern() const
When the template argument is a pack expansion, returns the pattern of the pack expansion.
QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
static TemplateArgument getEmptyPack()
Definition: TemplateBase.h:226
const TemplateArgument & get(unsigned Idx) const
Retrieve the template argument at a given index.
Definition: DeclTemplate.h:284
QualType getPointeeType() const
Definition: Type.h:2731
Expr * getAsExpr() const
Retrieve the template argument as an expression.
Definition: TemplateBase.h:329
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
Represents a dependent template name that cannot be resolved prior to template instantiation.
Definition: TemplateName.h:446
ArrayRef< QualType > getParamTypes() const
Definition: Type.h:3971
bool isObjCLifetimeType() const
Returns true if objects of this type have lifetime semantics under ARC.
Definition: Type.cpp:4080
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:71
TemplateDecl * getAsTemplateDecl() const
Retrieve the underlying template declaration that this template name refers to, if known...
bool IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base)
Determine whether the type Derived is a C++ class that is derived from the type Base.
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
TemplateName getTemplateName() const
Retrieve the name of the template that we are specializing.
Definition: Type.h:5059
const Type * getAsType() const
Retrieve the type stored in this nested name specifier.
static bool isVariadicFunctionTemplate(FunctionTemplateDecl *FunTmpl)
Determine whether this a function template whose parameter-type-list ends with a function parameter p...
Defines the ExceptionSpecificationType enumeration and various utility functions. ...
static Sema::TemplateDeductionResult CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template, ArrayRef< TemplateArgument > DeducedArgs, TemplateDeductionInfo &Info)
static TemplateArgumentList * CreateCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument list that copies the given set of template arguments.
bool isReferenceType() const
Definition: Type.h:6516
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:417
Represents the result of substituting a set of types for a template type parameter pack...
Definition: Type.h:4784
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc)
static NonTypeTemplateParmDecl * getDeducedParameterFromExpr(TemplateDeductionInfo &Info, Expr *E)
If the given expression is of a form that permits the deduction of a non-type template parameter...
void copyTemplateArgumentsInto(TemplateArgumentListInfo &List) const
Copies the template arguments into the given structure.
Definition: ExprCXX.h:3015
bool hasNonTrivialObjCLifetime() const
True if the lifetime is neither None or ExplicitNone.
Definition: Type.h:347
ConstraintSatisfaction AssociatedConstraintsSatisfaction
The constraint satisfaction details resulting from the associated constraints satisfaction tests...
Within template argument deduction from overload resolution per C++ [over.over] allow matching functi...
QualType getParamTypeForDecl() const
Definition: TemplateBase.h:268
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2399
Within template argument deduction from a function call, we are matching with a parameter type for wh...
Describes an C or C++ initializer list.
Definition: Expr.h:4403
void adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc)
Adjust the calling convention of a method to be the ABI default if it wasn&#39;t specified explicitly...
Definition: SemaType.cpp:7289
DeduceAutoResult DeduceAutoType(TypeSourceInfo *AutoType, Expr *&Initializer, QualType &Result, Optional< unsigned > DependentDeductionDepth=None, bool IgnoreConstraints=false)
FunctionTemplateDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this template.
bool isCompleteType(SourceLocation Loc, QualType T)
Definition: Sema.h:1817
An rvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2815
void setNameLoc(SourceLocation Loc)
Definition: TypeLoc.h:527
PtrTy get() const
Definition: Ownership.h:170
RefQualifierKind getRefQualifier() const
Retrieve the ref-qualifier associated with this method.
Definition: DeclCXX.h:2091
bool refersToBitField() const
Returns true if this expression is a gl-value that potentially refers to a bit-field.
Definition: Expr.h:446
TemplateSpecCandidateSet - A set of generalized overload candidates, used in template specializations...
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
All associated constraints of this partial specialization, including the requires clause and any cons...
bool hasAddressSpace() const
Definition: Type.h:358
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3561
bool isMoreSpecializedThanPrimary(ClassTemplatePartialSpecializationDecl *T, sema::TemplateDeductionInfo &Info)
QualType getNullPtrType() const
Retrieve the type for null non-type template argument.
Definition: TemplateBase.h:274
unsigned toTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:66
bool IsFunctionConversion(QualType FromType, QualType ToType, QualType &ResultTy)
Determine whether the conversion from FromType to ToType is a valid conversion that strips "noexcept"...
bool containsUnexpandedParameterPack() const
Whether this type is or contains an unexpanded parameter pack, used to support C++0x variadic templat...
Definition: Type.h:1896
Substitution of the deduced template argument values resulted in an error.
Definition: Sema.h:7776
SourceLocation RAngleLoc
The source location of the right angle bracket (&#39;>&#39;).
Definition: TemplateBase.h:617
LangAS getAddressSpace() const
Definition: Type.h:359
const TemplateArgument & getArg(unsigned Idx) const
Definition: TemplateBase.h:700
const Type * getClass() const
Definition: Type.h:2867
void MarkDeducedTemplateParameters(const FunctionTemplateDecl *FunctionTemplate, llvm::SmallBitVector &Deduced)
Definition: Sema.h:7965
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
static TemplateArgument CreatePackCopy(ASTContext &Context, ArrayRef< TemplateArgument > Args)
Create a new template argument pack by copying the given set of template arguments.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:6256
param_type_iterator param_type_begin() const
Definition: Type.h:4123
unsigned getIndex() const
Get the index of the template parameter within its parameter list.
const DependentSizedArrayType * getAsDependentSizedArrayType(QualType T) const
Definition: ASTContext.h:2475
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:828
TemplateArgumentLoc getIdentityTemplateArgumentLoc(NamedDecl *Param, SourceLocation Location)
Get a template argument mapping the given template parameter to itself, e.g.
SmallVector< DeducedTemplateArgument, 4 > New
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1818
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
bool isTypeDependent() const
isTypeDependent - Determines whether this expression is type-dependent (C++ [temp.dep.expr]), which means that its type could change from one template instantiation to the next.
Definition: Expr.h:176
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1817
bool hasConst() const
Definition: Type.h:260
Expr * getSizeExpr() const
Definition: Type.h:3115
TemplateArgumentLoc getTrivialTemplateArgumentLoc(const TemplateArgument &Arg, QualType NTTPType, SourceLocation Loc)
Allocate a TemplateArgumentLoc where all locations have been initialized to the given location...
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:877
QualType getElementType() const
Definition: Type.h:3211
RAII object used to change the argument pack substitution index within a Sema object.
Definition: Sema.h:8206
Represents an extended vector type where either the type or size is dependent.
Definition: Type.h:3195
This object can be modified without requiring retains or releases.
Definition: Type.h:164
TyLocType push(QualType T)
Pushes space for a new TypeLoc of the given type.
A helper class for building up ExtParameterInfos.
Definition: Sema.h:8617
Class that aids in the construction of nested-name-specifiers along with source-location information ...
static bool diagnoseAutoDeductionFailure(Sema &S, Sema::TemplateDeductionResult TDK, TemplateDeductionInfo &Info, ArrayRef< SourceRange > Ranges)
Attempt to produce an informative diagostic explaining why auto deduction failed. ...
bool isExpandedParameterPack() const
Whether this parameter is a non-type template parameter pack that has a known list of different types...
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3653
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:8450
Expr * getAddrSpaceExpr() const
Definition: Type.h:3166
Provides definitions for the various language-specific address spaces.
static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, TemplateArgument Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
void adjustDeducedFunctionResultType(FunctionDecl *FD, QualType ResultType)
Change the result type of a function type once it is deduced.
bool hasAttr() const
Definition: DeclBase.h:542
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc, FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1)
Determine whether the function template FT1 is at least as specialized as FT2.
bool CheckTemplateArgument(NamedDecl *Param, TemplateArgumentLoc &Arg, NamedDecl *Template, SourceLocation TemplateLoc, SourceLocation RAngleLoc, unsigned ArgumentPackIndex, SmallVectorImpl< TemplateArgument > &Converted, CheckTemplateArgumentKind CTAK=CTAK_Specified)
Check that the given template argument corresponds to the given template parameter.
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
bool compatiblyIncludes(Qualifiers other) const
Determines if these qualifiers compatibly include another set.
Definition: Type.h:496
void reset(TemplateArgumentList *NewDeduced)
Provide a new template argument list that contains the results of template argument deduction...
bool isStdInitializerList(QualType Ty, QualType *Element)
Tests whether Ty is an instance of std::initializer_list and, if it is and Element is not NULL...
std::pair< unsigned, unsigned > getDepthAndIndex(NamedDecl *ND)
Retrieve the depth and index of a template parameter.
Definition: SemaInternal.h:65
static bool hasDeducibleTemplateParameters(Sema &S, FunctionTemplateDecl *FunctionTemplate, QualType T)
Template argument deduction did not deduce a value for every template parameter.
Definition: Sema.h:7762
bool isNonOverloadPlaceholderType() const
Test for a placeholder type other than Overload; see BuiltinType::isNonOverloadPlaceholderType.
Definition: Type.h:6771
bool hasQualifiers() const
Determine whether this type has any qualifiers.
Definition: Type.h:6331
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:978
static Sema::TemplateDeductionResult DeduceFromInitializerList(Sema &S, TemplateParameterList *TemplateParams, QualType AdjustedParamType, InitListExpr *ILE, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< Sema::OriginalCallArg > &OriginalCallArgs, unsigned ArgIdx, unsigned TDF)
Attempt template argument deduction from an initializer list deemed to be an argument in a function c...
The result of a constraint satisfaction check, containing the necessary information to diagnose an un...
Definition: ASTConcept.h:29
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
ValueDecl * getAsDecl() const
Retrieve the declaration for a declaration non-type template argument.
Definition: TemplateBase.h:263
static bool isSimpleTemplateIdType(QualType T)
Determine whether the given type T is a simple-template-id type.
void setExplicitArgs(TemplateArgumentList *NewDeduced)
Provide an initial template argument list that contains the explicitly-specified arguments.
void runWithSufficientStackSpace(llvm::function_ref< void()> Diag, llvm::function_ref< void()> Fn)
Run a given function on a stack with "sufficient" space.
Definition: Stack.h:40
Represents an array type in C++ whose size is a value-dependent expression.
Definition: Type.h:3093
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:421
static Sema::TemplateDeductionResult DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, QualType NullPtrType, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
Deduce the value of the given non-type template parameter from the given null pointer template argume...
A single parameter index whose accessors require each use to make explicit the parameter index encodi...
Definition: Attr.h:212
QualType getInjectedSpecializationType() const
Retrieves the injected specialization type for this partial specialization.
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5455
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
This represents one expression.
Definition: Expr.h:108
Defines the clang::LangOptions interface.
QualType getPointeeType() const
Definition: Type.h:2771
SourceLocation getLocation() const
Returns the location at which template argument is occurring.
static Sema::TemplateDeductionResult DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams, NonTypeTemplateParmDecl *NTTP, const DeducedTemplateArgument &NewDeduced, QualType ValueType, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced)
Deduce the value of the given non-type template parameter as the given deduced template argument...
Declaration of a template type parameter.
unsigned getIndex() const
Definition: Type.h:4691
static DeclContext * getAsDeclContextOrEnclosing(Decl *D)
static FindResult find(Expr *E)
Finds the overloaded expression in the given expression E of OverloadTy.
Definition: ExprCXX.h:2904
bool CheckConstraintSatisfaction(const NamedDecl *Template, ArrayRef< const Expr *> ConstraintExprs, ArrayRef< TemplateArgument > TemplateArgs, SourceRange TemplateIDRange, ConstraintSatisfaction &Satisfaction)
Check whether the given list of constraint expressions are satisfied (as if in a &#39;conjunction&#39;) given...
static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(Sema &S, TemplateParameterList *TemplateParams, QualType Param, QualType Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, unsigned TDF, bool PartialOrdering=false, bool DeducedFromArrayBound=false)
Deduce the template arguments by comparing the parameter type and the argument type (C++ [temp...
static Sema::TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType ParamType, Expr *Arg, TemplateDeductionInfo &Info, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< Sema::OriginalCallArg > &OriginalCallArgs, bool DecomposedParam, unsigned ArgIdx, unsigned TDF)
Perform template argument deduction per [temp.deduct.call] for a single parameter / argument pair...
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs.
Definition: TemplateBase.h:620
SourceLocation getLAngleLoc() const
Definition: TypeLoc.h:1998
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:67
static bool ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, DeducedTemplateArgument Arg, NamedDecl *Template, TemplateDeductionInfo &Info, bool IsDeduced, SmallVectorImpl< TemplateArgument > &Output)
Convert the given deduced template argument and add it to the set of fully-converted template argumen...
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:88
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
unsigned getNumInits() const
Definition: Expr.h:4433
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3669
bool CheckTemplateArgumentList(TemplateDecl *Template, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs, SmallVectorImpl< TemplateArgument > &Converted, bool UpdateArgsWithConversions=true, bool *ConstraintsNotSatisfied=nullptr)
Check that the given template arguments can be be provided to the given template, converting the argu...
void completeExprArrayBound(Expr *E)
Definition: SemaType.cpp:7821
#define bool
Definition: stdbool.h:15
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
ObjCLifetime getObjCLifetime() const
Definition: Type.h:333
DeclContext * getDeclContext()
Definition: DeclBase.h:438
static Sema::DeduceAutoResult CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type, AutoTypeLoc TypeLoc, QualType Deduced)
llvm::PointerUnion< TemplateTypeParmDecl *, NonTypeTemplateParmDecl *, TemplateTemplateParmDecl * > TemplateParameter
Stores a template parameter of any kind.
Definition: DeclTemplate.h:63
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:293
NonTypeTemplateParmDecl - Declares a non-type template parameter, e.g., "Size" in.
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
Represents a C++ template name within the type system.
Definition: TemplateName.h:191
decls_iterator decls_begin() const
Definition: ExprCXX.h:2936
Defines the clang::TypeLoc interface and its subclasses.
int Depth
Definition: ASTDiff.cpp:190
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
ArrayRef< Expr * > inits()
Definition: Expr.h:4443
AutoType * getContainedAutoType() const
Get the AutoType whose type will be deduced for a variable with an initializer of this type...
Definition: Type.h:2251
FunctionDecl * ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain=false, DeclAccessPair *Found=nullptr)
Given an expression that refers to an overloaded function, try to resolve that overloaded function ex...
bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg)
Compare types for equality with respect to possibly compatible function types (noreturn adjustment...
bool isInvalid() const
QualType getType() const
Definition: Expr.h:137
TemplateDeductionResult SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate, TemplateArgumentListInfo &ExplicitTemplateArgs, SmallVectorImpl< DeducedTemplateArgument > &Deduced, SmallVectorImpl< QualType > &ParamTypes, QualType *FunctionType, sema::TemplateDeductionInfo &Info)
Substitute the explicitly-provided template arguments into the given function template according to C...
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
Data structure that captures multiple levels of template argument lists for use in template instantia...
Definition: Template.h:64
bool isInvalid() const
Definition: Ownership.h:166
SourceLocation getEnd() const
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1401
bool DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose=true)
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2797
TemplateTemplateParmDecl - Declares a template template parameter, e.g., "T" in.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4209
Common base class for placeholders for types that get replaced by placeholder type deduction: C++11 a...
Definition: Type.h:4833
const FunctionProtoType::ExtParameterInfo * getPointerOrNull(unsigned numParams)
Return a pointer (suitable for setting in an ExtProtoInfo) to the ExtParameterInfo array we&#39;ve built ...
Definition: Sema.h:8636
bool isPackExpansion() const
Determine whether this template argument is a pack expansion.
ValueDecl * getDecl()
Definition: Expr.h:1247
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1842
After substituting deduced template arguments, a dependent parameter type did not match the correspon...
Definition: Sema.h:7779
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2713
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1417
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
void removeCVRQualifiers(unsigned mask)
Definition: Type.h:283
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:265
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1111
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6289
Captures a template argument whose value has been deduced via c++ template argument deduction...
Definition: Template.h:189
static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, QualType ArgType)
Determine whether the parameter has qualifiers that the argument lacks.
bool hasTrailingReturn() const
Whether this function prototype has a trailing return type.
Definition: Type.h:4102
RecordDecl * getDecl() const
Definition: Type.h:4505
static unsigned getPackIndexForParam(Sema &S, FunctionTemplateDecl *FunctionTemplate, const MultiLevelTemplateArgumentList &Args, unsigned ParamIdx)
Find the pack index for a particular parameter index in an instantiation of a function template with ...
SmallVector< DeducedPack *, 8 > PendingDeducedPacks
Information on packs that we&#39;re currently expanding.
CanQualType OverloadTy
Definition: ASTContext.h:1045
There is no lifetime qualification on this type.
Definition: Type.h:160
AutoTypeLoc getContainedAutoTypeLoc() const
Get the typeloc of an AutoType whose type will be deduced for a variable with an initializer of this ...
Definition: TypeLoc.cpp:681
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:171
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2844
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
FunctionDecl * resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &FoundResult)
Given an expression that refers to an overloaded function, try to resolve that function to a single f...
A stack object to be created when performing template instantiation.
Definition: Sema.h:8243
Stores a list of template parameters and the associated requires-clause (if any) for a TemplateDecl a...
Definition: DeclTemplate.h:217
ExtProtoInfo getExtProtoInfo() const
Definition: Type.h:3975
bool Subst(const TemplateArgumentLoc *Args, unsigned NumArgs, TemplateArgumentListInfo &Result, const MultiLevelTemplateArgumentList &TemplateArgs)
The template argument was deduced from an array bound via template argument deduction.
Definition: Sema.h:7154
SourceLocation getNameLoc() const
Gets the location of the name.
Definition: ExprCXX.h:2956
const ExtParameterInfo * ExtParameterInfos
Definition: Type.h:3844
DeduceAutoResult
Result type of DeduceAutoType.
Definition: Sema.h:7886
Encodes a location in the source.
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
static TemplateParameter makeTemplateParameter(Decl *D)
Helper function to build a TemplateParameter when we don&#39;t know its type statically.
QualType getReturnType() const
Definition: Type.h:3680
bool hasSameTemplateName(TemplateName X, TemplateName Y)
Determine whether the given template names refer to the same template.
llvm::APSInt APSInt
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6377
Template argument deduction failed due to inconsistent cv-qualifiers on a template parameter type tha...
Definition: Sema.h:7773
TemplateArgument getArgumentPack() const
Definition: Type.cpp:3403
static bool isSameTemplate(TemplateDecl *T1, TemplateDecl *T2)
Determine if the two templates are equivalent.
QualType getElementType() const
Definition: Type.h:3270
static QualType getUnderlyingType(const SubRegion *R)
Template argument deduction did not deduce a value for every expansion of an expanded template parame...
Definition: Sema.h:7765
Within template argument deduction from a function call, we are matching in a case where we ignore cv...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2466
bool hasExceptionSpec() const
Return whether this function has any kind of exception spec.
Definition: Type.h:3995
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2422
void DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init)
void reserve(size_t Requested)
Ensures that this buffer has at least as much capacity as described.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
unsigned pack_size() const
The number of template arguments in the given template argument pack.
Definition: TemplateBase.h:359
QualType getInjectedClassNameSpecialization()
Retrieve the template specialization type of the injected-class-name for this class template...
Qualifiers getMethodQuals() const
Definition: Type.h:4104
const TemplateTypeParmType * getReplacedParameter() const
Gets the template parameter that was substituted for.
Definition: Type.h:4802
Expr * getNoexceptExpr() const
Return the expression inside noexcept(expression), or a null pointer if there is none (because the ex...
Definition: Type.h:4047
SourceLocation getRAngleLoc() const
Definition: TypeLoc.h:2006
TemplateDeductionResult DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, const TemplateArgumentList &TemplateArgs, sema::TemplateDeductionInfo &Info)
Perform template argument deduction to determine whether the given template arguments match the given...
Qualifiers withoutObjCLifetime() const
Definition: Type.h:321
TypeSourceInfo * SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto, QualType Replacement)
Substitute Replacement for auto in TypeWithAuto.
bool isMemberFunctionPointerType() const
Definition: Type.h:6556
bool isObjCObjectPointerType() const
Definition: Type.h:6618
bool isAnyPointerType() const
Definition: Type.h:6508
static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD)
Get the index of the first template parameter that was originally from the innermost template-paramet...
Within template argument deduction from a function call, we are matching in a case where we can perfo...
llvm::APInt APInt
Definition: Integral.h:27
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3274
bool isLValue() const
isLValue - True if this expression is an "l-value" according to the rules of the current language...
Definition: Expr.h:258
static bool isSameDeclaration(Decl *X, Decl *Y)
Determine whether two declaration pointers refer to the same declaration.
AutoTypeKeyword getKeyword() const
Definition: Type.h:4920
TypeClass getTypeClass() const
Definition: Type.h:1876
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3263
llvm::APSInt getAsIntegral() const
Retrieve the template argument as an integral value.
Definition: TemplateBase.h:300
SourceLocation getRAngleLoc() const
Definition: DeclTemplate.h:197
bool isTargetAddressSpace(LangAS AS)
Definition: AddressSpaces.h:62
unsigned getDeducedDepth() const
The depth of template parameters for which deduction is being performed.
diag_iterator diag_end() const
Returns an iterator at the end of the sequence of suppressed diagnostics.
An rvalue ref-qualifier was provided (&&).
Definition: Type.h:1409
void removeObjCGCAttr()
Definition: Type.h:311
unsigned getFullDataSize() const
Returns the size of the type source info data block.
Definition: TypeLoc.h:163
Optional< unsigned > getNumExpansions() const
Retrieve the number of expansions that this pack expansion will generate, if known.
Definition: Type.h:5536
bool isCanonical() const
Definition: Type.h:6300
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
DependentTemplateName * getAsDependentTemplateName() const
Retrieve the underlying dependent template name structure, if any.
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2345
static bool hasPackExpansionBeforeEnd(ArrayRef< TemplateArgument > Args)
Determine whether the given set of template arguments has a pack expansion that is not the last templ...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:224
QualType getArrayDecayedType(QualType T) const
Return the properly qualified result of decaying the specified array type to a pointer.
The injected class name of a C++ class template or class template partial specialization.
Definition: Type.h:5133
CanProxy< U > getAs() const
Retrieve a canonical type pointer with a different static type, upcasting or downcasting as needed...
QualType getPointeeType() const
Definition: Type.h:3167
Represents a pack expansion of types.
Definition: Type.h:5511
FunctionTemplateDecl * getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, FunctionTemplateDecl *FT2, SourceLocation Loc, TemplatePartialOrderingContext TPOC, unsigned NumCallArguments1, unsigned NumCallArguments2)
Returns the more specialized function template according to the rules of function template partial or...
ArrayRef< TemplateArgument > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:353
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
bool isPlaceholderType() const
Test for a type which does not represent an actual type-system type but is instead used as a placehol...
Definition: Type.h:6751
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments.
Definition: TemplateBase.h:626
static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn)
Gets the type of a function for template-argument-deducton purposes when it&#39;s considered as part of a...
static std::enable_if< IsPartialSpecialization< T >::value, Sema::TemplateDeductionResult >::type FinishTemplateArgumentDeduction(Sema &S, T *Partial, bool IsPartialOrdering, const TemplateArgumentList &TemplateArgs, SmallVectorImpl< DeducedTemplateArgument > &Deduced, TemplateDeductionInfo &Info)
Complete template argument deduction for a partial specialization.
Represents a template argument.
Definition: TemplateBase.h:50
QualType getTemplateSpecializationType(TemplateName T, ArrayRef< TemplateArgument > Args, QualType Canon=QualType()) const
void collectUnexpandedParameterPacks(TemplateArgument Arg, SmallVectorImpl< UnexpandedParameterPack > &Unexpanded)
Collect the set of unexpanded parameter packs within the given template argument. ...
Represents a template name that was expressed as a qualified name.
Definition: TemplateName.h:390
GC getObjCGCAttr() const
Definition: Type.h:307
Dataflow Directional Tag Classes.
void getInjectedTemplateArgs(const TemplateParameterList *Params, SmallVectorImpl< TemplateArgument > &Args)
Get a template argument list with one argument per template parameter in a template parameter list...
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1427
const TemplateArgument & getArgument() const
Definition: TemplateBase.h:498
NestedNameSpecifier * getQualifier() const
Definition: Type.h:5446
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
CanQualType NullPtrTy
Definition: ASTContext.h:1044
static QualType ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Expr *Arg, QualType ParamType, bool ParamWasReference)
Apply the deduction rules for overload sets.
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:402
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:529
QualType getType() const
Get the type for which this source info wrapper provides information.
Definition: TypeLoc.h:132
The template argument is a pack expansion of a template name that was provided for a template templat...
Definition: TemplateBase.h:79
Qualifiers getMethodQualifiers() const
Definition: DeclCXX.h:2076
A non-depnedent component of the parameter did not match the corresponding component of the argument...
Definition: Sema.h:7786
FunctionDecl * getTemplateInstantiationPattern() const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3612
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2046
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4015
SourceLocation LAngleLoc
The source location of the left angle bracket (&#39;<&#39;).
Definition: TemplateBase.h:614
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2833
bool isParameterPack() const
Determine whether this variable is actually a function parameter pack or init-capture pack...
Definition: Decl.cpp:2464
bool hasObjCLifetime() const
Definition: Type.h:332
void setCVRQualifiers(unsigned mask)
Definition: Type.h:279
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1421
bool wasDeducedFromArrayBound() const
For a non-type template argument, determine whether the template argument was deduced from an array b...
Definition: Template.h:212
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:339
bool isNull() const
Determine whether this template argument has no value.
Definition: TemplateBase.h:237
No template argument deduction flags, which indicates the strictest results for template argument ded...
bool isUndeducedType() const
Determine whether this type is an undeduced type, meaning that it somehow involves a C++11 &#39;auto&#39; typ...
Definition: Type.h:6900
Allow non-dependent types to differ, e.g., when performing template argument deduction from a functio...
unsigned getDepth() const
Get the depth of this template parameter list in the set of template parameter lists.
Represents a pointer to an Objective C object.
Definition: Type.h:5951
Pointer to a block type.
Definition: Type.h:2716
static bool isForwardingReference(QualType Param, unsigned FirstInnerIndex)
Determine whether a type denotes a forwarding reference.
unsigned getIntWidth(QualType T) const
bool isIncompleteArrayType() const
Definition: Type.h:6578
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
Complex values, per C99 6.2.5p11.
Definition: Type.h:2554
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
unsigned getNumArgs() const
Retrieve the number of template arguments.
Definition: Type.h:5067
The template argument was specified in the code or was instantiated with some deduced template argume...
Definition: Sema.h:7146
TemplateArgumentList * take()
Take ownership of the deduced template argument list.
CanThrowResult canThrow() const
Determine whether this function type has a non-throwing exception specification.
Definition: Type.cpp:3098
const TemplateArgument & getArg(unsigned Idx) const
Retrieve a specific template argument as a type.
Definition: TemplateBase.h:694
const llvm::APInt & getSize() const
Definition: Type.h:2958
CanQualType DependentTy
Definition: ASTContext.h:1045
bool isFunctionType() const
Definition: Type.h:6500
ExtVectorType - Extended vector type.
Definition: Type.h:3354
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2321
The deduced arguments did not satisfy the constraints associated with the template.
Definition: Sema.h:7800
The template argument is a type.
Definition: TemplateBase.h:59
Deduction failed; that&#39;s all we know.
Definition: Sema.h:7802
TemplateArgument getInjectedTemplateArg(NamedDecl *ParamDecl)
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
The template argument is actually a parameter pack.
Definition: TemplateBase.h:90
static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, TemplateParameterList *TemplateParams, unsigned FirstInnerIndex, QualType &ParamType, QualType &ArgType, Expr *Arg, unsigned &TDF)
Perform the adjustments to the parameter and argument types described in C++ [temp.deduct.call].
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
bool hasObjCGCAttr() const
Definition: Type.h:306
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
A template argument list.
Definition: DeclTemplate.h:239
bool isLValueReferenceType() const
Definition: Type.h:6520
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:244
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:14781
pack_iterator pack_end() const
Iterator referencing one past the last argument of a template argument pack.
Definition: TemplateBase.h:346
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:234
unsigned getDepth() const
Definition: Type.h:4690
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
QualType getParamType(unsigned i) const
Definition: Type.h:3966
Defines the clang::SourceLocation class and associated facilities.
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Within template argument deduction for a conversion function, we are matching with an argument type f...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6336
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:5420
ArrayRef< TemplateArgument > template_arguments() const
Definition: Type.h:5075
void getAssociatedConstraints(llvm::SmallVectorImpl< const Expr *> &AC) const
Get the total constraint-expression associated with this template, including constraint-expressions d...
QualType getRValueReferenceType(QualType T) const
Return the uniqued reference to the type for an rvalue reference to the specified type...
bool isVoidType() const
Definition: Type.h:6777
The template argument is a template name that was provided for a template template parameter...
Definition: TemplateBase.h:75
unsigned getNumExplicitArgs() const
Get the number of explicitly-specified arguments.
Represents a C array with an unspecified size.
Definition: Type.h:2995
TemplateName getCanonicalTemplateName(TemplateName Name) const
Retrieves the "canonical" template name that refers to a given template.
bool hasExplicitTemplateArgs() const
Definition: TypeLoc.h:1994
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6283
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that&#39;s ...
TPOC
The context in which partial ordering of function templates occurs.
Definition: Template.h:160
Location information for a TemplateArgument.
Definition: TemplateBase.h:392
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:397
TemplateArgument SecondArg
The second template argument to which the template argument deduction failure refers.
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:223
Declaration of a class template.
Partial ordering of function templates for a function call.
Definition: Template.h:162
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
After substituting deduced template arguments, an element of a dependent parameter type did not match...
Definition: Sema.h:7783
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
A pack that we&#39;re currently deducing.
DeducedTemplateArgument Saved
SourceLocation getNameLoc() const
Definition: TypeLoc.h:523
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3868
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
unsigned getCVRQualifiers() const
Definition: Type.h:276
static bool isSameTemplateArg(ASTContext &Context, TemplateArgument X, const TemplateArgument &Y, bool PackExpansionMatchesPack=false)
Determine whether two template arguments are the same.
QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement)
Completely replace the auto in TypeWithAuto by Replacement.
Decl * SubstDecl(Decl *D, DeclContext *Owner, const MultiLevelTemplateArgumentList &TemplateArgs)
ClassTemplatePartialSpecializationDecl * getMoreSpecializedPartialSpecialization(ClassTemplatePartialSpecializationDecl *PS1, ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc)
Returns the more specialized class template partial specialization according to the rules of partial ...
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:947
CanQualType IntTy
Definition: ASTContext.h:1025
unsigned getNumElements() const
Definition: Type.h:3271
bool IsQualificationConversion(QualType FromType, QualType ToType, bool CStyle, bool &ObjCLifetimeConversion)
IsQualificationConversion - Determines whether the conversion from an rvalue of type FromType to ToTy...
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2150
QualType getAsType() const
Retrieve the type for a type template argument.
Definition: TemplateBase.h:256
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
Represents an extended address space qualifier where the input address space value is dependent...
Definition: Type.h:3153
Represents a type template specialization; the template must be a class template, a type alias templa...
Definition: Type.h:4996
Optional< unsigned > getNumArgumentsInExpansion(QualType T, const MultiLevelTemplateArgumentList &TemplateArgs)
Determine the number of arguments in the given pack expansion type.
void MarkUsedTemplateParameters(const Expr *E, bool OnlyDeduced, unsigned Depth, llvm::SmallBitVector &Used)
Mark which template parameters are used in a given expression.
bool isPointerType() const
Definition: Type.h:6504
TemplateArgumentLoc getArgLoc(unsigned i) const
Definition: TypeLoc.h:2026
unsigned CallArgIndex
The index of the function argument that caused a deduction failure.
void NoteCandidates(Sema &S, SourceLocation Loc)
NoteCandidates - When no template specialization match is found, prints diagnostic messages containin...
TemplateArgument FirstArg
The first template argument to which the template argument deduction failure refers.
TypeSourceInfo * SubstType(TypeSourceInfo *T, const MultiLevelTemplateArgumentList &TemplateArgs, SourceLocation Loc, DeclarationName Entity, bool AllowDeducedTST=false)
Perform substitution on the type T with a given set of template arguments.
QualType getType() const
Definition: Decl.h:630
static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y)
Compare two APSInts, extending and switching the sign as necessary to compare their values regardless...
static bool hasTemplateArgumentForDeduction(ArrayRef< TemplateArgument > &Args, unsigned &ArgIdx)
Determine whether there is a template argument to be used for deduction.
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
Wrapper for template type parameters.
Definition: TypeLoc.h:734
A trivial tuple used to represent a source range.
ASTContext & Context
Definition: Sema.h:385
FunctionDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3158
This represents a decl that may have a name.
Definition: Decl.h:223
Partial ordering of function templates in other contexts, e.g., taking the address of a function temp...
Definition: Template.h:171
static Optional< unsigned > getExpandedPackSize(NamedDecl *Param)
If Param is an expanded parameter pack, get the number of expansions.
CanQualType BoolTy
Definition: ASTContext.h:1017
static void AddImplicitObjectParameterType(ASTContext &Context, CXXMethodDecl *Method, SmallVectorImpl< QualType > &ArgTypes)
If this is a non-static member function,.
QualType getNonTypeTemplateArgumentType() const
If this is a non-type template argument, get its type.
TemplateName getAsTemplate() const
Retrieve the template name for a template name argument.
Definition: TemplateBase.h:280
The template argument was deduced via template argument deduction.
Definition: Sema.h:7150
const ExtParameterInfo * getExtParameterInfosOrNull() const
Return a pointer to the beginning of the array of extra parameter information, if present...
Definition: Type.h:4161
ConceptDecl * getTypeConstraintConcept() const
Definition: Type.h:4908
bool isFunctionPointerType() const
Definition: Type.h:6538
TemplateName getAsTemplateOrTemplatePattern() const
Retrieve the template argument as a template name; if the argument is a pack expansion, return the pattern as a template name.
Definition: TemplateBase.h:287
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3242
void removeAddressSpace()
Definition: Type.h:384
brief A function argument from which we performed template argument
Definition: Sema.h:7826
TemplateDecl * getDeducedTemplate() const
Get the template for which this guide performs deduction.
Definition: DeclCXX.h:1879
const LangOptions & getLangOpts() const
Definition: ASTContext.h:724
diag_iterator diag_begin() const
Returns an iterator at the beginning of the sequence of suppressed diagnostics.
decls_iterator decls_end() const
Definition: ExprCXX.h:2939
QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent, bool IsPack=false, ConceptDecl *TypeConstraintConcept=nullptr, ArrayRef< TemplateArgument > TypeConstraintArgs={}) const
C++11 deduced auto type.
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2935
Declaration of a template function.
Definition: DeclTemplate.h:977
SourceLocation getConceptNameLoc() const
Definition: TypeLoc.h:1972
QualType getUnqualifiedArrayType(QualType T, Qualifiers &Quals)
Return this type as a completely-unqualified array type, capturing the qualifiers in Quals...
DeducedTemplateArgument DeferredDeduction
SourceLocation getLocation() const
Definition: DeclBase.h:429
QualType getPointeeType() const
Definition: Type.h:2853
CanQualType UnsignedIntTy
Definition: ASTContext.h:1026
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:8481
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
param_type_iterator param_type_end() const
Definition: Type.h:4127
A RAII object to temporarily push a declaration context.
Definition: Sema.h:797