Lines Matching defs:Deduced
88 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
121 Deduced,
133 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
163 /// \brief Verify that the given, deduced template arguments are compatible.
165 /// \returns The deduced template argument, or a NULL template argument if
166 /// the deduced template arguments were incompatible.
179 llvm_unreachable("Non-deduced template arguments handled above");
190 // If we deduced a constant in one case and either a dependent expression or
222 // If we deduced a dependent expression in one case and either an integral
243 // If we deduced a declaration and a dependent expression, keep the
248 // If we deduced a declaration and an integral constant, keep the
253 // If we deduced two declarations, make sure they they refer to the
292 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
298 Deduced[NTTP->getIndex()],
302 Info.FirstArg = Deduced[NTTP->getIndex()];
307 Deduced[NTTP->getIndex()] = Result;
320 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
328 Deduced[NTTP->getIndex()],
333 Info.FirstArg = Deduced[NTTP->getIndex()];
338 Deduced[NTTP->getIndex()] = Result;
351 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
357 Deduced[NTTP->getIndex()],
361 Info.FirstArg = Deduced[NTTP->getIndex()];
366 Deduced[NTTP->getIndex()] = Result;
376 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
388 Deduced[TempParam->getIndex()],
392 Info.FirstArg = Deduced[TempParam->getIndex()];
397 Deduced[TempParam->getIndex()] = Result;
424 /// \param Deduced the deduced template arguments
435 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
446 Info, Deduced))
456 Info, Deduced,
478 Info, Deduced))
486 Info, Deduced);
550 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
555 // Save the deduced template arguments for each parameter pack expanded
558 // Save the previously-deduced argument pack, then clear it out so that we
560 SavedPacks[I] = Deduced[PackIndices[I]];
561 Deduced[PackIndices[I]] = TemplateArgument();
564 // the set of deduced arguments.
585 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
597 Deduced[PackIndices[I]] = SavedPacks[I];
604 // If we deduced an empty argument pack, create it now.
627 Deduced[PackIndices[I]] = Result;
651 /// \param Deduced the deduced template arguments
672 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
711 Info, Deduced, TDF,
721 // The non-deduced contexts are:
753 // Keep track of the deduced template arguments for each parameter pack
760 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
770 Args[ArgIdx], Info, Deduced,
775 // Capture the deduced template arguments for each parameter pack expanded
776 // by this pack expansion, add them to the list of arguments we've deduced
777 // for that pack, then clear out the deduced argument.
779 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
791 Deduced, PackIndices, SavedPacks,
847 /// \param Deduced the deduced template arguments
866 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
930 // - If the original P is a reference type, the deduced A (i.e., the type
952 // deduced as X&. - end note ]
967 // template non-type argument i can be deduced if P and A have one of
1006 // Remove any qualifiers on the parameter from the deduced type.
1045 Deduced[Index],
1049 Info.FirstArg = Deduced[Index];
1054 Deduced[Index] = Result;
1130 Info, Deduced, TDF);
1140 Info, Deduced, TDF);
1160 Info, Deduced, SubTDF);
1171 ReferenceArg->getPointeeType(), Info, Deduced, 0);
1183 Info, Deduced, 0);
1197 Info, Deduced, SubTDF);
1216 Info, Deduced, SubTDF);
1234 Info, Deduced, SubTDF))
1253 Info, Deduced);
1260 Info, Deduced);
1291 Info, Deduced, 0))
1299 Info, Deduced, SubTDF);
1324 Info, Deduced);
1329 // derived class of the deduced A. Likewise, if P is a pointer to a
1331 // class pointed to by the deduced A.
1350 SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
1351 Deduced.end());
1366 QualType(NextT, 0), Info, Deduced);
1374 DeducedOrig.append(Deduced.begin(), Deduced.end());
1377 Deduced = DeducedOrig;
1419 Info, Deduced,
1426 Info, Deduced,
1445 Info, Deduced, 0);
1462 Info, Deduced, TDF);
1475 Info, Deduced, TDF);
1494 Info, Deduced, TDF))
1506 false, Info, Deduced);
1516 Info, Deduced, TDF))
1526 Info, Deduced);
1554 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1570 Info, Deduced, 0);
1579 Arg.getAsTemplate(), Info, Deduced);
1624 Info, Deduced);
1627 Info, Deduced);
1630 Info, Deduced);
1705 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
1710 // non-deduced context.
1739 Info, Deduced))
1775 // and set any deduced parameter packs to an empty argument pack.
1778 // Save the deduced template arguments for each parameter pack expanded
1784 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
1787 // Keep track of the deduced template arguments for each parameter pack
1797 Info, Deduced))
1800 // Capture the deduced template arguments for each parameter pack expanded
1801 // by this pack expansion, add them to the list of arguments we've deduced
1802 // for that pack, then clear out the deduced argument.
1804 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
1818 Deduced, PackIndices, SavedPacks,
1837 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1841 Info, Deduced);
1966 /// \brief Convert the given deduced template argument and add it to the set of
1983 // When converting the deduced template argument, append it to the
2005 // Convert the deduced template argument into a template
2031 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2040 // [...] or if any template argument remains neither deduced nor
2046 if (Deduced[I].isNull()) {
2051 // We have deduced this argument, so it still needs to be
2079 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
2090 // Form the template argument list from the deduced template arguments.
2097 // Substitute the deduced template arguments into the template
2158 // specialization can be deduced from the actual template argument
2165 SmallVector<DeducedTemplateArgument, 4> Deduced;
2166 Deduced.resize(Partial->getTemplateParameters()->size());
2171 TemplateArgs, Info, Deduced))
2175 Deduced.data(), Deduced.size(), Info);
2183 Deduced, Info);
2204 /// \param Deduced the deduced template arguments, which will be populated
2223 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2260 FunctionTemplate, Deduced.data(), Deduced.size(),
2290 // If we deduced template arguments for a template parameter pack,
2373 // Trailing template arguments that can be deduced (14.8.2) may be
2375 // template arguments can be deduced, they may all be omitted; in this
2379 // the set of deduced template arguments. Explicitly-specified
2382 Deduced.reserve(TemplateParams->size());
2386 Deduced.push_back(DeducedTemplateArgument());
2388 Deduced.push_back(Arg);
2394 /// \brief Check whether the deduced argument type for a call to a function
2417 // - If the original P is a reference type, the deduced A (i.e., the
2433 // deduced argument type's qualifiers as if we had performed the
2440 // type that can be converted to the deduced A via a qualification
2456 // transformed A can be a derived class of the deduced A. [...]
2459 // derived class pointed to by the deduced A.
2484 /// checking the deduced template arguments for completeness and forming
2488 /// which the deduced argument types should be compared.
2491 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2506 FunctionTemplate, Deduced.data(), Deduced.size(),
2515 // [...] or if any template argument remains neither deduced nor
2521 if (!Deduced[I].isNull()) {
2526 Builder.push_back(Deduced[I]);
2530 // We have deduced this argument, so it still needs to be
2558 if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
2572 // A trailing template parameter pack (14.5.3) not otherwise deduced will
2573 // be deduced to an empty sequence of template arguments.
2624 // Form the template argument list from the deduced template arguments.
2629 // Substitute the deduced template arguments into the function template
2660 // values that will make the deduced A identical to A (after the type A
2758 // non-deduced context.
2787 // treated as a non-deduced context.
2791 // the deduced template argument values are then combined.
2794 Deduced(TemplateParams->size());
2798 ArgType, Info, Deduced, TDF);
2892 // values that will make the deduced A identical to A (after the type A
2896 // - If the original P is a reference type, the deduced A (i.e., the
2902 // type that can be converted to the deduced A via a qualification
2908 // transformed A can be a derived class of the deduced A. Likewise,
2911 // the deduced A.
2934 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2948 Info, Deduced, TDF))
2960 ArgType, Info, Deduced, TDF);
3020 SmallVector<DeducedTemplateArgument, 4> Deduced;
3027 Deduced,
3034 NumExplicitlySpecified = Deduced.size();
3042 Deduced.resize(TemplateParams->size());
3075 // result is the deduced type if it's the same for all elements.
3085 Info, Deduced, TDF))
3093 // so we can check for compatibility between the deduced A and A.
3100 Info, Deduced, TDF))
3114 // the parameter pack is a non-deduced context.
3135 // Keep track of the deduced template arguments for each parameter pack
3142 PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
3175 Info, Deduced, TDF))
3181 // so we can check for compatibility between the deduced A and A.
3189 Deduced, TDF))
3193 // Capture the deduced template arguments for each parameter pack expanded
3194 // by this pack expansion, add them to the list of arguments we've deduced
3195 // for that pack, then clear out the deduced argument.
3197 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
3209 Deduced, PackIndices, SavedPacks,
3217 return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3258 SmallVector<DeducedTemplateArgument, 4> Deduced;
3265 Deduced, ParamTypes,
3269 NumExplicitlySpecified = Deduced.size();
3276 Deduced.resize(TemplateParams->size());
3283 Deduced, TDF_TopLevelParameterTypeList))
3288 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3368 SmallVector<DeducedTemplateArgument, 4> Deduced;
3369 Deduced.resize(TemplateParams->size());
3373 // argument values that will make the deduced A identical to
3377 // cv-qualified than the deduced A (i.e., the type referred to
3381 // - The deduced A can be another pointer or pointer to member
3393 P, A, Info, Deduced, TDF))
3400 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
3449 // auto type deduced as T" in order for [temp.deduct.call]p3 to apply.
3474 /// \param Init the initializer for the variable whose type is to be deduced.
3477 /// deduced type. This may still contain undeduced autos if the type is
3514 SmallVector<DeducedTemplateArgument, 1> Deduced;
3515 Deduced.resize(1);
3527 Info, Deduced, TDF))
3537 InitType, Info, Deduced, TDF))
3541 QualType DeducedType = Deduced[0].getAsType();
3553 // Check that the deduced argument type is compatible with the original
3581 llvm::SmallBitVector &Deduced);
3623 SmallVector<DeducedTemplateArgument, 4> Deduced;
3624 Deduced.resize(TemplateParams->size());
3679 Args1.data(), Args1.size(), Info, Deduced,
3693 Info, Deduced, TDF_None,
3704 Info, Deduced, TDF_None,
3716 // in a non-deduced context is considered used. -end note]
3717 unsigned ArgIdx = 0, NumArgs = Deduced.size();
3719 if (Deduced[ArgIdx].isNull())
3723 // All template arguments were deduced. FT1 is at least as specialized
3760 // If this argument had no value deduced but was used in one of the types
3762 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
4064 SmallVector<DeducedTemplateArgument, 4> Deduced;
4071 Deduced.resize(PS2->getTemplateParameters()->size());
4074 PT2, PT1, Info, Deduced, TDF_None,
4079 Deduced.data(), Deduced.size(), Info);
4082 Deduced, Info);
4086 Deduced.clear();
4087 Deduced.resize(PS1->getTemplateParameters()->size());
4090 PT1, PT2, Info, Deduced, TDF_None,
4095 Deduced.data(), Deduced.size(), Info);
4098 Deduced, Info);
4308 // non-deduced context.
4350 deduced context.
4459 /// \brief Mark the template parameters can be deduced by the given
4463 /// parameters will be deduced.
4465 /// \param Deduced a bit vector whose elements will be set to \c true
4467 /// deduced.
4475 // non-deduced context.
4485 /// \brief Marks all of the template parameters that will be deduced by a
4490 llvm::SmallBitVector &Deduced) {
4493 Deduced.clear();
4494 Deduced.resize(TemplateParams->size());
4499 true, TemplateParams->getDepth(), Deduced);
4510 llvm::SmallBitVector Deduced(TemplateParams->size());
4512 Deduced);
4514 return Deduced.any();
