diff options
Diffstat (limited to 'contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp')
| -rw-r--r-- | contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp | 642 |
1 files changed, 307 insertions, 335 deletions
diff --git a/contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp b/contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp index 8d66ff6..53a75d2 100644 --- a/contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/contrib/llvm/tools/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -126,7 +126,7 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl<RefParamPartialOrderingComparison> * - RefParamComparisons = 0); + RefParamComparisons = nullptr); static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, @@ -155,7 +155,7 @@ static NonTypeTemplateParmDecl *getDeducedParameterFromExpr(Expr *E) { if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) return dyn_cast<NonTypeTemplateParmDecl>(DRE->getDecl()); - return 0; + return nullptr; } /// \brief Determine whether two declaration pointers refer to the same @@ -297,6 +297,7 @@ checkDeducedTemplateArguments(ASTContext &Context, XAEnd = X.pack_end(), YA = Y.pack_begin(); XA != XAEnd; ++XA, ++YA) { + // FIXME: Do we need to merge the results together here? if (checkDeducedTemplateArguments(Context, DeducedTemplateArgument(*XA, X.wasDeducedFromArrayBound()), DeducedTemplateArgument(*YA, Y.wasDeducedFromArrayBound())) @@ -382,7 +383,7 @@ DeduceNonTypeTemplateArgument(Sema &S, assert(NTTP->getDepth() == 0 && "Cannot deduce non-type template argument with depth > 0"); - D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : 0; + D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr; TemplateArgument New(D, NTTP->getType()->isReferenceType()); DeducedTemplateArgument NewDeduced(New); DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, @@ -581,96 +582,181 @@ static TemplateParameter makeTemplateParameter(Decl *D) { return TemplateParameter(cast<TemplateTemplateParmDecl>(D)); } -typedef SmallVector<SmallVector<DeducedTemplateArgument, 4>, 2> - NewlyDeducedPacksType; +/// A pack that we're currently deducing. +struct clang::DeducedPack { + DeducedPack(unsigned Index) : Index(Index), Outer(nullptr) {} -/// \brief Prepare to perform template argument deduction for all of the -/// arguments in a set of argument packs. -static void -PrepareArgumentPackDeduction(Sema &S, - SmallVectorImpl<DeducedTemplateArgument> &Deduced, - ArrayRef<unsigned> PackIndices, - SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, - NewlyDeducedPacksType &NewlyDeducedPacks) { - // Save the deduced template arguments for each parameter pack expanded - // by this pack expansion, then clear out the deduction. - for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { - // Save the previously-deduced argument pack, then clear it out so that we - // can deduce a new argument pack. - SavedPacks[I] = Deduced[PackIndices[I]]; - Deduced[PackIndices[I]] = TemplateArgument(); - - if (!S.CurrentInstantiationScope) - continue; + // The index of the pack. + unsigned Index; + + // The old value of the pack before we started deducing it. + DeducedTemplateArgument Saved; + + // A deferred value of this pack from an inner deduction, that couldn't be + // deduced because this deduction hadn't happened yet. + DeducedTemplateArgument DeferredDeduction; + + // The new value of the pack. + SmallVector<DeducedTemplateArgument, 4> New; + + // The outer deduction for this pack, if any. + DeducedPack *Outer; +}; + +/// A scope in which we're performing pack deduction. +class PackDeductionScope { +public: + PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams, + SmallVectorImpl<DeducedTemplateArgument> &Deduced, + TemplateDeductionInfo &Info, TemplateArgument Pattern) + : S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info) { + // Compute the set of template parameter indices that correspond to + // parameter packs expanded by the pack expansion. + { + llvm::SmallBitVector SawIndices(TemplateParams->size()); + SmallVector<UnexpandedParameterPack, 2> Unexpanded; + S.collectUnexpandedParameterPacks(Pattern, Unexpanded); + for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { + unsigned Depth, Index; + std::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); + if (Depth == 0 && !SawIndices[Index]) { + SawIndices[Index] = true; - // If the template argument pack was explicitly specified, add that to - // the set of deduced arguments. - const TemplateArgument *ExplicitArgs; - unsigned NumExplicitArgs; - if (NamedDecl *PartiallySubstitutedPack - = S.CurrentInstantiationScope->getPartiallySubstitutedPack( - &ExplicitArgs, - &NumExplicitArgs)) { - if (getDepthAndIndex(PartiallySubstitutedPack).second == PackIndices[I]) - NewlyDeducedPacks[I].append(ExplicitArgs, - ExplicitArgs + NumExplicitArgs); + // Save the deduced template argument for the parameter pack expanded + // by this pack expansion, then clear out the deduction. + DeducedPack Pack(Index); + Pack.Saved = Deduced[Index]; + Deduced[Index] = TemplateArgument(); + + Packs.push_back(Pack); + } + } } - } -} + assert(!Packs.empty() && "Pack expansion without unexpanded packs?"); -/// \brief Finish template argument deduction for a set of argument packs, -/// producing the argument packs and checking for consistency with prior -/// deductions. -static Sema::TemplateDeductionResult -FinishArgumentPackDeduction(Sema &S, - TemplateParameterList *TemplateParams, - bool HasAnyArguments, - SmallVectorImpl<DeducedTemplateArgument> &Deduced, - ArrayRef<unsigned> PackIndices, - SmallVectorImpl<DeducedTemplateArgument> &SavedPacks, - NewlyDeducedPacksType &NewlyDeducedPacks, - TemplateDeductionInfo &Info) { - // Build argument packs for each of the parameter packs expanded by this - // pack expansion. - for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { - if (HasAnyArguments && NewlyDeducedPacks[I].empty()) { - // We were not able to deduce anything for this parameter pack, - // so just restore the saved argument pack. - Deduced[PackIndices[I]] = SavedPacks[I]; - continue; + for (auto &Pack : Packs) { + if (Info.PendingDeducedPacks.size() > Pack.Index) + Pack.Outer = Info.PendingDeducedPacks[Pack.Index]; + else + Info.PendingDeducedPacks.resize(Pack.Index + 1); + Info.PendingDeducedPacks[Pack.Index] = &Pack; + + if (S.CurrentInstantiationScope) { + // If the template argument pack was explicitly specified, add that to + // the set of deduced arguments. + const TemplateArgument *ExplicitArgs; + unsigned NumExplicitArgs; + NamedDecl *PartiallySubstitutedPack = + S.CurrentInstantiationScope->getPartiallySubstitutedPack( + &ExplicitArgs, &NumExplicitArgs); + if (PartiallySubstitutedPack && + getDepthAndIndex(PartiallySubstitutedPack).second == Pack.Index) + Pack.New.append(ExplicitArgs, ExplicitArgs + NumExplicitArgs); + } } + } + + ~PackDeductionScope() { + for (auto &Pack : Packs) + Info.PendingDeducedPacks[Pack.Index] = Pack.Outer; + } - DeducedTemplateArgument NewPack; - - if (NewlyDeducedPacks[I].empty()) { - // If we deduced an empty argument pack, create it now. - NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); - } else { - TemplateArgument *ArgumentPack - = new (S.Context) TemplateArgument [NewlyDeducedPacks[I].size()]; - std::copy(NewlyDeducedPacks[I].begin(), NewlyDeducedPacks[I].end(), - ArgumentPack); - NewPack - = DeducedTemplateArgument(TemplateArgument(ArgumentPack, - NewlyDeducedPacks[I].size()), - NewlyDeducedPacks[I][0].wasDeducedFromArrayBound()); + /// Move to deducing the next element in each pack that is being deduced. + void nextPackElement() { + // Capture the deduced template arguments for each parameter pack expanded + // by this pack expansion, add them to the list of arguments we've deduced + // for that pack, then clear out the deduced argument. + for (auto &Pack : Packs) { + DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index]; + if (!DeducedArg.isNull()) { + Pack.New.push_back(DeducedArg); + DeducedArg = DeducedTemplateArgument(); + } } + } - DeducedTemplateArgument Result - = checkDeducedTemplateArguments(S.Context, SavedPacks[I], NewPack); - if (Result.isNull()) { - Info.Param - = makeTemplateParameter(TemplateParams->getParam(PackIndices[I])); - Info.FirstArg = SavedPacks[I]; - Info.SecondArg = NewPack; - return Sema::TDK_Inconsistent; + /// \brief Finish template argument deduction for a set of argument packs, + /// producing the argument packs and checking for consistency with prior + /// deductions. + Sema::TemplateDeductionResult finish(bool HasAnyArguments) { + // Build argument packs for each of the parameter packs expanded by this + // pack expansion. + for (auto &Pack : Packs) { + // Put back the old value for this pack. + Deduced[Pack.Index] = Pack.Saved; + + // Build or find a new value for this pack. + DeducedTemplateArgument NewPack; + if (HasAnyArguments && Pack.New.empty()) { + if (Pack.DeferredDeduction.isNull()) { + // We were not able to deduce anything for this parameter pack + // (because it only appeared in non-deduced contexts), so just + // restore the saved argument pack. + continue; + } + + NewPack = Pack.DeferredDeduction; + Pack.DeferredDeduction = TemplateArgument(); + } else if (Pack.New.empty()) { + // If we deduced an empty argument pack, create it now. + NewPack = DeducedTemplateArgument(TemplateArgument::getEmptyPack()); + } else { + TemplateArgument *ArgumentPack = + new (S.Context) TemplateArgument[Pack.New.size()]; + std::copy(Pack.New.begin(), Pack.New.end(), ArgumentPack); + NewPack = DeducedTemplateArgument( + TemplateArgument(ArgumentPack, Pack.New.size()), + Pack.New[0].wasDeducedFromArrayBound()); + } + + // Pick where we're going to put the merged pack. + DeducedTemplateArgument *Loc; + if (Pack.Outer) { + if (Pack.Outer->DeferredDeduction.isNull()) { + // Defer checking this pack until we have a complete pack to compare + // it against. + Pack.Outer->DeferredDeduction = NewPack; + continue; + } + Loc = &Pack.Outer->DeferredDeduction; + } else { + Loc = &Deduced[Pack.Index]; + } + + // Check the new pack matches any previous value. + DeducedTemplateArgument OldPack = *Loc; + DeducedTemplateArgument Result = + checkDeducedTemplateArguments(S.Context, OldPack, NewPack); + + // If we deferred a deduction of this pack, check that one now too. + if (!Result.isNull() && !Pack.DeferredDeduction.isNull()) { + OldPack = Result; + NewPack = Pack.DeferredDeduction; + Result = checkDeducedTemplateArguments(S.Context, OldPack, NewPack); + } + + if (Result.isNull()) { + Info.Param = + makeTemplateParameter(TemplateParams->getParam(Pack.Index)); + Info.FirstArg = OldPack; + Info.SecondArg = NewPack; + return Sema::TDK_Inconsistent; + } + + *Loc = Result; } - Deduced[PackIndices[I]] = Result; + return Sema::TDK_Success; } - return Sema::TDK_Success; -} +private: + Sema &S; + TemplateParameterList *TemplateParams; + SmallVectorImpl<DeducedTemplateArgument> &Deduced; + TemplateDeductionInfo &Info; + + SmallVector<DeducedPack, 2> Packs; +}; /// \brief Deduce the template arguments by comparing the list of parameter /// types to the list of argument types, as in the parameter-type-lists of @@ -715,7 +801,7 @@ DeduceTemplateArguments(Sema &S, unsigned TDF, bool PartialOrdering = false, SmallVectorImpl<RefParamPartialOrderingComparison> * - RefParamComparisons = 0) { + RefParamComparisons = nullptr) { // Fast-path check to see if we have too many/too few arguments. if (NumParams != NumArgs && !(NumParams && isa<PackExpansionType>(Params[NumParams - 1])) && @@ -773,33 +859,8 @@ DeduceTemplateArguments(Sema &S, // comparison deduces template arguments for subsequent positions in the // template parameter packs expanded by the function parameter pack. - // Compute the set of template parameter indices that correspond to - // parameter packs expanded by the pack expansion. - SmallVector<unsigned, 2> PackIndices; QualType Pattern = Expansion->getPattern(); - { - llvm::SmallBitVector SawIndices(TemplateParams->size()); - SmallVector<UnexpandedParameterPack, 2> Unexpanded; - S.collectUnexpandedParameterPacks(Pattern, Unexpanded); - for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { - unsigned Depth, Index; - llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); - if (Depth == 0 && !SawIndices[Index]) { - SawIndices[Index] = true; - PackIndices.push_back(Index); - } - } - } - assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); - - // Keep track of the deduced template arguments for each parameter pack - // expanded by this pack expansion (the outer index) and for each - // template argument (the inner SmallVectors). - NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); - SmallVector<DeducedTemplateArgument, 2> - SavedPacks(PackIndices.size()); - PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks); + PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); bool HasAnyArguments = false; for (; ArgIdx < NumArgs; ++ArgIdx) { @@ -813,24 +874,12 @@ DeduceTemplateArguments(Sema &S, RefParamComparisons)) return Result; - // Capture the deduced template arguments for each parameter pack expanded - // by this pack expansion, add them to the list of arguments we've deduced - // for that pack, then clear out the deduced argument. - for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { - DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; - if (!DeducedArg.isNull()) { - NewlyDeducedPacks[I].push_back(DeducedArg); - DeducedArg = DeducedTemplateArgument(); - } - } + PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. - if (Sema::TemplateDeductionResult Result - = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, - Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks, Info)) + if (auto Result = PackScope.finish(HasAnyArguments)) return Result; } @@ -981,6 +1030,17 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, Comparison.Qualifiers = ParamMoreQualified; else if (ArgQuals.isStrictSupersetOf(ParamQuals)) Comparison.Qualifiers = ArgMoreQualified; + else if (ArgQuals.getObjCLifetime() != ParamQuals.getObjCLifetime() && + ArgQuals.withoutObjCLifetime() + == ParamQuals.withoutObjCLifetime()) { + // Prefer binding to non-__unsafe_autoretained parameters. + if (ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && + ParamQuals.getObjCLifetime()) + Comparison.Qualifiers = ParamMoreQualified; + else if (ParamQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone && + ArgQuals.getObjCLifetime()) + Comparison.Qualifiers = ArgMoreQualified; + } RefParamComparisons->push_back(Comparison); } @@ -1364,19 +1424,17 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, return Sema::TDK_NonDeducedMismatch; // Check return types. - if (Sema::TemplateDeductionResult Result - = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, - FunctionProtoParam->getResultType(), - FunctionProtoArg->getResultType(), - Info, Deduced, 0)) + if (Sema::TemplateDeductionResult Result = + DeduceTemplateArgumentsByTypeMatch( + S, TemplateParams, FunctionProtoParam->getReturnType(), + FunctionProtoArg->getReturnType(), Info, Deduced, 0)) return Result; - return DeduceTemplateArguments(S, TemplateParams, - FunctionProtoParam->arg_type_begin(), - FunctionProtoParam->getNumArgs(), - FunctionProtoArg->arg_type_begin(), - FunctionProtoArg->getNumArgs(), - Info, Deduced, SubTDF); + return DeduceTemplateArguments( + S, TemplateParams, FunctionProtoParam->param_type_begin(), + FunctionProtoParam->getNumParams(), + FunctionProtoArg->param_type_begin(), + FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF); } case Type::InjectedClassName: { @@ -1463,12 +1521,10 @@ DeduceTemplateArgumentsByTypeMatch(Sema &S, // Visit base classes CXXRecordDecl *Next = cast<CXXRecordDecl>(NextT->getDecl()); - for (CXXRecordDecl::base_class_iterator Base = Next->bases_begin(), - BaseEnd = Next->bases_end(); - Base != BaseEnd; ++Base) { - assert(Base->getType()->isRecordType() && + for (const auto &Base : Next->bases()) { + assert(Base.getType()->isRecordType() && "Base class that isn't a record?"); - ToVisit.push_back(Base->getType()->getAs<RecordType>()); + ToVisit.push_back(Base.getType()->getAs<RecordType>()); } } @@ -1845,41 +1901,18 @@ DeduceTemplateArguments(Sema &S, // template parameter packs expanded by Pi. TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern(); - // Compute the set of template parameter indices that correspond to - // parameter packs expanded by the pack expansion. - SmallVector<unsigned, 2> PackIndices; - { - llvm::SmallBitVector SawIndices(TemplateParams->size()); - SmallVector<UnexpandedParameterPack, 2> Unexpanded; - S.collectUnexpandedParameterPacks(Pattern, Unexpanded); - for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { - unsigned Depth, Index; - llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); - if (Depth == 0 && !SawIndices[Index]) { - SawIndices[Index] = true; - PackIndices.push_back(Index); - } - } - } - assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); - // FIXME: If there are no remaining arguments, we can bail out early // and set any deduced parameter packs to an empty argument pack. // The latter part of this is a (minor) correctness issue. - // Save the deduced template arguments for each parameter pack expanded - // by this pack expansion, then clear out the deduction. - SmallVector<DeducedTemplateArgument, 2> - SavedPacks(PackIndices.size()); - NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); - PrepareArgumentPackDeduction(S, Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks); + // Prepare to deduce the packs within the pattern. + PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern); // Keep track of the deduced template arguments for each parameter pack // expanded by this pack expansion (the outer index) and for each // template argument (the inner SmallVectors). bool HasAnyArguments = false; - while (hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs)) { + for (; hasTemplateArgumentForDeduction(Args, ArgIdx, NumArgs); ++ArgIdx) { HasAnyArguments = true; // Deduce template arguments from the pattern. @@ -1888,26 +1921,12 @@ DeduceTemplateArguments(Sema &S, Info, Deduced)) return Result; - // Capture the deduced template arguments for each parameter pack expanded - // by this pack expansion, add them to the list of arguments we've deduced - // for that pack, then clear out the deduced argument. - for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { - DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; - if (!DeducedArg.isNull()) { - NewlyDeducedPacks[I].push_back(DeducedArg); - DeducedArg = DeducedTemplateArgument(); - } - } - - ++ArgIdx; + PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. - if (Sema::TemplateDeductionResult Result - = FinishArgumentPackDeduction(S, TemplateParams, HasAnyArguments, - Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks, Info)) + if (auto Result = PackScope.finish(HasAnyArguments)) return Result; } @@ -2013,21 +2032,21 @@ getTrivialTemplateArgumentLoc(Sema &S, case TemplateArgument::Declaration: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) - .takeAs<Expr>(); + .getAs<Expr>(); return TemplateArgumentLoc(TemplateArgument(E), E); } case TemplateArgument::NullPtr: { Expr *E = S.BuildExpressionFromDeclTemplateArgument(Arg, NTTPType, Loc) - .takeAs<Expr>(); + .getAs<Expr>(); return TemplateArgumentLoc(TemplateArgument(NTTPType, /*isNullPtr*/true), E); } case TemplateArgument::Integral: { Expr *E - = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).takeAs<Expr>(); + = S.BuildExpressionFromIntegralTemplateArgument(Arg, Loc).getAs<Expr>(); return TemplateArgumentLoc(TemplateArgument(E), E); } @@ -2076,13 +2095,11 @@ ConvertDeducedTemplateArgument(Sema &S, NamedDecl *Param, // This is a template argument pack, so check each of its arguments against // the template parameter. SmallVector<TemplateArgument, 2> PackedArgsBuilder; - for (TemplateArgument::pack_iterator PA = Arg.pack_begin(), - PAEnd = Arg.pack_end(); - PA != PAEnd; ++PA) { + for (const auto &P : Arg.pack_elements()) { // When converting the deduced template argument, append it to the // general output list. We need to do this so that the template argument // checking logic has all of the prior template arguments available. - DeducedTemplateArgument InnerArg(*PA); + DeducedTemplateArgument InnerArg(P); InnerArg.setDeducedFromArrayBound(Arg.wasDeducedFromArrayBound()); if (ConvertDeducedTemplateArgument(S, Param, InnerArg, Template, NTTPType, PackedArgsBuilder.size(), @@ -2274,8 +2291,8 @@ Sema::DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial, return Result; SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, - DeducedArgs, Info); + InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, + Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; @@ -2438,8 +2455,8 @@ Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, return Result; SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, Partial->getLocation(), Partial, - DeducedArgs, Info); + InstantiatingTemplate Inst(*this, Info.getLocation(), Partial, DeducedArgs, + Info); if (Inst.isInvalid()) return TDK_InstantiationDepth; @@ -2454,7 +2471,7 @@ Sema::DeduceTemplateArguments(VarTemplatePartialSpecializationDecl *Partial, static bool isSimpleTemplateIdType(QualType T) { if (const TemplateSpecializationType *Spec = T->getAs<TemplateSpecializationType>()) - return Spec->getTemplateName().getAsTemplateDecl() != 0; + return Spec->getTemplateName().getAsTemplateDecl() != nullptr; return false; } @@ -2498,11 +2515,8 @@ Sema::SubstituteExplicitTemplateArguments( if (ExplicitTemplateArgs.size() == 0) { // No arguments to substitute; just copy over the parameter types and // fill in the function type. - for (FunctionDecl::param_iterator P = Function->param_begin(), - PEnd = Function->param_end(); - P != PEnd; - ++P) - ParamTypes.push_back((*P)->getType()); + for (auto P : Function->params()) + ParamTypes.push_back(P->getType()); if (FunctionType) *FunctionType = Function->getType(); @@ -2524,8 +2538,8 @@ Sema::SubstituteExplicitTemplateArguments( // explicitly-specified template arguments against this function template, // and then substitute them into the function parameter types. SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), - FunctionTemplate, DeducedArgs, + InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, + DeducedArgs, ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) @@ -2596,7 +2610,7 @@ Sema::SubstituteExplicitTemplateArguments( // and the end of the function-definition, member-declarator, or // declarator. unsigned ThisTypeQuals = 0; - CXXRecordDecl *ThisContext = 0; + CXXRecordDecl *ThisContext = nullptr; if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { ThisContext = Method->getParent(); ThisTypeQuals = Method->getTypeQualifiers(); @@ -2604,11 +2618,11 @@ Sema::SubstituteExplicitTemplateArguments( CXXThisScopeRAII ThisScope(*this, ThisContext, ThisTypeQuals, getLangOpts().CPlusPlus11); - - ResultType = SubstType(Proto->getResultType(), - MultiLevelTemplateArgumentList(*ExplicitArgumentList), - Function->getTypeSpecStartLoc(), - Function->getDeclName()); + + ResultType = + SubstType(Proto->getReturnType(), + MultiLevelTemplateArgumentList(*ExplicitArgumentList), + Function->getTypeSpecStartLoc(), Function->getDeclName()); if (ResultType.isNull() || Trap.hasErrorOccurred()) return TDK_SubstitutionFailure; } @@ -2778,8 +2792,8 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, // Enter a new template instantiation context while we instantiate the // actual function declaration. SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, FunctionTemplate->getLocation(), - FunctionTemplate, DeducedArgs, + InstantiatingTemplate Inst(*this, Info.getLocation(), FunctionTemplate, + DeducedArgs, ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution, Info); if (Inst.isInvalid()) @@ -2800,9 +2814,19 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, // argument, because it was explicitly-specified. Just record the // presence of this argument. Builder.push_back(Deduced[I]); + // We may have had explicitly-specified template arguments for a + // template parameter pack (that may or may not have been extended + // via additional deduced arguments). + if (Param->isParameterPack() && CurrentInstantiationScope) { + if (CurrentInstantiationScope->getPartiallySubstitutedPack() == + Param) { + // Forget the partially-substituted pack; its substitution is now + // complete. + CurrentInstantiationScope->ResetPartiallySubstitutedPack(); + } + } continue; } - // We have deduced this argument, so it still needs to be // checked and converted. @@ -2976,8 +3000,8 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R, FunctionDecl *Fn) { // We may need to deduce the return type of the function now. - if (S.getLangOpts().CPlusPlus1y && Fn->getResultType()->isUndeducedType() && - S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/false)) + if (S.getLangOpts().CPlusPlus1y && Fn->getReturnType()->isUndeducedType() && + S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false)) return QualType(); if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) @@ -3048,7 +3072,7 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, return QualType(); // Otherwise, see if we can resolve a function type - FunctionDecl *Specialization = 0; + FunctionDecl *Specialization = nullptr; TemplateDeductionInfo Info(Ovl->getNameLoc()); if (S.DeduceTemplateArguments(FunTmpl, &ExplicitTemplateArgs, Specialization, Info)) @@ -3140,7 +3164,7 @@ static bool AdjustFunctionParmAndArgTypesForDeduction(Sema &S, if (ArgType == S.Context.OverloadTy) { ArgType = ResolveOverloadForDeduction(S, TemplateParams, Arg, ParamType, - ParamRefType != 0); + ParamRefType != nullptr); if (ArgType.isNull()) return true; } @@ -3309,7 +3333,7 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( *ExplicitTemplateArgs, Deduced, ParamTypes, - 0, + nullptr, Info); if (Result) return Result; @@ -3399,30 +3423,9 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( break; QualType ParamPattern = ParamExpansion->getPattern(); - SmallVector<unsigned, 2> PackIndices; - { - llvm::SmallBitVector SawIndices(TemplateParams->size()); - SmallVector<UnexpandedParameterPack, 2> Unexpanded; - collectUnexpandedParameterPacks(ParamPattern, Unexpanded); - for (unsigned I = 0, N = Unexpanded.size(); I != N; ++I) { - unsigned Depth, Index; - llvm::tie(Depth, Index) = getDepthAndIndex(Unexpanded[I]); - if (Depth == 0 && !SawIndices[Index]) { - SawIndices[Index] = true; - PackIndices.push_back(Index); - } - } - } - assert(!PackIndices.empty() && "Pack expansion without unexpanded packs?"); + PackDeductionScope PackScope(*this, TemplateParams, Deduced, Info, + ParamPattern); - // Keep track of the deduced template arguments for each parameter pack - // expanded by this pack expansion (the outer index) and for each - // template argument (the inner SmallVectors). - NewlyDeducedPacksType NewlyDeducedPacks(PackIndices.size()); - SmallVector<DeducedTemplateArgument, 2> - SavedPacks(PackIndices.size()); - PrepareArgumentPackDeduction(*this, Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks); bool HasAnyArguments = false; for (; ArgIdx < Args.size(); ++ArgIdx) { HasAnyArguments = true; @@ -3431,7 +3434,7 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( ParamType = OrigParamType; Expr *Arg = Args[ArgIdx]; QualType ArgType = Arg->getType(); - + unsigned TDF = 0; if (AdjustFunctionParmAndArgTypesForDeduction(*this, TemplateParams, ParamType, ArgType, Arg, @@ -3472,24 +3475,12 @@ Sema::TemplateDeductionResult Sema::DeduceTemplateArguments( return Result; } - // Capture the deduced template arguments for each parameter pack expanded - // by this pack expansion, add them to the list of arguments we've deduced - // for that pack, then clear out the deduced argument. - for (unsigned I = 0, N = PackIndices.size(); I != N; ++I) { - DeducedTemplateArgument &DeducedArg = Deduced[PackIndices[I]]; - if (!DeducedArg.isNull()) { - NewlyDeducedPacks[I].push_back(DeducedArg); - DeducedArg = DeducedTemplateArgument(); - } - } + PackScope.nextPackElement(); } // Build argument packs for each of the parameter packs expanded by this // pack expansion. - if (Sema::TemplateDeductionResult Result - = FinishArgumentPackDeduction(*this, TemplateParams, HasAnyArguments, - Deduced, PackIndices, SavedPacks, - NewlyDeducedPacks, Info)) + if (auto Result = PackScope.finish(HasAnyArguments)) return Result; // After we've matching against a parameter pack, we're done. @@ -3589,7 +3580,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, // type so that we treat it as a non-deduced context in what follows. bool HasDeducedReturnType = false; if (getLangOpts().CPlusPlus1y && InOverloadResolution && - Function->getResultType()->getContainedAutoType()) { + Function->getReturnType()->getContainedAutoType()) { FunctionType = SubstAutoType(FunctionType, Context.DependentTy); HasDeducedReturnType = true; } @@ -3614,7 +3605,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, // If the function has a deduced return type, deduce it now, so we can check // that the deduced function type matches the requested type. if (HasDeducedReturnType && - Specialization->getResultType()->isUndeducedType() && + Specialization->getReturnType()->isUndeducedType() && DeduceReturnType(Specialization, Info.getLocation(), false)) return TDK_MiscellaneousDeductionFailure; @@ -3643,7 +3634,7 @@ static inline void SubstAutoWithinFunctionReturnType(FunctionDecl *F, QualType TypeToReplaceAutoWith, Sema &S) { assert(!TypeToReplaceAutoWith->getContainedAutoType()); - QualType AutoResultType = F->getResultType(); + QualType AutoResultType = F->getReturnType(); assert(AutoResultType->getContainedAutoType()); QualType DeducedResultType = S.SubstAutoType(AutoResultType, TypeToReplaceAutoWith); @@ -3668,14 +3659,14 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( assert(LambdaClass && LambdaClass->isGenericLambda()); CXXMethodDecl *CallOpGeneric = LambdaClass->getLambdaCallOperator(); - QualType CallOpResultType = CallOpGeneric->getResultType(); + QualType CallOpResultType = CallOpGeneric->getReturnType(); const bool GenericLambdaCallOperatorHasDeducedReturnType = CallOpResultType->getContainedAutoType(); FunctionTemplateDecl *CallOpTemplate = CallOpGeneric->getDescribedFunctionTemplate(); - FunctionDecl *CallOpSpecialized = 0; + FunctionDecl *CallOpSpecialized = nullptr; // Use the deduced arguments of the conversion function, to specialize our // generic lambda's call operator. if (Sema::TemplateDeductionResult Result @@ -3685,15 +3676,15 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( return Result; // If we need to deduce the return type, do so (instantiates the callop). - if (GenericLambdaCallOperatorHasDeducedReturnType && - CallOpSpecialized->getResultType()->isUndeducedType()) + if (GenericLambdaCallOperatorHasDeducedReturnType && + CallOpSpecialized->getReturnType()->isUndeducedType()) S.DeduceReturnType(CallOpSpecialized, CallOpSpecialized->getPointOfInstantiation(), /*Diagnose*/ true); // Check to see if the return type of the destination ptr-to-function // matches the return type of the call operator. - if (!S.Context.hasSameType(CallOpSpecialized->getResultType(), + if (!S.Context.hasSameType(CallOpSpecialized->getReturnType(), ReturnTypeOfDestFunctionPtr)) return Sema::TDK_NonDeducedMismatch; // Since we have succeeded in matching the source and destination @@ -3701,7 +3692,7 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( // specialized our corresponding call operator, we are ready to // specialize the static invoker with the deduced arguments of our // ptr-to-function. - FunctionDecl *InvokerSpecialized = 0; + FunctionDecl *InvokerSpecialized = nullptr; FunctionTemplateDecl *InvokerTemplate = LambdaClass-> getLambdaStaticInvoker()->getDescribedFunctionTemplate(); @@ -3712,8 +3703,8 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( "If the call operator succeeded so should the invoker!"); // Set the result type to match the corresponding call operator // specialization's result type. - if (GenericLambdaCallOperatorHasDeducedReturnType && - InvokerSpecialized->getResultType()->isUndeducedType()) { + if (GenericLambdaCallOperatorHasDeducedReturnType && + InvokerSpecialized->getReturnType()->isUndeducedType()) { // Be sure to get the type to replace 'auto' with and not // the full result type of the call op specialization // to substitute into the 'auto' of the invoker and conversion @@ -3722,9 +3713,9 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( // int* (*fp)(int*) = [](auto* a) -> auto* { return a; }; // We don't want to subst 'int*' into 'auto' to get int**. - QualType TypeToReplaceAutoWith = - CallOpSpecialized->getResultType()-> - getContainedAutoType()->getDeducedType(); + QualType TypeToReplaceAutoWith = CallOpSpecialized->getReturnType() + ->getContainedAutoType() + ->getDeducedType(); SubstAutoWithinFunctionReturnType(InvokerSpecialized, TypeToReplaceAutoWith, S); SubstAutoWithinFunctionReturnType(ConversionSpecialized, @@ -3740,7 +3731,7 @@ SpecializeCorrespondingLambdaCallOperatorAndInvoker( FunctionProtoType::ExtProtoInfo EPI = InvokerFPT->getExtProtoInfo(); EPI.TypeQuals = 0; InvokerSpecialized->setType(S.Context.getFunctionType( - InvokerFPT->getResultType(), InvokerFPT->getArgTypes(),EPI)); + InvokerFPT->getReturnType(), InvokerFPT->getParamTypes(), EPI)); return Sema::TDK_Success; } /// \brief Deduce template arguments for a templated conversion @@ -3844,7 +3835,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, // Create an Instantiation Scope for finalizing the operator. LocalInstantiationScope InstScope(*this); // Finish template argument deduction. - FunctionDecl *ConversionSpecialized = 0; + FunctionDecl *ConversionSpecialized = nullptr; TemplateDeductionResult Result = FinishTemplateArgumentDeduction(ConversionTemplate, Deduced, 0, ConversionSpecialized, Info); @@ -3863,8 +3854,8 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *ConversionTemplate, "Can only convert from lambda to ptr-to-function"); const FunctionType *ToFunType = A->getPointeeType().getTypePtr()->getAs<FunctionType>(); - const QualType DestFunctionPtrReturnType = ToFunType->getResultType(); - + const QualType DestFunctionPtrReturnType = ToFunType->getReturnType(); + // Create the corresponding specializations of the call operator and // the static-invoker; and if the return type is auto, // deduce the return type and check if it matches the @@ -3978,7 +3969,7 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { ExprResult NonPlaceholder = CheckPlaceholderExpr(Init); if (NonPlaceholder.isInvalid()) return DAR_FailedAlreadyDiagnosed; - Init = NonPlaceholder.take(); + Init = NonPlaceholder.get(); } if (Init->isTypeDependent() || Type.getType()->isDependentType()) { @@ -4013,8 +4004,8 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result) { // Build template<class TemplParam> void Func(FuncParam); TemplateTypeParmDecl *TemplParam = - TemplateTypeParmDecl::Create(Context, 0, SourceLocation(), Loc, 0, 0, 0, - false, false); + TemplateTypeParmDecl::Create(Context, nullptr, SourceLocation(), Loc, 0, 0, + nullptr, false, false); QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0); NamedDecl *TemplParamPtr = TemplParam; FixedSizeTemplateParameterList<1> TemplateParams(Loc, Loc, &TemplParamPtr, @@ -4109,12 +4100,12 @@ void Sema::DiagnoseAutoDeductionFailure(VarDecl *VDecl, Expr *Init) { bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose) { - assert(FD->getResultType()->isUndeducedType()); + assert(FD->getReturnType()->isUndeducedType()); if (FD->getTemplateInstantiationPattern()) InstantiateFunctionDefinition(Loc, FD); - bool StillUndeduced = FD->getResultType()->isUndeducedType(); + bool StillUndeduced = FD->getReturnType()->isUndeducedType(); if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) { Diag(Loc, diag::err_auto_fn_used_before_defined) << FD; Diag(FD->getLocation(), diag::note_callee_decl) << FD; @@ -4195,35 +4186,25 @@ static bool isAtLeastAsSpecializedAs(Sema &S, // otherwise, the ordering rules for static functions against non-static // functions don't make any sense. // - // C++98/03 doesn't have this provision, so instead we drop the - // first argument of the free function, which seems to match - // existing practice. + // C++98/03 doesn't have this provision but we've extended DR532 to cover + // it as wording was broken prior to it. SmallVector<QualType, 4> Args1; - unsigned Skip1 = 0, Skip2 = 0; unsigned NumComparedArguments = NumCallArguments1; if (!Method2 && Method1 && !Method1->isStatic()) { - if (S.getLangOpts().CPlusPlus11) { - // Compare 'this' from Method1 against first parameter from Method2. - AddImplicitObjectParameterType(S.Context, Method1, Args1); - ++NumComparedArguments; - } else - // Ignore first parameter from Method2. - ++Skip2; + // Compare 'this' from Method1 against first parameter from Method2. + AddImplicitObjectParameterType(S.Context, Method1, Args1); + ++NumComparedArguments; } else if (!Method1 && Method2 && !Method2->isStatic()) { - if (S.getLangOpts().CPlusPlus11) - // Compare 'this' from Method2 against first parameter from Method1. - AddImplicitObjectParameterType(S.Context, Method2, Args2); - else - // Ignore first parameter from Method1. - ++Skip1; + // Compare 'this' from Method2 against first parameter from Method1. + AddImplicitObjectParameterType(S.Context, Method2, Args2); } - Args1.insert(Args1.end(), - Proto1->arg_type_begin() + Skip1, Proto1->arg_type_end()); - Args2.insert(Args2.end(), - Proto2->arg_type_begin() + Skip2, Proto2->arg_type_end()); + Args1.insert(Args1.end(), Proto1->param_type_begin(), + Proto1->param_type_end()); + Args2.insert(Args2.end(), Proto2->param_type_begin(), + Proto2->param_type_end()); // C++ [temp.func.order]p5: // The presence of unused ellipsis and default arguments has no effect on @@ -4236,7 +4217,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, Args1.data(), Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true, RefParamComparisons)) - return false; + return false; break; } @@ -4244,12 +4225,10 @@ static bool isAtLeastAsSpecializedAs(Sema &S, case TPOC_Conversion: // - In the context of a call to a conversion operator, the return types // of the conversion function templates are used. - if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, - Proto2->getResultType(), - Proto1->getResultType(), - Info, Deduced, TDF_None, - /*PartialOrdering=*/true, - RefParamComparisons)) + if (DeduceTemplateArgumentsByTypeMatch( + S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(), + Info, Deduced, TDF_None, + /*PartialOrdering=*/true, RefParamComparisons)) return false; break; @@ -4293,9 +4272,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S, break; case TPOC_Conversion: - ::MarkUsedTemplateParameters(S.Context, Proto2->getResultType(), false, - TemplateParams->getDepth(), - UsedParameters); + ::MarkUsedTemplateParameters(S.Context, Proto2->getReturnType(), false, + TemplateParams->getDepth(), UsedParameters); break; case TPOC_Other: @@ -4362,7 +4340,7 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, unsigned NumCallArguments2) { SmallVector<RefParamPartialOrderingComparison, 4> RefParamComparisons; bool Better1 = isAtLeastAsSpecializedAs(*this, Loc, FT1, FT2, TPOC, - NumCallArguments1, 0); + NumCallArguments1, nullptr); bool Better2 = isAtLeastAsSpecializedAs(*this, Loc, FT2, FT1, TPOC, NumCallArguments2, &RefParamComparisons); @@ -4371,7 +4349,7 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, return Better1? FT1 : FT2; if (!Better1 && !Better2) // Neither is better than the other - return 0; + return nullptr; // C++0x [temp.deduct.partial]p10: // If for each type being considered a given template is at least as @@ -4397,13 +4375,13 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, RefParamComparisons[I].ParamIsRvalueRef) { Better2 = true; if (Better1) - return 0; + return nullptr; continue; } else if (!RefParamComparisons[I].ParamIsRvalueRef && RefParamComparisons[I].ArgIsRvalueRef) { Better1 = true; if (Better2) - return 0; + return nullptr; continue; } @@ -4418,13 +4396,13 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, case ParamMoreQualified: Better1 = true; if (Better2) - return 0; + return nullptr; continue; case ArgMoreQualified: Better2 = true; if (Better1) - return 0; + return nullptr; continue; } @@ -4445,7 +4423,7 @@ Sema::getMoreSpecializedTemplate(FunctionTemplateDecl *FT1, if (Variadic1 != Variadic2) return Variadic1? FT2 : FT1; - return 0; + return nullptr; } /// \brief Determine if the two templates are equivalent. @@ -4610,11 +4588,10 @@ Sema::getMoreSpecializedPartialSpecialization( PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, - /*RefParamComparisons=*/0); + /*RefParamComparisons=*/nullptr); if (Better1) { SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); - InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, DeducedArgs, - Info); + InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction( *this, PS2, PS1->getTemplateArgs(), Deduced, Info); } @@ -4625,18 +4602,17 @@ Sema::getMoreSpecializedPartialSpecialization( bool Better2 = !DeduceTemplateArgumentsByTypeMatch( *this, PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, - /*RefParamComparisons=*/0); + /*RefParamComparisons=*/nullptr); if (Better2) { SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, DeducedArgs, - Info); + InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction( *this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) - return 0; + return nullptr; return Better1 ? PS1 : PS2; } @@ -4653,7 +4629,7 @@ Sema::getMoreSpecializedPartialSpecialization( SmallVector<DeducedTemplateArgument, 4> Deduced; TemplateDeductionInfo Info(Loc); - assert(PS1->getSpecializedTemplate() == PS1->getSpecializedTemplate() && + assert(PS1->getSpecializedTemplate() == PS2->getSpecializedTemplate() && "the partial specializations being compared should specialize" " the same template."); TemplateName Name(PS1->getSpecializedTemplate()); @@ -4670,12 +4646,11 @@ Sema::getMoreSpecializedPartialSpecialization( bool Better1 = !DeduceTemplateArgumentsByTypeMatch( *this, PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, - /*RefParamComparisons=*/0); + /*RefParamComparisons=*/nullptr); if (Better1) { SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(), Deduced.end()); - InstantiatingTemplate Inst(*this, PS2->getLocation(), PS2, - DeducedArgs, Info); + InstantiatingTemplate Inst(*this, Loc, PS2, DeducedArgs, Info); Better1 = !::FinishTemplateArgumentDeduction(*this, PS2, PS1->getTemplateArgs(), Deduced, Info); @@ -4688,18 +4663,17 @@ Sema::getMoreSpecializedPartialSpecialization( PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, - /*RefParamComparisons=*/0); + /*RefParamComparisons=*/nullptr); if (Better2) { SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),Deduced.end()); - InstantiatingTemplate Inst(*this, PS1->getLocation(), PS1, - DeducedArgs, Info); + InstantiatingTemplate Inst(*this, Loc, PS1, DeducedArgs, Info); Better2 = !::FinishTemplateArgumentDeduction(*this, PS1, PS2->getTemplateArgs(), Deduced, Info); } if (Better1 == Better2) - return 0; + return nullptr; return Better1? PS1 : PS2; } @@ -4874,10 +4848,10 @@ MarkUsedTemplateParameters(ASTContext &Ctx, QualType T, case Type::FunctionProto: { const FunctionProtoType *Proto = cast<FunctionProtoType>(T); - MarkUsedTemplateParameters(Ctx, Proto->getResultType(), OnlyDeduced, - Depth, Used); - for (unsigned I = 0, N = Proto->getNumArgs(); I != N; ++I) - MarkUsedTemplateParameters(Ctx, Proto->getArgType(I), OnlyDeduced, + MarkUsedTemplateParameters(Ctx, Proto->getReturnType(), OnlyDeduced, Depth, + Used); + for (unsigned I = 0, N = Proto->getNumParams(); I != N; ++I) + MarkUsedTemplateParameters(Ctx, Proto->getParamType(I), OnlyDeduced, Depth, Used); break; } @@ -5061,10 +5035,8 @@ MarkUsedTemplateParameters(ASTContext &Ctx, break; case TemplateArgument::Pack: - for (TemplateArgument::pack_iterator P = TemplateArg.pack_begin(), - PEnd = TemplateArg.pack_end(); - P != PEnd; ++P) - MarkUsedTemplateParameters(Ctx, *P, OnlyDeduced, Depth, Used); + for (const auto &P : TemplateArg.pack_elements()) + MarkUsedTemplateParameters(Ctx, P, OnlyDeduced, Depth, Used); break; } } |
