Lines Matching +full:ps +full:- +full:seq +full:- +full:loop
1 //===- SemaTemplateDeduction.cpp - Template Argument Deduction ------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
66 /// These flags can be bitwise-OR'd together.
79 /// are matching in a case where we ignore cv-qualifiers.
84 /// deduction from a template-id of a derived class of the argument type.
87 /// Allow non-dependent types to differ, e.g., when performing
93 /// parameters and arguments in a top-level template argument
145 ArrayRef<TemplateArgument> Ps,
162 /// of a non-type template parameter, return the declaration of that
163 /// non-type template parameter.
170 E = IC->getSubExpr(); in getDeducedParameterFromExpr()
172 E = CE->getSubExpr(); in getDeducedParameterFromExpr()
174 E = Subst->getReplacement(); in getDeducedParameterFromExpr()
177 if (CCE->getParenOrBraceRange().isValid()) in getDeducedParameterFromExpr()
180 assert(CCE->getNumArgs() >= 1 && "implicit construct expr should have 1 arg"); in getDeducedParameterFromExpr()
181 E = CCE->getArg(0); in getDeducedParameterFromExpr()
187 if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl())) in getDeducedParameterFromExpr()
188 if (NTTP->getDepth() == Depth) in getDeducedParameterFromExpr()
203 X = NX->getUnderlyingDecl(); in isSameDeclaration()
205 Y = NY->getUnderlyingDecl(); in isSameDeclaration()
207 return X->getCanonicalDecl() == Y->getCanonicalDecl(); in isSameDeclaration()
225 // If we have two non-type template argument values deduced for the same in checkDeducedTemplateArguments()
241 llvm_unreachable("Non-deduced template arguments handled above"); in checkDeducedTemplateArguments()
306 X.getAsExpr()->Profile(ID1, Context, true); in checkDeducedTemplateArguments()
307 Y.getAsExpr()->Profile(ID2, Context, true); in checkDeducedTemplateArguments()
347 X.getNullPtrType(), Y.getAsExpr()->getType()), in checkDeducedTemplateArguments()
378 if (Merged.isNull() && !(XA->isNull() && YA->isNull())) in checkDeducedTemplateArguments()
395 /// Deduce the value of the given non-type template parameter
396 /// as the given deduced template argument. All non-type template parameter
404 assert(NTTP->getDepth() == Info.getDeducedDepth() && in DeduceNonTypeTemplateArgument()
405 "deducing non-type template argument with wrong depth"); in DeduceNonTypeTemplateArgument()
408 S.Context, Deduced[NTTP->getIndex()], NewDeduced); in DeduceNonTypeTemplateArgument()
411 Info.FirstArg = Deduced[NTTP->getIndex()]; in DeduceNonTypeTemplateArgument()
416 Deduced[NTTP->getIndex()] = Result; in DeduceNonTypeTemplateArgument()
420 if (NTTP->isExpandedParameterPack()) in DeduceNonTypeTemplateArgument()
429 QualType ParamType = S.Context.getAdjustedParameterType(NTTP->getType()); in DeduceNonTypeTemplateArgument()
431 ParamType = Expansion->getPattern(); in DeduceNonTypeTemplateArgument()
434 // type from an argument (of non-reference type) should be performed. in DeduceNonTypeTemplateArgument()
438 if (ParamType->isReferenceType()) in DeduceNonTypeTemplateArgument()
441 // Top-level cv-qualifiers are irrelevant for a non-reference type. in DeduceNonTypeTemplateArgument()
450 /// Deduce the value of the given non-type template parameter
464 /// Deduce the value of the given non-type template parameter
473 NTTP->getLocation()), in DeduceNullPtrTemplateArgument()
475 NullPtrType->isMemberPointerType() ? CK_NullToMemberPointer in DeduceNullPtrTemplateArgument()
480 Value->getType(), Info, Deduced); in DeduceNullPtrTemplateArgument()
483 /// Deduce the value of the given non-type template parameter
484 /// from the given type- or value-dependent expression.
494 Value->getType(), Info, Deduced); in DeduceNonTypeTemplateArgument()
497 /// Deduce the value of the given non-type template parameter
506 D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr; in DeduceNonTypeTemplateArgument()
519 switch (A->getKind()) { in getTemplateParameterWithDefault()
523 S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(), in getTemplateParameterWithDefault()
524 T->getDepth(), T->getIndex(), T->getIdentifier(), in getTemplateParameterWithDefault()
525 T->wasDeclaredWithTypename(), T->isParameterPack(), in getTemplateParameterWithDefault()
526 T->hasTypeConstraint()); in getTemplateParameterWithDefault()
527 R->setDefaultArgument( in getTemplateParameterWithDefault()
530 if (R->hasTypeConstraint()) { in getTemplateParameterWithDefault()
531 auto *C = R->getTypeConstraint(); in getTemplateParameterWithDefault()
532 R->setTypeConstraint(C->getConceptReference(), in getTemplateParameterWithDefault()
533 C->getImmediatelyDeclaredConstraint()); in getTemplateParameterWithDefault()
540 S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(), in getTemplateParameterWithDefault()
541 T->getDepth(), T->getIndex(), T->getIdentifier(), T->getType(), in getTemplateParameterWithDefault()
542 T->isParameterPack(), T->getTypeSourceInfo()); in getTemplateParameterWithDefault()
543 R->setDefaultArgument(S.Context, in getTemplateParameterWithDefault()
547 if (auto *PTC = T->getPlaceholderTypeConstraint()) in getTemplateParameterWithDefault()
548 R->setPlaceholderTypeConstraint(PTC); in getTemplateParameterWithDefault()
554 S.Context, A->getDeclContext(), SourceLocation(), T->getDepth(), in getTemplateParameterWithDefault()
555 T->getIndex(), T->isParameterPack(), T->getIdentifier(), in getTemplateParameterWithDefault()
556 T->wasDeclaredWithTypename(), T->getTemplateParameters()); in getTemplateParameterWithDefault()
557 R->setDefaultArgument( in getTemplateParameterWithDefault()
582 if (TempParam->getDepth() != Info.getDeducedDepth()) in DeduceTemplateArguments()
592 assert(!TempArg->isExpandedParameterPack()); in DeduceTemplateArguments()
594 TemplateParameterList *As = TempArg->getTemplateParameters(); in DeduceTemplateArguments()
596 assert(DefaultArguments.size() <= As->size()); in DeduceTemplateArguments()
597 SmallVector<NamedDecl *, 4> Params(As->size()); in DeduceTemplateArguments()
599 Params[I] = getTemplateParameterWithDefault(S, As->getParam(I), in DeduceTemplateArguments()
601 for (unsigned I = DefaultArguments.size(); I < As->size(); ++I) in DeduceTemplateArguments()
602 Params[I] = As->getParam(I); in DeduceTemplateArguments()
608 SourceLocation(), As->getRequiresClause()); in DeduceTemplateArguments()
611 S.Context, TempArg->getDeclContext(), SourceLocation(), in DeduceTemplateArguments()
612 TempArg->getDepth(), TempArg->getPosition(), in DeduceTemplateArguments()
613 TempArg->isParameterPack(), TempArg->getIdentifier(), in DeduceTemplateArguments()
614 TempArg->wasDeclaredWithTypename(), TPL))); in DeduceTemplateArguments()
619 Deduced[TempParam->getIndex()], in DeduceTemplateArguments()
623 Info.FirstArg = Deduced[TempParam->getIndex()]; in DeduceTemplateArguments()
628 Deduced[TempParam->getIndex()] = Result; in DeduceTemplateArguments()
636 // Mismatch of non-dependent template parameter to argument. in DeduceTemplateArguments()
643 /// type (which is a template-id) with the template argument type.
664 T->getAs<TemplateSpecializationType>(); in getLastTemplateSpecType()
666 if (!TST->isSugared()) in getLastTemplateSpecType()
668 T = TST->desugar().getTypePtr(); in getLastTemplateSpecType()
678 if (const auto *IP = P->getAs<InjectedClassNameType>()) in DeduceTemplateSpecArguments()
679 UP = IP->getInjectedSpecializationType(); in DeduceTemplateSpecArguments()
683 TemplateName TNP = TP->getTemplateName(); in DeduceTemplateSpecArguments()
686 if (const auto *TD = TNP.getAsTemplateDecl(); TD && TD->isTypeAlias()) in DeduceTemplateSpecArguments()
692 TP->getCanonicalTypeInternal() in DeduceTemplateSpecArguments()
693 ->castAs<TemplateSpecializationType>() in DeduceTemplateSpecArguments()
694 ->template_arguments(); in DeduceTemplateSpecArguments()
698 // Treat an injected-class-name as its underlying template-id. in DeduceTemplateSpecArguments()
699 if (const auto *Elaborated = A->getAs<ElaboratedType>()) { in DeduceTemplateSpecArguments()
700 NNS = Elaborated->getQualifier(); in DeduceTemplateSpecArguments()
701 } else if (const auto *Injected = A->getAs<InjectedClassNameType>()) { in DeduceTemplateSpecArguments()
702 UA = Injected->getInjectedSpecializationType(); in DeduceTemplateSpecArguments()
706 // Check whether the template argument is a dependent template-id. in DeduceTemplateSpecArguments()
709 TemplateName TNA = SA->getTemplateName(); in DeduceTemplateSpecArguments()
712 if (const auto *TD = TNA.getAsTemplateDecl(); TD && TD->isTypeAlias()) in DeduceTemplateSpecArguments()
718 SA->getCanonicalTypeInternal() in DeduceTemplateSpecArguments()
719 ->castAs<TemplateSpecializationType>() in DeduceTemplateSpecArguments()
720 ->template_arguments(); in DeduceTemplateSpecArguments()
739 const auto *RA = UA->getAs<RecordType>(); in DeduceTemplateSpecArguments()
741 RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) : nullptr; in DeduceTemplateSpecArguments()
748 TemplateName TNA = TemplateName(SA->getSpecializedTemplate()); in DeduceTemplateSpecArguments()
751 *NNS, false, TemplateName(SA->getSpecializedTemplate())); in DeduceTemplateSpecArguments()
756 SA->getTemplateArgs().asArray(), Deduced); in DeduceTemplateSpecArguments()
762 SA->getTemplateArgs().asArray(), Info, Deduced, in DeduceTemplateSpecArguments()
767 assert(T->isCanonicalUnqualified()); in IsPossiblyOpaquelyQualifiedTypeInternal()
769 switch (T->getTypeClass()) { in IsPossiblyOpaquelyQualifiedTypeInternal()
785 cast<ArrayType>(T)->getElementType().getTypePtr()); in IsPossiblyOpaquelyQualifiedTypeInternal()
796 T->getCanonicalTypeInternal().getTypePtr()); in IsPossiblyOpaquelyQualifiedType()
866 // pre-expanded expansions? (This should already have been diagnosed in addPack()
869 getExpandedPackSize(TemplateParams->getParam(Index))) in addPack()
878 llvm::SmallBitVector SawIndices(TemplateParams->size()); in addPacks()
889 // in C++17 onwards, deducing a non-type template parameter deduces its in addPacks()
892 TemplateParams->getParam(Index))) { in addPacks()
893 if (!NTTP->isExpandedParameterPack()) in addPacks()
894 if (auto *Expansion = dyn_cast<PackExpansionType>(NTTP->getType())) in addPacks()
895 ExtraDeductions.push_back(Expansion->getPattern()); in addPacks()
927 // Dig out the partially-substituted pack, if there is one. in finishConstruction()
930 std::pair<unsigned, unsigned> PartialPackDepthIndex(-1u, -1u); in finishConstruction()
932 if (auto *Partial = Scope->getPartiallySubstitutedPack( in finishConstruction()
937 // it only names explicitly-specified parameter packs (including the in finishConstruction()
938 // partially-substituted one, if any). in finishConstruction()
969 // We pre-populate the deduced value of the partially-substituted in finishConstruction()
975 // parameter, we could substitute the partially-substituted pack in finishConstruction()
1058 // and post-substitution checking will always fail if the arity of any in finish()
1061 // hard errors from those follow-on steps by the intent (but not the in finish()
1091 if (Pack.Outer->DeferredDeduction.isNull()) { in finish()
1094 Pack.Outer->DeferredDeduction = NewPack; in finish()
1097 Loc = &Pack.Outer->DeferredDeduction; in finish()
1119 NamedDecl *Param = TemplateParams->getParam(Pack.Index); in finish()
1127 // If we have a pre-expanded pack and we didn't deduce enough elements in finish()
1152 /// The number of expansions, if we have a fully-expanded pack in this scope.
1161 /// types to the list of argument types, as in the parameter-type-lists of
1199 // Pi of the respective parameter-type- list of P is compared with the in DeduceTemplateArguments()
1200 // corresponding parameter type Ai of the corresponding parameter-type-list in DeduceTemplateArguments()
1235 // If the parameter-declaration corresponding to Pi is a function in DeduceTemplateArguments()
1236 // parameter pack, then the type of its declarator- id is compared with in DeduceTemplateArguments()
1237 // each remaining parameter type in the parameter-type-list of A. Each in DeduceTemplateArguments()
1241 QualType Pattern = Expansion->getPattern(); in DeduceTemplateArguments()
1245 // a non-deduced context. in DeduceTemplateArguments()
1260 // The non-deduced contexts are: in DeduceTemplateArguments()
1261 // - A function parameter pack that does not occur at the end of the in DeduceTemplateArguments()
1262 // parameter-declaration-clause. in DeduceTemplateArguments()
1267 // explicitly-specified values (or to <> if there is no such value). in DeduceTemplateArguments()
1269 // This is seemingly-arbitrarily different from the case of a template-id in DeduceTemplateArguments()
1270 // with a non-trailing pack-expansion in its arguments, which renders the in DeduceTemplateArguments()
1271 // entire template-argument-list a non-deduced context. in DeduceTemplateArguments()
1273 // If the parameter type contains an explicitly-specified pack that we in DeduceTemplateArguments()
1276 std::optional<unsigned> NumExpansions = Expansion->getNumExpansions(); in DeduceTemplateArguments()
1293 // If the parameter-declaration corresponding to P_i ... in DeduceTemplateArguments()
1295 // - if P does not contain a function parameter type corresponding to Ai then in DeduceTemplateArguments()
1320 // Mismatched (but not missing) Objective-C GC attributes. in hasInconsistentOrSupersetQualifiersOf()
1330 // Mismatched (but not missing) Objective-C lifetime qualifiers. in hasInconsistentOrSupersetQualifiersOf()
1340 const FunctionType *PF = P->getAs<FunctionType>(), in isSameOrCompatibleFunctionType()
1341 *AF = A->getAs<FunctionType>(); in isSameOrCompatibleFunctionType()
1356 /// innermost template-parameter-list. This is 0 except when we concatenate
1360 auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl()); in getFirstInnerIndex()
1361 if (!Guide || !Guide->isImplicit()) in getFirstInnerIndex()
1363 return Guide->getDeducedTemplate()->getTemplateParameters()->size(); in getFirstInnerIndex()
1369 // A forwarding reference is an rvalue reference to a cv-unqualified in isForwardingReference()
1372 if (auto *ParamRef = Param->getAs<RValueReferenceType>()) { in isForwardingReference()
1373 if (ParamRef->getPointeeType().getQualifiers()) in isForwardingReference()
1375 auto *TypeParm = ParamRef->getPointeeType()->getAs<TemplateTypeParmType>(); in isForwardingReference()
1376 return TypeParm && TypeParm->getIndex() >= FirstInnerIndex; in isForwardingReference()
1383 T->castAs<RecordType>()->getDecl()->getCanonicalDecl()); in getCanonicalRD()
1410 // If P is a class and P has the form simple-template-id, then the in DeduceTemplateBases()
1412 // P is a pointer to a class of the form simple-template-id, the in DeduceTemplateBases()
1423 // Use a breadth-first search through the bases to collect the set of in DeduceTemplateBases()
1437 for (const auto &Base : RD->bases()) { in DeduceTemplateBases()
1439 assert(T->isRecordType() && "Base class that isn't a record?"); in DeduceTemplateBases()
1445 // Set up the loop by adding all the bases. in DeduceTemplateBases()
1533 A = AExp->getPattern(); in DeduceTemplateArgumentsByTypeMatch()
1540 // - If P is a reference type, P is replaced by the type referred to. in DeduceTemplateArgumentsByTypeMatch()
1541 const ReferenceType *PRef = P->getAs<ReferenceType>(); in DeduceTemplateArgumentsByTypeMatch()
1543 P = PRef->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
1545 // - If A is a reference type, A is replaced by the type referred to. in DeduceTemplateArgumentsByTypeMatch()
1546 const ReferenceType *ARef = A->getAs<ReferenceType>(); in DeduceTemplateArgumentsByTypeMatch()
1548 A = A->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
1555 // - if [one type] was an lvalue reference and [the other type] was in DeduceTemplateArgumentsByTypeMatch()
1558 // - if [one type] is more cv-qualified than [the other type], in DeduceTemplateArgumentsByTypeMatch()
1561 // Objective-C ARC adds: in DeduceTemplateArgumentsByTypeMatch()
1562 // - [one type] has non-trivial lifetime, [the other type] has in DeduceTemplateArgumentsByTypeMatch()
1571 if ((PRef->isLValueReferenceType() && !ARef->isLValueReferenceType()) || in DeduceTemplateArgumentsByTypeMatch()
1583 // Remove any top-level cv-qualifiers: in DeduceTemplateArgumentsByTypeMatch()
1584 // - If P is a cv-qualified type, P is replaced by the cv-unqualified in DeduceTemplateArgumentsByTypeMatch()
1587 // - If A is a cv-qualified type, A is replaced by the cv-unqualified in DeduceTemplateArgumentsByTypeMatch()
1592 // - If the original P is a reference type, the deduced A (i.e., the type in DeduceTemplateArgumentsByTypeMatch()
1593 // referred to by the reference) can be more cv-qualified than the in DeduceTemplateArgumentsByTypeMatch()
1602 if ((TDF & TDF_TopLevelParameterTypeList) && !P->isFunctionType()) { in DeduceTemplateArgumentsByTypeMatch()
1607 // Ai are parameters of the top-level parameter-type-list of P and A, in DeduceTemplateArgumentsByTypeMatch()
1613 // deduced as X&. - end note ] in DeduceTemplateArgumentsByTypeMatch()
1616 A->isLValueReferenceType()) in DeduceTemplateArgumentsByTypeMatch()
1617 P = P->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
1623 // template non-type argument i can be deduced if P and A have one of in DeduceTemplateArgumentsByTypeMatch()
1627 // cv-list T in DeduceTemplateArgumentsByTypeMatch()
1628 if (const auto *TTP = P->getAs<TemplateTypeParmType>()) { in DeduceTemplateArgumentsByTypeMatch()
1631 if (A->isPlaceholderType() || Info.getDeducedDepth() != TTP->getDepth()) in DeduceTemplateArgumentsByTypeMatch()
1634 unsigned Index = TTP->getIndex(); in DeduceTemplateArgumentsByTypeMatch()
1638 if (A->isArrayType()) { in DeduceTemplateArgumentsByTypeMatch()
1649 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); in DeduceTemplateArgumentsByTypeMatch()
1655 // Do not match a function type with a cv-qualified type. in DeduceTemplateArgumentsByTypeMatch()
1656 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584 in DeduceTemplateArgumentsByTypeMatch()
1657 if (A->isFunctionType() && P.hasQualifiers()) in DeduceTemplateArgumentsByTypeMatch()
1660 assert(TTP->getDepth() == Info.getDeducedDepth() && in DeduceTemplateArgumentsByTypeMatch()
1662 assert(A->getCanonicalTypeInternal() != S.Context.OverloadTy && in DeduceTemplateArgumentsByTypeMatch()
1678 // Objective-C ARC: in DeduceTemplateArgumentsByTypeMatch()
1681 if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() && in DeduceTemplateArgumentsByTypeMatch()
1682 !DeducedType->isDependentType()) { in DeduceTemplateArgumentsByTypeMatch()
1683 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); in DeduceTemplateArgumentsByTypeMatch()
1689 // Objective-C ARC: in DeduceTemplateArgumentsByTypeMatch()
1692 if (S.getLangOpts().ObjCAutoRefCount && DeducedType->isObjCLifetimeType() && in DeduceTemplateArgumentsByTypeMatch()
1703 Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index)); in DeduceTemplateArgumentsByTypeMatch()
1717 // If the parameter is an already-substituted template parameter in DeduceTemplateArgumentsByTypeMatch()
1721 if (P->getAs<SubstTemplateTypeParmPackType>()) in DeduceTemplateArgumentsByTypeMatch()
1724 // Check the cv-qualifiers on the parameter and argument types. in DeduceTemplateArgumentsByTypeMatch()
1731 // If the original A is a reference type, A can be more cv-qualified in DeduceTemplateArgumentsByTypeMatch()
1748 if (!P->isDependentType()) { in DeduceTemplateArgumentsByTypeMatch()
1761 // must keep going and analyze with a non-dependent parameter type. in DeduceTemplateArgumentsByTypeMatch()
1764 switch (P.getCanonicalType()->getTypeClass()) { in DeduceTemplateArgumentsByTypeMatch()
1765 // Non-canonical types cannot appear here. in DeduceTemplateArgumentsByTypeMatch()
1767 case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class); in DeduceTemplateArgumentsByTypeMatch()
1778 // non-deduced context. in DeduceTemplateArgumentsByTypeMatch()
1781 if (P->isDependentType()) in DeduceTemplateArgumentsByTypeMatch()
1803 const auto *CP = P->castAs<ComplexType>(), *CA = A->getAs<ComplexType>(); in DeduceTemplateArgumentsByTypeMatch()
1807 S, TemplateParams, CP->getElementType(), CA->getElementType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1813 const auto *PA = P->castAs<AtomicType>(), *AA = A->getAs<AtomicType>(); in DeduceTemplateArgumentsByTypeMatch()
1817 S, TemplateParams, PA->getValueType(), AA->getValueType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1824 if (const auto *PA = A->getAs<PointerType>()) { in DeduceTemplateArgumentsByTypeMatch()
1825 PointeeType = PA->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
1826 } else if (const auto *PA = A->getAs<ObjCObjectPointerType>()) { in DeduceTemplateArgumentsByTypeMatch()
1827 PointeeType = PA->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
1832 S, TemplateParams, P->castAs<PointerType>()->getPointeeType(), in DeduceTemplateArgumentsByTypeMatch()
1839 const auto *RP = P->castAs<LValueReferenceType>(), in DeduceTemplateArgumentsByTypeMatch()
1840 *RA = A->getAs<LValueReferenceType>(); in DeduceTemplateArgumentsByTypeMatch()
1845 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1851 const auto *RP = P->castAs<RValueReferenceType>(), in DeduceTemplateArgumentsByTypeMatch()
1852 *RA = A->getAs<RValueReferenceType>(); in DeduceTemplateArgumentsByTypeMatch()
1857 S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1871 S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1875 // T [integer-constant] in DeduceTemplateArgumentsByTypeMatch()
1880 if (!CAA || CAA->getSize() != CAP->getSize()) in DeduceTemplateArgumentsByTypeMatch()
1884 S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info, in DeduceTemplateArgumentsByTypeMatch()
1898 S, TemplateParams, DAP->getElementType(), AA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
1905 getDeducedParameterFromExpr(Info, DAP->getSizeExpr()); in DeduceTemplateArgumentsByTypeMatch()
1909 // We can perform template argument deduction for the given non-type in DeduceTemplateArgumentsByTypeMatch()
1911 assert(NTTP->getDepth() == Info.getDeducedDepth() && in DeduceTemplateArgumentsByTypeMatch()
1912 "saw non-type template parameter with wrong depth"); in DeduceTemplateArgumentsByTypeMatch()
1914 llvm::APSInt Size(CAA->getSize()); in DeduceTemplateArgumentsByTypeMatch()
1920 if (DAA->getSizeExpr()) in DeduceTemplateArgumentsByTypeMatch()
1922 S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
1924 // Incomplete type does not match a dependently-sized array type in DeduceTemplateArgumentsByTypeMatch()
1932 const auto *FPP = P->castAs<FunctionProtoType>(), in DeduceTemplateArgumentsByTypeMatch()
1933 *FPA = A->getAs<FunctionProtoType>(); in DeduceTemplateArgumentsByTypeMatch()
1937 if (FPP->getMethodQuals() != FPA->getMethodQuals() || in DeduceTemplateArgumentsByTypeMatch()
1938 FPP->getRefQualifier() != FPA->getRefQualifier() || in DeduceTemplateArgumentsByTypeMatch()
1939 FPP->isVariadic() != FPA->isVariadic()) in DeduceTemplateArgumentsByTypeMatch()
1944 S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(), in DeduceTemplateArgumentsByTypeMatch()
1953 S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(), in DeduceTemplateArgumentsByTypeMatch()
1954 FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced, in DeduceTemplateArgumentsByTypeMatch()
1962 // FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit in DeduceTemplateArgumentsByTypeMatch()
1963 // deducing through the noexcept-specifier if it's part of the canonical in DeduceTemplateArgumentsByTypeMatch()
1965 Expr *NoexceptExpr = FPP->getNoexceptExpr(); in DeduceTemplateArgumentsByTypeMatch()
1969 assert(NTTP->getDepth() == Info.getDeducedDepth() && in DeduceTemplateArgumentsByTypeMatch()
1970 "saw non-type template parameter with wrong depth"); in DeduceTemplateArgumentsByTypeMatch()
1973 switch (FPA->canThrow()) { in DeduceTemplateArgumentsByTypeMatch()
1986 if (Expr *ArgNoexceptExpr = FPA->getNoexceptExpr()) in DeduceTemplateArgumentsByTypeMatch()
1993 // FIXME: Detect non-deduced exception specification mismatches? in DeduceTemplateArgumentsByTypeMatch()
1996 // top-level differences in noexcept-specifications. in DeduceTemplateArgumentsByTypeMatch()
2002 // Treat a template's injected-class-name as if the template in DeduceTemplateArgumentsByTypeMatch()
2005 // template-name<T> (where template-name refers to a class template) in DeduceTemplateArgumentsByTypeMatch()
2006 // template-name<i> in DeduceTemplateArgumentsByTypeMatch()
2012 // arguments from the template-id. in DeduceTemplateArgumentsByTypeMatch()
2013 if (!(TDF & TDF_DerivedClass) || !A->isRecordType()) in DeduceTemplateArgumentsByTypeMatch()
2031 if (getCanonicalRD(A)->isInvalidDecl()) in DeduceTemplateArgumentsByTypeMatch()
2054 const auto *MPP = P->castAs<MemberPointerType>(), in DeduceTemplateArgumentsByTypeMatch()
2055 *MPA = A->getAs<MemberPointerType>(); in DeduceTemplateArgumentsByTypeMatch()
2059 QualType PPT = MPP->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
2060 if (PPT->isFunctionType()) in DeduceTemplateArgumentsByTypeMatch()
2063 QualType APT = MPA->getPointeeType(); in DeduceTemplateArgumentsByTypeMatch()
2064 if (APT->isFunctionType()) in DeduceTemplateArgumentsByTypeMatch()
2074 S, TemplateParams, QualType(MPP->getClass(), 0), in DeduceTemplateArgumentsByTypeMatch()
2075 QualType(MPA->getClass(), 0), Info, Deduced, SubTDF); in DeduceTemplateArgumentsByTypeMatch()
2084 const auto *BPP = P->castAs<BlockPointerType>(), in DeduceTemplateArgumentsByTypeMatch()
2085 *BPA = A->getAs<BlockPointerType>(); in DeduceTemplateArgumentsByTypeMatch()
2089 S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info, in DeduceTemplateArgumentsByTypeMatch()
2097 const auto *VP = P->castAs<ExtVectorType>(); in DeduceTemplateArgumentsByTypeMatch()
2099 if (const auto *VA = A->getAs<ExtVectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2101 if (VP->getNumElements() != VA->getNumElements()) in DeduceTemplateArgumentsByTypeMatch()
2103 ElementType = VA->getElementType(); in DeduceTemplateArgumentsByTypeMatch()
2104 } else if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2108 ElementType = VA->getElementType(); in DeduceTemplateArgumentsByTypeMatch()
2114 S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced, in DeduceTemplateArgumentsByTypeMatch()
2119 const auto *VP = P->castAs<DependentVectorType>(); in DeduceTemplateArgumentsByTypeMatch()
2121 if (const auto *VA = A->getAs<VectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2124 S, TemplateParams, VP->getElementType(), VA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
2131 getDeducedParameterFromExpr(Info, VP->getSizeExpr()); in DeduceTemplateArgumentsByTypeMatch()
2136 ArgSize = VA->getNumElements(); in DeduceTemplateArgumentsByTypeMatch()
2145 if (const auto *VA = A->getAs<DependentVectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2148 S, TemplateParams, VP->getElementType(), VA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
2155 getDeducedParameterFromExpr(Info, VP->getSizeExpr()); in DeduceTemplateArgumentsByTypeMatch()
2160 VA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2170 const auto *VP = P->castAs<DependentSizedExtVectorType>(); in DeduceTemplateArgumentsByTypeMatch()
2172 if (const auto *VA = A->getAs<ExtVectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2175 S, TemplateParams, VP->getElementType(), VA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
2182 getDeducedParameterFromExpr(Info, VP->getSizeExpr()); in DeduceTemplateArgumentsByTypeMatch()
2187 ArgSize = VA->getNumElements(); in DeduceTemplateArgumentsByTypeMatch()
2196 if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) { in DeduceTemplateArgumentsByTypeMatch()
2199 S, TemplateParams, VP->getElementType(), VA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
2206 getDeducedParameterFromExpr(Info, VP->getSizeExpr()); in DeduceTemplateArgumentsByTypeMatch()
2211 VA->getSizeExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2222 const auto *MP = P->castAs<ConstantMatrixType>(), in DeduceTemplateArgumentsByTypeMatch()
2223 *MA = A->getAs<ConstantMatrixType>(); in DeduceTemplateArgumentsByTypeMatch()
2228 if (MP->getNumRows() != MA->getNumRows() || in DeduceTemplateArgumentsByTypeMatch()
2229 MP->getNumColumns() != MA->getNumColumns()) { in DeduceTemplateArgumentsByTypeMatch()
2234 S, TemplateParams, MP->getElementType(), MA->getElementType(), Info, in DeduceTemplateArgumentsByTypeMatch()
2239 const auto *MP = P->castAs<DependentSizedMatrixType>(); in DeduceTemplateArgumentsByTypeMatch()
2240 const auto *MA = A->getAs<MatrixType>(); in DeduceTemplateArgumentsByTypeMatch()
2246 S, TemplateParams, MP->getElementType(), MA->getElementType(), in DeduceTemplateArgumentsByTypeMatch()
2259 if (!ParamExpr->isValueDependent()) { in DeduceTemplateArgumentsByTypeMatch()
2261 ParamExpr->getIntegerConstantExpr(S.Context); in DeduceTemplateArgumentsByTypeMatch()
2266 if ((ACM->*GetArgDimension)() == *ParamConst) in DeduceTemplateArgumentsByTypeMatch()
2271 Expr *ArgExpr = (ADM->*GetArgDimensionExpr)(); in DeduceTemplateArgumentsByTypeMatch()
2273 ArgExpr->getIntegerConstantExpr(S.Context)) in DeduceTemplateArgumentsByTypeMatch()
2287 ArgConst = (ACM->*GetArgDimension)(); in DeduceTemplateArgumentsByTypeMatch()
2294 (ADM->*GetArgDimensionExpr)(), in DeduceTemplateArgumentsByTypeMatch()
2298 if (auto Result = DeduceMatrixArg(MP->getRowExpr(), MA, in DeduceTemplateArgumentsByTypeMatch()
2304 return DeduceMatrixArg(MP->getColumnExpr(), MA, in DeduceTemplateArgumentsByTypeMatch()
2313 const auto *ASP = P->castAs<DependentAddressSpaceType>(); in DeduceTemplateArgumentsByTypeMatch()
2315 if (const auto *ASA = A->getAs<DependentAddressSpaceType>()) { in DeduceTemplateArgumentsByTypeMatch()
2318 S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(), in DeduceTemplateArgumentsByTypeMatch()
2325 getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr()); in DeduceTemplateArgumentsByTypeMatch()
2330 S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced); in DeduceTemplateArgumentsByTypeMatch()
2340 S, TemplateParams, ASP->getPointeeType(), in DeduceTemplateArgumentsByTypeMatch()
2347 getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr()); in DeduceTemplateArgumentsByTypeMatch()
2359 const auto *IP = P->castAs<DependentBitIntType>(); in DeduceTemplateArgumentsByTypeMatch()
2361 if (const auto *IA = A->getAs<BitIntType>()) { in DeduceTemplateArgumentsByTypeMatch()
2362 if (IP->isUnsigned() != IA->isUnsigned()) in DeduceTemplateArgumentsByTypeMatch()
2366 getDeducedParameterFromExpr(Info, IP->getNumBitsExpr()); in DeduceTemplateArgumentsByTypeMatch()
2371 ArgSize = IA->getNumBits(); in DeduceTemplateArgumentsByTypeMatch()
2378 if (const auto *IA = A->getAs<DependentBitIntType>()) { in DeduceTemplateArgumentsByTypeMatch()
2379 if (IP->isUnsigned() != IA->isUnsigned()) in DeduceTemplateArgumentsByTypeMatch()
2402 const PackIndexingType *PIT = P->getAs<PackIndexingType>(); in DeduceTemplateArgumentsByTypeMatch()
2403 if (PIT->hasSelectedType()) { in DeduceTemplateArgumentsByTypeMatch()
2405 S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF); in DeduceTemplateArgumentsByTypeMatch()
2529 /// This routine "expands" argument packs in-place, overriding its input
2543 assert(ArgIdx == Args.size() - 1 && "Pack not at the end of argument list?"); in hasTemplateArgumentForDeduction()
2560 // FIXME: If this is a fixed-arity pack expansion from an outer level of in hasPackExpansionBeforeEnd()
2571 ArrayRef<TemplateArgument> Ps, in DeduceTemplateArguments() argument
2577 std::swap(Ps, As); in DeduceTemplateArguments()
2581 // non-deduced context. in DeduceTemplateArguments()
2582 if (hasPackExpansionBeforeEnd(Ps)) in DeduceTemplateArguments()
2590 for (; hasTemplateArgumentForDeduction(Ps, ParamIdx); ++ParamIdx) { in DeduceTemplateArguments()
2591 const TemplateArgument &P = Ps[ParamIdx]; in DeduceTemplateArguments()
2662 TemplateParameterList *TemplateParams, ArrayRef<TemplateArgument> Ps, in DeduceTemplateArguments() argument
2666 return ::DeduceTemplateArguments(*this, TemplateParams, Ps, As, Info, Deduced, in DeduceTemplateArguments()
2677 // we will have flattened packs to non-expansions in X. in isSameTemplateArg()
2713 X.getAsExpr()->Profile(XID, Context, true); in isSameTemplateArg()
2714 Y.getAsExpr()->Profile(YID, Context, true); in isSameTemplateArg()
2726 // - if P does not contain a template argument corresponding to Ai in isSameTemplateArg()
2791 Builder.MakeTrivial(Context, DTN->getQualifier(), Loc); in getTrivialTemplateArgumentLoc()
2794 Builder.MakeTrivial(Context, QTN->getQualifier(), Loc); in getTrivialTemplateArgumentLoc()
2822 /// fully-converted template arguments.
2838 Param, ArgLoc, Template, Template->getLocation(), in ConvertDeducedTemplateArgument()
2839 Template->getSourceRange().getEnd(), ArgumentPackIndex, SugaredOutput, in ConvertDeducedTemplateArgument()
2862 // all of them. This happens if we get a conditionally-non-deduced in ConvertDeducedTemplateArgument()
2865 S.Diag(Param->getLocation(), in ConvertDeducedTemplateArgument()
2886 Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, in ConvertDeducedTemplateArgument()
2888 Template->getSourceRange()); in ConvertDeducedTemplateArgument()
2890 S.SubstType(NTTP->getType(), Args, NTTP->getLocation(), in ConvertDeducedTemplateArgument()
2891 NTTP->getDeclName()).isNull()) in ConvertDeducedTemplateArgument()
2894 Sema::InstantiatingTemplate Inst(S, Template->getLocation(), Template, in ConvertDeducedTemplateArgument()
2896 Template->getSourceRange()); in ConvertDeducedTemplateArgument()
2926 TemplateParameterList *TemplateParams = Template->getTemplateParameters(); in ConvertDeducedTemplateArguments()
2928 for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) { in ConvertDeducedTemplateArguments()
2929 NamedDecl *Param = TemplateParams->getParam(I); in ConvertDeducedTemplateArguments()
2935 if (Deduced[I].isNull() && Param->isTemplateParameterPack()) { in ConvertDeducedTemplateArguments()
2944 // We may have had explicitly-specified template arguments for a in ConvertDeducedTemplateArguments()
2947 if (Param->isParameterPack() && CurrentInstantiationScope && in ConvertDeducedTemplateArguments()
2948 CurrentInstantiationScope->getPartiallySubstitutedPack() == Param) { in ConvertDeducedTemplateArguments()
2949 // Forget the partially-substituted pack; its substitution is now in ConvertDeducedTemplateArguments()
2951 CurrentInstantiationScope->ResetPartiallySubstitutedPack(); in ConvertDeducedTemplateArguments()
2955 // We have already fully type-checked and converted this in ConvertDeducedTemplateArguments()
2956 // argument, because it was explicitly-specified. Just record the in ConvertDeducedTemplateArguments()
2994 if (auto *Rec = dyn_cast<CXXRecordDecl>(TD->getDeclContext())) in ConvertDeducedTemplateArguments()
2995 if (Rec->isLambda()) in ConvertDeducedTemplateArguments()
2996 if (auto *Method = dyn_cast<CXXMethodDecl>(Rec->getDeclContext())) { in ConvertDeducedTemplateArguments()
2997 ThisContext = Method->getParent(); in ConvertDeducedTemplateArguments()
2998 ThisTypeQuals = Method->getMethodQualifiers(); in ConvertDeducedTemplateArguments()
3005 TD, TD->getLocation(), TD->getSourceRange().getEnd(), Param, in ConvertDeducedTemplateArguments()
3012 const_cast<NamedDecl *>(TemplateParams->getParam(I))); in ConvertDeducedTemplateArguments()
3023 Param, DefArg, TD, TD->getLocation(), TD->getSourceRange().getEnd(), in ConvertDeducedTemplateArguments()
3026 const_cast<NamedDecl *>(TemplateParams->getParam(I))); in ConvertDeducedTemplateArguments()
3042 return D->getDeclContext(); in getAsDeclContextOrEnclosing()
3063 return !Spec->isClassScopeExplicitSpecialization(); in DeducedArgsNeedReplacement()
3068 return !Spec->isClassScopeExplicitSpecialization(); in DeducedArgsNeedReplacement()
3078 Template->getAssociatedConstraints(AssociatedConstraints); in CheckDeducedArgumentConstraints()
3082 // we can add them immediately as the inner-most argument list. in CheckDeducedArgumentConstraints()
3087 Template, Template->getDeclContext(), /*Final=*/false, Innermost, 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()
3094 // instead of adding to inner-most. in CheckDeducedArgumentConstraints()
3150 auto *Template = Partial->getSpecializedTemplate(); in FinishTemplateArgumentDeduction()
3152 Partial->getTemplateArgsAsWritten(); in FinishTemplateArgumentDeduction()
3154 TemplateArgumentListInfo InstArgs(PartialTemplArgInfo->LAngleLoc, in FinishTemplateArgumentDeduction()
3155 PartialTemplArgInfo->RAngleLoc); in FinishTemplateArgumentDeduction()
3157 if (S.SubstTemplateArguments(PartialTemplArgInfo->arguments(), in FinishTemplateArgumentDeduction()
3163 if (ParamIdx >= Partial->getTemplateParameters()->size()) in FinishTemplateArgumentDeduction()
3164 ParamIdx = Partial->getTemplateParameters()->size() - 1; in FinishTemplateArgumentDeduction()
3167 Partial->getTemplateParameters()->getParam(ParamIdx)); in FinishTemplateArgumentDeduction()
3177 Template, Partial->getLocation(), InstArgs, false, in FinishTemplateArgumentDeduction()
3184 TemplateParameterList *TemplateParams = Template->getTemplateParameters(); in FinishTemplateArgumentDeduction()
3185 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { in FinishTemplateArgumentDeduction()
3189 Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); in FinishTemplateArgumentDeduction()
3235 TemplateParameterList *TemplateParams = Template->getTemplateParameters(); in FinishTemplateArgumentDeduction()
3236 for (unsigned I = 0, E = TemplateParams->size(); I != E; ++I) { in FinishTemplateArgumentDeduction()
3240 Info.Param = makeTemplateParameter(TemplateParams->getParam(I)); in FinishTemplateArgumentDeduction()
3301 if (Partial->isInvalidDecl()) in DeduceTemplateArguments()
3320 Deduced.resize(Partial->getTemplateParameters()->size()); in DeduceTemplateArguments()
3322 S, Partial->getTemplateParameters(), in DeduceTemplateArguments()
3323 Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced, in DeduceTemplateArguments()
3362 if (TD->isInvalidDecl()) in DeduceTemplateArgumentsFromType()
3368 PType = Context.getTypeDeclType(CTD->getTemplatedDecl()); in DeduceTemplateArgumentsFromType()
3370 PType = AliasTemplate->getTemplatedDecl() in DeduceTemplateArgumentsFromType()
3371 ->getUnderlyingType() in DeduceTemplateArgumentsFromType()
3387 TD->getTemplateParameters()->size()); in DeduceTemplateArgumentsFromType()
3391 TD->getTemplateParameters(), PArgs, AArgs, Info, Deduced, false); in DeduceTemplateArgumentsFromType()
3411 /// Determine whether the given type T is a simple-template-id type.
3414 = T->getAs<TemplateSpecializationType>()) in isSimpleTemplateIdType()
3415 return Spec->getTemplateName().getAsTemplateDecl() != nullptr; in isSimpleTemplateIdType()
3418 // the injected-class-name [...] is equivalent to the template-name followed in isSimpleTemplateIdType()
3419 // by the template-arguments of the class template specialization or partial in isSimpleTemplateIdType()
3421 // ... which means it's equivalent to a simple-template-id. in isSimpleTemplateIdType()
3425 if (T->getAs<InjectedClassNameType>()) in isSimpleTemplateIdType()
3437 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); in SubstituteExplicitTemplateArguments()
3439 = FunctionTemplate->getTemplateParameters(); in SubstituteExplicitTemplateArguments()
3444 for (auto *P : Function->parameters()) in SubstituteExplicitTemplateArguments()
3445 ParamTypes.push_back(P->getType()); in SubstituteExplicitTemplateArguments()
3448 *FunctionType = Function->getType(); in SubstituteExplicitTemplateArguments()
3459 // declaration order of their corresponding template-parameters. The in SubstituteExplicitTemplateArguments()
3460 // template argument list shall not specify more template-arguments than in SubstituteExplicitTemplateArguments()
3461 // there are corresponding template-parameters. in SubstituteExplicitTemplateArguments()
3465 // explicitly-specified template arguments against this function template, in SubstituteExplicitTemplateArguments()
3480 if (Index >= TemplateParams->size()) in SubstituteExplicitTemplateArguments()
3482 Info.Param = makeTemplateParameter(TemplateParams->getParam(Index)); in SubstituteExplicitTemplateArguments()
3486 // Form the template argument list from the explicitly-specified in SubstituteExplicitTemplateArguments()
3499 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); in SubstituteExplicitTemplateArguments()
3505 unsigned PartiallySubstitutedPackIndex = -1u; in SubstituteExplicitTemplateArguments()
3509 auto *Param = TemplateParams->getParam(CanonicalBuilder.size() - 1); in SubstituteExplicitTemplateArguments()
3510 // If this is a fully-saturated fixed-size pack, it should be in SubstituteExplicitTemplateArguments()
3511 // fully-substituted, not partially-substituted. in SubstituteExplicitTemplateArguments()
3514 PartiallySubstitutedPackIndex = CanonicalBuilder.size() - 1; in SubstituteExplicitTemplateArguments()
3515 CurrentInstantiationScope->SetPartiallySubstitutedPack( in SubstituteExplicitTemplateArguments()
3522 = Function->getType()->getAs<FunctionProtoType>(); in SubstituteExplicitTemplateArguments()
3531 SugaredExplicitArgumentList->asArray(), in SubstituteExplicitTemplateArguments()
3535 // explicitly-specified template arguments. If the function has a trailing in SubstituteExplicitTemplateArguments()
3538 if (Proto->hasTrailingReturn()) { in SubstituteExplicitTemplateArguments()
3539 if (SubstParmTypes(Function->getLocation(), Function->parameters(), in SubstituteExplicitTemplateArguments()
3540 Proto->getExtParameterInfosOrNull(), MLTAL, ParamTypes, in SubstituteExplicitTemplateArguments()
3551 // "pointer to cv-qualifier-seq X" between the optional cv-qualifer-seq in SubstituteExplicitTemplateArguments()
3552 // and the end of the function-definition, member-declarator, or in SubstituteExplicitTemplateArguments()
3557 ThisContext = Method->getParent(); in SubstituteExplicitTemplateArguments()
3558 ThisTypeQuals = Method->getMethodQualifiers(); in SubstituteExplicitTemplateArguments()
3565 SubstType(Proto->getReturnType(), MLTAL, in SubstituteExplicitTemplateArguments()
3566 Function->getTypeSpecStartLoc(), Function->getDeclName()); in SubstituteExplicitTemplateArguments()
3571 if (Function->hasAttr<CUDAGlobalAttr>() && !ResultType->isVoidType()) { in SubstituteExplicitTemplateArguments()
3572 Diag(Function->getLocation(), diag::err_kern_type_not_void_return) in SubstituteExplicitTemplateArguments()
3573 << Function->getType() << Function->getSourceRange(); in SubstituteExplicitTemplateArguments()
3579 // explicitly-specified template arguments if we didn't do so earlier. in SubstituteExplicitTemplateArguments()
3580 if (!Proto->hasTrailingReturn() && in SubstituteExplicitTemplateArguments()
3581 SubstParmTypes(Function->getLocation(), Function->parameters(), in SubstituteExplicitTemplateArguments()
3582 Proto->getExtParameterInfosOrNull(), MLTAL, ParamTypes, in SubstituteExplicitTemplateArguments()
3587 auto EPI = Proto->getExtProtoInfo(); in SubstituteExplicitTemplateArguments()
3590 Function->getLocation(), in SubstituteExplicitTemplateArguments()
3591 Function->getDeclName(), in SubstituteExplicitTemplateArguments()
3593 if (FunctionType->isNull() || Trap.hasErrorOccurred()) in SubstituteExplicitTemplateArguments()
3599 // omitted from the list of explicit template-arguments. If all of the in SubstituteExplicitTemplateArguments()
3603 // Take all of the explicitly-specified arguments and put them into in SubstituteExplicitTemplateArguments()
3604 // the set of deduced template arguments. The partially-substituted in SubstituteExplicitTemplateArguments()
3606 // mechanism handles the partially-substituted argument pack directly. in SubstituteExplicitTemplateArguments()
3607 Deduced.reserve(TemplateParams->size()); in SubstituteExplicitTemplateArguments()
3608 for (unsigned I = 0, N = SugaredExplicitArgumentList->size(); I != N; ++I) { in SubstituteExplicitTemplateArguments()
3609 const TemplateArgument &Arg = SugaredExplicitArgumentList->get(I); in SubstituteExplicitTemplateArguments()
3627 auto Failed = [&]() -> TemplateDeductionResult { in CheckOriginalCallArgDeduction()
3639 // Check for type equality (top-level cv-qualifiers are ignored). in CheckOriginalCallArgDeduction()
3645 if (const ReferenceType *DeducedARef = DeducedA->getAs<ReferenceType>()) in CheckOriginalCallArgDeduction()
3646 DeducedA = DeducedARef->getPointeeType(); in CheckOriginalCallArgDeduction()
3647 if (const ReferenceType *ARef = A->getAs<ReferenceType>()) in CheckOriginalCallArgDeduction()
3648 A = ARef->getPointeeType(); in CheckOriginalCallArgDeduction()
3652 // - If the original P is a reference type, the deduced A (i.e., the in CheckOriginalCallArgDeduction()
3653 // type referred to by the reference) can be more cv-qualified than in CheckOriginalCallArgDeduction()
3656 = OriginalParamType->getAs<ReferenceType>()) { in CheckOriginalCallArgDeduction()
3658 OriginalParamType = OriginalParamRef->getPointeeType(); in CheckOriginalCallArgDeduction()
3664 if (A->isFunctionType() && S.IsFunctionConversion(A, DeducedA, Tmp)) in CheckOriginalCallArgDeduction()
3670 // Under Objective-C++ ARC, the deduced type may have implicitly in CheckOriginalCallArgDeduction()
3694 // - The transformed A can be another pointer or pointer to member in CheckOriginalCallArgDeduction()
3702 if ((A->isAnyPointerType() || A->isMemberPointerType()) && in CheckOriginalCallArgDeduction()
3708 // - If P is a class and P has the form simple-template-id, then the in CheckOriginalCallArgDeduction()
3711 // simple-template-id, the transformed A can be a pointer to a in CheckOriginalCallArgDeduction()
3714 = OriginalParamType->getAs<PointerType>()) { in CheckOriginalCallArgDeduction()
3715 if (const PointerType *DeducedAPtr = DeducedA->getAs<PointerType>()) { in CheckOriginalCallArgDeduction()
3716 if (const PointerType *APtr = A->getAs<PointerType>()) { in CheckOriginalCallArgDeduction()
3717 if (A->getPointeeType()->isRecordType()) { in CheckOriginalCallArgDeduction()
3718 OriginalParamType = OriginalParamPtr->getPointeeType(); in CheckOriginalCallArgDeduction()
3719 DeducedA = DeducedAPtr->getPointeeType(); in CheckOriginalCallArgDeduction()
3720 A = APtr->getPointeeType(); in CheckOriginalCallArgDeduction()
3729 if (A->isRecordType() && isSimpleTemplateIdType(OriginalParamType) && in CheckOriginalCallArgDeduction()
3739 /// \return The pack index for whichever pack produced this parameter, or -1
3749 for (auto *PD : FunctionTemplate->getTemplatedDecl()->parameters()) { in getPackIndexForParam()
3750 if (PD->isParameterPack()) { in getPackIndexForParam()
3752 S.getNumArgumentsInExpansion(PD->getType(), Args).value_or(1); in getPackIndexForParam()
3754 return ParamIdx - Idx; in getPackIndexForParam()
3758 return -1; // Not a pack expansion in getPackIndexForParam()
3776 ? cast<CXXConstructorDecl>(D)->getExplicitSpecifier() in instantiateExplicitSpecifierDeferred()
3777 : cast<CXXConversionDecl>(D)->getExplicitSpecifier(); in instantiateExplicitSpecifierDeferred()
3781 ? cast<CXXConstructorDecl>(D)->setExplicitSpecifier(ES) in instantiateExplicitSpecifierDeferred()
3782 : cast<CXXConversionDecl>(D)->setExplicitSpecifier(ES); in instantiateExplicitSpecifierDeferred()
3789 if (!ExplicitExpr->isValueDependent()) in instantiateExplicitSpecifierDeferred()
3801 Specialization->setInvalidDecl(true); in instantiateExplicitSpecifierDeferred()
3829 ContextRAII SavedContext(*this, FunctionTemplate->getTemplatedDecl()); in FinishTemplateArgumentDeduction()
3844 // template-parameters that participate in template argument deduction, in FinishTemplateArgumentDeduction()
3848 // P with a type that was non-dependent before substitution of any in FinishTemplateArgumentDeduction()
3849 // explicitly-specified template arguments, if the corresponding argument in FinishTemplateArgumentDeduction()
3863 DeclContext *Owner = FunctionTemplate->getDeclContext(); in FinishTemplateArgumentDeduction()
3864 if (FunctionTemplate->getFriendObjectKind()) in FinishTemplateArgumentDeduction()
3865 Owner = FunctionTemplate->getLexicalDeclContext(); in FinishTemplateArgumentDeduction()
3866 FunctionDecl *FD = FunctionTemplate->getTemplatedDecl(); in FinishTemplateArgumentDeduction()
3877 if (FD->getFriendObjectKind() == Decl::FriendObjectKind::FOK_None && in FinishTemplateArgumentDeduction()
3878 FD->isDefined(FDFriend, /*CheckForPendingFriendDefinition*/ true) && in FinishTemplateArgumentDeduction()
3879 FDFriend->getFriendObjectKind() != Decl::FriendObjectKind::FOK_None) { in FinishTemplateArgumentDeduction()
3881 Owner = FD->getLexicalDeclContext(); in FinishTemplateArgumentDeduction()
3884 FunctionTemplate, CanonicalDeducedArgumentList->asArray(), in FinishTemplateArgumentDeduction()
3888 if (!Specialization || Specialization->isInvalidDecl()) in FinishTemplateArgumentDeduction()
3891 assert(Specialization->getPrimaryTemplate()->getCanonicalDecl() == in FinishTemplateArgumentDeduction()
3892 FunctionTemplate->getCanonicalDecl()); in FinishTemplateArgumentDeduction()
3896 if (Specialization->getTemplateSpecializationArgs() == in FinishTemplateArgumentDeduction()
3905 Specialization->setInvalidDecl(true); in FinishTemplateArgumentDeduction()
3919 FunctionTemplate->getTemplateParameters()->size())) { in FinishTemplateArgumentDeduction()
3932 // We skipped the instantiation of the explicit-specifier during the in FinishTemplateArgumentDeduction()
3950 for (unsigned I = 0, N = OriginalCallArgs->size(); I != N; ++I) { in FinishTemplateArgumentDeduction()
3955 Specialization->hasCXXExplicitFunctionObjectParameter() ? 1 : 0; in FinishTemplateArgumentDeduction()
3956 if (ParamIdx >= Specialization->getNumParams() - ExplicitOffset) in FinishTemplateArgumentDeduction()
3967 Specialization->getParamDecl(ParamIdx + ExplicitOffset)->getType(); in FinishTemplateArgumentDeduction()
3970 // braced-init-list argument. Substitute back into P to find the in FinishTemplateArgumentDeduction()
3980 Specialization->getTypeSpecStartLoc(), in FinishTemplateArgumentDeduction()
3981 Specialization->getDeclName()); in FinishTemplateArgumentDeduction()
3999 Pos = SuppressedDiagnostics.find(Specialization->getCanonicalDecl()); in FinishTemplateArgumentDeduction()
4001 SuppressedDiagnostics[Specialization->getCanonicalDecl()] in FinishTemplateArgumentDeduction()
4008 /// Gets the type of a function for template-argument-deducton
4013 if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() && in GetTypeOfFunction()
4014 S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) in GetTypeOfFunction()
4018 if (Method->isImplicitObjectMemberFunction()) { in GetTypeOfFunction()
4024 return S.Context.getMemberPointerType(Fn->getType(), in GetTypeOfFunction()
4025 S.Context.getTypeDeclType(Method->getParent()).getTypePtr()); in GetTypeOfFunction()
4028 if (!R.IsAddressOfOperand) return Fn->getType(); in GetTypeOfFunction()
4029 return S.Context.getPointerType(Fn->getType()); in GetTypeOfFunction()
4057 if (!ParamType->isFunctionType() && in ResolveOverloadForDeduction()
4058 !ParamType->isFunctionPointerType() && in ResolveOverloadForDeduction()
4059 !ParamType->isMemberFunctionPointerType()) { in ResolveOverloadForDeduction()
4060 if (Ovl->hasExplicitTemplateArgs()) { in ResolveOverloadForDeduction()
4079 if (Ovl->hasExplicitTemplateArgs()) in ResolveOverloadForDeduction()
4080 Ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs); in ResolveOverloadForDeduction()
4082 for (UnresolvedSetIterator I = Ovl->decls_begin(), in ResolveOverloadForDeduction()
4083 E = Ovl->decls_end(); I != E; ++I) { in ResolveOverloadForDeduction()
4084 NamedDecl *D = (*I)->getUnderlyingDecl(); in ResolveOverloadForDeduction()
4087 // - If the argument is an overload set containing one or more in ResolveOverloadForDeduction()
4089 // non-deduced context. in ResolveOverloadForDeduction()
4090 if (!Ovl->hasExplicitTemplateArgs()) in ResolveOverloadForDeduction()
4095 TemplateDeductionInfo Info(Ovl->getNameLoc()); in ResolveOverloadForDeduction()
4108 // Function-to-pointer conversion. in ResolveOverloadForDeduction()
4109 if (!ParamWasReference && ParamType->isPointerType() && in ResolveOverloadForDeduction()
4110 ArgType->isFunctionType()) in ResolveOverloadForDeduction()
4113 // - If the argument is an overload set (not containing function in ResolveOverloadForDeduction()
4119 // treated as a non-deduced context. in ResolveOverloadForDeduction()
4126 Deduced(TemplateParams->size()); in ResolveOverloadForDeduction()
4127 TemplateDeductionInfo Info(Ovl->getNameLoc()); in ResolveOverloadForDeduction()
4152 // If P is a cv-qualified type, the top level cv-qualifiers of P's type in AdjustFunctionParmAndArgTypesForDeduction()
4159 const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>(); in AdjustFunctionParmAndArgTypesForDeduction()
4161 ParamType = ParamRefType->getPointeeType(); in AdjustFunctionParmAndArgTypesForDeduction()
4165 // involving a template-id-expr. in AdjustFunctionParmAndArgTypesForDeduction()
4167 assert(Arg && "expected a non-null arg expression"); in AdjustFunctionParmAndArgTypesForDeduction()
4176 if (ArgType->isIncompleteArrayType()) { in AdjustFunctionParmAndArgTypesForDeduction()
4177 assert(Arg && "expected a non-null arg expression"); in AdjustFunctionParmAndArgTypesForDeduction()
4194 // - If A is an array type, the pointer type produced by the in AdjustFunctionParmAndArgTypesForDeduction()
4195 // array-to-pointer standard conversion (4.2) is used in place of in AdjustFunctionParmAndArgTypesForDeduction()
4197 // - If A is a function type, the pointer type produced by the in AdjustFunctionParmAndArgTypesForDeduction()
4198 // function-to-pointer standard conversion (4.3) is used in place in AdjustFunctionParmAndArgTypesForDeduction()
4200 if (ArgType->canDecayToPointerType()) in AdjustFunctionParmAndArgTypesForDeduction()
4203 // - If A is a cv-qualified type, the top level cv-qualifiers of A's in AdjustFunctionParmAndArgTypesForDeduction()
4215 // - If the original P is a reference type, the deduced A (i.e., the in AdjustFunctionParmAndArgTypesForDeduction()
4216 // type referred to by the reference) can be more cv-qualified than in AdjustFunctionParmAndArgTypesForDeduction()
4220 // - The transformed A can be another pointer or pointer to member in AdjustFunctionParmAndArgTypesForDeduction()
4223 if (ArgType->isPointerType() || ArgType->isMemberPointerType() || in AdjustFunctionParmAndArgTypesForDeduction()
4224 ArgType->isObjCObjectPointerType()) in AdjustFunctionParmAndArgTypesForDeduction()
4226 // - If P is a class and P has the form simple-template-id, then the in AdjustFunctionParmAndArgTypesForDeduction()
4228 // if P is a pointer to a class of the form simple-template-id, the in AdjustFunctionParmAndArgTypesForDeduction()
4234 ParamType->castAs<PointerType>()->getPointeeType()))) in AdjustFunctionParmAndArgTypesForDeduction()
4263 // If removing references and cv-qualifiers from P gives in DeduceFromInitializerList()
4265 // a non-empty initializer list, then deduction is performed instead for in DeduceFromInitializerList()
4269 // We've already removed references and cv-qualifiers here. in DeduceFromInitializerList()
4270 if (!ILE->getNumInits()) in DeduceFromInitializerList()
4276 ElTy = ArrTy->getElementType(); in DeduceFromInitializerList()
4279 // considered a non-deduced context in DeduceFromInitializerList()
4283 // Resolving a core issue: a braced-init-list containing any designators is in DeduceFromInitializerList()
4284 // a non-deduced context. in DeduceFromInitializerList()
4285 for (Expr *E : ILE->inits()) in DeduceFromInitializerList()
4290 if (ElTy->isDependentType()) { in DeduceFromInitializerList()
4291 for (Expr *E : ILE->inits()) { in DeduceFromInitializerList()
4293 S, TemplateParams, 0, ElTy, E->getType(), 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()
4306 getDeducedParameterFromExpr(Info, DependentArrTy->getSizeExpr())) { in DeduceFromInitializerList()
4307 // We can perform template argument deduction for the given non-type in DeduceFromInitializerList()
4312 llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits()); in DeduceFromInitializerList()
4339 // If P is a cv-qualified type [...] in DeduceTemplateArgumentsFromCallArgument()
4345 // If [...] the argument is a non-empty initializer list [...] in DeduceTemplateArgumentsFromCallArgument()
4369 if (FunctionTemplate->isInvalidDecl()) in DeduceTemplateArguments()
4372 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); in DeduceTemplateArguments()
4373 unsigned NumParams = Function->getNumParams(); in DeduceTemplateArguments()
4376 if (Function->hasCXXExplicitFunctionObjectParameter()) { in DeduceTemplateArguments()
4387 if (Args.size() < Function->getMinRequiredExplicitArguments() && in DeduceTemplateArguments()
4392 const auto *Proto = Function->getType()->castAs<FunctionProtoType>(); in DeduceTemplateArguments()
4393 if (Proto->isTemplateVariadic()) in DeduceTemplateArguments()
4395 else if (!Proto->isVariadic()) in DeduceTemplateArguments()
4403 = FunctionTemplate->getTemplateParameters(); in DeduceTemplateArguments()
4421 ParamTypes.push_back(Function->getParamDecl(I)->getType()); in DeduceTemplateArguments()
4431 // parameter that contains template-parameters that participate in in DeduceTemplateArguments()
4448 Args[ArgIdx]->getType(), Args[ArgIdx]->Classify(getASTContext()), in DeduceTemplateArguments()
4454 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4487 QualType ParamPattern = ParamExpansion->getPattern(); in DeduceTemplateArguments()
4494 // parameter-declaration-list, the type A of each remaining argument of in DeduceTemplateArguments()
4495 // the call is compared with the type P of the declarator-id of the in DeduceTemplateArguments()
4499 // in a non-deduced context [not at the end of the list], the type of in DeduceTemplateArguments()
4503 // after we skip it (in the non-deduced case). That makes no sense, so in DeduceTemplateArguments()
4505 // the length of the explicitly-specified pack if it's expanded by the in DeduceTemplateArguments()
4507 // non-deduced context. in DeduceTemplateArguments()
4518 // If the parameter type contains an explicitly-specified pack that we in DeduceTemplateArguments()
4522 ParamExpansion->getNumExpansions(); in DeduceTemplateArguments()
4593 const auto *FunctionTypeP = FunctionType->castAs<FunctionProtoType>(); in adjustCCAndNoReturn()
4594 const auto *ArgFunctionTypeP = ArgFunctionType->castAs<FunctionProtoType>(); in adjustCCAndNoReturn()
4595 FunctionProtoType::ExtProtoInfo EPI = ArgFunctionTypeP->getExtProtoInfo(); in adjustCCAndNoReturn()
4598 CallingConv CC = FunctionTypeP->getCallConv(); in adjustCCAndNoReturn()
4604 bool NoReturn = FunctionTypeP->getNoReturnAttr(); in adjustCCAndNoReturn()
4610 if (AdjustExceptionSpec && (FunctionTypeP->hasExceptionSpec() || in adjustCCAndNoReturn()
4611 ArgFunctionTypeP->hasExceptionSpec())) { in adjustCCAndNoReturn()
4612 EPI.ExceptionSpec = FunctionTypeP->getExtProtoInfo().ExceptionSpec; in adjustCCAndNoReturn()
4619 return Context.getFunctionType(ArgFunctionTypeP->getReturnType(), in adjustCCAndNoReturn()
4620 ArgFunctionTypeP->getParamTypes(), EPI); in adjustCCAndNoReturn()
4628 if (FunctionTemplate->isInvalidDecl()) in DeduceTemplateArguments()
4631 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); in DeduceTemplateArguments()
4633 = FunctionTemplate->getTemplateParameters(); in DeduceTemplateArguments()
4634 QualType FunctionType = Function->getType(); in DeduceTemplateArguments()
4666 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4669 // type so that we treat it as a non-deduced context in what follows. in DeduceTemplateArguments()
4672 Function->getReturnType()->getContainedAutoType()) { in DeduceTemplateArguments()
4700 Specialization->getReturnType()->isUndeducedType() && in DeduceTemplateArguments()
4705 // An expression or conversion is immediate-escalating if it is not initially in DeduceTemplateArguments()
4707 // a potentially-evaluated id-expression that denotes an immediate function. in DeduceTemplateArguments()
4709 Specialization->isImmediateEscalating() && in DeduceTemplateArguments()
4719 QualType SpecializationType = Specialization->getType(); in DeduceTemplateArguments()
4754 if (ConversionTemplate->isInvalidDecl()) in DeduceTemplateArguments()
4758 = cast<CXXConversionDecl>(ConversionTemplate->getTemplatedDecl()); in DeduceTemplateArguments()
4760 QualType FromType = ConversionGeneric->getConversionType(); in DeduceTemplateArguments()
4769 if (const ReferenceType *PRef = P->getAs<ReferenceType>()) in DeduceTemplateArguments()
4770 P = PRef->getPointeeType(); in DeduceTemplateArguments()
4775 if (const ReferenceType *ARef = A->getAs<ReferenceType>()) { in DeduceTemplateArguments()
4776 A = ARef->getPointeeType(); in DeduceTemplateArguments()
4777 // We work around a defect in the standard here: cv-qualifiers are also in DeduceTemplateArguments()
4780 if (!FromType->getAs<ReferenceType>()) { in DeduceTemplateArguments()
4789 assert(!A->isReferenceType() && "Reference types were handled above"); in DeduceTemplateArguments()
4791 // - If P is an array type, the pointer type produced by the in DeduceTemplateArguments()
4792 // array-to-pointer standard conversion (4.2) is used in place in DeduceTemplateArguments()
4794 if (P->isArrayType()) in DeduceTemplateArguments()
4796 // - If P is a function type, the pointer type produced by the in DeduceTemplateArguments()
4797 // function-to-pointer standard conversion (4.3) is used in in DeduceTemplateArguments()
4799 else if (P->isFunctionType()) in DeduceTemplateArguments()
4801 // - If P is a cv-qualified type, the top level cv-qualifiers of in DeduceTemplateArguments()
4807 // If A is a cv-qualified type, the top level cv-qualifiers of A's in DeduceTemplateArguments()
4824 = ConversionTemplate->getTemplateParameters(); in DeduceTemplateArguments()
4826 Deduced.resize(TemplateParams->size()); in DeduceTemplateArguments()
4833 // - If the original A is a reference type, A can be more in DeduceTemplateArguments()
4834 // cv-qualified than the deduced A (i.e., the type referred to in DeduceTemplateArguments()
4836 if (ToType->isReferenceType()) in DeduceTemplateArguments()
4838 // - The deduced A can be another pointer or pointer to member in DeduceTemplateArguments()
4844 // just ignore cv-qualifiers completely). in DeduceTemplateArguments()
4845 if ((P->isPointerType() && A->isPointerType()) || in DeduceTemplateArguments()
4846 (P->isMemberPointerType() && A->isMemberPointerType())) in DeduceTemplateArguments()
4850 if (ConversionGeneric->isExplicitObjectMemberFunction()) { in DeduceTemplateArguments()
4851 QualType ParamType = ConversionGeneric->getParamDecl(0)->getType(); in DeduceTemplateArguments()
4938 Replacement, TL.getTypePtr()->getKeyword(), Replacement.isNull(), in TransformAutoType()
4939 ReplacementIsPack, TL.getTypePtr()->getTypeConstraintConcept(), in TransformAutoType()
4940 TL.getTypePtr()->getTypeConstraintArguments()); in TransformAutoType()
4952 TL.getTypePtr()->getTemplateName(), in TransformDeducedTemplateSpecializationType()
5018 S.getASTContext(), Concept->getDeclContext(), Concept->getLocation(), in CheckDeducedPlaceholderConstraints()
5020 if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()}, in CheckDeducedPlaceholderConstraints()
5027 OS << "'" << Concept->getName(); in CheckDeducedPlaceholderConstraints()
5031 Type.getTypeConstraintConcept()->getTemplateParameters()); in CheckDeducedPlaceholderConstraints()
5050 if (Init->containsErrors()) in DeduceAutoType()
5053 const AutoType *AT = Type.getType()->getContainedAutoType(); in DeduceAutoType()
5056 if (Init->getType()->isNonOverloadPlaceholderType() || AT->isDecltypeAuto()) { in DeduceAutoType()
5067 (Type.getType()->isDependentType() || Init->isTypeDependent() || in DeduceAutoType()
5068 Init->containsUnexpandedParameterPack())) { in DeduceAutoType()
5076 if (getLangOpts().C23 && String && Type.getType()->isArrayType()) { in DeduceAutoType()
5078 TypeLoc TL = TypeLoc(Init->getType(), Type.getOpaqueData()); in DeduceAutoType()
5085 if (getLangOpts().C23 && Type.getType()->isPointerType()) { in DeduceAutoType()
5091 Diag(Init->getBeginLoc(), diag::err_auto_init_list_from_c) in DeduceAutoType()
5092 << (int)AT->getKeyword() << getLangOpts().C23; in DeduceAutoType()
5103 if (Init->isTypeDependent()) { in DeduceAutoType()
5116 if (AT->isDecltypeAuto()) { in DeduceAutoType()
5118 Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list); in DeduceAutoType()
5128 SourceLocation Loc = Init->getExprLoc(); in DeduceAutoType()
5132 QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); in DeduceAutoType()
5140 // cv-qualifiers and references results in std::initializer_list<T>. in DeduceAutoType()
5141 if (!Type.getType().getNonReferenceType()->getAs<AutoType>()) in DeduceAutoType()
5145 for (Expr *Init : InitList->inits()) { in DeduceAutoType()
5146 // Resolving a core issue: a braced-init-list containing any designators in DeduceAutoType()
5147 // is a non-deduced context. in DeduceAutoType()
5151 *this, TemplateParamsSt.get(), 0, TemplArg, Init->getType(), in DeduceAutoType()
5152 Init->Classify(getASTContext()), Init, Info, Deduced, in DeduceAutoType()
5159 << Init->getSourceRange(); in DeduceAutoType()
5167 DeducedFromInitRange = Init->getSourceRange(); in DeduceAutoType()
5170 if (!getLangOpts().CPlusPlus && Init->refersToBitField()) { in DeduceAutoType()
5179 *this, TemplateParamsSt.get(), 0, FuncParam, Init->getType(), 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()
5208 if (AT->isConstrained() && !IgnoreConstraints && in DeduceAutoType()
5222 "decomposed non-init-list in auto deduction?"); in DeduceAutoType()
5276 Diag(VDecl->getLocation(), in DiagnoseAutoDeductionFailure()
5277 VDecl->isInitCapture() in DiagnoseAutoDeductionFailure()
5280 << VDecl->getDeclName() << VDecl->getType() << Init->getSourceRange(); in DiagnoseAutoDeductionFailure()
5282 Diag(VDecl->getLocation(), in DiagnoseAutoDeductionFailure()
5283 VDecl->isInitCapture() ? diag::err_init_capture_deduction_failure in DiagnoseAutoDeductionFailure()
5285 << VDecl->getDeclName() << VDecl->getType() << Init->getType() in DiagnoseAutoDeductionFailure()
5286 << Init->getSourceRange(); in DiagnoseAutoDeductionFailure()
5291 assert(FD->getReturnType()->isUndeducedType()); in DeduceReturnType()
5296 CXXRecordDecl *Lambda = cast<CXXMethodDecl>(FD)->getParent(); in DeduceReturnType()
5297 FunctionDecl *CallOp = Lambda->getLambdaCallOperator(); in DeduceReturnType()
5300 if (auto *Args = FD->getTemplateSpecializationArgs()) { in DeduceReturnType()
5302 CallOp->getDescribedFunctionTemplate(), Args, Loc); in DeduceReturnType()
5303 if (!CallOp || CallOp->isInvalidDecl()) in DeduceReturnType()
5308 if (CallOp->getReturnType()->isUndeducedType()) { in DeduceReturnType()
5315 if (CallOp->isInvalidDecl()) in DeduceReturnType()
5317 assert(!CallOp->getReturnType()->isUndeducedType() && in DeduceReturnType()
5321 CallingConv RetTyCC = FD->getReturnType() in DeduceReturnType()
5322 ->getPointeeType() in DeduceReturnType()
5323 ->castAs<FunctionType>() in DeduceReturnType()
5324 ->getCallConv(); in DeduceReturnType()
5326 CallOp->getType()->castAs<FunctionProtoType>(), RetTyCC); in DeduceReturnType()
5327 if (FD->getReturnType()->getAs<PointerType>()) in DeduceReturnType()
5330 assert(FD->getReturnType()->getAs<BlockPointerType>()); in DeduceReturnType()
5337 if (FD->getTemplateInstantiationPattern()) { in DeduceReturnType()
5343 bool StillUndeduced = FD->getReturnType()->isUndeducedType(); in DeduceReturnType()
5344 if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { in DeduceReturnType()
5346 Diag(FD->getLocation(), diag::note_callee_decl) << FD; in DeduceReturnType()
5354 assert(FD->isImmediateEscalating()); in CheckIfFunctionSpecializationIsImmediate()
5357 CXXRecordDecl *Lambda = cast<CXXMethodDecl>(FD)->getParent(); in CheckIfFunctionSpecializationIsImmediate()
5358 FunctionDecl *CallOp = Lambda->getLambdaCallOperator(); in CheckIfFunctionSpecializationIsImmediate()
5361 if (auto *Args = FD->getTemplateSpecializationArgs()) { in CheckIfFunctionSpecializationIsImmediate()
5363 CallOp->getDescribedFunctionTemplate(), Args, Loc); in CheckIfFunctionSpecializationIsImmediate()
5364 if (!CallOp || CallOp->isInvalidDecl()) in CheckIfFunctionSpecializationIsImmediate()
5369 return CallOp->isInvalidDecl(); in CheckIfFunctionSpecializationIsImmediate()
5372 if (FD->getTemplateInstantiationPattern()) { in CheckIfFunctionSpecializationIsImmediate()
5384 // - The type X(M) is "rvalue reference to cv A" if the optional in GetImplicitObjectParameterType()
5385 // ref-qualifier of M is && or if M has no ref-qualifier and the in GetImplicitObjectParameterType()
5386 // positionally-corresponding parameter of the other transformed template in GetImplicitObjectParameterType()
5391 // - Otherwise, X(M) is "lvalue reference to cv A". in GetImplicitObjectParameterType()
5392 assert(Method && !Method->isExplicitObjectMemberFunction() && in GetImplicitObjectParameterType()
5395 RawType = Context.getQualifiedType(RawType, Method->getMethodQualifiers()); in GetImplicitObjectParameterType()
5396 if (Method->getRefQualifier() == RQ_RValue || in GetImplicitObjectParameterType()
5397 (IsOtherRvr && Method->getRefQualifier() == RQ_None)) in GetImplicitObjectParameterType()
5413 FunctionDecl *FD1 = FT1->getTemplatedDecl(); in isAtLeastAsSpecializedAs()
5414 FunctionDecl *FD2 = FT2->getTemplatedDecl(); in isAtLeastAsSpecializedAs()
5415 const FunctionProtoType *Proto1 = FD1->getType()->getAs<FunctionProtoType>(); in isAtLeastAsSpecializedAs()
5416 const FunctionProtoType *Proto2 = FD2->getType()->getAs<FunctionProtoType>(); in isAtLeastAsSpecializedAs()
5419 TemplateParameterList *TemplateParams = FT2->getTemplateParameters(); in isAtLeastAsSpecializedAs()
5421 Deduced.resize(TemplateParams->size()); in isAtLeastAsSpecializedAs()
5438 // - In the context of a call to a conversion operator, the return types in isAtLeastAsSpecializedAs()
5441 S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(), in isAtLeastAsSpecializedAs()
5448 // - In other contexts (14.6.6.2) the function template's function type 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()
5480 llvm::SmallBitVector UsedParameters(TemplateParams->size()); in isAtLeastAsSpecializedAs()
5485 TemplateParams->getDepth(), UsedParameters); in isAtLeastAsSpecializedAs()
5489 ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), in isAtLeastAsSpecializedAs()
5491 TemplateParams->getDepth(), UsedParameters); in isAtLeastAsSpecializedAs()
5516 S.Context.getFunctionTypeWithExceptionSpec(FD2->getType(), EST_None), in isAtLeastAsSpecializedAs()
5517 /*OnlyDeduced=*/false, TemplateParams->getDepth(), UsedParameters); in isAtLeastAsSpecializedAs()
5536 const FunctionDecl *FD1 = FT1->getTemplatedDecl(); in getMoreSpecializedTemplate()
5537 const FunctionDecl *FD2 = FT2->getTemplatedDecl(); in getMoreSpecializedTemplate()
5544 FD1->getType()->castAs<FunctionProtoType>(); in getMoreSpecializedTemplate()
5546 FD2->getType()->castAs<FunctionProtoType>(); in getMoreSpecializedTemplate()
5548 // - In the context of a function call, the function parameter types are in getMoreSpecializedTemplate()
5561 ShouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction(); in getMoreSpecializedTemplate()
5562 ShouldConvert2 = Method2 && !Method2->isExplicitObjectMemberFunction(); in getMoreSpecializedTemplate()
5566 ? Method2->getRefQualifier() == RQ_RValue in getMoreSpecializedTemplate()
5567 : Proto2->param_type_begin()[0]->isRValueReferenceType(); in getMoreSpecializedTemplate()
5569 Obj1Ty = GetImplicitObjectParameterType(this->Context, Method1, RawObj1Ty, in getMoreSpecializedTemplate()
5576 ? Method1->getRefQualifier() == RQ_RValue in getMoreSpecializedTemplate()
5577 : Proto1->param_type_begin()[0]->isRValueReferenceType(); in getMoreSpecializedTemplate()
5579 Obj2Ty = GetImplicitObjectParameterType(this->Context, Method2, RawObj2Ty, in getMoreSpecializedTemplate()
5589 Args1.insert(Args1.end(), Proto1->param_type_begin(), in getMoreSpecializedTemplate()
5590 Proto1->param_type_end()); in getMoreSpecializedTemplate()
5591 Args2.insert(Args2.end(), Proto2->param_type_begin(), in getMoreSpecializedTemplate()
5592 Proto2->param_type_end()); in getMoreSpecializedTemplate()
5622 Param1.reserve(FD1->param_size() + ShouldConvert1); in getMoreSpecializedTemplate()
5625 for (const auto &P : FD1->parameters()) in getMoreSpecializedTemplate()
5626 Param1.push_back(P->getType()); in getMoreSpecializedTemplate()
5629 Param2.reserve(FD2->param_size() + ShouldConvert2); in getMoreSpecializedTemplate()
5632 for (const auto &P : FD2->parameters()) in getMoreSpecializedTemplate()
5633 Param2.push_back(P->getType()); in getMoreSpecializedTemplate()
5639 FD1->param_size() && FD1->parameters().back()->isParameterPack(); in getMoreSpecializedTemplate()
5641 FD2->param_size() && FD2->parameters().back()->isParameterPack(); in getMoreSpecializedTemplate()
5658 const TemplateArgument &TA1 = TST1->template_arguments().back(); in getMoreSpecializedTemplate()
5660 assert(TST1->template_arguments().size() == in getMoreSpecializedTemplate()
5661 TST2->template_arguments().size()); in getMoreSpecializedTemplate()
5662 const TemplateArgument &TA2 = TST2->template_arguments().back(); in getMoreSpecializedTemplate()
5689 // If their template-parameter-lists (possibly including template-parameters in getMoreSpecializedTemplate()
5693 TemplateParameterList *TPL1 = FT1->getTemplateParameters(); in getMoreSpecializedTemplate()
5694 TemplateParameterList *TPL2 = FT2->getTemplateParameters(); in getMoreSpecializedTemplate()
5695 if (TPL1->size() != TPL2->size() || NumParams1 != NumParams2) in getMoreSpecializedTemplate()
5699 // Otherwise, if the corresponding template-parameters of the in getMoreSpecializedTemplate()
5700 // template-parameter-lists are not equivalent ([temp.over.link]) or if the in getMoreSpecializedTemplate()
5709 // Any top-level cv-qualifiers modifying a parameter type are deleted when in getMoreSpecializedTemplate()
5721 !Context.hasSameType(FD1->getReturnType(), FD2->getReturnType())) in getMoreSpecializedTemplate()
5725 FT1->getAssociatedConstraints(AC1); in getMoreSpecializedTemplate()
5726 FT2->getAssociatedConstraints(AC2); in getMoreSpecializedTemplate()
5745 return T1->getCanonicalDecl() == T2->getCanonicalDecl(); in isSameTemplate()
5769 = cast<FunctionDecl>(*Best)->getPrimaryTemplate(); in getMostSpecialized()
5773 = cast<FunctionDecl>(*I)->getPrimaryTemplate(); in getMostSpecialized()
5788 = cast<FunctionDecl>(*I)->getPrimaryTemplate(); in getMostSpecialized()
5812 FD->getPrimaryTemplate()->getTemplateParameters(), in getMostSpecialized()
5813 *FD->getTemplateSpecializationArgs()); in getMostSpecialized()
5815 HandleFunctionTypeMismatch(PD, FD->getType(), TargetType); in getMostSpecialized()
5816 Diag((*I)->getLocation(), PD); in getMostSpecialized()
5825 assert(!FD1->getDescribedTemplate() && !FD2->getDescribedTemplate() && in getMoreConstrainedFunction()
5828 if (FunctionDecl *MF = FD1->getInstantiatedFromMemberFunction()) in getMoreConstrainedFunction()
5831 if (FunctionDecl *MF = FD2->getInstantiatedFromMemberFunction()) in getMoreConstrainedFunction()
5834 F1->getAssociatedConstraints(AC1); in getMoreConstrainedFunction()
5835 F2->getAssociatedConstraints(AC2); in getMoreConstrainedFunction()
5851 /// \param T1 The injected-class-name of P1 (faked for a variable template).
5852 /// \param T2 The injected-class-name of P2 (faked for a variable template).
5863 // - the first function template has the same template parameters as the in isAtLeastAsSpecializedAs()
5867 // - the second function template has the same template parameters as the in isAtLeastAsSpecializedAs()
5884 Deduced.resize(P2->getTemplateParameters()->size()); in isAtLeastAsSpecializedAs()
5886 S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None, in isAtLeastAsSpecializedAs()
5902 S, P2, /*IsPartialOrdering=*/true, TST1->template_arguments(), in isAtLeastAsSpecializedAs()
5932 ArrayRef<TemplateArgument> Args1 = PS1->getTemplateArgs().asArray(), in operator ()()
5933 Args2 = PS2->getTemplateArgs().asArray(); in operator ()()
5951 ArrayRef<TemplateArgument> Args1 = Spec->getTemplateArgs().asArray(), in operator ()()
5952 Args2 = Primary->getInjectedTemplateArgs(); in operator ()()
5973 /// - If IsMoreSpecialThanPrimaryCheck is true, T1/P1 is the partial
5975 /// - otherwise, both T1/P1 and T2/P2 are the partial specialization.
5988 /// \returns - If IsMoreSpecialThanPrimaryCheck is true, returns P1 if P1 is
5990 /// - otherwise, returns the more specialized template partial
6021 const TemplateArgument &TA1 = TST1->template_arguments().back(); in getMoreSpecialized()
6023 assert(TST1->template_arguments().size() == in getMoreSpecialized()
6024 TST2->template_arguments().size()); in getMoreSpecialized()
6025 const TemplateArgument &TA2 = TST2->template_arguments().back(); in getMoreSpecialized()
6050 TemplateParameterList *TPL1 = P1->getTemplateParameters(); in getMoreSpecialized()
6051 TemplateParameterList *TPL2 = P2->getTemplateParameters(); in getMoreSpecialized()
6052 if (TPL1->size() != TPL2->size()) in getMoreSpecialized()
6056 // Otherwise, if the corresponding template-parameters of the in getMoreSpecialized()
6057 // template-parameter-lists are not equivalent ([temp.over.link]) or if the in getMoreSpecialized()
6069 P1->getAssociatedConstraints(AC1); in getMoreSpecialized()
6070 P2->getAssociatedConstraints(AC2); in getMoreSpecialized()
6087 QualType PT1 = PS1->getInjectedSpecializationType(); in getMoreSpecializedPartialSpecialization()
6088 QualType PT2 = PS2->getInjectedSpecializationType(); in getMoreSpecializedPartialSpecialization()
6096 ClassTemplateDecl *Primary = Spec->getSpecializedTemplate(); in isMoreSpecializedThanPrimary()
6097 QualType PrimaryT = Primary->getInjectedClassNameSpecialization(); in isMoreSpecializedThanPrimary()
6098 QualType PartialT = Spec->getInjectedSpecializationType(); in isMoreSpecializedThanPrimary()
6113 assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() && in getMoreSpecializedPartialSpecialization()
6116 TemplateName Name(PS1->getSpecializedTemplate()); in getMoreSpecializedPartialSpecialization()
6119 CanonTemplate, PS1->getTemplateArgs().asArray()); in getMoreSpecializedPartialSpecialization()
6121 CanonTemplate, PS2->getTemplateArgs().asArray()); in getMoreSpecializedPartialSpecialization()
6129 VarTemplateDecl *Primary = Spec->getSpecializedTemplate(); in isMoreSpecializedThanPrimary()
6133 CanonTemplate, Primary->getInjectedTemplateArgs()); in isMoreSpecializedThanPrimary()
6135 CanonTemplate, Spec->getTemplateArgs().asArray()); in isMoreSpecializedThanPrimary()
6148 // A template template-parameter P is at least as specialized as a in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6149 // template template-argument A if, given the following rewrite to two in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6156 TemplateParameterList *A = AArg->getTemplateParameters(); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6160 // - Each function template has a single function parameter whose type is in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6175 TemplateArgumentListInfo PArgList(P->getLAngleLoc(), in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6176 P->getRAngleLoc()); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6177 for (unsigned I = 0, N = P->size(); I != N; ++I) { in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6182 assert(Arg.pack_size() == 1 && Arg.pack_begin()->isPackExpansion()); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6186 Arg, QualType(), P->getParam(I)->getLocation())); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
6203 TemplateDeductionInfo Info(Loc, A->getDepth()); in isTemplateTemplateParameterAtLeastAsSpecializedAs()
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()
6252 if (T->getDepth() == Depth) in VisitTemplateTypeParmType()
6253 Used[T->getIndex()] = true; in VisitTemplateTypeParmType()
6260 if (TTP->getDepth() == Depth) in TraverseTemplateName()
6261 Used[TTP->getIndex()] = true; in TraverseTemplateName()
6268 if (auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(E->getDecl())) in VisitDeclRefExpr()
6269 if (NTTP->getDepth() == Depth) in VisitDeclRefExpr()
6270 Used[NTTP->getIndex()] = true; in VisitDeclRefExpr()
6292 E = Expansion->getPattern(); in MarkUsedTemplateParameters()
6298 if (NTTP->getDepth() == Depth) in MarkUsedTemplateParameters()
6299 Used[NTTP->getIndex()] = true; in MarkUsedTemplateParameters()
6302 // non-type argument. in MarkUsedTemplateParameters()
6304 MarkUsedTemplateParameters(Ctx, NTTP->getType(), OnlyDeduced, Depth, Used); in MarkUsedTemplateParameters()
6318 MarkUsedTemplateParameters(Ctx, NNS->getPrefix(), OnlyDeduced, Depth, in MarkUsedTemplateParameters()
6320 MarkUsedTemplateParameters(Ctx, QualType(NNS->getAsType(), 0), in MarkUsedTemplateParameters()
6335 if (TTP->getDepth() == Depth) in MarkUsedTemplateParameters()
6336 Used[TTP->getIndex()] = true; in MarkUsedTemplateParameters()
6342 MarkUsedTemplateParameters(Ctx, QTN->getQualifier(), OnlyDeduced, in MarkUsedTemplateParameters()
6345 MarkUsedTemplateParameters(Ctx, DTN->getQualifier(), OnlyDeduced, in MarkUsedTemplateParameters()
6359 // Non-dependent types have nothing deducible in MarkUsedTemplateParameters()
6360 if (!T->isDependentType()) in MarkUsedTemplateParameters()
6364 switch (T->getTypeClass()) { in MarkUsedTemplateParameters()
6367 cast<PointerType>(T)->getPointeeType(), in MarkUsedTemplateParameters()
6375 cast<BlockPointerType>(T)->getPointeeType(), in MarkUsedTemplateParameters()
6384 cast<ReferenceType>(T)->getPointeeType(), in MarkUsedTemplateParameters()
6392 MarkUsedTemplateParameters(Ctx, MemPtr->getPointeeType(), OnlyDeduced, in MarkUsedTemplateParameters()
6394 MarkUsedTemplateParameters(Ctx, QualType(MemPtr->getClass(), 0), in MarkUsedTemplateParameters()
6401 cast<DependentSizedArrayType>(T)->getSizeExpr(), in MarkUsedTemplateParameters()
6410 cast<ArrayType>(T)->getElementType(), in MarkUsedTemplateParameters()
6416 cast<VectorType>(T)->getElementType(), in MarkUsedTemplateParameters()
6422 MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, in MarkUsedTemplateParameters()
6424 MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, Depth, in MarkUsedTemplateParameters()
6431 MarkUsedTemplateParameters(Ctx, VecType->getElementType(), OnlyDeduced, in MarkUsedTemplateParameters()
6433 MarkUsedTemplateParameters(Ctx, VecType->getSizeExpr(), OnlyDeduced, in MarkUsedTemplateParameters()
6441 MarkUsedTemplateParameters(Ctx, DependentASType->getPointeeType(), in MarkUsedTemplateParameters()
6444 DependentASType->getAddrSpaceExpr(), in MarkUsedTemplateParameters()
6451 MarkUsedTemplateParameters(Ctx, MatType->getElementType(), OnlyDeduced, in MarkUsedTemplateParameters()
6458 MarkUsedTemplateParameters(Ctx, MatType->getElementType(), OnlyDeduced, in MarkUsedTemplateParameters()
6460 MarkUsedTemplateParameters(Ctx, MatType->getRowExpr(), OnlyDeduced, Depth, in MarkUsedTemplateParameters()
6462 MarkUsedTemplateParameters(Ctx, MatType->getColumnExpr(), OnlyDeduced, in MarkUsedTemplateParameters()
6469 MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth, in MarkUsedTemplateParameters()
6471 for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) { in MarkUsedTemplateParameters()
6473 // The non-deduced contexts are: [...] in MarkUsedTemplateParameters()
6474 // -- A function parameter pack that does not occur at the end of the in MarkUsedTemplateParameters()
6475 // parameter-declaration-list. in MarkUsedTemplateParameters()
6477 !Proto->getParamType(I)->getAs<PackExpansionType>()) { in MarkUsedTemplateParameters()
6478 MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, in MarkUsedTemplateParameters()
6482 // When a function parameter pack appears in a non-deduced context, in MarkUsedTemplateParameters()
6489 if (auto *E = Proto->getNoexceptExpr()) in MarkUsedTemplateParameters()
6496 if (TTP->getDepth() == Depth) in MarkUsedTemplateParameters()
6497 Used[TTP->getIndex()] = true; in MarkUsedTemplateParameters()
6504 if (Subst->getReplacedParameter()->getDepth() == Depth) in MarkUsedTemplateParameters()
6505 Used[Subst->getIndex()] = true; in MarkUsedTemplateParameters()
6506 MarkUsedTemplateParameters(Ctx, Subst->getArgumentPack(), in MarkUsedTemplateParameters()
6512 T = cast<InjectedClassNameType>(T)->getInjectedSpecializationType(); in MarkUsedTemplateParameters()
6518 MarkUsedTemplateParameters(Ctx, Spec->getTemplateName(), OnlyDeduced, in MarkUsedTemplateParameters()
6524 // non-deduced context. in MarkUsedTemplateParameters()
6526 hasPackExpansionBeforeEnd(Spec->template_arguments())) in MarkUsedTemplateParameters()
6529 for (const auto &Arg : Spec->template_arguments()) in MarkUsedTemplateParameters()
6537 cast<ComplexType>(T)->getElementType(), in MarkUsedTemplateParameters()
6544 cast<AtomicType>(T)->getValueType(), in MarkUsedTemplateParameters()
6551 cast<DependentNameType>(T)->getQualifier(), in MarkUsedTemplateParameters()
6557 // The non-deduced contexts are: in MarkUsedTemplateParameters()
6558 // -- The nested-name-specifier of a type that was specified using a in MarkUsedTemplateParameters()
6559 // qualified-id in MarkUsedTemplateParameters()
6562 // When a type name is specified in a way that includes a non-deduced in MarkUsedTemplateParameters()
6564 // non-deduced. in MarkUsedTemplateParameters()
6571 MarkUsedTemplateParameters(Ctx, Spec->getQualifier(), in MarkUsedTemplateParameters()
6574 for (const auto &Arg : Spec->template_arguments()) in MarkUsedTemplateParameters()
6581 MarkUsedTemplateParameters(Ctx, cast<TypeOfType>(T)->getUnmodifiedType(), in MarkUsedTemplateParameters()
6588 cast<TypeOfExprType>(T)->getUnderlyingExpr(), in MarkUsedTemplateParameters()
6595 cast<DecltypeType>(T)->getUnderlyingExpr(), in MarkUsedTemplateParameters()
6601 MarkUsedTemplateParameters(Ctx, cast<PackIndexingType>(T)->getPattern(), in MarkUsedTemplateParameters()
6603 MarkUsedTemplateParameters(Ctx, cast<PackIndexingType>(T)->getIndexExpr(), in MarkUsedTemplateParameters()
6611 cast<UnaryTransformType>(T)->getUnderlyingType(), in MarkUsedTemplateParameters()
6617 cast<PackExpansionType>(T)->getPattern(), in MarkUsedTemplateParameters()
6624 cast<DeducedType>(T)->getDeducedType(), in MarkUsedTemplateParameters()
6629 cast<DependentBitIntType>(T)->getNumBitsExpr(), in MarkUsedTemplateParameters()
6708 // non-deduced context. in MarkUsedTemplateParameters()
6722 = FunctionTemplate->getTemplateParameters(); in MarkDeducedTemplateParameters()
6724 Deduced.resize(TemplateParams->size()); in MarkDeducedTemplateParameters()
6726 FunctionDecl *Function = FunctionTemplate->getTemplatedDecl(); in MarkDeducedTemplateParameters()
6727 for (unsigned I = 0, N = Function->getNumParams(); I != N; ++I) in MarkDeducedTemplateParameters()
6728 ::MarkUsedTemplateParameters(Ctx, Function->getParamDecl(I)->getType(), in MarkDeducedTemplateParameters()
6729 true, TemplateParams->getDepth(), Deduced); in MarkDeducedTemplateParameters()
6735 if (!T->isDependentType()) in hasDeducibleTemplateParameters()
6739 = FunctionTemplate->getTemplateParameters(); in hasDeducibleTemplateParameters()
6740 llvm::SmallBitVector Deduced(TemplateParams->size()); in hasDeducibleTemplateParameters()
6741 ::MarkUsedTemplateParameters(S.Context, T, true, TemplateParams->getDepth(), in hasDeducibleTemplateParameters()