Lines Matching full:deduced
139 SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
148 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
159 llvm::SmallBitVector &Deduced);
210 /// Verify that the given, deduced template arguments are compatible.
212 /// \returns The deduced template argument, or a NULL template argument if
213 /// the deduced template arguments were incompatible.
225 // If we have two non-type template argument values deduced for the same in checkDeducedTemplateArguments()
228 // for that now. The exception is that if either was deduced from an array in checkDeducedTemplateArguments()
241 llvm_unreachable("Non-deduced template arguments handled above"); in checkDeducedTemplateArguments()
251 // If one of the two arguments was deduced from an array bound, the other in checkDeducedTemplateArguments()
261 // If we deduced a constant in one case and either a dependent expression or in checkDeducedTemplateArguments()
274 // If we deduced a value and a dependent expression, keep the value. in checkDeducedTemplateArguments()
318 // If we deduced a declaration and a dependent expression, keep the in checkDeducedTemplateArguments()
323 // If we deduced a declaration and an integral constant, keep the in checkDeducedTemplateArguments()
333 // If we deduced two declarations, make sure that they refer to the in checkDeducedTemplateArguments()
343 // If we deduced a null pointer and a dependent expression, keep the in checkDeducedTemplateArguments()
350 // If we deduced a null pointer and an integral constant, keep the in checkDeducedTemplateArguments()
355 // If we deduced two null pointers, they are the same. in checkDeducedTemplateArguments()
396 /// as the given deduced template argument. All non-type template parameter
403 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceNonTypeTemplateArgument() argument
408 S.Context, Deduced[NTTP->getIndex()], NewDeduced); in DeduceNonTypeTemplateArgument()
411 Info.FirstArg = Deduced[NTTP->getIndex()]; in DeduceNonTypeTemplateArgument()
416 Deduced[NTTP->getIndex()] = Result; in DeduceNonTypeTemplateArgument()
445 S, TemplateParams, ParamType, ValueType, Info, Deduced, in DeduceNonTypeTemplateArgument()
456 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceNonTypeTemplateArgument() argument
461 ValueType, Info, Deduced); in DeduceNonTypeTemplateArgument()
470 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceNullPtrTemplateArgument() argument
480 Value->getType(), Info, Deduced); in DeduceNullPtrTemplateArgument()
491 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceNonTypeTemplateArgument() argument
494 Value->getType(), Info, Deduced); in DeduceNonTypeTemplateArgument()
505 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceNonTypeTemplateArgument() argument
509 S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced); in DeduceNonTypeTemplateArgument()
572 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceTemplateArguments() argument
619 Deduced[TempParam->getIndex()], in DeduceTemplateArguments()
623 Info.FirstArg = Deduced[TempParam->getIndex()]; in DeduceTemplateArguments()
628 Deduced[TempParam->getIndex()] = Result; in DeduceTemplateArguments()
655 /// \param Deduced the deduced template arguments
676 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceTemplateSpecArguments() argument
724 AResolved, Deduced); in DeduceTemplateSpecArguments()
732 Info, Deduced, in DeduceTemplateSpecArguments()
756 SA->getTemplateArgs().asArray(), Deduced); in DeduceTemplateSpecArguments()
762 SA->getTemplateArgs().asArray(), Info, Deduced, in DeduceTemplateSpecArguments()
819 // deduced because this deduction hadn't happened yet.
838 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in PackDeductionScope() argument
841 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info), in PackDeductionScope()
849 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in PackDeductionScope() argument
851 : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { in PackDeductionScope()
858 // Save the deduced template argument for the parameter pack expanded in addPack()
860 DeducedFromEarlierParameter = !Deduced[Index].isNull(); in addPack()
862 Pack.Saved = Deduced[Index]; in addPack()
863 Deduced[Index] = TemplateArgument(); in addPack()
888 // packs appearing in that parameter to have the same deduced arity. Also, in addPacks()
890 // type, so we need to collect the pending deduced values for those packs. in addPacks()
918 // Also look for unexpanded packs that are indirectly deduced by deducing in addPacks()
969 // We pre-populate the deduced value of the partially-substituted in finishConstruction()
971 // value is supposed to have been substituted, not deduced, but the in finishConstruction()
978 Deduced[Pack.Index] = Pack.New[PackElements]; in finishConstruction()
1000 /// Determine whether this pack has already been deduced from a previous
1022 /// Move to deducing the next element in each pack that is being deduced.
1024 // Capture the deduced template arguments for each parameter pack expanded in nextPackElement()
1025 // by this pack expansion, add them to the list of arguments we've deduced in nextPackElement()
1026 // for that pack, then clear out the deduced argument. in nextPackElement()
1028 DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; in nextPackElement()
1052 Deduced[Pack.Index] = Pack.Saved; in finish()
1072 // If we deduced an empty argument pack, create it now. in finish()
1081 // deduced from an array bound and others are not: in finish()
1099 Loc = &Deduced[Pack.Index]; in finish()
1146 SmallVectorImpl<DeducedTemplateArgument> &Deduced; member in __anonc4c693d00111::PackDeductionScope
1178 /// \param Deduced the deduced template arguments
1195 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in DeduceTemplateArguments() argument
1224 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF, in DeduceTemplateArguments()
1242 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); in DeduceTemplateArguments()
1245 // a non-deduced context. in DeduceTemplateArguments()
1251 Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF, in DeduceTemplateArguments()
1260 // The non-deduced contexts are: in DeduceTemplateArguments()
1271 // entire template-argument-list a non-deduced context. in DeduceTemplateArguments()
1310 /// a deduced set of qualifiers to the ParamType that would result in
1399 /// \param Deduced the deduced template arguments.
1408 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceTemplateBases() argument
1411 // transformed A can be a derived class of the deduced A. Likewise if in DeduceTemplateBases()
1414 // deduced A. However, if there is a class C that is a (direct or in DeduceTemplateBases()
1416 // class B and that would be a valid deduced A, the deduced A cannot be in DeduceTemplateBases()
1420 // otherwise fail. If they yield more than one possible deduced A, the in DeduceTemplateBases()
1453 SmallVector<DeducedTemplateArgument, 8> DeducedCopy(Deduced.begin(), in DeduceTemplateBases()
1454 Deduced.end()); in DeduceTemplateBases()
1496 std::swap(Matches.front().second, Deduced); in DeduceTemplateBases()
1513 /// \param Deduced the deduced template arguments
1527 SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF, in DeduceTemplateArgumentsByTypeMatch() argument
1592 // - If the original P is a reference type, the deduced A (i.e., the type in DeduceTemplateArgumentsByTypeMatch()
1613 // deduced as X&. - end note ] in DeduceTemplateArgumentsByTypeMatch()
1623 // template non-type argument i can be deduced if P and A have one of in DeduceTemplateArgumentsByTypeMatch()
1666 // Remove any qualifiers on the parameter from the deduced type. in DeduceTemplateArgumentsByTypeMatch()
1701 checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced); in DeduceTemplateArgumentsByTypeMatch()
1704 Info.FirstArg = Deduced[Index]; in DeduceTemplateArgumentsByTypeMatch()
1709 Deduced[Index] = Result; in DeduceTemplateArgumentsByTypeMatch()
1732 // than the deduced A in DeduceTemplateArgumentsByTypeMatch()
1778 // non-deduced context. in DeduceTemplateArgumentsByTypeMatch()
1808 Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
1818 Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
1833 PointeeType, Info, Deduced, in DeduceTemplateArgumentsByTypeMatch()
1846 Deduced, 0); in DeduceTemplateArgumentsByTypeMatch()
1858 Deduced, 0); in DeduceTemplateArgumentsByTypeMatch()
1872 Deduced, TDF & TDF_IgnoreQualifiers); in DeduceTemplateArgumentsByTypeMatch()
1885 Deduced, TDF & TDF_IgnoreQualifiers); in DeduceTemplateArgumentsByTypeMatch()
1899 Info, Deduced, TDF & TDF_IgnoreQualifiers); in DeduceTemplateArgumentsByTypeMatch()
1917 /*ArrayBound=*/true, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
1922 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
1945 Info, Deduced, 0, in DeduceTemplateArgumentsByTypeMatch()
1954 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced, in DeduceTemplateArgumentsByTypeMatch()
1979 // We give E in noexcept(E) the "deduced from array bound" treatment. in DeduceTemplateArgumentsByTypeMatch()
1983 /*DeducedFromArrayBound=*/true, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
1988 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
1993 // FIXME: Detect non-deduced exception specification mismatches? in DeduceTemplateArgumentsByTypeMatch()
2015 Deduced); in DeduceTemplateArgumentsByTypeMatch()
2017 SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(), in DeduceTemplateArgumentsByTypeMatch()
2018 Deduced.end()); in DeduceTemplateArgumentsByTypeMatch()
2021 DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2034 // Reset the incorrectly deduced argument from above. in DeduceTemplateArgumentsByTypeMatch()
2035 Deduced = DeducedOrig; in DeduceTemplateArgumentsByTypeMatch()
2039 TemplateParams, P, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2070 S, TemplateParams, PPT, APT, Info, Deduced, SubTDF); in DeduceTemplateArgumentsByTypeMatch()
2075 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF); in DeduceTemplateArgumentsByTypeMatch()
2090 Deduced, 0); in DeduceTemplateArgumentsByTypeMatch()
2114 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced, in DeduceTemplateArgumentsByTypeMatch()
2125 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2142 Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2149 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2160 VA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2176 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2193 Deduced); in DeduceTemplateArgumentsByTypeMatch()
2200 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2211 VA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2235 Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2247 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2253 [&S, &Info, &Deduced, &TemplateParams]( in DeduceTemplateArgumentsByTypeMatch()
2290 /*ArrayBound=*/true, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2295 Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2319 Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2330 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2341 S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2353 true, Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2375 Deduced); in DeduceTemplateArgumentsByTypeMatch()
2405 S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2418 SmallVectorImpl<DeducedTemplateArgument> &Deduced) { in DeduceTemplateArguments() argument
2432 S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0); in DeduceTemplateArguments()
2441 /*DefaultArguments=*/{}, Deduced); in DeduceTemplateArguments()
2494 A.getNonTypeTemplateArgumentType(), Info, Deduced); in DeduceTemplateArguments()
2498 A.getNullPtrType(), Info, Deduced); in DeduceTemplateArguments()
2503 Info, Deduced); in DeduceTemplateArguments()
2574 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in DeduceTemplateArguments() argument
2581 // non-deduced context. in DeduceTemplateArguments()
2612 DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced); in DeduceTemplateArguments()
2631 PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); in DeduceTemplateArguments()
2633 // Keep track of the deduced template arguments for each parameter pack in DeduceTemplateArguments()
2644 DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced); in DeduceTemplateArguments()
2664 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in DeduceTemplateArguments() argument
2666 return ::DeduceTemplateArguments(*this, TemplateParams, Ps, As, Info, Deduced, in DeduceTemplateArguments()
2676 // If we're checking deduced arguments (X) against original arguments (Y), in isSameTemplateArg()
2821 /// Convert the given deduced template argument and add it to the set of
2830 // Convert the deduced template argument into a template in ConvertDeducedTemplateArgument()
2853 // When converting the deduced template argument, append it to the in ConvertDeducedTemplateArgument()
2859 "deduced nested pack"); in ConvertDeducedTemplateArgument()
2861 // We deduced arguments for some elements of this pack, but not for in ConvertDeducedTemplateArgument()
2862 // all of them. This happens if we get a conditionally-non-deduced in ConvertDeducedTemplateArgument()
2920 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in ConvertDeducedTemplateArguments() argument
2932 // A trailing template parameter pack (14.5.3) not otherwise deduced will in ConvertDeducedTemplateArguments()
2933 // be deduced to an empty sequence of template arguments. in ConvertDeducedTemplateArguments()
2935 if (Deduced[I].isNull() && Param->isTemplateParameterPack()) { in ConvertDeducedTemplateArguments()
2937 PackDeductionScope(S, TemplateParams, Deduced, Info, I).finish(); in ConvertDeducedTemplateArguments()
2942 if (!Deduced[I].isNull()) { in ConvertDeducedTemplateArguments()
2946 // via additional deduced arguments). in ConvertDeducedTemplateArguments()
2958 SugaredBuilder.push_back(Deduced[I]); in ConvertDeducedTemplateArguments()
2960 S.Context.getCanonicalTemplateArgument(Deduced[I])); in ConvertDeducedTemplateArguments()
2965 // We may have deduced this argument, so it still needs to be in ConvertDeducedTemplateArguments()
2967 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I], Template, Info, in ConvertDeducedTemplateArguments()
3081 // If we don't need to replace the deduced template arguments, in CheckDeducedArgumentConstraints()
3091 // getTemplateInstantiationArgs picks up the non-deduced version of the in CheckDeducedArgumentConstraints()
3093 // not class-scope explicit specialization, so replace with Deduced Args in CheckDeducedArgumentConstraints()
3117 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in FinishTemplateArgumentDeduction() argument
3127 // [...] or if any template argument remains neither deduced nor in FinishTemplateArgumentDeduction()
3131 S, Partial, IsPartialOrdering, Deduced, Info, SugaredBuilder, in FinishTemplateArgumentDeduction()
3136 // Form the template argument list from the deduced template arguments. in FinishTemplateArgumentDeduction()
3144 // Substitute the deduced template arguments into the template in FinishTemplateArgumentDeduction()
3213 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in FinishTemplateArgumentDeduction() argument
3223 // [...] or if any template argument remains neither deduced nor in FinishTemplateArgumentDeduction()
3227 S, Template, /*IsDeduced*/ PartialOrdering, Deduced, Info, in FinishTemplateArgumentDeduction()
3262 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in FinishTemplateArgumentDeduction() argument
3272 // [...] or if any template argument remains neither deduced nor in FinishTemplateArgumentDeduction()
3276 S, TD, /*IsPartialOrdering=*/false, Deduced, Info, SugaredBuilder, in FinishTemplateArgumentDeduction()
3307 // specialization can be deduced from the actual template argument in DeduceTemplateArguments()
3319 SmallVector<DeducedTemplateArgument, 4> Deduced; in DeduceTemplateArguments() local
3320 Deduced.resize(Partial->getTemplateParameters()->size()); in DeduceTemplateArguments()
3323 Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced, in DeduceTemplateArguments()
3328 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); in DeduceTemplateArguments()
3341 TemplateArgs, Deduced, Info); in DeduceTemplateArguments()
3386 SmallVector<DeducedTemplateArgument> Deduced( in DeduceTemplateArgumentsFromType() local
3391 TD->getTemplateParameters(), PArgs, AArgs, Info, Deduced, false); in DeduceTemplateArgumentsFromType()
3396 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); in DeduceTemplateArgumentsFromType()
3406 Result = ::FinishTemplateArgumentDeduction(*this, TD, Deduced, Info); in DeduceTemplateArgumentsFromType()
3434 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in SubstituteExplicitTemplateArguments() argument
3501 // If we deduced template arguments for a template parameter pack, in SubstituteExplicitTemplateArguments()
3598 // Trailing template arguments that can be deduced (14.8.2) may be in SubstituteExplicitTemplateArguments()
3600 // template arguments can be deduced, they may all be omitted; in this in SubstituteExplicitTemplateArguments()
3604 // the set of deduced template arguments. The partially-substituted in SubstituteExplicitTemplateArguments()
3607 Deduced.reserve(TemplateParams->size()); in SubstituteExplicitTemplateArguments()
3611 Deduced.push_back(DeducedTemplateArgument()); in SubstituteExplicitTemplateArguments()
3613 Deduced.push_back(Arg); in SubstituteExplicitTemplateArguments()
3619 /// Check whether the deduced argument type for a call to a function
3652 // - If the original P is a reference type, the deduced A (i.e., the in CheckOriginalCallArgDeduction()
3662 // the deduced A can be F. in CheckOriginalCallArgDeduction()
3670 // Under Objective-C++ ARC, the deduced type may have implicitly in CheckOriginalCallArgDeduction()
3688 // deduced argument type's qualifiers as if we had performed the in CheckOriginalCallArgDeduction()
3695 // type that can be converted to the deduced A via a function pointer in CheckOriginalCallArgDeduction()
3709 // transformed A can be a derived class of the deduced A. [...] in CheckOriginalCallArgDeduction()
3712 // derived class pointed to by the deduced A. in CheckOriginalCallArgDeduction()
3810 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in FinishTemplateArgumentDeduction() argument
3822 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); in FinishTemplateArgumentDeduction()
3832 // [...] or if any template argument remains neither deduced nor in FinishTemplateArgumentDeduction()
3836 *this, FunctionTemplate, /*IsDeduced*/ true, Deduced, Info, in FinishTemplateArgumentDeduction()
3845 // and all template arguments are explicitly specified, deduced, or in FinishTemplateArgumentDeduction()
3854 // Form the template argument list from the deduced template arguments. in FinishTemplateArgumentDeduction()
3861 // Substitute the deduced template arguments into the function template in FinishTemplateArgumentDeduction()
3910 // [...] When all template arguments have been deduced [...] all uses of in FinishTemplateArgumentDeduction()
3911 // template parameters [...] are replaced with the corresponding deduced in FinishTemplateArgumentDeduction()
3947 // values that will make the deduced A identical to A (after the type A in FinishTemplateArgumentDeduction()
3971 // deduced A. in FinishTemplateArgumentDeduction()
4089 // non-deduced context. in ResolveOverloadForDeduction()
4119 // treated as a non-deduced context. in ResolveOverloadForDeduction()
4123 // the deduced template argument values are then combined. in ResolveOverloadForDeduction()
4126 Deduced(TemplateParams->size()); in ResolveOverloadForDeduction() local
4129 S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF); in ResolveOverloadForDeduction()
4211 // values that will make the deduced A identical to A (after the type A in AdjustFunctionParmAndArgTypesForDeduction()
4215 // - If the original P is a reference type, the deduced A (i.e., the in AdjustFunctionParmAndArgTypesForDeduction()
4221 // type that can be converted to the deduced A via a qualification in AdjustFunctionParmAndArgTypesForDeduction()
4227 // transformed A can be a derived class of the deduced A. Likewise, in AdjustFunctionParmAndArgTypesForDeduction()
4230 // the deduced A. in AdjustFunctionParmAndArgTypesForDeduction()
4249 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
4259 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in DeduceFromInitializerList() argument
4279 // considered a non-deduced context in DeduceFromInitializerList()
4284 // a non-deduced context. in DeduceFromInitializerList()
4294 E->Classify(S.getASTContext()), E, Info, Deduced, in DeduceFromInitializerList()
4301 // in the P0[N] case, if N is a non-type template parameter, N is deduced in DeduceFromInitializerList()
4315 /*ArrayBound=*/true, Info, Deduced); in DeduceFromInitializerList()
4331 SmallVectorImpl<DeducedTemplateArgument> &Deduced, in DeduceTemplateArgumentsFromCallArgument() argument
4348 Deduced, OriginalCallArgs, ArgIdx, TDF); in DeduceTemplateArgumentsFromCallArgument()
4351 // that will make the deduced A identical to A in DeduceTemplateArgumentsFromCallArgument()
4354 // so we can check for compatibility between the deduced A and A. in DeduceTemplateArgumentsFromCallArgument()
4359 ArgType, Info, Deduced, TDF); in DeduceTemplateArgumentsFromCallArgument()
4404 SmallVector<DeducedTemplateArgument, 4> Deduced; in DeduceTemplateArguments() local
4411 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, nullptr, in DeduceTemplateArguments()
4417 NumExplicitlySpecified = Deduced.size(); in DeduceTemplateArguments()
4441 /*Arg=*/nullptr, Info, Deduced, OriginalCallArgs, in DeduceTemplateArguments()
4449 Args[ArgIdx], Info, Deduced, OriginalCallArgs, /*Decomposed*/ false, in DeduceTemplateArguments()
4454 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4488 PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, in DeduceTemplateArguments()
4499 // in a non-deduced context [not at the end of the list], the type of in DeduceTemplateArguments()
4500 // that parameter pack is never deduced. in DeduceTemplateArguments()
4503 // after we skip it (in the non-deduced case). That makes no sense, so in DeduceTemplateArguments()
4507 // non-deduced context. in DeduceTemplateArguments()
4534 // When all template arguments have been deduced in DeduceTemplateArguments()
4537 // replaced with the corresponding deduced or default argument values in DeduceTemplateArguments()
4539 // If we have a trailing parameter pack, that has been deduced in DeduceTemplateArguments()
4544 // the already deduced parameter. in DeduceTemplateArguments()
4578 FunctionTemplate, Deduced, NumExplicitlySpecified, Specialization, Info, in DeduceTemplateArguments()
4638 SmallVector<DeducedTemplateArgument, 4> Deduced; in DeduceTemplateArguments() local
4645 FunctionTemplate, *ExplicitTemplateArgs, Deduced, ParamTypes, in DeduceTemplateArguments()
4651 NumExplicitlySpecified = Deduced.size(); in DeduceTemplateArguments()
4666 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4668 // If the function has a deduced return type, substitute it for a dependent in DeduceTemplateArguments()
4669 // type so that we treat it as a non-deduced context in what follows. in DeduceTemplateArguments()
4682 *this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced, in DeduceTemplateArguments()
4690 Result = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, in DeduceTemplateArguments()
4697 // If the function has a deduced return type, deduce it now, so we can check in DeduceTemplateArguments()
4698 // that the deduced function type matches the requested type. in DeduceTemplateArguments()
4825 SmallVector<DeducedTemplateArgument, 4> Deduced; in DeduceTemplateArguments() local
4826 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4830 // argument values that will make the deduced A identical to in DeduceTemplateArguments()
4834 // cv-qualified than the deduced A (i.e., the type referred to in DeduceTemplateArguments()
4838 // - The deduced A can be another pointer or pointer to member in DeduceTemplateArguments()
4856 /*Arg=*/nullptr, Info, Deduced, OriginalCallArgs, in DeduceTemplateArguments()
4863 *this, TemplateParams, P, A, Info, Deduced, TDF); in DeduceTemplateArguments()
4873 Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, in DeduceTemplateArguments()
4895 /// Substitute the 'auto' specifier or deduced template specialization type
4931 // auto type deduced as T" in order for [temp.deduct.call]p3 to apply. in TransformAutoType()
4987 QualType Deduced) { in CheckDeducedPlaceholderConstraints() argument
4993 TemplateArgumentLoc(TemplateArgument(Deduced), in CheckDeducedPlaceholderConstraints()
4995 Deduced, TypeLoc.getNameLoc()))); in CheckDeducedPlaceholderConstraints()
5037 << Deduced << Buf << TypeLoc.getLocalSourceRange(); in CheckDeducedPlaceholderConstraints()
5097 SmallVector<DeducedTemplateArgument, 1> Deduced; in DeduceAutoType() local
5098 Deduced.resize(1); in DeduceAutoType()
5147 // is a non-deduced context. in DeduceAutoType()
5152 Init->Classify(getASTContext()), Init, Info, Deduced, in DeduceAutoType()
5166 Deduced[0].getKind() != TemplateArgument::Null) in DeduceAutoType()
5180 Init->Classify(getASTContext()), Init, Info, Deduced, in DeduceAutoType()
5187 // Could be null if somehow 'auto' appears in a non-deduced context. in DeduceAutoType()
5188 if (Deduced[0].getKind() != TemplateArgument::Type) in DeduceAutoType()
5190 DeducedType = Deduced[0].getAsType(); in DeduceAutoType()
5217 // Check that the deduced argument type is compatible with the original in DeduceAutoType()
5219 QualType DeducedA = InitList ? Deduced[0].getAsType() : Result; in DeduceAutoType()
5420 SmallVector<DeducedTemplateArgument, 4> Deduced; in isAtLeastAsSpecializedAs() local
5421 Deduced.resize(TemplateParams->size()); in isAtLeastAsSpecializedAs()
5430 Args1.data(), Args1.size(), Info, Deduced, in isAtLeastAsSpecializedAs()
5442 Info, Deduced, TDF_None, in isAtLeastAsSpecializedAs()
5451 S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced, in isAtLeastAsSpecializedAs()
5463 // in a non-deduced context is considered used. -end note] in isAtLeastAsSpecializedAs()
5464 unsigned ArgIdx = 0, NumArgs = Deduced.size(); in isAtLeastAsSpecializedAs()
5466 if (Deduced[ArgIdx].isNull()) in isAtLeastAsSpecializedAs()
5470 // to substitute the deduced arguments back into the template and check that in isAtLeastAsSpecializedAs()
5474 // All template arguments were deduced. FT1 is at least as specialized in isAtLeastAsSpecializedAs()
5522 // If this argument had no value deduced but was used in one of the types in isAtLeastAsSpecializedAs()
5524 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx]) in isAtLeastAsSpecializedAs()
5881 SmallVector<DeducedTemplateArgument, 4> Deduced; in isAtLeastAsSpecializedAs() local
5884 Deduced.resize(P2->getTemplateParameters()->size()); in isAtLeastAsSpecializedAs()
5886 S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None, in isAtLeastAsSpecializedAs()
5890 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), in isAtLeastAsSpecializedAs()
5891 Deduced.end()); in isAtLeastAsSpecializedAs()
5903 Deduced, Info) == TemplateDeductionResult::Success; in isAtLeastAsSpecializedAs()
6204 SmallVector<DeducedTemplateArgument, 4> Deduced; in isTemplateTemplateParameterAtLeastAsSpecializedAs() local
6205 Deduced.resize(A->size()); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6214 // - In a deduced context, the matching of packs versus fixed-size needs to in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6215 // be inverted between Ps and As. On non-deduced context, matching needs to in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6218 if (::DeduceTemplateArguments(*this, A, AArgs, PArgs, Info, Deduced, in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6225 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6235 *this, AArg, /*IsPartialOrdering=*/true, PArgs, Deduced, Info) == in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6301 // In C++17 mode, additional arguments may be deduced from the type of a in MarkUsedTemplateParameters()
6473 // The non-deduced contexts are: [...] in MarkUsedTemplateParameters()
6482 // When a function parameter pack appears in a non-deduced context, in MarkUsedTemplateParameters()
6483 // the type of that pack is never deduced. in MarkUsedTemplateParameters()
6485 // We should also track a set of "never deduced" parameters, and in MarkUsedTemplateParameters()
6486 // subtract that from the list of deduced parameters after marking. in MarkUsedTemplateParameters()
6524 // non-deduced context. in MarkUsedTemplateParameters()
6557 // The non-deduced contexts are: in MarkUsedTemplateParameters()
6562 // When a type name is specified in a way that includes a non-deduced in MarkUsedTemplateParameters()
6564 // non-deduced. in MarkUsedTemplateParameters()
6708 // non-deduced context. in MarkUsedTemplateParameters()
6720 llvm::SmallBitVector &Deduced) { in MarkDeducedTemplateParameters() argument
6723 Deduced.clear(); in MarkDeducedTemplateParameters()
6724 Deduced.resize(TemplateParams->size()); in MarkDeducedTemplateParameters()
6729 true, TemplateParams->getDepth(), Deduced); in MarkDeducedTemplateParameters()
6740 llvm::SmallBitVector Deduced(TemplateParams->size()); in hasDeducibleTemplateParameters() local
6742 Deduced); in hasDeducibleTemplateParameters()
6744 return Deduced.any(); in hasDeducibleTemplateParameters()