From bb95e51a3668c50133b989467cd44ba4d8a42e8a Mon Sep 17 00:00:00 2001 From: Sebastian Redl Date: Tue, 17 Jan 2012 22:49:52 +0000 Subject: [PATCH] Rename the first of 11 DeduceTemplateArguments overloads. There are 5 functions of this name in Sema, and 6 more static helpers in SemaTemplateDeduction.cpp. The Sema functions have jobs like "deduce for function call", "deduce for taking the address", etc. The static helpers have jobs like "deduce by comparing two types", "deduce by comparing two lists of types", "deduce by comparing two template arguments", etc. The fact that they all are called the same and only differ in two of their 6 or more arguments makes the code using them very hard to read. Here I rename the one function that concerns me most at the moment, but as a matter of cleanup, the others will eventually be renamed as well. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@148351 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Sema/SemaTemplateDeduction.cpp | 231 +++++++++++++++-------------- 1 file changed, 117 insertions(+), 114 deletions(-) diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp index 7f30f7b73e..ab2c2a3e67 100644 --- a/lib/Sema/SemaTemplateDeduction.cpp +++ b/lib/Sema/SemaTemplateDeduction.cpp @@ -112,15 +112,16 @@ struct RefParamPartialOrderingComparison { static Sema::TemplateDeductionResult -DeduceTemplateArguments(Sema &S, - TemplateParameterList *TemplateParams, - QualType Param, - QualType Arg, - TemplateDeductionInfo &Info, - SmallVectorImpl &Deduced, - unsigned TDF, - bool PartialOrdering = false, - SmallVectorImpl * +DeduceTemplateArgumentsByTypeMatch(Sema &S, + TemplateParameterList *TemplateParams, + QualType Param, + QualType Arg, + TemplateDeductionInfo &Info, + SmallVectorImpl & + Deduced, + unsigned TDF, + bool PartialOrdering = false, + SmallVectorImpl * RefParamComparisons = 0); static Sema::TemplateDeductionResult @@ -705,12 +706,11 @@ DeduceTemplateArguments(Sema &S, } if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - Params[ParamIdx], - Args[ArgIdx], - Info, Deduced, TDF, - PartialOrdering, - RefParamComparisons)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + Params[ParamIdx], Args[ArgIdx], + Info, Deduced, TDF, + PartialOrdering, + RefParamComparisons)) return Result; ++ArgIdx; @@ -766,9 +766,10 @@ DeduceTemplateArguments(Sema &S, // Deduce template arguments from the pattern. if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx], - Info, Deduced, TDF, PartialOrdering, - RefParamComparisons)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern, + Args[ArgIdx], Info, Deduced, + TDF, PartialOrdering, + RefParamComparisons)) return Result; // Capture the deduced template arguments for each parameter pack expanded @@ -858,14 +859,15 @@ static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType, /// "success" result means that template argument deduction has not yet failed, /// but it may still fail, later, for other reasons. static Sema::TemplateDeductionResult -DeduceTemplateArguments(Sema &S, - TemplateParameterList *TemplateParams, - QualType ParamIn, QualType ArgIn, - TemplateDeductionInfo &Info, - SmallVectorImpl &Deduced, - unsigned TDF, - bool PartialOrdering, - SmallVectorImpl *RefParamComparisons) { +DeduceTemplateArgumentsByTypeMatch(Sema &S, + TemplateParameterList *TemplateParams, + QualType ParamIn, QualType ArgIn, + TemplateDeductionInfo &Info, + SmallVectorImpl &Deduced, + unsigned TDF, + bool PartialOrdering, + SmallVectorImpl * + RefParamComparisons) { // We only want to look at the canonical types, since typedefs and // sugar are not part of template argument deduction. QualType Param = S.Context.getCanonicalType(ParamIn); @@ -1110,17 +1112,17 @@ DeduceTemplateArguments(Sema &S, // _Complex T [placeholder extension] case Type::Complex: if (const ComplexType *ComplexArg = Arg->getAs()) - return DeduceTemplateArguments(S, TemplateParams, + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getElementType(), - ComplexArg->getElementType(), - Info, Deduced, TDF); + ComplexArg->getElementType(), + Info, Deduced, TDF); return Sema::TDK_NonDeducedMismatch; // _Atomic T [extension] case Type::Atomic: if (const AtomicType *AtomicArg = Arg->getAs()) - return DeduceTemplateArguments(S, TemplateParams, + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getValueType(), AtomicArg->getValueType(), Info, Deduced, TDF); @@ -1140,8 +1142,8 @@ DeduceTemplateArguments(Sema &S, } unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass); - return DeduceTemplateArguments(S, TemplateParams, - cast(Param)->getPointeeType(), + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + cast(Param)->getPointeeType(), PointeeType, Info, Deduced, SubTDF); } @@ -1152,10 +1154,9 @@ DeduceTemplateArguments(Sema &S, if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; - return DeduceTemplateArguments(S, TemplateParams, + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, cast(Param)->getPointeeType(), - ReferenceArg->getPointeeType(), - Info, Deduced, 0); + ReferenceArg->getPointeeType(), Info, Deduced, 0); } // T && [C++0x] @@ -1164,10 +1165,10 @@ DeduceTemplateArguments(Sema &S, if (!ReferenceArg) return Sema::TDK_NonDeducedMismatch; - return DeduceTemplateArguments(S, TemplateParams, - cast(Param)->getPointeeType(), - ReferenceArg->getPointeeType(), - Info, Deduced, 0); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + cast(Param)->getPointeeType(), + ReferenceArg->getPointeeType(), + Info, Deduced, 0); } // T [] (implied, but not stated explicitly) @@ -1178,10 +1179,10 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; - return DeduceTemplateArguments(S, TemplateParams, - S.Context.getAsIncompleteArrayType(Param)->getElementType(), - IncompleteArrayArg->getElementType(), - Info, Deduced, SubTDF); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + S.Context.getAsIncompleteArrayType(Param)->getElementType(), + IncompleteArrayArg->getElementType(), + Info, Deduced, SubTDF); } // T [integer-constant] @@ -1197,10 +1198,10 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_NonDeducedMismatch; unsigned SubTDF = TDF & TDF_IgnoreQualifiers; - return DeduceTemplateArguments(S, TemplateParams, - ConstantArrayParm->getElementType(), - ConstantArrayArg->getElementType(), - Info, Deduced, SubTDF); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + ConstantArrayParm->getElementType(), + ConstantArrayArg->getElementType(), + Info, Deduced, SubTDF); } // type [i] @@ -1215,10 +1216,10 @@ DeduceTemplateArguments(Sema &S, const DependentSizedArrayType *DependentArrayParm = S.Context.getAsDependentSizedArrayType(Param); if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - DependentArrayParm->getElementType(), - ArrayArg->getElementType(), - Info, Deduced, SubTDF)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + DependentArrayParm->getElementType(), + ArrayArg->getElementType(), + Info, Deduced, SubTDF)) return Result; // Determine the array bound is something we can deduce. @@ -1272,10 +1273,10 @@ DeduceTemplateArguments(Sema &S, // Check return types. if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - FunctionProtoParam->getResultType(), - FunctionProtoArg->getResultType(), - Info, Deduced, 0)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + FunctionProtoParam->getResultType(), + FunctionProtoArg->getResultType(), + Info, Deduced, 0)) return Result; return DeduceTemplateArguments(S, TemplateParams, @@ -1399,17 +1400,17 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_NonDeducedMismatch; if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - MemPtrParam->getPointeeType(), - MemPtrArg->getPointeeType(), - Info, Deduced, - TDF & TDF_IgnoreQualifiers)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + MemPtrParam->getPointeeType(), + MemPtrArg->getPointeeType(), + Info, Deduced, + TDF & TDF_IgnoreQualifiers)) return Result; - return DeduceTemplateArguments(S, TemplateParams, - QualType(MemPtrParam->getClass(), 0), - QualType(MemPtrArg->getClass(), 0), - Info, Deduced, 0); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + QualType(MemPtrParam->getClass(), 0), + QualType(MemPtrArg->getClass(), 0), + Info, Deduced, 0); } // (clang extension) @@ -1424,10 +1425,10 @@ DeduceTemplateArguments(Sema &S, if (!BlockPtrArg) return Sema::TDK_NonDeducedMismatch; - return DeduceTemplateArguments(S, TemplateParams, - BlockPtrParam->getPointeeType(), - BlockPtrArg->getPointeeType(), Info, - Deduced, 0); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + BlockPtrParam->getPointeeType(), + BlockPtrArg->getPointeeType(), + Info, Deduced, 0); } // (clang extension) @@ -1441,11 +1442,10 @@ DeduceTemplateArguments(Sema &S, return Sema::TDK_NonDeducedMismatch; // Perform deduction on the element types. - return DeduceTemplateArguments(S, TemplateParams, - VectorParam->getElementType(), - VectorArg->getElementType(), - Info, Deduced, - TDF); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + VectorParam->getElementType(), + VectorArg->getElementType(), + Info, Deduced, TDF); } if (const DependentSizedExtVectorType *VectorArg @@ -1455,11 +1455,10 @@ DeduceTemplateArguments(Sema &S, // ordering. // Perform deduction on the element types. - return DeduceTemplateArguments(S, TemplateParams, - VectorParam->getElementType(), - VectorArg->getElementType(), - Info, Deduced, - TDF); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + VectorParam->getElementType(), + VectorArg->getElementType(), + Info, Deduced, TDF); } return Sema::TDK_NonDeducedMismatch; @@ -1475,11 +1474,10 @@ DeduceTemplateArguments(Sema &S, if (const ExtVectorType *VectorArg = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - VectorParam->getElementType(), - VectorArg->getElementType(), - Info, Deduced, - TDF)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + VectorParam->getElementType(), + VectorArg->getElementType(), + Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. @@ -1498,11 +1496,10 @@ DeduceTemplateArguments(Sema &S, = dyn_cast(Arg)) { // Perform deduction on the element types. if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - VectorParam->getElementType(), - VectorArg->getElementType(), - Info, Deduced, - TDF)) + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + VectorParam->getElementType(), + VectorArg->getElementType(), + Info, Deduced, TDF)) return Result; // Perform deduction on the vector size, if we can. @@ -1553,8 +1550,10 @@ DeduceTemplateArguments(Sema &S, case TemplateArgument::Type: if (Arg.getKind() == TemplateArgument::Type) - return DeduceTemplateArguments(S, TemplateParams, Param.getAsType(), - Arg.getAsType(), Info, Deduced, 0); + return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + Param.getAsType(), + Arg.getAsType(), + Info, Deduced, 0); Info.FirstArg = Param; Info.SecondArg = Arg; return Sema::TDK_NonDeducedMismatch; @@ -2737,9 +2736,8 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams, Deduced(TemplateParams->size()); TemplateDeductionInfo Info(S.Context, Ovl->getNameLoc()); Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - ParamType, ArgType, - Info, Deduced, TDF); + = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType, + ArgType, Info, Deduced, TDF); if (Result) continue; if (!Match.isNull()) return QualType(); Match = ArgType; @@ -2979,9 +2977,9 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, ArgType)); if (TemplateDeductionResult Result - = ::DeduceTemplateArguments(*this, TemplateParams, - ParamType, ArgType, Info, Deduced, - TDF)) + = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, + ParamType, ArgType, + Info, Deduced, TDF)) return Result; continue; @@ -3051,9 +3049,9 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, ArgType)); if (TemplateDeductionResult Result - = ::DeduceTemplateArguments(*this, TemplateParams, - ParamType, ArgType, Info, Deduced, - TDF)) + = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, + ParamType, ArgType, Info, + Deduced, TDF)) return Result; // Capture the deduced template arguments for each parameter pack expanded @@ -3144,7 +3142,7 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, if (!ArgFunctionType.isNull()) { // Deduce template arguments from the function type. if (TemplateDeductionResult Result - = ::DeduceTemplateArguments(*this, TemplateParams, + = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced, TDF_TopLevelParameterTypeList)) return Result; @@ -3255,8 +3253,8 @@ Sema::DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate, (P->isMemberPointerType() && A->isMemberPointerType())) TDF |= TDF_IgnoreQualifiers; if (TemplateDeductionResult Result - = ::DeduceTemplateArguments(*this, TemplateParams, - P, A, Info, Deduced, TDF)) + = DeduceTemplateArgumentsByTypeMatch(*this, TemplateParams, + P, A, Info, Deduced, TDF)) return Result; // Finish template argument deduction. @@ -3384,9 +3382,8 @@ Sema::DeduceAutoType(TypeSourceInfo *Type, Expr *&Init, return false; TemplateDeductionInfo Info(Context, Loc); - if (::DeduceTemplateArguments(*this, &TemplateParams, - FuncParam, InitType, Info, Deduced, - TDF)) + if (DeduceTemplateArgumentsByTypeMatch(*this, &TemplateParams, FuncParam, + InitType, Info, Deduced, TDF)) return false; QualType DeducedType = Deduced[0].getAsType(); @@ -3521,19 +3518,23 @@ 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 (DeduceTemplateArguments(S, TemplateParams, Proto2->getResultType(), - Proto1->getResultType(), Info, Deduced, - TDF_None, /*PartialOrdering=*/true, - RefParamComparisons)) + if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + Proto2->getResultType(), + Proto1->getResultType(), + Info, Deduced, TDF_None, + /*PartialOrdering=*/true, + RefParamComparisons)) return false; break; case TPOC_Other: // - In other contexts (14.6.6.2) the function template's function type // is used. - if (DeduceTemplateArguments(S, TemplateParams, FD2->getType(), - FD1->getType(), Info, Deduced, TDF_None, - /*PartialOrdering=*/true, RefParamComparisons)) + if (DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, + FD2->getType(), FD1->getType(), + Info, Deduced, TDF_None, + /*PartialOrdering=*/true, + RefParamComparisons)) return false; break; } @@ -3900,7 +3901,8 @@ Sema::getMoreSpecializedPartialSpecialization( // Determine whether PS1 is at least as specialized as PS2 Deduced.resize(PS2->getTemplateParameters()->size()); - bool Better1 = !::DeduceTemplateArguments(*this, PS2->getTemplateParameters(), + bool Better1 = !DeduceTemplateArgumentsByTypeMatch(*this, + PS2->getTemplateParameters(), PT2, PT1, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); @@ -3915,7 +3917,8 @@ Sema::getMoreSpecializedPartialSpecialization( // Determine whether PS2 is at least as specialized as PS1 Deduced.clear(); Deduced.resize(PS1->getTemplateParameters()->size()); - bool Better2 = !::DeduceTemplateArguments(*this, PS1->getTemplateParameters(), + bool Better2 = !DeduceTemplateArgumentsByTypeMatch(*this, + PS1->getTemplateParameters(), PT1, PT2, Info, Deduced, TDF_None, /*PartialOrdering=*/true, /*RefParamComparisons=*/0); -- 2.40.0