Lines Matching defs:Deduced
88 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
121 Deduced,
133 SmallVectorImpl<DeducedTemplateArgument> &Deduced);
168 /// \brief Verify that the given, deduced template arguments are compatible.
170 /// \returns The deduced template argument, or a NULL template argument if
171 /// the deduced template arguments were incompatible.
184 llvm_unreachable("Non-deduced template arguments handled above");
195 // If we deduced a constant in one case and either a dependent expression or
227 // If we deduced a dependent expression in one case and either an integral
248 // If we deduced a declaration and a dependent expression, keep the
253 // If we deduced a declaration and an integral constant, keep the
258 // If we deduced two declarations, make sure they they refer to the
269 // If we deduced a null pointer and a dependent expression, keep the
274 // If we deduced a null pointer and an integral constant, keep the
279 // If we deduced two null pointers, make sure they have the same type.
317 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
324 Deduced[NTTP->getIndex()],
328 Info.FirstArg = Deduced[NTTP->getIndex()];
333 Deduced[NTTP->getIndex()] = Result;
346 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
354 Deduced[NTTP->getIndex()],
359 Info.FirstArg = Deduced[NTTP->getIndex()];
364 Deduced[NTTP->getIndex()] = Result;
377 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
385 Deduced[NTTP->getIndex()],
389 Info.FirstArg = Deduced[NTTP->getIndex()];
394 Deduced[NTTP->getIndex()] = Result;
404 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
416 Deduced[TempParam->getIndex()],
420 Info.FirstArg = Deduced[TempParam->getIndex()];
425 Deduced[TempParam->getIndex()] = Result;
452 /// \param Deduced the deduced template arguments
463 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
474 Info, Deduced))
484 Info, Deduced);
511 Info, Deduced))
519 Info, Deduced);
583 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
588 // Save the deduced template arguments for each parameter pack expanded
591 // Save the previously-deduced argument pack, then clear it out so that we
593 SavedPacks[I] = Deduced[PackIndices[I]];
594 Deduced[PackIndices[I]] = TemplateArgument();
600 // the set of deduced arguments.
621 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
633 Deduced[PackIndices[I]] = SavedPacks[I];
640 // If we deduced an empty argument pack, create it now.
663 Deduced[PackIndices[I]] = Result;
687 /// \param Deduced the deduced template arguments
708 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
747 Info, Deduced, TDF,
757 // The non-deduced contexts are:
789 // Keep track of the deduced template arguments for each parameter pack
796 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
806 Args[ArgIdx], Info, Deduced,
811 // Capture the deduced template arguments for each parameter pack expanded
812 // by this pack expansion, add them to the list of arguments we've deduced
813 // for that pack, then clear out the deduced argument.
815 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
827 Deduced, PackIndices, SavedPacks,
883 /// \param Deduced the deduced template arguments
902 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
966 // - If the original P is a reference type, the deduced A (i.e., the type
988 // deduced as X&. - end note ]
1003 // template non-type argument i can be deduced if P and A have one of
1042 // Remove any qualifiers on the parameter from the deduced type.
1081 Deduced[Index],
1085 Info.FirstArg = Deduced[Index];
1090 Deduced[Index] = Result;
1166 Info, Deduced, TDF);
1176 Info, Deduced, TDF);
1196 Info, Deduced, SubTDF);
1207 ReferenceArg->getPointeeType(), Info, Deduced, 0);
1219 Info, Deduced, 0);
1233 Info, Deduced, SubTDF);
1252 Info, Deduced, SubTDF);
1270 Info, Deduced, SubTDF))
1289 Info, Deduced);
1296 Info, Deduced);
1327 Info, Deduced, 0))
1335 Info, Deduced, SubTDF);
1360 Info, Deduced);
1365 // derived class of the deduced A. Likewise, if P is a pointer to a
1367 // class pointed to by the deduced A.
1386 SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
1387 Deduced.end());
1404 Deduced);
1412 DeducedOrig.append(Deduced.begin(), Deduced.end());
1418 Deduced = DeducedOrig;
1460 Info, Deduced,
1467 Info, Deduced,
1486 Info, Deduced, 0);
1503 Info, Deduced, TDF);
1516 Info, Deduced, TDF);
1535 Info, Deduced, TDF))
1547 false, Info, Deduced);
1557 Info, Deduced, TDF))
1567 Info, Deduced);
1595 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1611 Info, Deduced, 0);
1620 Arg.getAsTemplate(), Info, Deduced);
1675 Info, Deduced);
1678 Info, Deduced);
1681 Info, Deduced);
1756 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1760 // non-deduced context.
1788 Info, Deduced))
1824 // and set any deduced parameter packs to an empty argument pack.
1827 // Save the deduced template arguments for each parameter pack expanded
1833 PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks,
1836 // Keep track of the deduced template arguments for each parameter pack
1846 Info, Deduced))
1849 // Capture the deduced template arguments for each parameter pack expanded
1850 // by this pack expansion, add them to the list of arguments we've deduced
1851 // for that pack, then clear out the deduced argument.
1853 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
1867 Deduced, PackIndices, SavedPacks,
1881 SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
1885 Info, Deduced);
2022 /// \brief Convert the given deduced template argument and add it to the set of
2039 // When converting the deduced template argument, append it to the
2061 // Convert the deduced template argument into a template
2087 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2096 // [...] or if any template argument remains neither deduced nor
2102 if (Deduced[I].isNull()) {
2107 // We have deduced this argument, so it still needs to be
2135 if (ConvertDeducedTemplateArgument(S, Param, Deduced[I],
2146 // Form the template argument list from the deduced template arguments.
2153 // Substitute the deduced template arguments into the template
2217 // specialization can be deduced from the actual template argument
2224 SmallVector<DeducedTemplateArgument, 4> Deduced;
2225 Deduced.resize(Partial->getTemplateParameters()->size());
2230 TemplateArgs, Info, Deduced))
2233 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2243 Deduced, Info);
2264 /// \param Deduced the deduced template arguments, which will be populated
2283 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2319 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2351 // If we deduced template arguments for a template parameter pack,
2429 // Trailing template arguments that can be deduced (14.8.2) may be
2431 // template arguments can be deduced, they may all be omitted; in this
2435 // the set of deduced template arguments. Explicitly-specified
2438 Deduced.reserve(TemplateParams->size());
2442 Deduced.push_back(DeducedTemplateArgument());
2444 Deduced.push_back(Arg);
2450 /// \brief Check whether the deduced argument type for a call to a function
2473 // - If the original P is a reference type, the deduced A (i.e., the
2484 // Under Objective-C++ ARC, the deduced type may have implicitly been
2499 // deduced argument type's qualifiers as if we had performed the
2506 // type that can be converted to the deduced A via a qualification
2522 // transformed A can be a derived class of the deduced A. [...]
2525 // derived class pointed to by the deduced A.
2550 /// checking the deduced template arguments for completeness and forming
2554 /// which the deduced argument types should be compared.
2557 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
2571 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end());
2582 // [...] or if any template argument remains neither deduced nor
2588 if (!Deduced[I].isNull()) {
2593 Builder.push_back(Deduced[I]);
2597 // We have deduced this argument, so it still needs to be
2625 if (ConvertDeducedTemplateArgument(*this, Param, Deduced[I],
2639 // A trailing template parameter pack (14.5.3) not otherwise deduced will
2640 // be deduced to an empty sequence of template arguments.
2696 // Form the template argument list from the deduced template arguments.
2701 // Substitute the deduced template arguments into the function template
2732 // values that will make the deduced A identical to A (after the type A
2830 // non-deduced context.
2859 // treated as a non-deduced context.
2863 // the deduced template argument values are then combined.
2866 Deduced(TemplateParams->size());
2870 ArgType, Info, Deduced, TDF);
2963 // values that will make the deduced A identical to A (after the type A
2967 // - If the original P is a reference type, the deduced A (i.e., the
2973 // type that can be converted to the deduced A via a qualification
2979 // transformed A can be a derived class of the deduced A. Likewise,
2982 // the deduced A.
3005 SmallVectorImpl<DeducedTemplateArgument> &Deduced,
3019 Info, Deduced, TDF))
3033 ArgType, Info, Deduced, TDF);
3089 SmallVector<DeducedTemplateArgument, 4> Deduced;
3096 Deduced,
3103 NumExplicitlySpecified = Deduced.size();
3111 Deduced.resize(TemplateParams->size());
3144 // result is the deduced type if it's the same for all elements.
3154 Info, Deduced, TDF))
3162 // so we can check for compatibility between the deduced A and A.
3169 Info, Deduced, TDF))
3183 // the parameter pack is a non-deduced context.
3204 // Keep track of the deduced template arguments for each parameter pack
3211 PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks,
3244 Info, Deduced, TDF))
3250 // so we can check for compatibility between the deduced A and A.
3258 Deduced, TDF))
3262 // Capture the deduced template arguments for each parameter pack expanded
3263 // by this pack expansion, add them to the list of arguments we've deduced
3264 // for that pack, then clear out the deduced argument.
3266 DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]];
3278 Deduced, PackIndices, SavedPacks,
3286 return FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3330 SmallVector<DeducedTemplateArgument, 4> Deduced;
3337 Deduced, ParamTypes,
3341 NumExplicitlySpecified = Deduced.size();
3348 Deduced.resize(TemplateParams->size());
3355 Deduced, TDF_TopLevelParameterTypeList))
3360 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced,
3443 SmallVector<DeducedTemplateArgument, 4> Deduced;
3444 Deduced.resize(TemplateParams->size());
3448 // argument values that will make the deduced A identical to
3452 // cv-qualified than the deduced A (i.e., the type referred to
3456 // - The deduced A can be another pointer or pointer to member
3468 P, A, Info, Deduced, TDF))
3475 = FinishTemplateArgumentDeduction(FunctionTemplate, Deduced, 0, Spec,
3524 // auto type deduced
3584 /// \param Init the initializer for the variable whose type is to be deduced.
3587 /// deduced type. This may still contain undeduced autos if the type is
3624 SmallVector<DeducedTemplateArgument, 1> Deduced;
3625 Deduced.resize(1);
3637 Info, Deduced, TDF))
3647 InitType, Info, Deduced, TDF))
3651 if (Deduced[0].getKind() != TemplateArgument::Type)
3654 QualType DeducedType = Deduced[0].getAsType();
3664 // Check that the deduced argument type is compatible with the original
3692 llvm::SmallBitVector &Deduced);
3731 SmallVector<DeducedTemplateArgument, 4> Deduced;
3732 Deduced.resize(TemplateParams->size());
3790 Args1.data(), Args1.size(), Info, Deduced,
3804 Info, Deduced, TDF_None,
3815 Info, Deduced, TDF_None,
3827 // in a non-deduced context is considered used. -end note]
3828 unsigned ArgIdx = 0, NumArgs = Deduced.size();
3830 if (Deduced[ArgIdx].isNull())
3834 // All template arguments were deduced. FT1 is at least as specialized
3871 // If this argument had no value deduced but was used in one of the types
3873 if (Deduced[ArgIdx].isNull() && UsedParameters[ArgIdx])
4171 SmallVector<DeducedTemplateArgument, 4> Deduced;
4178 Deduced.resize(PS2->getTemplateParameters()->size());
4181 PT2, PT1, Info, Deduced, TDF_None,
4185 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
4190 Deduced, Info);
4194 Deduced.clear();
4195 Deduced.resize(PS1->getTemplateParameters()->size());
4198 PT1, PT2, Info, Deduced, TDF_None,
4202 SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end());
4207 Deduced, Info);
4425 // non-deduced context.
4467 // non-deduced context.
4581 /// \brief Mark which template parameters can be deduced from a given
4585 /// parameters will be deduced.
4589 /// deduced.
4597 // non-deduced context.
4607 /// \brief Marks all of the template parameters that will be deduced by a
4612 llvm::SmallBitVector &Deduced) {
4615 Deduced.clear();
4616 Deduced.resize(TemplateParams->size());
4621 true, TemplateParams->getDepth(), Deduced);
4632 llvm::SmallBitVector Deduced(TemplateParams->size());
4634 Deduced);
4636 return Deduced.any();
