[clang] [clang-tools-extra] [clang] Implement CWG2398 provisional TTP matching to class templates (PR #94981)
Matheus Izvekov via cfe-commits
cfe-commits at lists.llvm.org
Mon Jul 29 20:50:22 PDT 2024
https://github.com/mizvekov updated https://github.com/llvm/llvm-project/pull/94981
>From 89e5db41f3d3bc939078b63d43b7181bfc765fd1 Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Wed, 24 Jul 2024 03:59:41 -0300
Subject: [PATCH 1/2] [clang] check deduction consistency when partial ordering
function templates
This makes partial ordering of function templates consistent with
other entities.
Fixes #18291
---
clang/docs/ReleaseNotes.rst | 2 +
clang/include/clang/Sema/Sema.h | 7 +-
clang/lib/AST/ExprConstant.cpp | 1 -
clang/lib/Sema/SemaTemplateDeduction.cpp | 828 ++++++++++++------
clang/lib/Sema/SemaTemplateInstantiate.cpp | 29 +-
.../test/CodeCompletion/variadic-template.cpp | 2 +-
clang/test/Index/complete-call.cpp | 5 +-
clang/test/SemaTemplate/GH18291.cpp | 32 +
clang/test/SemaTemplate/cwg2398.cpp | 14 +
clang/test/SemaTemplate/temp_arg_nontype.cpp | 14 +-
clang/test/SemaTemplate/temp_arg_type.cpp | 7 +-
.../Templight/templight-empty-entries-fix.cpp | 92 +-
12 files changed, 727 insertions(+), 306 deletions(-)
create mode 100644 clang/test/SemaTemplate/GH18291.cpp
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 5dddd8f1c5af5..6098101a73a62 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -153,6 +153,8 @@ Bug Fixes to C++ Support
- Fixed a crash when an expression with a dependent ``__typeof__`` type is used as the operand of a unary operator. (#GH97646)
- Fixed a failed assertion when checking invalid delete operator declaration. (#GH96191)
+- When performing partial ordering of function templates, clang now checks that
+ the deduction was consistent. Fixes (#GH18291).
Bug Fixes to AST Handling
^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 2ec6367eccea0..06a06d7718781 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -13255,6 +13255,10 @@ class Sema final : public SemaBase {
/// \param AllowDeducedTST Whether a DeducedTemplateSpecializationType is
/// acceptable as the top level type of the result.
///
+ /// \param IsIncompleteSubstitution If provided, the pointee will be set
+ /// whenever substitution would perform a replacement with a null or
+ /// non-existent template argument.
+ ///
/// \returns If the instantiation succeeds, the instantiated
/// type. Otherwise, produces diagnostics and returns a NULL type.
TypeSourceInfo *SubstType(TypeSourceInfo *T,
@@ -13264,7 +13268,8 @@ class Sema final : public SemaBase {
QualType SubstType(QualType T,
const MultiLevelTemplateArgumentList &TemplateArgs,
- SourceLocation Loc, DeclarationName Entity);
+ SourceLocation Loc, DeclarationName Entity,
+ bool *IsIncompleteSubstitution = nullptr);
TypeSourceInfo *SubstType(TypeLoc TL,
const MultiLevelTemplateArgumentList &TemplateArgs,
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
index 558e20ed3e423..2512cd575fbdd 100644
--- a/clang/lib/AST/ExprConstant.cpp
+++ b/clang/lib/AST/ExprConstant.cpp
@@ -5346,7 +5346,6 @@ static EvalStmtResult EvaluateStmt(StmtResult &Result, EvalInfo &Info,
const Expr *RetExpr = cast<ReturnStmt>(S)->getRetValue();
FullExpressionRAII Scope(Info);
if (RetExpr && RetExpr->isValueDependent()) {
- EvaluateDependentExpr(RetExpr, Info);
// We know we returned, but we don't know what the value is.
return ESR_Failed;
}
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index b7b857ebf804b..612c23acffcbf 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -137,7 +137,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType Param,
QualType Arg, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering = false, bool DeducedFromArrayBound = false);
+ bool PartialOrdering, bool DeducedFromArrayBound, bool *HasDeducedAnyParam);
enum class PackFold { ParameterToArgument, ArgumentToParameter };
static TemplateDeductionResult
@@ -146,8 +146,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch,
- PackFold PackFold = PackFold::ParameterToArgument);
+ bool NumberOfArgumentsMustMatch, PackFold PackFold,
+ bool *HasDeducedAnyParam);
static void MarkUsedTemplateParameters(ASTContext &Ctx,
const TemplateArgument &TemplateArg,
@@ -395,12 +395,13 @@ checkDeducedTemplateArguments(ASTContext &Context,
/// Deduce the value of the given non-type template parameter
/// as the given deduced template argument. All non-type template parameter
/// deduction is funneled through here.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP,
- const DeducedTemplateArgument &NewDeduced, QualType ValueType,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP,
+ const DeducedTemplateArgument &NewDeduced,
+ QualType ValueType, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
"deducing non-type template argument with wrong depth");
@@ -444,7 +445,7 @@ static TemplateDeductionResult DeduceNonTypeTemplateArgument(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ParamType, ValueType, Info, Deduced,
TDF_SkipNonDependent, /*PartialOrdering=*/false,
- /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound());
+ /*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound(), HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
@@ -453,21 +454,23 @@ static TemplateDeductionResult DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP,
DeducedTemplateArgument(S.Context, Value, ValueType,
DeducedFromArrayBound),
- ValueType, Info, Deduced);
+ ValueType, Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given null pointer template argument type.
-static TemplateDeductionResult DeduceNullPtrTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, QualType NullPtrType,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP,
+ QualType NullPtrType, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
Expr *Value = S.ImpCastExprToType(
new (S.Context) CXXNullPtrLiteralExpr(S.Context.NullPtrTy,
NTTP->getLocation()),
@@ -475,38 +478,41 @@ static TemplateDeductionResult DeduceNullPtrTemplateArgument(
NullPtrType->isMemberPointerType() ? CK_NullToMemberPointer
: CK_NullToPointer)
.get();
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(Value),
- Value->getType(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(),
+ Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given type- or value-dependent expression.
///
/// \returns true if deduction succeeded, false otherwise.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, Expr *Value,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(Value),
- Value->getType(), Info, Deduced);
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP, Expr *Value,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(),
+ Info, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
/// from the given declaration.
///
/// \returns true if deduction succeeded, false otherwise.
-static TemplateDeductionResult DeduceNonTypeTemplateArgument(
- Sema &S, TemplateParameterList *TemplateParams,
- const NonTypeTemplateParmDecl *NTTP, ValueDecl *D, QualType T,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+static TemplateDeductionResult
+DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
+ const NonTypeTemplateParmDecl *NTTP, ValueDecl *D,
+ QualType T, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
TemplateArgument New(D, T);
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DeducedTemplateArgument(New), T, Info,
+ Deduced, HasDeducedAnyParam);
}
/// Create a shallow copy of a given template parameter declaration, with
@@ -569,7 +575,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
TemplateName Param, TemplateName Arg,
TemplateDeductionInfo &Info,
ArrayRef<TemplateArgument> DefaultArguments,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
if (!ParamDecl) {
// The parameter type is dependent and is not a template template parameter,
@@ -626,6 +633,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
}
Deduced[TempParam->getIndex()] = Result;
+ if (HasDeducedAnyParam)
+ *HasDeducedAnyParam = true;
return TemplateDeductionResult::Success;
}
@@ -673,7 +682,8 @@ static TemplateDeductionResult
DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
const QualType P, QualType A,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
QualType UP = P;
if (const auto *IP = P->getAs<InjectedClassNameType>())
UP = IP->getInjectedSpecializationType();
@@ -720,17 +730,19 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
->template_arguments();
// Perform template argument deduction for the template name.
- if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
- AResolved, Deduced);
+ if (auto Result =
+ DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
+ AResolved, Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Perform template argument deduction on each template
// argument. Ignore any missing/extra arguments, since they could be
// filled in by default arguments.
- return DeduceTemplateArguments(S, TemplateParams, PResolved, AResolved,
- Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false);
+ return DeduceTemplateArguments(
+ S, TemplateParams, PResolved, AResolved, Info, Deduced,
+ /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
+ HasDeducedAnyParam);
}
// If the argument type is a class template specialization, we
@@ -751,16 +763,18 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
*NNS, false, TemplateName(SA->getSpecializedTemplate()));
// Perform template argument deduction for the template name.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
- SA->getTemplateArgs().asArray(), Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
+ SA->getTemplateArgs().asArray(),
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Perform template argument deduction for the template arguments.
return DeduceTemplateArguments(S, TemplateParams, PResolved,
SA->getTemplateArgs().asArray(), Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/true);
+ /*NumberOfArgumentsMustMatch=*/true,
+ PackFold::ParameterToArgument,
+ HasDeducedAnyParam);
}
static bool IsPossiblyOpaquelyQualifiedTypeInternal(const Type *T) {
@@ -834,12 +848,16 @@ namespace {
class PackDeductionScope {
public:
/// Prepare to deduce the packs named within Pattern.
+ /// \param FinishingDeduction Don't attempt to deduce the pack. Useful when
+ /// just checking a previous deduction of the pack.
PackDeductionScope(Sema &S, TemplateParameterList *TemplateParams,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
TemplateDeductionInfo &Info, TemplateArgument Pattern,
- bool DeducePackIfNotAlreadyDeduced = false)
+ bool DeducePackIfNotAlreadyDeduced = false,
+ bool FinishingDeduction = false)
: S(S), TemplateParams(TemplateParams), Deduced(Deduced), Info(Info),
- DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced){
+ DeducePackIfNotAlreadyDeduced(DeducePackIfNotAlreadyDeduced),
+ FinishingDeduction(FinishingDeduction) {
unsigned NumNamedPacks = addPacks(Pattern);
finishConstruction(NumNamedPacks);
}
@@ -859,8 +877,10 @@ class PackDeductionScope {
// by this pack expansion, then clear out the deduction.
DeducedFromEarlierParameter = !Deduced[Index].isNull();
DeducedPack Pack(Index);
- Pack.Saved = Deduced[Index];
- Deduced[Index] = TemplateArgument();
+ if (!FinishingDeduction) {
+ Pack.Saved = Deduced[Index];
+ Deduced[Index] = TemplateArgument();
+ }
// FIXME: What if we encounter multiple packs with different numbers of
// pre-expanded expansions? (This should already have been diagnosed
@@ -974,7 +994,7 @@ class PackDeductionScope {
// FIXME: If we could represent a "depth i, index j, pack elem k"
// parameter, we could substitute the partially-substituted pack
// everywhere and avoid this.
- if (!IsPartiallyExpanded)
+ if (!FinishingDeduction && !IsPartiallyExpanded)
Deduced[Pack.Index] = Pack.New[PackElements];
}
}
@@ -1024,18 +1044,20 @@ class PackDeductionScope {
// 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 (!Pack.New.empty() || !DeducedArg.isNull()) {
- while (Pack.New.size() < PackElements)
- Pack.New.push_back(DeducedTemplateArgument());
- if (Pack.New.size() == PackElements)
- Pack.New.push_back(DeducedArg);
- else
- Pack.New[PackElements] = DeducedArg;
- DeducedArg = Pack.New.size() > PackElements + 1
- ? Pack.New[PackElements + 1]
- : DeducedTemplateArgument();
+ if (!FinishingDeduction) {
+ for (auto &Pack : Packs) {
+ DeducedTemplateArgument &DeducedArg = Deduced[Pack.Index];
+ if (!Pack.New.empty() || !DeducedArg.isNull()) {
+ while (Pack.New.size() < PackElements)
+ Pack.New.push_back(DeducedTemplateArgument());
+ if (Pack.New.size() == PackElements)
+ Pack.New.push_back(DeducedArg);
+ else
+ Pack.New[PackElements] = DeducedArg;
+ DeducedArg = Pack.New.size() > PackElements + 1
+ ? Pack.New[PackElements + 1]
+ : DeducedTemplateArgument();
+ }
}
}
++PackElements;
@@ -1045,11 +1067,14 @@ class PackDeductionScope {
/// producing the argument packs and checking for consistency with prior
/// deductions.
TemplateDeductionResult finish() {
+ if (FinishingDeduction)
+ return TemplateDeductionResult::Success;
// 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;
+ if (!FinishingDeduction)
+ Deduced[Pack.Index] = Pack.Saved;
// Always make sure the size of this pack is correct, even if we didn't
// deduce any values for it.
@@ -1149,6 +1174,7 @@ class PackDeductionScope {
bool IsPartiallyExpanded = false;
bool DeducePackIfNotAlreadyDeduced = false;
bool DeducedFromEarlierParameter = false;
+ bool FinishingDeduction = false;
/// The number of expansions, if we have a fully-expanded pack in this scope.
std::optional<unsigned> FixedNumExpansions;
@@ -1157,43 +1183,13 @@ class PackDeductionScope {
} // namespace
-/// Deduce the template arguments by comparing the list of parameter
-/// types to the list of argument types, as in the parameter-type-lists of
-/// function types (C++ [temp.deduct.type]p10).
-///
-/// \param S The semantic analysis object within which we are deducing
-///
-/// \param TemplateParams The template parameters that we are deducing
-///
-/// \param Params The list of parameter types
-///
-/// \param NumParams The number of types in \c Params
-///
-/// \param Args The list of argument types
-///
-/// \param NumArgs The number of types in \c Args
-///
-/// \param Info information about the template argument deduction itself
-///
-/// \param Deduced the deduced template arguments
-///
-/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
-/// how template argument deduction is performed.
-///
-/// \param PartialOrdering If true, we are performing template argument
-/// deduction for during partial ordering for a call
-/// (C++0x [temp.deduct.partial]).
-///
-/// \returns the result of template argument deduction so far. Note that a
-/// "success" result means that template argument deduction has not yet failed,
-/// but it may still fail, later, for other reasons.
-static TemplateDeductionResult
-DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
- const QualType *Params, unsigned NumParams,
- const QualType *Args, unsigned NumArgs,
- TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- unsigned TDF, bool PartialOrdering = false) {
+template <class T>
+static TemplateDeductionResult DeduceForEachType(
+ Sema &S, TemplateParameterList *TemplateParams, const QualType *Params,
+ unsigned NumParams, const QualType *Args, unsigned NumArgs,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced, bool PartialOrdering,
+ bool FinishingDeduction, T &&DeductFunc) {
// C++0x [temp.deduct.type]p10:
// Similarly, if P has a form that contains (T), then each parameter type
// Pi of the respective parameter-type- list of P is compared with the
@@ -1219,11 +1215,11 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
return TemplateDeductionResult::MiscellaneousDeductionFailure;
}
- if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, Params[ParamIdx].getUnqualifiedType(),
- Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
- PartialOrdering,
- /*DeducedFromArrayBound=*/false);
+ if (TemplateDeductionResult Result =
+ DeductFunc(S, TemplateParams, ParamIdx, ArgIdx,
+ Params[ParamIdx].getUnqualifiedType(),
+ Args[ArgIdx].getUnqualifiedType(), Info, Deduced,
+ PartialOrdering);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1239,20 +1235,21 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
// template parameter packs expanded by the function parameter pack.
QualType Pattern = Expansion->getPattern();
- PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
+ PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern,
+ /*DeducePackIfNotAlreadyDeduced=*/false,
+ FinishingDeduction);
// A pack scope with fixed arity is not really a pack any more, so is not
// a non-deduced context.
if (ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
// Deduce template arguments from the pattern.
- if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, Pattern.getUnqualifiedType(),
- Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
- PartialOrdering, /*DeducedFromArrayBound=*/false);
+ if (TemplateDeductionResult Result = DeductFunc(
+ S, TemplateParams, ParamIdx, ArgIdx,
+ Pattern.getUnqualifiedType(), Args[ArgIdx].getUnqualifiedType(),
+ Info, Deduced, PartialOrdering);
Result != TemplateDeductionResult::Success)
return Result;
-
PackScope.nextPackElement();
}
} else {
@@ -1305,6 +1302,62 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
return TemplateDeductionResult::Success;
}
+/// Deduce the template arguments by comparing the list of parameter
+/// types to the list of argument types, as in the parameter-type-lists of
+/// function types (C++ [temp.deduct.type]p10).
+///
+/// \param S The semantic analysis object within which we are deducing
+///
+/// \param TemplateParams The template parameters that we are deducing
+///
+/// \param Params The list of parameter types
+///
+/// \param NumParams The number of types in \c Params
+///
+/// \param Args The list of argument types
+///
+/// \param NumArgs The number of types in \c Args
+///
+/// \param Info information about the template argument deduction itself
+///
+/// \param Deduced the deduced template arguments
+///
+/// \param TDF bitwise OR of the TemplateDeductionFlags bits that describe
+/// how template argument deduction is performed.
+///
+/// \param PartialOrdering If true, we are performing template argument
+/// deduction for during partial ordering for a call
+/// (C++0x [temp.deduct.partial]).
+///
+/// \returns the result of template argument deduction so far. Note that a
+/// "success" result means that template argument deduction has not yet failed,
+/// but it may still fail, later, for other reasons.
+static TemplateDeductionResult DeduceTemplateArguments(
+ Sema &S, TemplateParameterList *TemplateParams, const QualType *Params,
+ unsigned NumParams, const QualType *Args, unsigned NumArgs,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
+ bool PartialOrdering, bool *HasDeducedAnyParam,
+ llvm::SmallBitVector *HasDeducedParam) {
+ return ::DeduceForEachType(
+ S, TemplateParams, Params, NumParams, Args, NumArgs, Info, Deduced,
+ PartialOrdering, /*FinishingDeduction=*/false,
+ [&](Sema &S, TemplateParameterList *TemplateParams, int ParamIdx,
+ int ArgIdx, QualType P, QualType A, TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool PartialOrdering) {
+ bool HasDeducedAnyParamCopy = false;
+ TemplateDeductionResult TDR = DeduceTemplateArgumentsByTypeMatch(
+ S, TemplateParams, P, A, Info, Deduced, TDF, PartialOrdering,
+ /*DeducedFromArrayBound=*/false, &HasDeducedAnyParamCopy);
+ if (HasDeducedAnyParam && HasDeducedAnyParamCopy)
+ *HasDeducedAnyParam = true;
+ if (HasDeducedParam && HasDeducedAnyParamCopy)
+ (*HasDeducedParam)[ParamIdx] = true;
+ return TDR;
+ });
+}
+
/// Determine whether the parameter has qualifiers that the argument
/// lacks. Put another way, determine whether there is no way to add
/// a deduced set of qualifiers to the ParamType that would result in
@@ -1405,7 +1458,8 @@ static TemplateDeductionResult
DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
TemplateParameterList *TemplateParams, QualType P,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
// C++14 [temp.deduct.call] p4b3:
// If P is a class and P has the form simple-template-id, then the
// transformed A can be a derived class of the deduced A. Likewise if
@@ -1430,7 +1484,7 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
// We iterate over this later, so we have to use MapVector to ensure
// determinism.
llvm::MapVector<const CXXRecordDecl *,
- SmallVector<DeducedTemplateArgument, 8>>
+ std::tuple<SmallVector<DeducedTemplateArgument, 8>, bool>>
Matches;
auto AddBases = [&Visited, &ToVisit](const CXXRecordDecl *RD) {
@@ -1453,14 +1507,16 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
SmallVector<DeducedTemplateArgument, 8> DeducedCopy(Deduced.begin(),
Deduced.end());
TemplateDeductionInfo BaseInfo(TemplateDeductionInfo::ForBase, Info);
- TemplateDeductionResult BaseResult = DeduceTemplateSpecArguments(
- S, TemplateParams, P, NextT, BaseInfo, DeducedCopy);
+ bool HasDeducedAnyParamCopy = false;
+ TemplateDeductionResult BaseResult =
+ DeduceTemplateSpecArguments(S, TemplateParams, P, NextT, BaseInfo,
+ DeducedCopy, &HasDeducedAnyParamCopy);
// If this was a successful deduction, add it to the list of matches,
// otherwise we need to continue searching its bases.
const CXXRecordDecl *RD = ::getCanonicalRD(NextT);
if (BaseResult == TemplateDeductionResult::Success)
- Matches.insert({RD, DeducedCopy});
+ Matches.insert({RD, {DeducedCopy, HasDeducedAnyParamCopy}});
else
AddBases(RD);
}
@@ -1493,7 +1549,10 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
if (Matches.size() > 1)
return TemplateDeductionResult::MiscellaneousDeductionFailure;
- std::swap(Matches.front().second, Deduced);
+ std::swap(std::get<0>(Matches.front().second), Deduced);
+ if (bool HasDeducedAnyParamCopy = std::get<1>(Matches.front().second);
+ HasDeducedAnyParamCopy && HasDeducedAnyParam)
+ *HasDeducedAnyParam = HasDeducedAnyParamCopy;
return TemplateDeductionResult::Success;
}
@@ -1525,7 +1584,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType P, QualType A,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering, bool DeducedFromArrayBound) {
+ bool PartialOrdering, bool DeducedFromArrayBound,
+ bool *HasDeducedAnyParam) {
// If the argument type is a pack expansion, look at its pattern.
// This isn't explicitly called out
@@ -1707,6 +1767,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
}
Deduced[Index] = Result;
+ if (HasDeducedAnyParam)
+ *HasDeducedAnyParam = true;
return TemplateDeductionResult::Success;
}
@@ -1805,7 +1867,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// _Atomic T [extension]
@@ -1815,7 +1878,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T *
@@ -1831,7 +1895,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, P->castAs<PointerType>()->getPointeeType(),
PointeeType, Info, Deduced,
- TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass));
+ TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass),
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
// T &
@@ -1843,7 +1909,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T && [C++0x]
@@ -1855,7 +1922,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T [] (implied, but not stated explicitly)
@@ -1869,7 +1937,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info,
- Deduced, TDF & TDF_IgnoreQualifiers);
+ Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T [integer-constant]
@@ -1882,7 +1951,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
- Deduced, TDF & TDF_IgnoreQualifiers);
+ Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// type [i]
@@ -1896,7 +1966,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
assert(DAP);
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, DAP->getElementType(), AA->getElementType(),
- Info, Deduced, TDF & TDF_IgnoreQualifiers);
+ Info, Deduced, TDF & TDF_IgnoreQualifiers,
+ /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1914,12 +1986,13 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
llvm::APSInt Size(CAA->getSize());
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Size, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
}
if (const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
if (DAA->getSizeExpr())
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DAA->getSizeExpr(), Info,
+ Deduced, HasDeducedAnyParam);
// Incomplete type does not match a dependently-sized array type
return TemplateDeductionResult::NonDeducedMismatch;
@@ -1944,7 +2017,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
Info, Deduced, 0,
/*PartialOrdering=*/false,
- /*DeducedFromArrayBound=*/false);
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1952,7 +2025,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArguments(
S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
- TDF & TDF_TopLevelParameterTypeList, PartialOrdering);
+ TDF & TDF_TopLevelParameterTypeList, PartialOrdering,
+ HasDeducedAnyParam, /*HasDeducedParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1980,12 +2054,14 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// FIXME: Should we?
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
- /*DeducedFromArrayBound=*/true, Info, Deduced);
+ /*DeducedFromArrayBound=*/true, Info, Deduced,
+ HasDeducedAnyParam);
case CT_Dependent:
if (Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ ArgNoexceptExpr, Info, Deduced,
+ HasDeducedAnyParam);
// Can't deduce anything from throw(T...).
break;
}
@@ -2012,13 +2088,13 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// arguments from the template-id.
if (!(TDF & TDF_DerivedClass) || !A->isRecordType())
return DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
Deduced.end());
- auto Result =
- DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info, Deduced);
+ auto Result = DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
+ Deduced, HasDeducedAnyParam);
if (Result == TemplateDeductionResult::Success)
return Result;
@@ -2035,8 +2111,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Deduced = DeducedOrig;
// Check bases according to C++14 [temp.deduct.call] p4b3:
- auto BaseResult = DeduceTemplateBases(S, getCanonicalRD(A),
- TemplateParams, P, Info, Deduced);
+ auto BaseResult =
+ DeduceTemplateBases(S, getCanonicalRD(A), TemplateParams, P, Info,
+ Deduced, HasDeducedAnyParam);
return BaseResult != TemplateDeductionResult::Invalid ? BaseResult
: Result;
}
@@ -2067,12 +2144,16 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, PPT, APT, Info, Deduced, SubTDF);
+ S, TemplateParams, PPT, APT, Info, Deduced, SubTDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, QualType(MPP->getClass(), 0),
- QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
+ QualType(MPA->getClass(), 0), Info, Deduced, SubTDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
// (clang extension)
@@ -2087,7 +2168,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
- Deduced, 0);
+ Deduced, 0, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// (clang extension)
@@ -2112,7 +2194,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
- TDF);
+ TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
case Type::DependentVector: {
@@ -2122,7 +2205,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2139,14 +2223,15 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// we can provide one if necessary.
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.UnsignedIntTy, true,
- Info, Deduced);
+ Info, Deduced, HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2157,7 +2242,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::Success;
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced);
+ VA->getSizeExpr(), Info, Deduced,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2173,7 +2259,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2190,14 +2277,15 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// we can provide one if necessary.
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.IntTy, true, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2208,7 +2296,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::Success;
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced);
+ VA->getSizeExpr(), Info, Deduced,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2232,7 +2321,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
- Deduced, TDF);
+ Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
case Type::DependentSizedMatrix: {
@@ -2244,13 +2334,14 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Check the element type of the matrixes.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Try to deduce a matrix dimension.
auto DeduceMatrixArg =
- [&S, &Info, &Deduced, &TemplateParams](
+ [&S, &Info, &Deduced, &TemplateParams, &HasDeducedAnyParam](
Expr *ParamExpr, const MatrixType *A,
unsigned (ConstantMatrixType::*GetArgDimension)() const,
Expr *(DependentSizedMatrixType::*GetArgDimensionExpr)() const) {
@@ -2287,12 +2378,12 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
ArgConst = (ACM->*GetArgDimension)();
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, ArgConst, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
}
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- (ADM->*GetArgDimensionExpr)(),
- Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, (ADM->*GetArgDimensionExpr)(), Info,
+ Deduced, HasDeducedAnyParam);
};
if (auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
@@ -2316,7 +2407,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the pointer type.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
- Info, Deduced, TDF);
+ Info, Deduced, TDF, /*PartialOrdering=*/false,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2326,8 +2418,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ ASA->getAddrSpaceExpr(), Info,
+ Deduced, HasDeducedAnyParam);
}
if (isTargetAddressSpace(A.getAddressSpace())) {
@@ -2338,7 +2431,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the pointer types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(),
- S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF);
+ S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2348,9 +2443,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- ArgAddressSpace, S.Context.IntTy,
- true, Info, Deduced);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true,
+ Info, Deduced, HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2372,7 +2467,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
S.Context.IntTy, true, Info,
- Deduced);
+ Deduced, HasDeducedAnyParam);
}
if (const auto *IA = A->getAs<DependentBitIntType>()) {
@@ -2402,7 +2497,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
const PackIndexingType *PIT = P->getAs<PackIndexingType>();
if (PIT->hasSelectedType()) {
return DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF);
+ S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::IncompletePack;
}
@@ -2415,7 +2512,8 @@ static TemplateDeductionResult
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
const TemplateArgument &P, TemplateArgument A,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
// If the template argument is a pack expansion, perform template argument
// deduction against the pattern of that expansion. This only occurs during
// partial ordering.
@@ -2429,16 +2527,18 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
case TemplateArgument::Type:
if (A.getKind() == TemplateArgument::Type)
return DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0);
+ S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
case TemplateArgument::Template:
if (A.getKind() == TemplateArgument::Template)
- return DeduceTemplateArguments(S, TemplateParams, P.getAsTemplate(),
- A.getAsTemplate(), Info,
- /*DefaultArguments=*/{}, Deduced);
+ return DeduceTemplateArguments(
+ S, TemplateParams, P.getAsTemplate(), A.getAsTemplate(), Info,
+ /*DefaultArguments=*/{}, Deduced, HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2489,18 +2589,20 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
case TemplateArgument::Integral:
case TemplateArgument::Expression:
case TemplateArgument::StructuralValue:
- return DeduceNonTypeTemplateArgument(
- S, TemplateParams, NTTP, DeducedTemplateArgument(A),
- A.getNonTypeTemplateArgumentType(), Info, Deduced);
+ return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+ DeducedTemplateArgument(A),
+ A.getNonTypeTemplateArgumentType(),
+ Info, Deduced, HasDeducedAnyParam);
case TemplateArgument::NullPtr:
return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
- A.getNullPtrType(), Info, Deduced);
+ A.getNullPtrType(), Info, Deduced,
+ HasDeducedAnyParam);
case TemplateArgument::Declaration:
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, A.getAsDecl(), A.getParamTypeForDecl(),
- Info, Deduced);
+ Info, Deduced, HasDeducedAnyParam);
case TemplateArgument::Null:
case TemplateArgument::Type:
@@ -2572,7 +2674,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch, PackFold PackFold) {
+ bool NumberOfArgumentsMustMatch, PackFold PackFold,
+ bool *HasDeducedAnyParam) {
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Ps, As);
// C++0x [temp.deduct.type]p9:
@@ -2608,8 +2711,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
TemplateArgument Pi = P, Ai = As[ArgIdx];
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Pi, Ai);
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2640,8 +2743,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Pi, Ai);
// Deduce template arguments from the pattern.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info, Deduced);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2663,8 +2766,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
ArrayRef<TemplateArgument> As, sema::TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool NumberOfArgumentsMustMatch) {
- return ::DeduceTemplateArguments(*this, TemplateParams, Ps, As, Info, Deduced,
- NumberOfArgumentsMustMatch);
+ return ::DeduceTemplateArguments(
+ *this, TemplateParams, Ps, As, Info, Deduced, NumberOfArgumentsMustMatch,
+ PackFold::ParameterToArgument, /*HasDeducedAnyParam=*/nullptr);
}
/// Determine whether two template arguments are the same.
@@ -2914,6 +3018,10 @@ static bool ConvertDeducedTemplateArgument(
// FIXME: This should not be a template, but
// ClassTemplatePartialSpecializationDecl sadly does not derive from
// TemplateDecl.
+/// \param IsIncomplete When used, we only consider template parameters that
+/// were deduced, disregarding any default arguments. After the function
+/// finishes, the object pointed at will contain a value indicating if the
+/// conversion was actually incomplete.
template <typename TemplateDeclT>
static TemplateDeductionResult ConvertDeducedTemplateArguments(
Sema &S, TemplateDeclT *Template, bool IsDeduced,
@@ -2922,7 +3030,7 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
SmallVectorImpl<TemplateArgument> &SugaredBuilder,
SmallVectorImpl<TemplateArgument> &CanonicalBuilder,
LocalInstantiationScope *CurrentInstantiationScope = nullptr,
- unsigned NumAlreadyConverted = 0, bool PartialOverloading = false) {
+ unsigned NumAlreadyConverted = 0, bool *IsIncomplete = nullptr) {
TemplateParameterList *TemplateParams = Template->getTemplateParameters();
for (unsigned I = 0, N = TemplateParams->size(); I != N; ++I) {
@@ -2978,6 +3086,17 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
continue;
}
+ // [temp.deduct.partial]p12 - When partial ordering, it's ok for template
+ // parameters to remain not deduced. As a provisional fix for a core issue
+ // that does not exist yet, only consider template parameters that were
+ // deduced, disregarding any default arguments.
+ if (IsIncomplete) {
+ *IsIncomplete = true;
+ SugaredBuilder.push_back({});
+ CanonicalBuilder.push_back({});
+ continue;
+ }
+
// Substitute into the default template argument, if available.
bool HasDefaultArg = false;
TemplateDecl *TD = dyn_cast<TemplateDecl>(Template);
@@ -3012,7 +3131,6 @@ static TemplateDeductionResult ConvertDeducedTemplateArguments(
const_cast<NamedDecl *>(TemplateParams->getParam(I)));
Info.reset(TemplateArgumentList::CreateCopy(S.Context, SugaredBuilder),
TemplateArgumentList::CreateCopy(S.Context, CanonicalBuilder));
- if (PartialOverloading) break;
return HasDefaultArg ? TemplateDeductionResult::SubstitutionFailure
: TemplateDeductionResult::Incomplete;
@@ -3227,7 +3345,7 @@ static TemplateDeductionResult FinishTemplateArgumentDeduction(
S, Template, /*IsDeduced*/ PartialOrdering, Deduced, Info,
SugaredBuilder, CanonicalBuilder,
/*CurrentInstantiationScope=*/nullptr,
- /*NumAlreadyConverted=*/0U, /*PartialOverloading=*/false);
+ /*NumAlreadyConverted=*/0U);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3321,7 +3439,8 @@ DeduceTemplateArguments(Sema &S, T *Partial,
if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
S, Partial->getTemplateParameters(),
Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false);
+ /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3831,11 +3950,12 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
// C++ [temp.deduct.type]p2:
// [...] or if any template argument remains neither deduced nor
// explicitly specified, template argument deduction fails.
+ bool IsIncomplete = false;
SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
if (auto Result = ConvertDeducedTemplateArguments(
*this, FunctionTemplate, /*IsDeduced*/ true, Deduced, Info,
SugaredBuilder, CanonicalBuilder, CurrentInstantiationScope,
- NumExplicitlySpecified, PartialOverloading);
+ NumExplicitlySpecified, PartialOverloading ? &IsIncomplete : nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3914,9 +4034,7 @@ TemplateDeductionResult Sema::FinishTemplateArgumentDeduction(
// ([temp.constr.decl]), those constraints are checked for satisfaction
// ([temp.constr.constr]). If the constraints are not satisfied, type
// deduction fails.
- if (!PartialOverloading ||
- (CanonicalBuilder.size() ==
- FunctionTemplate->getTemplateParameters()->size())) {
+ if (!IsIncomplete) {
if (CheckInstantiatedFunctionTemplateConstraints(
Info.getLocation(), Specialization, CanonicalBuilder,
Info.AssociatedConstraintsSatisfaction))
@@ -4126,7 +4244,9 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
Deduced(TemplateParams->size());
TemplateDeductionInfo Info(Ovl->getNameLoc());
TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF);
+ S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
if (Result != TemplateDeductionResult::Success)
continue;
if (!Match.isNull())
@@ -4312,7 +4432,8 @@ static TemplateDeductionResult DeduceFromInitializerList(
llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits());
if (auto Result = DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, llvm::APSInt(Size), T,
- /*ArrayBound=*/true, Info, Deduced);
+ /*ArrayBound=*/true, Info, Deduced,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
}
@@ -4355,8 +4476,10 @@ static TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(
if (Arg)
OriginalCallArgs.push_back(
Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType));
- return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
- ArgType, Info, Deduced, TDF);
+ return DeduceTemplateArgumentsByTypeMatch(
+ S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
}
TemplateDeductionResult Sema::DeduceTemplateArguments(
@@ -4680,7 +4803,8 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
// Deduce template arguments from the function type.
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced,
- TDF);
+ TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
}
@@ -4860,7 +4984,9 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
}
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
- *this, TemplateParams, P, A, Info, Deduced, TDF);
+ *this, TemplateParams, P, A, Info, Deduced, TDF,
+ /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -5399,11 +5525,100 @@ static QualType GetImplicitObjectParameterType(ASTContext &Context,
return Context.getLValueReferenceType(RawType);
}
+static TemplateDeductionResult CheckDeductionConsistency(
+ Sema &S, FunctionTemplateDecl *FTD, int ArgIdx, QualType P, QualType A,
+ ArrayRef<TemplateArgument> DeducedArgs, bool CheckConsistency) {
+ MultiLevelTemplateArgumentList MLTAL(FTD, DeducedArgs,
+ /*Final=*/true);
+ if (ArgIdx != -1)
+ if (auto *MD = dyn_cast<CXXMethodDecl>(FTD->getTemplatedDecl());
+ MD && MD->isImplicitObjectMemberFunction())
+ ArgIdx -= 1;
+ Sema::ArgumentPackSubstitutionIndexRAII PackIndex(
+ S, ArgIdx != -1 ? ::getPackIndexForParam(S, FTD, MLTAL, ArgIdx) : -1);
+ bool IsIncompleteSubstitution = false;
+ QualType InstP = S.SubstType(P, MLTAL, FTD->getLocation(), FTD->getDeclName(),
+ &IsIncompleteSubstitution);
+ if (InstP.isNull())
+ return TemplateDeductionResult::SubstitutionFailure;
+ if (!CheckConsistency)
+ return TemplateDeductionResult::Success;
+ if (IsIncompleteSubstitution)
+ return TemplateDeductionResult::Incomplete;
+
+ // [temp.deduct.call]/4 - Check we produced a consistent deduction.
+ // This handles just the cases that can appear when partial ordering.
+ if (auto *PA = dyn_cast<PackExpansionType>(A);
+ PA && !isa<PackExpansionType>(InstP))
+ A = PA->getPattern();
+ if (!S.Context.hasSameType(
+ S.Context.getUnqualifiedArrayType(InstP.getNonReferenceType()),
+ S.Context.getUnqualifiedArrayType(A.getNonReferenceType())))
+ return TemplateDeductionResult::NonDeducedMismatch;
+ return TemplateDeductionResult::Success;
+}
+
+template <class T>
+static TemplateDeductionResult FinishTemplateArgumentDeduction(
+ Sema &S, FunctionTemplateDecl *FTD,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ TemplateDeductionInfo &Info, T &&CheckDeductionConsistency) {
+ // Unevaluated SFINAE context.
+ EnterExpressionEvaluationContext Unevaluated(
+ S, Sema::ExpressionEvaluationContext::Unevaluated);
+ Sema::SFINAETrap Trap(S);
+
+ Sema::ContextRAII SavedContext(S, getAsDeclContextOrEnclosing(FTD));
+
+ // C++ [temp.deduct.type]p2:
+ // [...] or if any template argument remains neither deduced nor
+ // explicitly specified, template argument deduction fails.
+ bool IsIncomplete = false;
+ SmallVector<TemplateArgument, 4> SugaredBuilder, CanonicalBuilder;
+ if (auto Result = ConvertDeducedTemplateArguments(
+ S, FTD, /*IsDeduced=*/true, Deduced, Info, SugaredBuilder,
+ CanonicalBuilder, /*CurrentInstantiationScope=*/nullptr,
+ /*NumAlreadyConverted=*/0, &IsIncomplete);
+ Result != TemplateDeductionResult::Success)
+ return Result;
+
+ // Form the template argument list from the deduced template arguments.
+ TemplateArgumentList *SugaredDeducedArgumentList =
+ TemplateArgumentList::CreateCopy(S.Context, SugaredBuilder);
+ TemplateArgumentList *CanonicalDeducedArgumentList =
+ TemplateArgumentList::CreateCopy(S.Context, CanonicalBuilder);
+
+ Info.reset(SugaredDeducedArgumentList, CanonicalDeducedArgumentList);
+
+ // Substitute the deduced template arguments into the argument
+ // and verify that the instantiated argument is both valid
+ // and equivalent to the parameter.
+ LocalInstantiationScope InstScope(S);
+
+ if (auto TDR = CheckDeductionConsistency(S, FTD, SugaredBuilder);
+ TDR != TemplateDeductionResult::Success)
+ return TDR;
+
+ // C++20 [temp.deduct]p5 - Only check constraints when all parameters have
+ // been deduced.
+ if (!IsIncomplete) {
+ if (auto Result = CheckDeducedArgumentConstraints(S, FTD, SugaredBuilder,
+ CanonicalBuilder, Info);
+ Result != TemplateDeductionResult::Success)
+ return Result;
+ }
+
+ if (Trap.hasErrorOccurred())
+ return TemplateDeductionResult::SubstitutionFailure;
+
+ return TemplateDeductionResult::Success;
+}
+
/// Determine whether the function template \p FT1 is at least as
/// specialized as \p FT2.
static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
- const FunctionTemplateDecl *FT1,
- const FunctionTemplateDecl *FT2,
+ FunctionTemplateDecl *FT1,
+ FunctionTemplateDecl *FT2,
TemplatePartialOrderingContext TPOC,
bool Reversed,
const SmallVector<QualType> &Args1,
@@ -5425,34 +5640,139 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
// the partial ordering is done:
TemplateDeductionInfo Info(Loc);
switch (TPOC) {
- case TPOC_Call:
- if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
- Args1.data(), Args1.size(), Info, Deduced,
- TDF_None, /*PartialOrdering=*/true) !=
- TemplateDeductionResult::Success)
+ case TPOC_Call: {
+ llvm::SmallBitVector HasDeducedParam(Args2.size());
+ if (DeduceTemplateArguments(
+ S, TemplateParams, Args2.data(), Args2.size(), Args1.data(),
+ Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true,
+ /*HasDeducedAnyParam=*/nullptr,
+ &HasDeducedParam) != TemplateDeductionResult::Success)
return false;
- break;
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
- case TPOC_Conversion:
+ bool AtLeastAsSpecialized = true;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ return ::DeduceForEachType(
+ S, TemplateParams, Args2.data(), Args2.size(), Args1.data(),
+ Args1.size(), Info, Deduced,
+ /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ [&](Sema &S, TemplateParameterList *, int ParamIdx,
+ int ArgIdx, QualType P, QualType A,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool) {
+ // As a provisional fix for a core issue that does not
+ // exist yet, only check the consistency of parameters
+ // which participated in deduction. We still try to
+ // substitute them though.
+ return ::CheckDeductionConsistency(
+ S, FTD, ArgIdx, P, A, DeducedArgs,
+ HasDeducedParam[ParamIdx]);
+ });
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
+
+ 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->getReturnType(), Proto1->getReturnType(),
Info, Deduced, TDF_None,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
- break;
- case TPOC_Other:
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
+
+ bool AtLeastAsSpecialized;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ return ::CheckDeductionConsistency(
+ S, FTD, /*ArgIdx=*/-1, Proto2->getReturnType(),
+ Proto1->getReturnType(), DeducedArgs,
+ /*CheckConsistency=*/true);
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
+
+ case TPOC_Other: {
// - In other contexts (14.6.6.2) the function template's function type
// is used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced,
TDF_AllowCompatibleFunctionType,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
- break;
+
+ SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
+ Deduced.end());
+ Sema::InstantiatingTemplate Inst(
+ S, Info.getLocation(), FT2, DeducedArgs,
+ Sema::CodeSynthesisContext::DeducedTemplateArgumentSubstitution, Info);
+ if (Inst.isInvalid())
+ return false;
+
+ bool AtLeastAsSpecialized;
+ S.runWithSufficientStackSpace(Info.getLocation(), [&] {
+ AtLeastAsSpecialized =
+ ::FinishTemplateArgumentDeduction(
+ S, FT2, Deduced, Info,
+ [&](Sema &S, FunctionTemplateDecl *FTD,
+ ArrayRef<TemplateArgument> DeducedArgs) {
+ if (auto TDR = ::CheckDeductionConsistency(
+ S, FTD, /*ArgIdx=*/-1, Proto2->getReturnType(),
+ Proto1->getReturnType(), DeducedArgs,
+ /*CheckConsistency=*/true);
+ TDR != TemplateDeductionResult::Success)
+ return TDR;
+ return ::DeduceForEachType(
+ S, TemplateParams, Proto2->getParamTypes().data(),
+ Proto2->getParamTypes().size(),
+ Proto1->getParamTypes().data(),
+ Proto1->getParamTypes().size(), Info, Deduced,
+ /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ [&](Sema &S, TemplateParameterList *, int ParamIdx,
+ int ArgIdx, QualType P, QualType A,
+ TemplateDeductionInfo &Info,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool) {
+ return ::CheckDeductionConsistency(
+ S, FTD, ArgIdx, P, A, DeducedArgs,
+ /*CheckConsistency=*/true);
+ });
+ }) == TemplateDeductionResult::Success;
+ });
+ if (!AtLeastAsSpecialized)
+ return false;
+ } break;
}
// C++0x [temp.deduct.partial]p11:
@@ -5466,10 +5786,6 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
if (Deduced[ArgIdx].isNull())
break;
- // FIXME: We fail to implement [temp.deduct.type]p1 along this path. We need
- // to substitute the deduced arguments back into the template and check that
- // we get the right type.
-
if (ArgIdx == NumArgs) {
// All template arguments were deduced. FT1 is at least as specialized
// as FT2.
@@ -5558,38 +5874,50 @@ FunctionTemplateDecl *Sema::getMoreSpecializedTemplate(
// "that is a member function with no expicit object argument".
// Otherwise the ordering rules for methods with expicit objet arguments
// against anything else make no sense.
- ShouldConvert1 = Method1 && !Method1->isExplicitObjectMemberFunction();
- ShouldConvert2 = Method2 && !Method2->isExplicitObjectMemberFunction();
- if (ShouldConvert1) {
- bool IsRValRef2 =
- ShouldConvert2
- ? Method2->getRefQualifier() == RQ_RValue
- : Proto2->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method1 against first parameter from Method2.
- Obj1Ty = GetImplicitObjectParameterType(this->Context, Method1, RawObj1Ty,
- IsRValRef2);
- Args1.push_back(Obj1Ty);
- }
- if (ShouldConvert2) {
- bool IsRValRef1 =
- ShouldConvert1
- ? Method1->getRefQualifier() == RQ_RValue
- : Proto1->param_type_begin()[0]->isRValueReferenceType();
- // Compare 'this' from Method2 against first parameter from Method1.
- Obj2Ty = GetImplicitObjectParameterType(this->Context, Method2, RawObj2Ty,
- IsRValRef1);
- Args2.push_back(Obj2Ty);
- }
+
+ bool NonStaticMethod1 = Method1 && !Method1->isStatic(),
+ NonStaticMethod2 = Method2 && !Method2->isStatic();
+
+ auto Params1Begin = Proto1->param_type_begin(),
+ Params2Begin = Proto2->param_type_begin();
+
size_t NumComparedArguments = NumCallArguments1;
- // Either added an argument above or the prototype includes an explicit
- // object argument we need to count
- if (Method1)
- ++NumComparedArguments;
- Args1.insert(Args1.end(), Proto1->param_type_begin(),
- Proto1->param_type_end());
- Args2.insert(Args2.end(), Proto2->param_type_begin(),
- Proto2->param_type_end());
+ if ((NonStaticMethod1 && NonStaticMethod2) || FD1->isOverloadedOperator()) {
+ ShouldConvert1 =
+ NonStaticMethod1 && !Method1->hasCXXExplicitFunctionObjectParameter();
+ ShouldConvert2 =
+ NonStaticMethod2 && !Method2->hasCXXExplicitFunctionObjectParameter();
+ NumComparedArguments += 1;
+
+ if (ShouldConvert1) {
+ bool IsRValRef2 =
+ ShouldConvert2
+ ? Method2->getRefQualifier() == RQ_RValue
+ : Proto2->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method1 against first parameter from Method2.
+ Obj1Ty = GetImplicitObjectParameterType(this->Context, Method1,
+ RawObj1Ty, IsRValRef2);
+ Args1.push_back(Obj1Ty);
+ }
+ if (ShouldConvert2) {
+ bool IsRValRef1 =
+ ShouldConvert1
+ ? Method1->getRefQualifier() == RQ_RValue
+ : Proto1->param_type_begin()[0]->isRValueReferenceType();
+ // Compare 'this' from Method2 against first parameter from Method1.
+ Obj2Ty = GetImplicitObjectParameterType(this->Context, Method2,
+ RawObj2Ty, IsRValRef1);
+ Args2.push_back(Obj2Ty);
+ }
+ } else {
+ if (NonStaticMethod1 && Method1->hasCXXExplicitFunctionObjectParameter())
+ Params1Begin += 1;
+ if (NonStaticMethod2 && Method2->hasCXXExplicitFunctionObjectParameter())
+ Params2Begin += 1;
+ }
+ Args1.insert(Args1.end(), Params1Begin, Proto1->param_type_end());
+ Args2.insert(Args2.end(), Params2Begin, Proto2->param_type_end());
// C++ [temp.func.order]p5:
// The presence of unused ellipsis and default arguments has no effect on
@@ -5884,7 +6212,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
Deduced.resize(P2->getTemplateParameters()->size());
if (DeduceTemplateArgumentsByTypeMatch(
S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None,
- /*PartialOrdering=*/true) != TemplateDeductionResult::Success)
+ /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ /*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
SmallVector<TemplateArgument, 4> DeducedArgs(Deduced.begin(),
@@ -6218,7 +6547,8 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
if (::DeduceTemplateArguments(*this, A, AArgs, PArgs, Info, Deduced,
/*NumberOfArgumentsMustMatch=*/false,
IsDeduced ? PackFold::ArgumentToParameter
- : PackFold::ParameterToArgument) !=
+ : PackFold::ParameterToArgument,
+ /*HasDeducedAnyParam=*/nullptr) !=
TemplateDeductionResult::Success)
return false;
diff --git a/clang/lib/Sema/SemaTemplateInstantiate.cpp b/clang/lib/Sema/SemaTemplateInstantiate.cpp
index 8995d461362d7..71ce6ec0e10b4 100644
--- a/clang/lib/Sema/SemaTemplateInstantiate.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiate.cpp
@@ -1342,6 +1342,9 @@ namespace {
DeclarationName Entity;
// Whether to evaluate the C++20 constraints or simply substitute into them.
bool EvaluateConstraints = true;
+ // Whether Substitution was Incomplete, that is, we tried to substitute in
+ // any template arguments which were null.
+ bool IsIncomplete = false;
public:
typedef TreeTransform<TemplateInstantiator> inherited;
@@ -1372,6 +1375,9 @@ namespace {
/// Returns the name of the entity being instantiated, if any.
DeclarationName getBaseEntity() { return Entity; }
+ /// Returns whether any substitution so far was incomplete.
+ bool getIsIncomplete() const { return IsIncomplete; }
+
/// Sets the "base" location and entity when that
/// information is known based on another transformation.
void setBase(SourceLocation Loc, DeclarationName Entity) {
@@ -1418,6 +1424,8 @@ namespace {
if (TemplateArgs.hasTemplateArgument(Depth, Index)) {
Result = TemplateArgs(Depth, Index);
TemplateArgs.setArgument(Depth, Index, TemplateArgument());
+ } else {
+ IsIncomplete = true;
}
}
@@ -1815,8 +1823,10 @@ Decl *TemplateInstantiator::TransformDecl(SourceLocation Loc, Decl *D) {
// template arguments in a function template, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
- TTP->getPosition()))
+ TTP->getPosition())) {
+ IsIncomplete = true;
return D;
+ }
TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
@@ -1962,8 +1972,10 @@ TemplateName TemplateInstantiator::TransformTemplateName(
// template arguments in a function template, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(TTP->getDepth(),
- TTP->getPosition()))
+ TTP->getPosition())) {
+ IsIncomplete = true;
return Name;
+ }
TemplateArgument Arg = TemplateArgs(TTP->getDepth(), TTP->getPosition());
@@ -2045,8 +2057,10 @@ TemplateInstantiator::TransformTemplateParmRefExpr(DeclRefExpr *E,
// template arguments in a function template, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(NTTP->getDepth(),
- NTTP->getPosition()))
+ NTTP->getPosition())) {
+ IsIncomplete = true;
return E;
+ }
TemplateArgument Arg = TemplateArgs(NTTP->getDepth(), NTTP->getPosition());
@@ -2465,6 +2479,7 @@ TemplateInstantiator::TransformTemplateTypeParmType(TypeLocBuilder &TLB,
// template arguments in a function template class, but there were some
// arguments left unspecified.
if (!TemplateArgs.hasTemplateArgument(T->getDepth(), T->getIndex())) {
+ IsIncomplete = true;
TemplateTypeParmTypeLoc NewTL
= TLB.push<TemplateTypeParmTypeLoc>(TL.getType());
NewTL.setNameLoc(TL.getNameLoc());
@@ -2836,7 +2851,8 @@ TypeSourceInfo *Sema::SubstType(TypeLoc TL,
/// Deprecated form of the above.
QualType Sema::SubstType(QualType T,
const MultiLevelTemplateArgumentList &TemplateArgs,
- SourceLocation Loc, DeclarationName Entity) {
+ SourceLocation Loc, DeclarationName Entity,
+ bool *IsIncompleteSubstitution) {
assert(!CodeSynthesisContexts.empty() &&
"Cannot perform an instantiation without some context on the "
"instantiation stack");
@@ -2847,7 +2863,10 @@ QualType Sema::SubstType(QualType T,
return T;
TemplateInstantiator Instantiator(*this, TemplateArgs, Loc, Entity);
- return Instantiator.TransformType(T);
+ QualType QT = Instantiator.TransformType(T);
+ if (IsIncompleteSubstitution && Instantiator.getIsIncomplete())
+ *IsIncompleteSubstitution = true;
+ return QT;
}
static bool NeedsInstantiationAsFunctionType(TypeSourceInfo *T) {
diff --git a/clang/test/CodeCompletion/variadic-template.cpp b/clang/test/CodeCompletion/variadic-template.cpp
index 31fc55ee154f6..370cf5e8461d6 100644
--- a/clang/test/CodeCompletion/variadic-template.cpp
+++ b/clang/test/CodeCompletion/variadic-template.cpp
@@ -8,7 +8,7 @@ void f() {
// The important thing is that we provide OVERLOAD signature in all those cases.
//
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-5):7 %s -o - | FileCheck --check-prefix=CHECK-1 %s
- // CHECK-1: OVERLOAD: [#void#]fun(<#T x#>, Args args...)
+ // CHECK-1: OVERLOAD: [#void#]fun(<#T x#>)
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-7):10 %s -o - | FileCheck --check-prefix=CHECK-2 %s
// CHECK-2: OVERLOAD: [#void#]fun(int x)
// RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:%(line-9):13 %s -o - | FileCheck --check-prefix=CHECK-3 %s
diff --git a/clang/test/Index/complete-call.cpp b/clang/test/Index/complete-call.cpp
index 95bc8d49b2b90..f86c85a9983c7 100644
--- a/clang/test/Index/complete-call.cpp
+++ b/clang/test/Index/complete-call.cpp
@@ -409,7 +409,8 @@ struct Bar2Template : public BarTemplates {
// CHECK-CC22-NEXT: Objective-C interface
// RUN: c-index-test -code-completion-at=%s:64:10 %s | FileCheck -check-prefix=CHECK-CC23 %s
-// CHECK-CC23: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
+
+// CHECK-CC23: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder T}{RightParen )} (1)
// CHECK-CC23: Completion contexts:
// CHECK-CC23-NEXT: Any type
// CHECK-CC23-NEXT: Any value
@@ -702,7 +703,7 @@ struct Bar2Template : public BarTemplates {
// CHECK-CC46-NEXT: Objective-C interface
// RUN: c-index-test -code-completion-at=%s:84:12 %s | FileCheck -check-prefix=CHECK-CC47 %s
-// CHECK-CC47: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter int}{Comma , }{Placeholder int}{RightParen )} (1)
+// CHECK-CC47: OverloadCandidate:{ResultType void}{Text foo_12}{LeftParen (}{CurrentParameter T}{Comma , }{Placeholder T}{RightParen )} (1)
// CHECK-CC47: Completion contexts:
// CHECK-CC47-NEXT: Any type
// CHECK-CC47-NEXT: Any value
diff --git a/clang/test/SemaTemplate/GH18291.cpp b/clang/test/SemaTemplate/GH18291.cpp
new file mode 100644
index 0000000000000..e77a29c8e2c24
--- /dev/null
+++ b/clang/test/SemaTemplate/GH18291.cpp
@@ -0,0 +1,32 @@
+// RUN: %clang_cc1 -std=c++23 -verify %s
+
+namespace t1 {
+template<bool> struct enable_if { typedef void type; };
+template <class T> class Foo {};
+template <class X> constexpr bool check() { return true; }
+template <class X, class Enable = void> struct Bar {};
+
+template<class X> void func(Bar<X, typename enable_if<check<X>()>::type>) {}
+// expected-note at -1 {{candidate function}}
+
+template<class T> void func(Bar<Foo<T>>) {}
+// expected-note at -1 {{candidate function}}
+
+void g() {
+ func(Bar<Foo<int>>()); // expected-error {{call to 'func' is ambiguous}}
+}
+} // namespace t1
+
+namespace t2 {
+template <bool> struct enable_if;
+template <> struct enable_if<true> {
+ typedef int type;
+};
+struct pair {
+ template <int = 0> pair(int);
+ template <class _U2, enable_if<__is_constructible(int &, _U2)>::type = 0>
+ pair(_U2 &&);
+};
+int test_test_i;
+void test() { pair{test_test_i}; }
+} // namespace t2
diff --git a/clang/test/SemaTemplate/cwg2398.cpp b/clang/test/SemaTemplate/cwg2398.cpp
index 7675d4287cb88..6fe1bd3d4f165 100644
--- a/clang/test/SemaTemplate/cwg2398.cpp
+++ b/clang/test/SemaTemplate/cwg2398.cpp
@@ -74,6 +74,20 @@ namespace class_template {
// new-error at -1 {{ambiguous partial specialization}}
} // namespace class_template
+namespace class_template_func {
+ template <class T1, class T2 = float> struct A {};
+
+ template <template <class T4> class TT1, class T5> void f(TT1<T5>);
+ // new-note at -1 {{candidate function}}
+
+ template <class T6, class T7> void f(A<T6, T7>) {};
+ // new-note at -1 {{candidate function}}
+
+ void g() {
+ f(A<int>()); // new-error {{call to 'f' is ambiguous}}
+ }
+} // namespace class_template_func
+
namespace type_pack1 {
template<class T2> struct A;
template<template<class ...T3s> class TT1, class T4> struct A<TT1<T4>> ;
diff --git a/clang/test/SemaTemplate/temp_arg_nontype.cpp b/clang/test/SemaTemplate/temp_arg_nontype.cpp
index e091de669fab4..cbcfb2a5b8674 100644
--- a/clang/test/SemaTemplate/temp_arg_nontype.cpp
+++ b/clang/test/SemaTemplate/temp_arg_nontype.cpp
@@ -458,17 +458,13 @@ namespace dependent_nested_partial_specialization {
namespace nondependent_default_arg_ordering {
int n, m;
template<typename A, A B = &n> struct X {};
- template<typename A> void f(X<A>); // expected-note {{candidate}}
- template<typename A> void f(X<A, &m>); // expected-note {{candidate}}
- template<typename A, A B> void f(X<A, B>); // expected-note 2{{candidate}}
+ template<typename A> void f(X<A>);
+ template<typename A> void f(X<A, &m>);
+ template<typename A, A B> void f(X<A, B>);
template<template<typename U, U> class T, typename A, int *B> void f(T<A, B>);
void g() {
- // FIXME: The first and second function templates above should be
- // considered more specialized than the third, but during partial
- // ordering we fail to check that we actually deduced template arguments
- // that make the deduced A identical to A.
- X<int *, &n> x; f(x); // expected-error {{ambiguous}}
- X<int *, &m> y; f(y); // expected-error {{ambiguous}}
+ X<int *, &n> x; f(x);
+ X<int *, &m> y; f(y);
}
}
diff --git a/clang/test/SemaTemplate/temp_arg_type.cpp b/clang/test/SemaTemplate/temp_arg_type.cpp
index cdbcf281125ef..392d2573d3d0e 100644
--- a/clang/test/SemaTemplate/temp_arg_type.cpp
+++ b/clang/test/SemaTemplate/temp_arg_type.cpp
@@ -69,11 +69,10 @@ namespace deduce_noexcept {
void noexcept_function() noexcept;
void throwing_function();
- template<typename T, bool B> float &deduce_function(T(*)() noexcept(B)); // expected-note {{candidate}}
- template<typename T> int &deduce_function(T(*)() noexcept); // expected-note {{candidate}}
+ template<typename T, bool B> float &deduce_function(T(*)() noexcept(B));
+ template<typename T> int &deduce_function(T(*)() noexcept);
void test_function_deduction() {
- // FIXME: This should probably unambiguously select the second overload.
- int &r = deduce_function(noexcept_function); // expected-error {{ambiguous}}
+ int &r = deduce_function(noexcept_function);
float &s = deduce_function(throwing_function);
}
diff --git a/clang/test/Templight/templight-empty-entries-fix.cpp b/clang/test/Templight/templight-empty-entries-fix.cpp
index ad029d3070756..e17be9012e59c 100644
--- a/clang/test/Templight/templight-empty-entries-fix.cpp
+++ b/clang/test/Templight/templight-empty-entries-fix.cpp
@@ -170,6 +170,30 @@ template <bool d = true, class = typename b<d>::c> void a() { a(); }
template <bool = true> void d(int = 0) { d(); }
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:60:57'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+Begin$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
+// CHECK-LABEL: {{^---$}}
+// CHECK: {{^name:[ ]+a$}}
+// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
+// CHECK: {{^event:[ ]+End$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:20:25'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:60:63'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
@@ -225,41 +249,41 @@ void e() {
}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:248:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:248:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:248:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:224:5'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:248:5'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
// CHECK-LABEL: {{^---$}}
-// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:223:3\)'$}}
+// CHECK: {{^name:[ ]+'\(unnamed struct at .*templight-empty-entries-fix.cpp:247:3\)'$}}
// CHECK: {{^kind:[ ]+Memoization$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:223:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:247:3'$}}
template <template<typename> class>
@@ -275,59 +299,59 @@ void foo() {
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:289:35'$}}
// CHECK: {{^poi:[ ]+''$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+unnamed template template parameter 0 of d$}}
// CHECK: {{^kind:[ ]+PriorTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:265:35'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:289:35'$}}
// CHECK: {{^poi:[ ]+''$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+DeducedTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'d<C>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+Begin$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+'d<C>'$}}
// CHECK: {{^kind:[ ]+TemplateInstantiation$}}
// CHECK: {{^event:[ ]+End$}}
-// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:266:6'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:290:6'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+Begin$}}
// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:171:29'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
// CHECK-LABEL: {{^---$}}
// CHECK: {{^name:[ ]+d$}}
// CHECK: {{^kind:[ ]+ExplicitTemplateArgumentSubstitution$}}
// CHECK: {{^event:[ ]+End$}}
// CHECK: {{^orig:[ ]+'.*templight-empty-entries-fix.cpp:171:29'$}}
-// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:271:3'$}}
+// CHECK: {{^poi:[ ]+'.*templight-empty-entries-fix.cpp:295:3'$}}
>From 63d51f7c1d3d810bd536313dd2ea3ba204b82c1e Mon Sep 17 00:00:00 2001
From: Matheus Izvekov <mizvekov at gmail.com>
Date: Mon, 20 May 2024 01:15:03 -0300
Subject: [PATCH 2/2] [clang] Implement CWG2398 provisional TTP matching to
class templates
This extends default argument deduction to cover class templates as
well.
This solves some ambuguity introduced in P0522 regarding how
template template parameters are partially ordered, and should reduce
the negative impact of enabling `-frelaxed-template-template-args`
by default.
Given the following example:
```C++
template <class T1, class T2 = float> struct A;
template <class T3> struct B;
template <template <class T4> class TT1, class T5> struct B<TT1<T5>>; // #1
template <class T6, class T7> struct B<A<T6, T7>>; // #2
template struct B<A<int>>;
```
Prior to P0522, `#2` was picked. Afterwards, this became ambiguous.
This patch restores the pre-P0522 behavior, `#2` is picked again.
---
clang-tools-extra/clangd/DumpAST.cpp | 1 +
.../clangd/SemanticHighlighting.cpp | 1 +
clang/docs/ReleaseNotes.rst | 5 +-
clang/include/clang/AST/ASTContext.h | 11 +-
clang/include/clang/AST/ASTImporter.h | 5 +
clang/include/clang/AST/DependenceFlags.h | 5 +
clang/include/clang/AST/PropertiesBase.td | 17 +
clang/include/clang/AST/TemplateName.h | 63 ++-
clang/include/clang/Sema/Sema.h | 10 +-
clang/lib/AST/ASTContext.cpp | 153 +++++-
clang/lib/AST/ASTDiagnostic.cpp | 45 +-
clang/lib/AST/ASTImporter.cpp | 2 +
clang/lib/AST/ASTStructuralEquivalence.cpp | 3 +
clang/lib/AST/Decl.cpp | 3 +-
clang/lib/AST/ItaniumMangle.cpp | 14 +-
clang/lib/AST/ODRHash.cpp | 2 +
clang/lib/AST/TemplateName.cpp | 163 ++++--
clang/lib/AST/TextNodeDumper.cpp | 12 +
clang/lib/AST/Type.cpp | 3 +-
clang/lib/AST/TypePrinter.cpp | 3 +-
clang/lib/Sema/SemaDeclCXX.cpp | 9 +-
clang/lib/Sema/SemaTemplate.cpp | 63 ++-
clang/lib/Sema/SemaTemplateDeduction.cpp | 492 +++++++++---------
.../lib/Sema/SemaTemplateInstantiateDecl.cpp | 24 +-
clang/test/SemaTemplate/cwg2398.cpp | 50 +-
clang/tools/libclang/CIndex.cpp | 3 +
26 files changed, 776 insertions(+), 386 deletions(-)
diff --git a/clang-tools-extra/clangd/DumpAST.cpp b/clang-tools-extra/clangd/DumpAST.cpp
index 9a525efb938e8..e605f82e91fe4 100644
--- a/clang-tools-extra/clangd/DumpAST.cpp
+++ b/clang-tools-extra/clangd/DumpAST.cpp
@@ -187,6 +187,7 @@ class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
TEMPLATE_KIND(SubstTemplateTemplateParm);
TEMPLATE_KIND(SubstTemplateTemplateParmPack);
TEMPLATE_KIND(UsingTemplate);
+ TEMPLATE_KIND(DeducedTemplate);
#undef TEMPLATE_KIND
}
llvm_unreachable("Unhandled NameKind enum");
diff --git a/clang-tools-extra/clangd/SemanticHighlighting.cpp b/clang-tools-extra/clangd/SemanticHighlighting.cpp
index a366f1331c2d3..e6d16af2495fe 100644
--- a/clang-tools-extra/clangd/SemanticHighlighting.cpp
+++ b/clang-tools-extra/clangd/SemanticHighlighting.cpp
@@ -1120,6 +1120,7 @@ class CollectExtraHighlightings
case TemplateName::SubstTemplateTemplateParm:
case TemplateName::SubstTemplateTemplateParmPack:
case TemplateName::UsingTemplate:
+ case TemplateName::DeducedTemplate:
// Names that could be resolved to a TemplateDecl are handled elsewhere.
break;
}
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 6098101a73a62..903461532940c 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -84,6 +84,9 @@ C++2c Feature Support
Resolutions to C++ Defect Reports
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Clang now has improved resolution to CWG2398, allowing class templates to have
+ default arguments deduced when partial ordering.
+
C Language Changes
------------------
@@ -119,7 +122,7 @@ Improvements to Clang's diagnostics
- Some template related diagnostics have been improved.
.. code-block:: c++
-
+
void foo() { template <typename> int i; } // error: templates can only be declared in namespace or class scope
struct S {
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 6d1c8ca8a2f96..0dc0404cf01cd 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -263,6 +263,8 @@ class ASTContext : public RefCountedBase<ASTContext> {
mutable llvm::ContextualFoldingSet<SubstTemplateTemplateParmPackStorage,
ASTContext&>
SubstTemplateTemplateParmPacks;
+ mutable llvm::ContextualFoldingSet<DeducedTemplateStorage, ASTContext &>
+ DeducedTemplates;
mutable llvm::ContextualFoldingSet<ArrayParameterType, ASTContext &>
ArrayParameterTypes;
@@ -2288,6 +2290,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
unsigned Index,
bool Final) const;
+ TemplateName getDeducedTemplateName(TemplateName Underlying,
+ DefaultArguments DefaultArgs) const;
+
enum GetBuiltinTypeError {
/// No error
GE_None,
@@ -2771,11 +2776,13 @@ class ASTContext : public RefCountedBase<ASTContext> {
/// template name uses the shortest form of the dependent
/// nested-name-specifier, which itself contains all canonical
/// types, values, and templates.
- TemplateName getCanonicalTemplateName(const TemplateName &Name) const;
+ TemplateName getCanonicalTemplateName(TemplateName Name,
+ bool IgnoreDeduced = false) const;
/// Determine whether the given template names refer to the same
/// template.
- bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y) const;
+ bool hasSameTemplateName(const TemplateName &X, const TemplateName &Y,
+ bool IgnoreDeduced = false) const;
/// Determine whether the two declarations refer to the same entity.
bool isSameEntity(const NamedDecl *X, const NamedDecl *Y) const;
diff --git a/clang/include/clang/AST/ASTImporter.h b/clang/include/clang/AST/ASTImporter.h
index 4ffd913846575..7b890bdf492fa 100644
--- a/clang/include/clang/AST/ASTImporter.h
+++ b/clang/include/clang/AST/ASTImporter.h
@@ -485,6 +485,11 @@ class TypeSourceInfo;
/// the declarations it contains.
[[nodiscard]] llvm::Error ImportDefinition(Decl *From);
+ llvm::Error
+ ImportTemplateArguments(ArrayRef<TemplateArgument> FromArgs,
+ SmallVectorImpl<TemplateArgument> &ToArgs);
+ Expected<TemplateArgument> Import(const TemplateArgument &From);
+
/// Cope with a name conflict when importing a declaration into the
/// given context.
///
diff --git a/clang/include/clang/AST/DependenceFlags.h b/clang/include/clang/AST/DependenceFlags.h
index 3b3c1afb096ad..bdcaabc143cc4 100644
--- a/clang/include/clang/AST/DependenceFlags.h
+++ b/clang/include/clang/AST/DependenceFlags.h
@@ -315,6 +315,11 @@ toTemplateNameDependence(NestedNameSpecifierDependence D) {
return Dependence(D).templateName();
}
+inline TemplateNameDependence
+toTemplateNameDependence(TemplateArgumentDependence D) {
+ return Dependence(D).templateName();
+}
+
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
} // namespace clang
diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td
index 5f7d619518762..9b934b20cf255 100644
--- a/clang/include/clang/AST/PropertiesBase.td
+++ b/clang/include/clang/AST/PropertiesBase.td
@@ -752,6 +752,23 @@ let Class = PropertyTypeCase<TemplateName, "SubstTemplateTemplateParmPack"> in {
return ctx.getSubstTemplateTemplateParmPack(argumentPack, associatedDecl, index, final);
}]>;
}
+let Class = PropertyTypeCase<TemplateName, "DeducedTemplate"> in {
+ def : ReadHelper<[{
+ auto DTS = node.getAsDeducedTemplateName();
+ }]>;
+ def : Property<"underlying", TemplateName> {
+ let Read = [{ DTS->getUnderlying() }];
+ }
+ def : Property<"startPos", UInt32> {
+ let Read = [{ DTS->getDefaultArguments().StartPos }];
+ }
+ def : Property<"defaultArgs", Array<TemplateArgument>> {
+ let Read = [{ DTS->getDefaultArguments().Args }];
+ }
+ def : Creator<[{
+ return ctx.getDeducedTemplateName(underlying, {startPos, defaultArgs});
+ }]>;
+}
// Type cases for TemplateArgument.
def : PropertyTypeKind<TemplateArgument, TemplateArgumentKind,
diff --git a/clang/include/clang/AST/TemplateName.h b/clang/include/clang/AST/TemplateName.h
index e3b7dd261535d..ce97f834bfc1d 100644
--- a/clang/include/clang/AST/TemplateName.h
+++ b/clang/include/clang/AST/TemplateName.h
@@ -34,6 +34,7 @@ class NestedNameSpecifier;
enum OverloadedOperatorKind : int;
class OverloadedTemplateStorage;
class AssumedTemplateStorage;
+class DeducedTemplateStorage;
struct PrintingPolicy;
class QualifiedTemplateName;
class SubstTemplateTemplateParmPackStorage;
@@ -50,16 +51,17 @@ class UncommonTemplateNameStorage {
enum Kind {
Overloaded,
Assumed, // defined in DeclarationName.h
+ Deduced,
SubstTemplateTemplateParm,
SubstTemplateTemplateParmPack
};
struct BitsTag {
LLVM_PREFERRED_TYPE(Kind)
- unsigned Kind : 2;
+ unsigned Kind : 3;
// The template parameter index.
- unsigned Index : 15;
+ unsigned Index : 14;
/// The pack index, or the number of stored templates
/// or template arguments, depending on which subclass we have.
@@ -90,6 +92,12 @@ class UncommonTemplateNameStorage {
: nullptr;
}
+ DeducedTemplateStorage *getAsDeducedTemplateName() {
+ return Bits.Kind == Deduced
+ ? reinterpret_cast<DeducedTemplateStorage *>(this)
+ : nullptr;
+ }
+
SubstTemplateTemplateParmStorage *getAsSubstTemplateTemplateParm() {
return Bits.Kind == SubstTemplateTemplateParm
? reinterpret_cast<SubstTemplateTemplateParmStorage *>(this)
@@ -172,6 +180,15 @@ class SubstTemplateTemplateParmPackStorage : public UncommonTemplateNameStorage,
unsigned Index, bool Final);
};
+struct DefaultArguments {
+ // The position in the template parameter list
+ // the first argument corresponds to.
+ unsigned StartPos;
+ ArrayRef<TemplateArgument> Args;
+
+ operator bool() const { return !Args.empty(); }
+};
+
/// Represents a C++ template name within the type system.
///
/// A C++ template name refers to a template within the C++ type
@@ -246,6 +263,10 @@ class TemplateName {
/// A template name that refers to a template declaration found through a
/// specific using shadow declaration.
UsingTemplate,
+
+ /// A template name that refers to another TemplateName with deduced default
+ /// arguments.
+ DeducedTemplate,
};
TemplateName() = default;
@@ -257,6 +278,7 @@ class TemplateName {
explicit TemplateName(QualifiedTemplateName *Qual);
explicit TemplateName(DependentTemplateName *Dep);
explicit TemplateName(UsingShadowDecl *Using);
+ explicit TemplateName(DeducedTemplateStorage *Deduced);
/// Determine whether this template name is NULL.
bool isNull() const;
@@ -271,7 +293,13 @@ class TemplateName {
/// to, if any. If the template name does not refer to a specific
/// declaration because it is a dependent name, or if it refers to a
/// set of function templates, returns NULL.
- TemplateDecl *getAsTemplateDecl() const;
+ TemplateDecl *getAsTemplateDecl(bool IgnoreDeduced = false) const;
+
+ /// Retrieves the underlying template declaration that
+ /// this template name refers to, along with the
+ /// deduced default arguments, if any.
+ std::pair<TemplateDecl *, DefaultArguments>
+ getTemplateDeclAndDefaultArgs() const;
/// Retrieve the underlying, overloaded function template
/// declarations that this template name refers to, if known.
@@ -313,6 +341,11 @@ class TemplateName {
/// template declaration is introduced, if any.
UsingShadowDecl *getAsUsingShadowDecl() const;
+ /// Retrieve the deduced template info, if any.
+ DeducedTemplateStorage *getAsDeducedTemplateName() const;
+
+ std::optional<TemplateName> desugar(bool IgnoreDeduced) const;
+
TemplateName getUnderlying() const;
TemplateNameDependence getDependence() const;
@@ -412,6 +445,30 @@ class SubstTemplateTemplateParmStorage
std::optional<unsigned> PackIndex);
};
+class DeducedTemplateStorage : public UncommonTemplateNameStorage,
+ public llvm::FoldingSetNode {
+ friend class ASTContext;
+
+ TemplateName Underlying;
+
+ DeducedTemplateStorage(TemplateName Underlying,
+ const DefaultArguments &DefArgs);
+
+public:
+ TemplateName getUnderlying() const { return Underlying; }
+
+ DefaultArguments getDefaultArguments() const {
+ return {/*StartPos=*/Bits.Index,
+ /*Args=*/{reinterpret_cast<const TemplateArgument *>(this + 1),
+ Bits.Data}};
+ }
+
+ void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const;
+
+ static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
+ TemplateName Underlying, const DefaultArguments &DefArgs);
+};
+
inline TemplateName TemplateName::getUnderlying() const {
if (SubstTemplateTemplateParmStorage *subst
= getAsSubstTemplateTemplateParm())
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 06a06d7718781..9856c0f2a7b15 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -11710,6 +11710,9 @@ class Sema final : public SemaBase {
/// receive true if the cause for the error is the associated constraints of
/// the template not being satisfied by the template arguments.
///
+ /// \param DefaultArgs any default arguments from template specialization
+ /// deduction.
+ ///
/// \param PartialOrderingTTP If true, assume these template arguments are
/// the injected template arguments for a template template parameter.
/// This will relax the requirement that all its possible uses are valid:
@@ -11719,7 +11722,8 @@ class Sema final : public SemaBase {
/// \returns true if an error occurred, false otherwise.
bool CheckTemplateArgumentList(
TemplateDecl *Template, SourceLocation TemplateLoc,
- TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
+ TemplateArgumentListInfo &TemplateArgs,
+ const DefaultArguments &DefaultArgs, bool PartialTemplateArgs,
SmallVectorImpl<TemplateArgument> &SugaredConverted,
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
bool UpdateArgsWithConversions = true,
@@ -12453,8 +12457,8 @@ class Sema final : public SemaBase {
sema::TemplateDeductionInfo &Info);
bool isTemplateTemplateParameterAtLeastAsSpecializedAs(
- TemplateParameterList *PParam, TemplateDecl *AArg, SourceLocation Loc,
- bool IsDeduced);
+ TemplateParameterList *PParam, TemplateDecl *AArg,
+ const DefaultArguments &DefaultArgs, SourceLocation Loc, bool IsDeduced);
/// Mark which template parameters are used in a given expression.
///
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index a465cdfcf3c89..6c26216e7748a 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -881,8 +881,8 @@ ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
TemplateSpecializationTypes(this_()),
DependentTemplateSpecializationTypes(this_()), AutoTypes(this_()),
DependentBitIntTypes(this_()), SubstTemplateTemplateParmPacks(this_()),
- ArrayParameterTypes(this_()), CanonTemplateTemplateParms(this_()),
- SourceMgr(SM), LangOpts(LOpts),
+ DeducedTemplates(this_()), ArrayParameterTypes(this_()),
+ CanonTemplateTemplateParms(this_()), SourceMgr(SM), LangOpts(LOpts),
NoSanitizeL(new NoSanitizeList(LangOpts.NoSanitizeFiles, SM)),
XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
LangOpts.XRayNeverInstrumentFiles,
@@ -5352,7 +5352,7 @@ ASTContext::getTemplateSpecializationType(TemplateName Template,
assert(!Template.getAsDependentTemplateName() &&
"No dependent template names here!");
- const auto *TD = Template.getAsTemplateDecl();
+ const auto *TD = Template.getAsTemplateDecl(/*IgnoreDeduced=*/true);
bool IsTypeAlias = TD && TD->isTypeAlias();
QualType CanonType;
if (!Underlying.isNull())
@@ -5387,7 +5387,12 @@ QualType ASTContext::getCanonicalTemplateSpecializationType(
"No dependent template names here!");
// Build the canonical template specialization type.
- TemplateName CanonTemplate = getCanonicalTemplateName(Template);
+ // Any DeducedTemplateNames are ignored, because the effective name of a TST
+ // accounts for the TST arguments laid over any default arguments contained in
+ // its name.
+ TemplateName CanonTemplate =
+ getCanonicalTemplateName(Template, /*IgnoreDeduced=*/true);
+
bool AnyNonCanonArgs = false;
auto CanonArgs =
::getCanonicalTemplateArguments(*this, Args, AnyNonCanonArgs);
@@ -6684,16 +6689,41 @@ ASTContext::getNameForTemplate(TemplateName Name,
case TemplateName::UsingTemplate:
return DeclarationNameInfo(Name.getAsUsingShadowDecl()->getDeclName(),
NameLoc);
+ case TemplateName::DeducedTemplate: {
+ DeducedTemplateStorage *DTS = Name.getAsDeducedTemplateName();
+ return getNameForTemplate(DTS->getUnderlying(), NameLoc);
+ }
}
llvm_unreachable("bad template name kind!");
}
-TemplateName
-ASTContext::getCanonicalTemplateName(const TemplateName &Name) const {
+static const TemplateArgument *
+getDefaultTemplateArgumentOrNone(const NamedDecl *P) {
+ auto handleParam = [](auto *TP) -> const TemplateArgument * {
+ if (!TP->hasDefaultArgument())
+ return nullptr;
+ return &TP->getDefaultArgument().getArgument();
+ };
+ switch (P->getKind()) {
+ case NamedDecl::TemplateTypeParm:
+ return handleParam(cast<TemplateTypeParmDecl>(P));
+ case NamedDecl::NonTypeTemplateParm:
+ return handleParam(cast<NonTypeTemplateParmDecl>(P));
+ case NamedDecl::TemplateTemplateParm:
+ return handleParam(cast<TemplateTemplateParmDecl>(P));
+ default:
+ llvm_unreachable("Unexpected template parameter kind");
+ }
+}
+
+TemplateName ASTContext::getCanonicalTemplateName(TemplateName Name,
+ bool IgnoreDeduced) const {
+ while (std::optional<TemplateName> UnderlyingOrNone =
+ Name.desugar(IgnoreDeduced))
+ Name = *UnderlyingOrNone;
+
switch (Name.getKind()) {
- case TemplateName::UsingTemplate:
- case TemplateName::QualifiedTemplate:
case TemplateName::Template: {
TemplateDecl *Template = Name.getAsTemplateDecl();
if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template))
@@ -6713,12 +6743,6 @@ ASTContext::getCanonicalTemplateName(const TemplateName &Name) const {
return DTN->CanonicalTemplateName;
}
- case TemplateName::SubstTemplateTemplateParm: {
- SubstTemplateTemplateParmStorage *subst
- = Name.getAsSubstTemplateTemplateParm();
- return getCanonicalTemplateName(subst->getReplacement());
- }
-
case TemplateName::SubstTemplateTemplateParmPack: {
SubstTemplateTemplateParmPackStorage *subst =
Name.getAsSubstTemplateTemplateParmPack();
@@ -6728,15 +6752,58 @@ ASTContext::getCanonicalTemplateName(const TemplateName &Name) const {
canonArgPack, subst->getAssociatedDecl()->getCanonicalDecl(),
subst->getFinal(), subst->getIndex());
}
+ case TemplateName::DeducedTemplate: {
+ assert(IgnoreDeduced == false);
+ DeducedTemplateStorage *DTS = Name.getAsDeducedTemplateName();
+ DefaultArguments DefArgs = DTS->getDefaultArguments();
+ TemplateName Underlying = DTS->getUnderlying();
+
+ TemplateName CanonUnderlying =
+ getCanonicalTemplateName(Underlying, /*IgnoreDeduced=*/true);
+ bool NonCanonical = CanonUnderlying != Underlying;
+ auto CanonArgs =
+ getCanonicalTemplateArguments(*this, DefArgs.Args, NonCanonical);
+
+ ArrayRef<NamedDecl *> Params =
+ CanonUnderlying.getAsTemplateDecl()->getTemplateParameters()->asArray();
+ assert(CanonArgs.size() <= Params.size());
+ // A deduced template name which deduces the same default arguments already
+ // declared in the underlying template, is the same template as the
+ // underlying template. We need need to note any arguments which differ from
+ // the corresponding declaration. If they are not the same, we must build a
+ // deduced template name.
+ for (int I = CanonArgs.size() - 1; I >= 0; --I) {
+ const TemplateArgument *A = getDefaultTemplateArgumentOrNone(Params[I]);
+ if (!A)
+ break;
+ auto CanonParamDefArg = getCanonicalTemplateArgument(*A);
+ TemplateArgument &CanonDefArg = CanonArgs[I];
+ if (CanonDefArg.structurallyEquals(CanonParamDefArg))
+ continue;
+ // Keep popping from the back any deault arguments which are the same.
+ if (I == int(CanonArgs.size() - 1))
+ CanonArgs.pop_back();
+ NonCanonical = true;
+ }
+ return NonCanonical ? getDeducedTemplateName(
+ CanonUnderlying,
+ /*DefaultArgs=*/{DefArgs.StartPos, CanonArgs})
+ : Name;
+ }
+ case TemplateName::UsingTemplate:
+ case TemplateName::QualifiedTemplate:
+ case TemplateName::SubstTemplateTemplateParm:
+ llvm_unreachable("always sugar node");
}
llvm_unreachable("bad template name!");
}
bool ASTContext::hasSameTemplateName(const TemplateName &X,
- const TemplateName &Y) const {
- return getCanonicalTemplateName(X).getAsVoidPointer() ==
- getCanonicalTemplateName(Y).getAsVoidPointer();
+ const TemplateName &Y,
+ bool IgnoreDeduced) const {
+ return getCanonicalTemplateName(X, IgnoreDeduced) ==
+ getCanonicalTemplateName(Y, IgnoreDeduced);
}
bool ASTContext::isSameConstraintExpr(const Expr *XCE, const Expr *YCE) const {
@@ -7225,7 +7292,7 @@ ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
case TemplateArgument::StructuralValue:
return TemplateArgument(*this,
getCanonicalType(Arg.getStructuralValueType()),
- Arg.getAsStructuralValue());
+ Arg.getAsStructuralValue(), Arg.getIsDefaulted());
case TemplateArgument::Type:
return TemplateArgument(getCanonicalType(Arg.getAsType()),
@@ -7237,8 +7304,10 @@ ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
*this, Arg.pack_elements(), AnyNonCanonArgs);
if (!AnyNonCanonArgs)
return Arg;
- return TemplateArgument::CreatePackCopy(const_cast<ASTContext &>(*this),
- CanonArgs);
+ auto NewArg = TemplateArgument::CreatePackCopy(
+ const_cast<ASTContext &>(*this), CanonArgs);
+ NewArg.setIsDefaulted(Arg.getIsDefaulted());
+ return NewArg;
}
}
@@ -9793,6 +9862,30 @@ ASTContext::getSubstTemplateTemplateParmPack(const TemplateArgument &ArgPack,
return TemplateName(Subst);
}
+/// Retrieve the template name that represents a template name
+/// deduced from a specialization.
+TemplateName
+ASTContext::getDeducedTemplateName(TemplateName Underlying,
+ DefaultArguments DefaultArgs) const {
+ if (!DefaultArgs)
+ return Underlying;
+
+ llvm::FoldingSetNodeID ID;
+ DeducedTemplateStorage::Profile(ID, *this, Underlying, DefaultArgs);
+
+ void *InsertPos = nullptr;
+ DeducedTemplateStorage *DTS =
+ DeducedTemplates.FindNodeOrInsertPos(ID, InsertPos);
+ if (!DTS) {
+ void *Mem = Allocate(sizeof(DeducedTemplateStorage) +
+ sizeof(TemplateArgument) * DefaultArgs.Args.size(),
+ alignof(DeducedTemplateStorage));
+ DTS = new (Mem) DeducedTemplateStorage(Underlying, DefaultArgs);
+ DeducedTemplates.InsertNode(DTS, InsertPos);
+ }
+ return TemplateName(DTS);
+}
+
/// getFromTargetType - Given one of the integer types provided by
/// TargetInfo, produce the corresponding type. The unsigned @p Type
/// is actually a value of type @c TargetInfo::IntType.
@@ -12926,22 +13019,24 @@ static T *getCommonDeclChecked(T *X, T *Y) {
}
static TemplateName getCommonTemplateName(ASTContext &Ctx, TemplateName X,
- TemplateName Y) {
+ TemplateName Y,
+ bool IgnoreDeduced = false) {
if (X.getAsVoidPointer() == Y.getAsVoidPointer())
return X;
// FIXME: There are cases here where we could find a common template name
// with more sugar. For example one could be a SubstTemplateTemplate*
// replacing the other.
- TemplateName CX = Ctx.getCanonicalTemplateName(X);
+ TemplateName CX = Ctx.getCanonicalTemplateName(X, IgnoreDeduced);
if (CX.getAsVoidPointer() !=
Ctx.getCanonicalTemplateName(Y).getAsVoidPointer())
return TemplateName();
return CX;
}
-static TemplateName
-getCommonTemplateNameChecked(ASTContext &Ctx, TemplateName X, TemplateName Y) {
- TemplateName R = getCommonTemplateName(Ctx, X, Y);
+static TemplateName getCommonTemplateNameChecked(ASTContext &Ctx,
+ TemplateName X, TemplateName Y,
+ bool IgnoreDeduced) {
+ TemplateName R = getCommonTemplateName(Ctx, X, Y, IgnoreDeduced);
assert(R.getAsVoidPointer() != nullptr);
return R;
}
@@ -13428,7 +13523,8 @@ static QualType getCommonNonSugarTypeNode(ASTContext &Ctx, const Type *X,
TY->template_arguments());
return Ctx.getTemplateSpecializationType(
::getCommonTemplateNameChecked(Ctx, TX->getTemplateName(),
- TY->getTemplateName()),
+ TY->getTemplateName(),
+ /*IgnoreDeduced=*/true),
As, X->getCanonicalTypeInternal());
}
case Type::Decltype: {
@@ -13656,8 +13752,9 @@ static QualType getCommonSugarTypeNode(ASTContext &Ctx, const Type *X,
case Type::TemplateSpecialization: {
const auto *TX = cast<TemplateSpecializationType>(X),
*TY = cast<TemplateSpecializationType>(Y);
- TemplateName CTN = ::getCommonTemplateName(Ctx, TX->getTemplateName(),
- TY->getTemplateName());
+ TemplateName CTN =
+ ::getCommonTemplateName(Ctx, TX->getTemplateName(),
+ TY->getTemplateName(), /*IgnoreDeduced=*/true);
if (!CTN.getAsVoidPointer())
return QualType();
SmallVector<TemplateArgument, 8> Args;
diff --git a/clang/lib/AST/ASTDiagnostic.cpp b/clang/lib/AST/ASTDiagnostic.cpp
index 0680ff5e3a385..15c3efe421271 100644
--- a/clang/lib/AST/ASTDiagnostic.cpp
+++ b/clang/lib/AST/ASTDiagnostic.cpp
@@ -1114,8 +1114,8 @@ class TemplateDiff {
// These functions build up the template diff tree, including functions to
// retrieve and compare template arguments.
- static const TemplateSpecializationType *GetTemplateSpecializationType(
- ASTContext &Context, QualType Ty) {
+ static const TemplateSpecializationType *
+ GetTemplateSpecializationType(ASTContext &Context, QualType Ty) {
if (const TemplateSpecializationType *TST =
Ty->getAs<TemplateSpecializationType>())
return TST;
@@ -1159,7 +1159,7 @@ class TemplateDiff {
if (!FromArgTST || !ToArgTST)
return true;
- if (!hasSameTemplate(FromArgTST, ToArgTST))
+ if (!hasSameTemplate(Context, FromArgTST, ToArgTST))
return true;
return false;
@@ -1371,11 +1371,17 @@ class TemplateDiff {
/// argument info into a tree.
void DiffTemplate(const TemplateSpecializationType *FromTST,
const TemplateSpecializationType *ToTST) {
+ // FIXME: With P3310R0, A TST formed from a DeducedTemplateName might
+ // differ in template arguments which were not written.
// Begin descent into diffing template tree.
TemplateParameterList *ParamsFrom =
- FromTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
+ FromTST->getTemplateName()
+ .getAsTemplateDecl(/*IgnoreDeduced=*/true)
+ ->getTemplateParameters();
TemplateParameterList *ParamsTo =
- ToTST->getTemplateName().getAsTemplateDecl()->getTemplateParameters();
+ ToTST->getTemplateName()
+ .getAsTemplateDecl(/*IgnoreDeduced=*/true)
+ ->getTemplateParameters();
unsigned TotalArgs = 0;
for (TSTiterator FromIter(Context, FromTST), ToIter(Context, ToTST);
!FromIter.isEnd() || !ToIter.isEnd(); ++TotalArgs) {
@@ -1427,20 +1433,24 @@ class TemplateDiff {
/// hasSameBaseTemplate - Returns true when the base templates are the same,
/// even if the template arguments are not.
- static bool hasSameBaseTemplate(const TemplateSpecializationType *FromTST,
+ static bool hasSameBaseTemplate(ASTContext &Context,
+ const TemplateSpecializationType *FromTST,
const TemplateSpecializationType *ToTST) {
- return FromTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl() ==
- ToTST->getTemplateName().getAsTemplateDecl()->getCanonicalDecl();
+ return Context.getCanonicalTemplateName(FromTST->getTemplateName(),
+ /*IgnoreDeduced=*/true) ==
+ Context.getCanonicalTemplateName(ToTST->getTemplateName(),
+ /*IgnoreDeduced=*/true);
}
/// hasSameTemplate - Returns true if both types are specialized from the
/// same template declaration. If they come from different template aliases,
/// do a parallel ascension search to determine the highest template alias in
/// common and set the arguments to them.
- static bool hasSameTemplate(const TemplateSpecializationType *&FromTST,
+ static bool hasSameTemplate(ASTContext &Context,
+ const TemplateSpecializationType *&FromTST,
const TemplateSpecializationType *&ToTST) {
// Check the top templates if they are the same.
- if (hasSameBaseTemplate(FromTST, ToTST))
+ if (hasSameBaseTemplate(Context, FromTST, ToTST))
return true;
// Create vectors of template aliases.
@@ -1455,14 +1465,14 @@ class TemplateDiff {
ToIter = ToTemplateList.rbegin(), ToEnd = ToTemplateList.rend();
// Check if the lowest template types are the same. If not, return.
- if (!hasSameBaseTemplate(*FromIter, *ToIter))
+ if (!hasSameBaseTemplate(Context, *FromIter, *ToIter))
return false;
// Begin searching up the template aliases. The bottom most template
// matches so move up until one pair does not match. Use the template
// right before that one.
for (; FromIter != FromEnd && ToIter != ToEnd; ++FromIter, ++ToIter) {
- if (!hasSameBaseTemplate(*FromIter, *ToIter))
+ if (!hasSameBaseTemplate(Context, *FromIter, *ToIter))
break;
}
@@ -2123,7 +2133,7 @@ class TemplateDiff {
return;
// Different base templates.
- if (!hasSameTemplate(FromOrigTST, ToOrigTST)) {
+ if (!hasSameTemplate(Context, FromOrigTST, ToOrigTST)) {
return;
}
@@ -2131,10 +2141,11 @@ class TemplateDiff {
ToQual -= QualType(ToOrigTST, 0).getQualifiers();
// Same base template, but different arguments.
- Tree.SetTemplateDiff(FromOrigTST->getTemplateName().getAsTemplateDecl(),
- ToOrigTST->getTemplateName().getAsTemplateDecl(),
- FromQual, ToQual, false /*FromDefault*/,
- false /*ToDefault*/);
+ Tree.SetTemplateDiff(
+ FromOrigTST->getTemplateName().getAsTemplateDecl(
+ /*IgnoreDeduced=*/true),
+ ToOrigTST->getTemplateName().getAsTemplateDecl(/*IgnoreDeduced=*/true),
+ FromQual, ToQual, false /*FromDefault*/, false /*ToDefault*/);
DiffTemplate(FromOrigTST, ToOrigTST);
}
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
index 08ef09d353afc..9cec9a4e444e2 100644
--- a/clang/lib/AST/ASTImporter.cpp
+++ b/clang/lib/AST/ASTImporter.cpp
@@ -9899,6 +9899,8 @@ Expected<TemplateName> ASTImporter::Import(TemplateName From) {
return UsingOrError.takeError();
return TemplateName(cast<UsingShadowDecl>(*UsingOrError));
}
+ case TemplateName::DeducedTemplate:
+ llvm_unreachable("Unexpected DeducedTemplate");
}
llvm_unreachable("Invalid template name kind");
diff --git a/clang/lib/AST/ASTStructuralEquivalence.cpp b/clang/lib/AST/ASTStructuralEquivalence.cpp
index 37555c324282f..d81f45d5720a4 100644
--- a/clang/lib/AST/ASTStructuralEquivalence.cpp
+++ b/clang/lib/AST/ASTStructuralEquivalence.cpp
@@ -645,6 +645,9 @@ static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
// It is sufficient to check value of getAsTemplateDecl.
break;
+ case TemplateName::DeducedTemplate:
+ // FIXME: We can't reach here.
+ llvm_unreachable("unimplemented");
}
return true;
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index 490c4a2fc525c..caff9242e95aa 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -350,7 +350,8 @@ LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
case TemplateArgument::Template:
case TemplateArgument::TemplateExpansion:
if (TemplateDecl *Template =
- Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
+ Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl(
+ /*IgnoreDeduced=*/true))
LV.merge(getLVForDecl(Template, computation));
continue;
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index d46d621d4c7d4..c87baeb324bb6 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -2384,6 +2384,8 @@ void CXXNameMangler::mangleType(TemplateName TN) {
Out << "_SUBSTPACK_";
break;
}
+ case TemplateName::DeducedTemplate:
+ llvm_unreachable("Unexpected DeducedTemplate");
}
addSubstitution(TN);
@@ -2501,6 +2503,7 @@ bool CXXNameMangler::mangleUnresolvedTypeOrSimpleId(QualType Ty,
case TemplateName::OverloadedTemplate:
case TemplateName::AssumedTemplate:
case TemplateName::DependentTemplate:
+ case TemplateName::DeducedTemplate:
llvm_unreachable("invalid base for a template specialization type");
case TemplateName::SubstTemplateTemplateParm: {
@@ -5900,7 +5903,10 @@ struct CXXNameMangler::TemplateArgManglingInfo {
// that of the template.
auto *TTP = cast<TemplateTemplateParmDecl>(Param);
TemplateName ArgTemplateName = Arg.getAsTemplateOrTemplatePattern();
- const TemplateDecl *ArgTemplate = ArgTemplateName.getAsTemplateDecl();
+ assert(!ArgTemplateName.getTemplateDeclAndDefaultArgs().second &&
+ "A DeducedTemplateName shouldn't escape paretial ordering");
+ const TemplateDecl *ArgTemplate =
+ ArgTemplateName.getAsTemplateDecl(/*IgnoreDeduced=*/true);
if (!ArgTemplate)
return true;
@@ -6767,9 +6773,6 @@ bool CXXNameMangler::mangleSubstitution(QualType T) {
}
bool CXXNameMangler::mangleSubstitution(TemplateName Template) {
- if (TemplateDecl *TD = Template.getAsTemplateDecl())
- return mangleSubstitution(TD);
-
Template = Context.getASTContext().getCanonicalTemplateName(Template);
return mangleSubstitution(
reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
@@ -6939,9 +6942,6 @@ void CXXNameMangler::addSubstitution(QualType T) {
}
void CXXNameMangler::addSubstitution(TemplateName Template) {
- if (TemplateDecl *TD = Template.getAsTemplateDecl())
- return addSubstitution(TD);
-
Template = Context.getASTContext().getCanonicalTemplateName(Template);
addSubstitution(reinterpret_cast<uintptr_t>(Template.getAsVoidPointer()));
}
diff --git a/clang/lib/AST/ODRHash.cpp b/clang/lib/AST/ODRHash.cpp
index fbfe92318dc5e..2162915178eaa 100644
--- a/clang/lib/AST/ODRHash.cpp
+++ b/clang/lib/AST/ODRHash.cpp
@@ -162,6 +162,8 @@ void ODRHash::AddTemplateName(TemplateName Name) {
case TemplateName::SubstTemplateTemplateParmPack:
case TemplateName::UsingTemplate:
break;
+ case TemplateName::DeducedTemplate:
+ llvm_unreachable("Unexpected DeducedTemplate");
}
}
diff --git a/clang/lib/AST/TemplateName.cpp b/clang/lib/AST/TemplateName.cpp
index d4e8a8971a971..044a1a92469ac 100644
--- a/clang/lib/AST/TemplateName.cpp
+++ b/clang/lib/AST/TemplateName.cpp
@@ -34,6 +34,30 @@
using namespace clang;
+DeducedTemplateStorage::DeducedTemplateStorage(TemplateName Underlying,
+ const DefaultArguments &DefArgs)
+ : UncommonTemplateNameStorage(Deduced, /*Index=*/DefArgs.StartPos,
+ DefArgs.Args.size()),
+ Underlying(Underlying) {
+ llvm::copy(DefArgs.Args, reinterpret_cast<TemplateArgument *>(this + 1));
+}
+
+void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
+ const ASTContext &Context) const {
+ Profile(ID, Context, Underlying, getDefaultArguments());
+}
+
+void DeducedTemplateStorage::Profile(llvm::FoldingSetNodeID &ID,
+ const ASTContext &Context,
+ TemplateName Underlying,
+ const DefaultArguments &DefArgs) {
+ Underlying.Profile(ID);
+ ID.AddInteger(DefArgs.StartPos);
+ ID.AddInteger(DefArgs.Args.size());
+ for (const TemplateArgument &Arg : DefArgs.Args)
+ Arg.Profile(ID, Context);
+}
+
TemplateArgument
SubstTemplateTemplateParmPackStorage::getArgumentPack() const {
return TemplateArgument(llvm::ArrayRef(Arguments, Bits.Data));
@@ -115,6 +139,8 @@ TemplateName::TemplateName(SubstTemplateTemplateParmPackStorage *Storage)
TemplateName::TemplateName(QualifiedTemplateName *Qual) : Storage(Qual) {}
TemplateName::TemplateName(DependentTemplateName *Dep) : Storage(Dep) {}
TemplateName::TemplateName(UsingShadowDecl *Using) : Storage(Using) {}
+TemplateName::TemplateName(DeducedTemplateStorage *Deduced)
+ : Storage(Deduced) {}
bool TemplateName::isNull() const { return Storage.isNull(); }
@@ -139,28 +165,63 @@ TemplateName::NameKind TemplateName::getKind() const {
return AssumedTemplate;
if (uncommon->getAsSubstTemplateTemplateParm())
return SubstTemplateTemplateParm;
+ if (uncommon->getAsDeducedTemplateName())
+ return DeducedTemplate;
+
+ assert(uncommon->getAsSubstTemplateTemplateParmPack() != nullptr);
return SubstTemplateTemplateParmPack;
}
-TemplateDecl *TemplateName::getAsTemplateDecl() const {
- if (Decl *TemplateOrUsing = Storage.dyn_cast<Decl *>()) {
- if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(TemplateOrUsing))
- return cast<TemplateDecl>(USD->getTargetDecl());
-
- assert(isa<TemplateDecl>(TemplateOrUsing));
- return cast<TemplateDecl>(TemplateOrUsing);
- }
+TemplateDecl *TemplateName::getAsTemplateDecl(bool IgnoreDeduced) const {
+ TemplateName Name = *this;
+ while (std::optional<TemplateName> UnderlyingOrNone =
+ Name.desugar(IgnoreDeduced))
+ Name = *UnderlyingOrNone;
- if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
- return QTN->getUnderlyingTemplate().getAsTemplateDecl();
+ if (!IgnoreDeduced)
+ assert(Name.getAsDeducedTemplateName() == nullptr &&
+ "Unexpected canonical DeducedTemplateName; Did you mean to use "
+ "getTemplateDeclAndDefaultArgs instead?");
- if (SubstTemplateTemplateParmStorage *sub = getAsSubstTemplateTemplateParm())
- return sub->getReplacement().getAsTemplateDecl();
+ return cast_if_present<TemplateDecl>(Name.Storage.dyn_cast<Decl *>());
+}
- if (UsingShadowDecl *USD = getAsUsingShadowDecl())
- return cast<TemplateDecl>(USD->getTargetDecl());
+std::pair<TemplateDecl *, DefaultArguments>
+TemplateName::getTemplateDeclAndDefaultArgs() const {
+ for (TemplateName Name = *this; /**/; /**/) {
+ if (Name.getKind() == TemplateName::DeducedTemplate) {
+ DeducedTemplateStorage *DTS = Name.getAsDeducedTemplateName();
+ TemplateDecl *TD =
+ DTS->getUnderlying().getAsTemplateDecl(/*IgnoreDeduced=*/true);
+ DefaultArguments DefArgs = DTS->getDefaultArguments();
+ if (TD && DefArgs)
+ assert(DefArgs.StartPos + DefArgs.Args.size() <=
+ TD->getTemplateParameters()->size());
+ return {TD, DTS->getDefaultArguments()};
+ }
+ if (std::optional<TemplateName> UnderlyingOrNone =
+ Name.desugar(/*IgnoreDeduced=*/false)) {
+ Name = *UnderlyingOrNone;
+ continue;
+ }
+ return {cast_if_present<TemplateDecl>(Name.Storage.dyn_cast<Decl *>()), {}};
+ }
+}
- return nullptr;
+std::optional<TemplateName> TemplateName::desugar(bool IgnoreDeduced) const {
+ if (Decl *D = Storage.dyn_cast<Decl *>()) {
+ if (auto *USD = dyn_cast<UsingShadowDecl>(D))
+ return TemplateName(USD->getTargetDecl());
+ return std::nullopt;
+ }
+ if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
+ return QTN->getUnderlyingTemplate();
+ if (SubstTemplateTemplateParmStorage *S = getAsSubstTemplateTemplateParm())
+ return S->getReplacement();
+ if (IgnoreDeduced)
+ if (DeducedTemplateStorage *S = getAsDeducedTemplateName())
+ return S->getUnderlying();
+ return std::nullopt;
}
OverloadedTemplateStorage *TemplateName::getAsOverloadedTemplate() const {
@@ -214,26 +275,20 @@ UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const {
return nullptr;
}
+DeducedTemplateStorage *TemplateName::getAsDeducedTemplateName() const {
+ if (UncommonTemplateNameStorage *Uncommon =
+ Storage.dyn_cast<UncommonTemplateNameStorage *>())
+ return Uncommon->getAsDeducedTemplateName();
+
+ return nullptr;
+}
+
TemplateNameDependence TemplateName::getDependence() const {
- auto D = TemplateNameDependence::None;
switch (getKind()) {
- case TemplateName::NameKind::QualifiedTemplate:
- if (NestedNameSpecifier *NNS = getAsQualifiedTemplateName()->getQualifier())
- D |= toTemplateNameDependence(NNS->getDependence());
- break;
- case TemplateName::NameKind::DependentTemplate:
- D |= toTemplateNameDependence(
- getAsDependentTemplateName()->getQualifier()->getDependence());
- break;
- case TemplateName::NameKind::SubstTemplateTemplateParmPack:
- D |= TemplateNameDependence::UnexpandedPack;
- break;
- case TemplateName::NameKind::OverloadedTemplate:
- llvm_unreachable("overloaded templates shouldn't survive to here.");
- default:
- break;
- }
- if (TemplateDecl *Template = getAsTemplateDecl()) {
+ case NameKind::Template:
+ case NameKind::UsingTemplate: {
+ TemplateDecl *Template = getAsTemplateDecl();
+ auto D = TemplateNameDependence::None;
if (auto *TTP = dyn_cast<TemplateTemplateParmDecl>(Template)) {
D |= TemplateNameDependence::DependentInstantiation;
if (TTP->isParameterPack())
@@ -246,10 +301,41 @@ TemplateNameDependence TemplateName::getDependence() const {
if (Template->getDeclContext() &&
Template->getDeclContext()->isDependentContext())
D |= TemplateNameDependence::DependentInstantiation;
- } else {
- D |= TemplateNameDependence::DependentInstantiation;
+ return D;
+ }
+ case NameKind::QualifiedTemplate: {
+ QualifiedTemplateName *S = getAsQualifiedTemplateName();
+ TemplateNameDependence D = S->getUnderlyingTemplate().getDependence();
+ if (NestedNameSpecifier *NNS = S->getQualifier())
+ D |= toTemplateNameDependence(NNS->getDependence());
+ return D;
+ }
+ case NameKind::DependentTemplate: {
+ DependentTemplateName *S = getAsDependentTemplateName();
+ auto D = TemplateNameDependence::DependentInstantiation;
+ D |= toTemplateNameDependence(S->getQualifier()->getDependence());
+ return D;
+ }
+ case NameKind::SubstTemplateTemplateParm: {
+ auto *S = getAsSubstTemplateTemplateParm();
+ return S->getReplacement().getDependence();
+ }
+ case NameKind::SubstTemplateTemplateParmPack:
+ return TemplateNameDependence::UnexpandedPack |
+ TemplateNameDependence::DependentInstantiation;
+ case NameKind::DeducedTemplate: {
+ DeducedTemplateStorage *DTS = getAsDeducedTemplateName();
+ TemplateNameDependence D = DTS->getUnderlying().getDependence();
+ for (const TemplateArgument &Arg : DTS->getDefaultArguments().Args)
+ D |= toTemplateNameDependence(Arg.getDependence());
+ return D;
+ }
+ case NameKind::AssumedTemplate:
+ return TemplateNameDependence::DependentInstantiation;
+ case NameKind::OverloadedTemplate:
+ llvm_unreachable("overloaded templates shouldn't survive to here.");
}
- return D;
+ llvm_unreachable("Unknown TemplateName kind");
}
bool TemplateName::isDependent() const {
@@ -331,6 +417,11 @@ void TemplateName::print(raw_ostream &OS, const PrintingPolicy &Policy,
OS << *SubstPack->getParameterPack();
else if (AssumedTemplateStorage *Assumed = getAsAssumedTemplateName()) {
Assumed->getDeclName().print(OS, Policy);
+ } else if (DeducedTemplateStorage *Deduced = getAsDeducedTemplateName()) {
+ Deduced->getUnderlying().print(OS, Policy);
+ DefaultArguments DefArgs = Deduced->getDefaultArguments();
+ OS << ":" << DefArgs.StartPos;
+ printTemplateArgumentList(OS, DefArgs.Args, Policy);
} else {
assert(getKind() == TemplateName::OverloadedTemplate);
OverloadedTemplateStorage *OTS = getAsOverloadedTemplate();
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 5ba9523504258..65928e6c9a497 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -1198,6 +1198,18 @@ void TextNodeDumper::dumpBareTemplateName(TemplateName TN) {
dumpTemplateName(STS->getReplacement(), "replacement");
return;
}
+ case TemplateName::DeducedTemplate: {
+ OS << " deduced";
+ const DeducedTemplateStorage *DTS = TN.getAsDeducedTemplateName();
+ dumpTemplateName(DTS->getUnderlying(), "underlying");
+ AddChild("defaults", [=] {
+ auto [StartPos, Args] = DTS->getDefaultArguments();
+ OS << " start " << StartPos;
+ for (const TemplateArgument &Arg : Args)
+ AddChild([=] { Visit(Arg, SourceRange()); });
+ });
+ return;
+ }
// FIXME: Implement these.
case TemplateName::OverloadedTemplate:
OS << " overloaded";
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index fdaab8e434593..a051e240b1565 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -4295,7 +4295,8 @@ TemplateSpecializationType::TemplateSpecializationType(
T.getKind() == TemplateName::SubstTemplateTemplateParm ||
T.getKind() == TemplateName::SubstTemplateTemplateParmPack ||
T.getKind() == TemplateName::UsingTemplate ||
- T.getKind() == TemplateName::QualifiedTemplate) &&
+ T.getKind() == TemplateName::QualifiedTemplate ||
+ T.getKind() == TemplateName::DeducedTemplate) &&
"Unexpected template name for TemplateSpecializationType");
auto *TemplateArgs = reinterpret_cast<TemplateArgument *>(this + 1);
diff --git a/clang/lib/AST/TypePrinter.cpp b/clang/lib/AST/TypePrinter.cpp
index ffec3ef9d2269..03ee0f12d911c 100644
--- a/clang/lib/AST/TypePrinter.cpp
+++ b/clang/lib/AST/TypePrinter.cpp
@@ -1614,7 +1614,8 @@ void TypePrinter::printTemplateId(const TemplateSpecializationType *T,
raw_ostream &OS, bool FullyQualify) {
IncludeStrongLifetimeRAII Strong(Policy);
- TemplateDecl *TD = T->getTemplateName().getAsTemplateDecl();
+ TemplateDecl *TD =
+ T->getTemplateName().getAsTemplateDecl(/*IgnoreDeduced=*/true);
// FIXME: Null TD never exercised in test suite.
if (FullyQualify && TD) {
if (!Policy.SuppressScope)
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 1cca8ac9b9343..6d49ffcfd0c31 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -4396,8 +4396,9 @@ Sema::BuildMemInitializer(Decl *ConstructorD,
for (auto const &Base : ClassDecl->bases()) {
auto BaseTemplate =
Base.getType()->getAs<TemplateSpecializationType>();
- if (BaseTemplate && Context.hasSameTemplateName(
- BaseTemplate->getTemplateName(), TN)) {
+ if (BaseTemplate &&
+ Context.hasSameTemplateName(BaseTemplate->getTemplateName(), TN,
+ /*IgnoreDeduced=*/true)) {
Diag(IdLoc, diag::ext_unqualified_base_class)
<< SourceRange(IdLoc, Init->getSourceRange().getEnd());
BaseType = Base.getType();
@@ -11419,8 +11420,8 @@ bool Sema::CheckDeductionGuideDeclarator(Declarator &D, QualType &R,
if (auto RetTST =
TSI->getTypeLoc().getAsAdjusted<TemplateSpecializationTypeLoc>()) {
TemplateName SpecifiedName = RetTST.getTypePtr()->getTemplateName();
- bool TemplateMatches =
- Context.hasSameTemplateName(SpecifiedName, GuidedTemplate);
+ bool TemplateMatches = Context.hasSameTemplateName(
+ SpecifiedName, GuidedTemplate, /*IgnoreDeduced=*/true);
const QualifiedTemplateName *Qualifiers =
SpecifiedName.getAsQualifiedTemplateName();
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 87b1f98bbe5ac..40aa890adc0ee 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -3284,8 +3284,8 @@ Sema::findFailedBooleanCondition(Expr *Cond) {
QualType Sema::CheckTemplateIdType(TemplateName Name,
SourceLocation TemplateLoc,
TemplateArgumentListInfo &TemplateArgs) {
- DependentTemplateName *DTN
- = Name.getUnderlying().getAsDependentTemplateName();
+ DependentTemplateName *DTN =
+ Name.getUnderlying().getAsDependentTemplateName();
if (DTN && DTN->isIdentifier())
// When building a template-id where the template-name is dependent,
// assume the template is a type template. Either our assumption is
@@ -3296,10 +3296,11 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
TemplateArgs.arguments());
if (Name.getAsAssumedTemplateName() &&
- resolveAssumedTemplateNameAsType(/*Scope*/nullptr, Name, TemplateLoc))
+ resolveAssumedTemplateNameAsType(/*Scope=*/nullptr, Name, TemplateLoc))
return QualType();
- TemplateDecl *Template = Name.getAsTemplateDecl();
+ auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
+
if (!Template || isa<FunctionTemplateDecl>(Template) ||
isa<VarTemplateDecl>(Template) || isa<ConceptDecl>(Template)) {
// We might have a substituted template template parameter pack. If so,
@@ -3317,8 +3318,9 @@ QualType Sema::CheckTemplateIdType(TemplateName Name,
// Check that the template argument list is well-formed for this
// template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
- if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs, false,
- SugaredConverted, CanonicalConverted,
+ if (CheckTemplateArgumentList(Template, TemplateLoc, TemplateArgs,
+ DefaultArgs, false, SugaredConverted,
+ CanonicalConverted,
/*UpdateArgsWithConversions=*/true))
return QualType();
@@ -3988,7 +3990,8 @@ DeclResult Sema::ActOnVarTemplateSpecialization(
// template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (CheckTemplateArgumentList(VarTemplate, TemplateNameLoc, TemplateArgs,
- false, SugaredConverted, CanonicalConverted,
+ /*DefaultArgs=*/{}, false, SugaredConverted,
+ CanonicalConverted,
/*UpdateArgsWithConversions=*/true))
return true;
@@ -4155,8 +4158,8 @@ Sema::CheckVarTemplateId(VarTemplateDecl *Template, SourceLocation TemplateLoc,
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (CheckTemplateArgumentList(
Template, TemplateNameLoc,
- const_cast<TemplateArgumentListInfo &>(TemplateArgs), false,
- SugaredConverted, CanonicalConverted,
+ const_cast<TemplateArgumentListInfo &>(TemplateArgs),
+ /*DefaultArgs=*/{}, false, SugaredConverted, CanonicalConverted,
/*UpdateArgsWithConversions=*/true))
return true;
@@ -4350,6 +4353,7 @@ Sema::CheckConceptTemplateId(const CXXScopeSpec &SS,
if (CheckTemplateArgumentList(
NamedConcept, ConceptNameInfo.getLoc(),
const_cast<TemplateArgumentListInfo &>(*TemplateArgs),
+ /*DefaultArgs=*/{},
/*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted,
/*UpdateArgsWithConversions=*/false))
return ExprError();
@@ -5274,7 +5278,8 @@ static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
/// for specializing the given template.
bool Sema::CheckTemplateArgumentList(
TemplateDecl *Template, SourceLocation TemplateLoc,
- TemplateArgumentListInfo &TemplateArgs, bool PartialTemplateArgs,
+ TemplateArgumentListInfo &TemplateArgs, const DefaultArguments &DefaultArgs,
+ bool PartialTemplateArgs,
SmallVectorImpl<TemplateArgument> &SugaredConverted,
SmallVectorImpl<TemplateArgument> &CanonicalConverted,
bool UpdateArgsWithConversions, bool *ConstraintsNotSatisfied,
@@ -5302,9 +5307,29 @@ bool Sema::CheckTemplateArgumentList(
SmallVector<TemplateArgument, 2> CanonicalArgumentPack;
unsigned ArgIdx = 0, NumArgs = NewArgs.size();
LocalInstantiationScope InstScope(*this, true);
- for (TemplateParameterList::iterator Param = Params->begin(),
- ParamEnd = Params->end();
- Param != ParamEnd; /* increment in loop */) {
+ for (TemplateParameterList::iterator ParamBegin = Params->begin(),
+ ParamEnd = Params->end(),
+ Param = ParamBegin;
+ Param != ParamEnd;
+ /* increment in loop */) {
+ if (size_t ParamIdx = Param - ParamBegin;
+ DefaultArgs && ParamIdx >= DefaultArgs.StartPos) {
+ // All written arguments should have been consumed by this point.
+ assert(ArgIdx == NumArgs && "bad default argument deduction");
+ // FIXME: Don't ignore parameter packs.
+ if (ParamIdx == DefaultArgs.StartPos && !(*Param)->isParameterPack()) {
+ assert(Param + DefaultArgs.Args.size() <= ParamEnd);
+ // Default arguments from a DeducedTemplateName are already converted.
+ for (const TemplateArgument &DefArg : DefaultArgs.Args) {
+ SugaredConverted.push_back(DefArg);
+ CanonicalConverted.push_back(
+ Context.getCanonicalTemplateArgument(DefArg));
+ ++Param;
+ }
+ continue;
+ }
+ }
+
// If we have an expanded parameter pack, make sure we don't have too
// many arguments.
if (std::optional<unsigned> Expansions = getExpandedPackSize(*Param)) {
@@ -5518,6 +5543,7 @@ bool Sema::CheckTemplateArgumentList(
CTAK_Specified))
return true;
+ SugaredConverted.back().setIsDefaulted(true);
CanonicalConverted.back().setIsDefaulted(true);
// Core issue 150 (assumed resolution): if this is a template template
@@ -7101,7 +7127,7 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
TemplateArgumentLoc &Arg,
bool IsDeduced) {
TemplateName Name = Arg.getArgument().getAsTemplateOrTemplatePattern();
- TemplateDecl *Template = Name.getAsTemplateDecl();
+ auto [Template, DefaultArgs] = Name.getTemplateDeclAndDefaultArgs();
if (!Template) {
// Any dependent template name is fine.
assert(Name.isDependent() && "Non-dependent template isn't a declaration?");
@@ -7152,7 +7178,7 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param,
return false;
if (isTemplateTemplateParameterAtLeastAsSpecializedAs(
- Params, Template, Arg.getLocation(), IsDeduced)) {
+ Params, Template, DefaultArgs, Arg.getLocation(), IsDeduced)) {
// P2113
// C++20[temp.func.order]p2
// [...] If both deductions succeed, the partial ordering selects the
@@ -8196,7 +8222,9 @@ DeclResult Sema::ActOnClassTemplateSpecialization(
// template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, TemplateArgs,
- false, SugaredConverted, CanonicalConverted,
+ /*DefaultArgs=*/{},
+ /*PartialTemplateArgs=*/false, SugaredConverted,
+ CanonicalConverted,
/*UpdateArgsWithConversions=*/true))
return true;
@@ -9494,7 +9522,8 @@ DeclResult Sema::ActOnExplicitInstantiation(
// template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (CheckTemplateArgumentList(ClassTemplate, TemplateNameLoc, TemplateArgs,
- false, SugaredConverted, CanonicalConverted,
+ /*DefaultArgs=*/{}, false, SugaredConverted,
+ CanonicalConverted,
/*UpdateArgsWithConversions=*/true))
return true;
diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp
index 612c23acffcbf..9bf318d939480 100644
--- a/clang/lib/Sema/SemaTemplateDeduction.cpp
+++ b/clang/lib/Sema/SemaTemplateDeduction.cpp
@@ -133,11 +133,16 @@ static bool hasSameExtendedValue(llvm::APSInt X, llvm::APSInt Y) {
return X == Y;
}
+/// What kind of PartialOrdering we're performing template argument deduction
+/// for (C++0x [temp.deduct.partial]).
+enum class PartialOrderingKind { None, NonCall, Call };
+
static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType Param,
QualType Arg, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering, bool DeducedFromArrayBound, bool *HasDeducedAnyParam);
+ PartialOrderingKind POK, bool DeducedFromArrayBound,
+ bool *HasDeducedAnyParam);
enum class PackFold { ParameterToArgument, ArgumentToParameter };
static TemplateDeductionResult
@@ -146,8 +151,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch, PackFold PackFold,
- bool *HasDeducedAnyParam);
+ bool NumberOfArgumentsMustMatch, bool PartialOrdering,
+ PackFold PackFold, bool *HasDeducedAnyParam);
static void MarkUsedTemplateParameters(ASTContext &Ctx,
const TemplateArgument &TemplateArg,
@@ -400,6 +405,7 @@ DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP,
const DeducedTemplateArgument &NewDeduced,
QualType ValueType, TemplateDeductionInfo &Info,
+ bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
assert(NTTP->getDepth() == Info.getDeducedDepth() &&
@@ -444,7 +450,9 @@ DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ParamType, ValueType, Info, Deduced,
- TDF_SkipNonDependent, /*PartialOrdering=*/false,
+ TDF_SkipNonDependent,
+ PartialOrdering ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*ArrayBound=*/NewDeduced.wasDeducedFromArrayBound(), HasDeducedAnyParam);
}
@@ -454,13 +462,13 @@ static TemplateDeductionResult DeduceNonTypeTemplateArgument(
Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP, const llvm::APSInt &Value,
QualType ValueType, bool DeducedFromArrayBound, TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool PartialOrdering, SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP,
DeducedTemplateArgument(S.Context, Value, ValueType,
DeducedFromArrayBound),
- ValueType, Info, Deduced, HasDeducedAnyParam);
+ ValueType, Info, PartialOrdering, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
@@ -469,6 +477,7 @@ static TemplateDeductionResult
DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP,
QualType NullPtrType, TemplateDeductionInfo &Info,
+ bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
Expr *Value = S.ImpCastExprToType(
@@ -480,7 +489,7 @@ DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
.get();
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(),
- Info, Deduced, HasDeducedAnyParam);
+ Info, PartialOrdering, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
@@ -490,12 +499,12 @@ DeduceNullPtrTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
static TemplateDeductionResult
DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP, Expr *Value,
- TemplateDeductionInfo &Info,
+ TemplateDeductionInfo &Info, bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, DeducedTemplateArgument(Value), Value->getType(),
- Info, Deduced, HasDeducedAnyParam);
+ Info, PartialOrdering, Deduced, HasDeducedAnyParam);
}
/// Deduce the value of the given non-type template parameter
@@ -506,77 +515,22 @@ static TemplateDeductionResult
DeduceNonTypeTemplateArgument(Sema &S, TemplateParameterList *TemplateParams,
const NonTypeTemplateParmDecl *NTTP, ValueDecl *D,
QualType T, TemplateDeductionInfo &Info,
+ bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
D = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr;
TemplateArgument New(D, T);
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(New), T, Info,
- Deduced, HasDeducedAnyParam);
-}
-
-/// Create a shallow copy of a given template parameter declaration, with
-/// empty source locations and using the given TemplateArgument as it's
-/// default argument.
-///
-/// \returns The new template parameter declaration.
-static NamedDecl *getTemplateParameterWithDefault(Sema &S, NamedDecl *A,
- TemplateArgument Default) {
- switch (A->getKind()) {
- case Decl::TemplateTypeParm: {
- auto *T = cast<TemplateTypeParmDecl>(A);
- auto *R = TemplateTypeParmDecl::Create(
- S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(),
- T->getDepth(), T->getIndex(), T->getIdentifier(),
- T->wasDeclaredWithTypename(), T->isParameterPack(),
- T->hasTypeConstraint());
- R->setDefaultArgument(
- S.Context,
- S.getTrivialTemplateArgumentLoc(Default, QualType(), SourceLocation()));
- if (R->hasTypeConstraint()) {
- auto *C = R->getTypeConstraint();
- R->setTypeConstraint(C->getConceptReference(),
- C->getImmediatelyDeclaredConstraint());
- }
- return R;
- }
- case Decl::NonTypeTemplateParm: {
- auto *T = cast<NonTypeTemplateParmDecl>(A);
- auto *R = NonTypeTemplateParmDecl::Create(
- S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(),
- T->getDepth(), T->getIndex(), T->getIdentifier(), T->getType(),
- T->isParameterPack(), T->getTypeSourceInfo());
- R->setDefaultArgument(S.Context,
- S.getTrivialTemplateArgumentLoc(
- Default, Default.getNonTypeTemplateArgumentType(),
- SourceLocation()));
- if (auto *PTC = T->getPlaceholderTypeConstraint())
- R->setPlaceholderTypeConstraint(PTC);
- return R;
- }
- case Decl::TemplateTemplateParm: {
- auto *T = cast<TemplateTemplateParmDecl>(A);
- auto *R = TemplateTemplateParmDecl::Create(
- S.Context, A->getDeclContext(), SourceLocation(), T->getDepth(),
- T->getIndex(), T->isParameterPack(), T->getIdentifier(),
- T->wasDeclaredWithTypename(), T->getTemplateParameters());
- R->setDefaultArgument(
- S.Context,
- S.getTrivialTemplateArgumentLoc(Default, QualType(), SourceLocation()));
- return R;
- }
- default:
- llvm_unreachable("Unexpected Decl Kind");
- }
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info,
+ PartialOrdering, Deduced, HasDeducedAnyParam);
}
-static TemplateDeductionResult
-DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
- TemplateName Param, TemplateName Arg,
- TemplateDeductionInfo &Info,
- ArrayRef<TemplateArgument> DefaultArguments,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool *HasDeducedAnyParam) {
+static TemplateDeductionResult DeduceTemplateArguments(
+ Sema &S, TemplateParameterList *TemplateParams, TemplateName Param,
+ TemplateName Arg, TemplateDeductionInfo &Info,
+ ArrayRef<TemplateArgument> DefaultArguments, bool PartialOrdering,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced,
+ bool *HasDeducedAnyParam) {
TemplateDecl *ParamDecl = Param.getAsTemplateDecl();
if (!ParamDecl) {
// The parameter type is dependent and is not a template template parameter,
@@ -589,42 +543,30 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (TempParam->getDepth() != Info.getDeducedDepth())
return TemplateDeductionResult::Success;
- auto NewDeduced = DeducedTemplateArgument(Arg);
- // Provisional resolution for CWG2398: If Arg is also a template template
- // param, and it names a template specialization, then we deduce a
- // synthesized template template parameter based on A, but using the TS's
- // arguments as defaults.
- if (auto *TempArg = dyn_cast_or_null<TemplateTemplateParmDecl>(
- Arg.getAsTemplateDecl())) {
- assert(!TempArg->isExpandedParameterPack());
-
- TemplateParameterList *As = TempArg->getTemplateParameters();
- if (DefaultArguments.size() != 0) {
- assert(DefaultArguments.size() <= As->size());
- SmallVector<NamedDecl *, 4> Params(As->size());
- for (unsigned I = 0; I < DefaultArguments.size(); ++I)
- Params[I] = getTemplateParameterWithDefault(S, As->getParam(I),
- DefaultArguments[I]);
- for (unsigned I = DefaultArguments.size(); I < As->size(); ++I)
- Params[I] = As->getParam(I);
- // FIXME: We could unique these, and also the parameters, but we don't
- // expect programs to contain a large enough amount of these deductions
- // for that to be worthwhile.
- auto *TPL = TemplateParameterList::Create(
- S.Context, SourceLocation(), SourceLocation(), Params,
- SourceLocation(), As->getRequiresClause());
- NewDeduced = DeducedTemplateArgument(
- TemplateName(TemplateTemplateParmDecl::Create(
- S.Context, TempArg->getDeclContext(), SourceLocation(),
- TempArg->getDepth(), TempArg->getPosition(),
- TempArg->isParameterPack(), TempArg->getIdentifier(),
- TempArg->wasDeclaredWithTypename(), TPL)));
+ ArrayRef<NamedDecl *> Params =
+ ParamDecl->getTemplateParameters()->asArray();
+ unsigned StartPos = 0;
+ for (unsigned I = 0, E = std::min(Params.size(), DefaultArguments.size());
+ I < E; ++I) {
+ if (Params[I]->isParameterPack()) {
+ StartPos = DefaultArguments.size();
+ break;
}
+ StartPos = I + 1;
}
- DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
- Deduced[TempParam->getIndex()],
- NewDeduced);
+ // Provisional resolution for CWG2398: If Arg names a template
+ // specialization, then we deduce a synthesized template name
+ // based on A, but using the TS's extra arguments, relative to P, as
+ // defaults.
+ DeducedTemplateArgument NewDeduced =
+ PartialOrdering
+ ? TemplateArgument(S.Context.getDeducedTemplateName(
+ Arg, {StartPos, DefaultArguments.drop_front(StartPos)}))
+ : Arg;
+
+ DeducedTemplateArgument Result = checkDeducedTemplateArguments(
+ S.Context, Deduced[TempParam->getIndex()], NewDeduced);
if (Result.isNull()) {
Info.Param = TempParam;
Info.FirstArg = Deduced[TempParam->getIndex()];
@@ -639,7 +581,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
}
// Verify that the two template names are equivalent.
- if (S.Context.hasSameTemplateName(Param, Arg))
+ if (S.Context.hasSameTemplateName(
+ Param, Arg, /*IgnoreDeduced=*/DefaultArguments.size() != 0))
return TemplateDeductionResult::Success;
// Mismatch of non-dependent template parameter to argument.
@@ -681,7 +624,7 @@ static const TemplateSpecializationType *getLastTemplateSpecType(QualType QT) {
static TemplateDeductionResult
DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
const QualType P, QualType A,
- TemplateDeductionInfo &Info,
+ TemplateDeductionInfo &Info, bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
QualType UP = P;
@@ -730,9 +673,10 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
->template_arguments();
// Perform template argument deduction for the template name.
- if (auto Result =
- DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
- AResolved, Deduced, HasDeducedAnyParam);
+ if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
+ /*DefaultArguments=*/AResolved,
+ PartialOrdering, Deduced,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -741,8 +685,8 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
// filled in by default arguments.
return DeduceTemplateArguments(
S, TemplateParams, PResolved, AResolved, Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
- HasDeducedAnyParam);
+ /*NumberOfArgumentsMustMatch=*/false, PartialOrdering,
+ PackFold::ParameterToArgument, HasDeducedAnyParam);
}
// If the argument type is a class template specialization, we
@@ -763,9 +707,10 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
*NNS, false, TemplateName(SA->getSpecializedTemplate()));
// Perform template argument deduction for the template name.
- if (auto Result = DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info,
- SA->getTemplateArgs().asArray(),
- Deduced, HasDeducedAnyParam);
+ if (auto Result = DeduceTemplateArguments(
+ S, TemplateParams, TNP, TNA, Info,
+ /*DefaultArguments=*/SA->getTemplateArgs().asArray(), PartialOrdering,
+ Deduced, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -773,7 +718,7 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
return DeduceTemplateArguments(S, TemplateParams, PResolved,
SA->getTemplateArgs().asArray(), Info, Deduced,
/*NumberOfArgumentsMustMatch=*/true,
- PackFold::ParameterToArgument,
+ PartialOrdering, PackFold::ParameterToArgument,
HasDeducedAnyParam);
}
@@ -1188,7 +1133,7 @@ static TemplateDeductionResult DeduceForEachType(
Sema &S, TemplateParameterList *TemplateParams, const QualType *Params,
unsigned NumParams, const QualType *Args, unsigned NumArgs,
TemplateDeductionInfo &Info,
- SmallVectorImpl<DeducedTemplateArgument> &Deduced, bool PartialOrdering,
+ SmallVectorImpl<DeducedTemplateArgument> &Deduced, PartialOrderingKind POK,
bool FinishingDeduction, T &&DeductFunc) {
// C++0x [temp.deduct.type]p10:
// Similarly, if P has a form that contains (T), then each parameter type
@@ -1218,8 +1163,7 @@ static TemplateDeductionResult DeduceForEachType(
if (TemplateDeductionResult Result =
DeductFunc(S, TemplateParams, ParamIdx, ArgIdx,
Params[ParamIdx].getUnqualifiedType(),
- Args[ArgIdx].getUnqualifiedType(), Info, Deduced,
- PartialOrdering);
+ Args[ArgIdx].getUnqualifiedType(), Info, Deduced, POK);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1247,7 +1191,7 @@ static TemplateDeductionResult DeduceForEachType(
if (TemplateDeductionResult Result = DeductFunc(
S, TemplateParams, ParamIdx, ArgIdx,
Pattern.getUnqualifiedType(), Args[ArgIdx].getUnqualifiedType(),
- Info, Deduced, PartialOrdering);
+ Info, Deduced, POK);
Result != TemplateDeductionResult::Success)
return Result;
PackScope.nextPackElement();
@@ -1291,7 +1235,7 @@ static TemplateDeductionResult DeduceForEachType(
// During partial ordering, if Ai was originally a function parameter pack:
// - if P does not contain a function parameter type corresponding to Ai then
// Ai is ignored;
- if (PartialOrdering && ArgIdx + 1 == NumArgs &&
+ if (POK == PartialOrderingKind::Call && ArgIdx + 1 == NumArgs &&
isa<PackExpansionType>(Args[ArgIdx]))
return TemplateDeductionResult::Success;
@@ -1337,18 +1281,18 @@ static TemplateDeductionResult DeduceTemplateArguments(
unsigned NumParams, const QualType *Args, unsigned NumArgs,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering, bool *HasDeducedAnyParam,
+ PartialOrderingKind POK, bool *HasDeducedAnyParam,
llvm::SmallBitVector *HasDeducedParam) {
return ::DeduceForEachType(
- S, TemplateParams, Params, NumParams, Args, NumArgs, Info, Deduced,
- PartialOrdering, /*FinishingDeduction=*/false,
+ S, TemplateParams, Params, NumParams, Args, NumArgs, Info, Deduced, POK,
+ /*FinishingDeduction=*/false,
[&](Sema &S, TemplateParameterList *TemplateParams, int ParamIdx,
int ArgIdx, QualType P, QualType A, TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool PartialOrdering) {
+ PartialOrderingKind POK) {
bool HasDeducedAnyParamCopy = false;
TemplateDeductionResult TDR = DeduceTemplateArgumentsByTypeMatch(
- S, TemplateParams, P, A, Info, Deduced, TDF, PartialOrdering,
+ S, TemplateParams, P, A, Info, Deduced, TDF, POK,
/*DeducedFromArrayBound=*/false, &HasDeducedAnyParamCopy);
if (HasDeducedAnyParam && HasDeducedAnyParamCopy)
*HasDeducedAnyParam = true;
@@ -1457,7 +1401,7 @@ static CXXRecordDecl *getCanonicalRD(QualType T) {
static TemplateDeductionResult
DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
TemplateParameterList *TemplateParams, QualType P,
- TemplateDeductionInfo &Info,
+ TemplateDeductionInfo &Info, bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
// C++14 [temp.deduct.call] p4b3:
@@ -1508,9 +1452,9 @@ DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
Deduced.end());
TemplateDeductionInfo BaseInfo(TemplateDeductionInfo::ForBase, Info);
bool HasDeducedAnyParamCopy = false;
- TemplateDeductionResult BaseResult =
- DeduceTemplateSpecArguments(S, TemplateParams, P, NextT, BaseInfo,
- DeducedCopy, &HasDeducedAnyParamCopy);
+ TemplateDeductionResult BaseResult = DeduceTemplateSpecArguments(
+ S, TemplateParams, P, NextT, BaseInfo, PartialOrdering, DeducedCopy,
+ &HasDeducedAnyParamCopy);
// If this was a successful deduction, add it to the list of matches,
// otherwise we need to continue searching its bases.
@@ -1584,7 +1528,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Sema &S, TemplateParameterList *TemplateParams, QualType P, QualType A,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
- bool PartialOrdering, bool DeducedFromArrayBound,
+ PartialOrderingKind POK, bool DeducedFromArrayBound,
bool *HasDeducedAnyParam) {
// If the argument type is a pack expansion, look at its pattern.
@@ -1593,7 +1537,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
A = AExp->getPattern();
assert(!isa<PackExpansionType>(A.getCanonicalType()));
- if (PartialOrdering) {
+ if (POK == PartialOrderingKind::Call) {
// C++11 [temp.deduct.partial]p5:
// Before the partial ordering is done, certain transformations are
// performed on the types used for partial ordering:
@@ -1867,7 +1811,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
- Deduced, TDF, /*PartialOrdering=*/false,
+ Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1878,7 +1824,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
- Deduced, TDF, /*PartialOrdering=*/false,
+ Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1896,8 +1844,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, P->castAs<PointerType>()->getPointeeType(),
PointeeType, Info, Deduced,
TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass),
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// T &
@@ -1909,7 +1858,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0, /*PartialOrdering=*/false,
+ Deduced, 0,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1922,7 +1873,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
- Deduced, 0, /*PartialOrdering=*/false,
+ Deduced, 0,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1937,7 +1890,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, IAP->getElementType(), IAA->getElementType(), Info,
- Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ Deduced, TDF & TDF_IgnoreQualifiers,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1951,7 +1906,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
- Deduced, TDF & TDF_IgnoreQualifiers, /*PartialOrdering=*/false,
+ Deduced, TDF & TDF_IgnoreQualifiers,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -1967,7 +1924,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, DAP->getElementType(), AA->getElementType(),
Info, Deduced, TDF & TDF_IgnoreQualifiers,
- /*PartialOrdering=*/false,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -1986,13 +1944,14 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
llvm::APSInt Size(CAA->getSize());
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Size, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
+ /*ArrayBound=*/true, Info, POK != PartialOrderingKind::None,
+ Deduced, HasDeducedAnyParam);
}
if (const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
if (DAA->getSizeExpr())
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DAA->getSizeExpr(), Info,
- Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DAA->getSizeExpr(), Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
// Incomplete type does not match a dependently-sized array type
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2016,7 +1975,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
Info, Deduced, 0,
- /*PartialOrdering=*/false,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2025,8 +1985,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArguments(
S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
- TDF & TDF_TopLevelParameterTypeList, PartialOrdering,
- HasDeducedAnyParam, /*HasDeducedParam=*/nullptr);
+ TDF & TDF_TopLevelParameterTypeList, POK, HasDeducedAnyParam,
+ /*HasDeducedParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2054,14 +2014,14 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// FIXME: Should we?
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
- /*DeducedFromArrayBound=*/true, Info, Deduced,
- HasDeducedAnyParam);
+ /*DeducedFromArrayBound=*/true, Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
case CT_Dependent:
if (Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- ArgNoexceptExpr, Info, Deduced,
- HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgNoexceptExpr, Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
// Can't deduce anything from throw(T...).
break;
}
@@ -2088,13 +2048,15 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// arguments from the template-id.
if (!(TDF & TDF_DerivedClass) || !A->isRecordType())
return DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
+ POK != PartialOrderingKind::None,
Deduced, HasDeducedAnyParam);
SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
Deduced.end());
- auto Result = DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
- Deduced, HasDeducedAnyParam);
+ auto Result = DeduceTemplateSpecArguments(
+ S, TemplateParams, P, A, Info, POK != PartialOrderingKind::None,
+ Deduced, HasDeducedAnyParam);
if (Result == TemplateDeductionResult::Success)
return Result;
@@ -2111,9 +2073,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
Deduced = DeducedOrig;
// Check bases according to C++14 [temp.deduct.call] p4b3:
- auto BaseResult =
- DeduceTemplateBases(S, getCanonicalRD(A), TemplateParams, P, Info,
- Deduced, HasDeducedAnyParam);
+ auto BaseResult = DeduceTemplateBases(
+ S, getCanonicalRD(A), TemplateParams, P, Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
return BaseResult != TemplateDeductionResult::Invalid ? BaseResult
: Result;
}
@@ -2145,15 +2107,17 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, PPT, APT, Info, Deduced, SubTDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, QualType(MPP->getClass(), 0),
QualType(MPA->getClass(), 0), Info, Deduced, SubTDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
// (clang extension)
@@ -2168,7 +2132,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return TemplateDeductionResult::NonDeducedMismatch;
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
- Deduced, 0, /*PartialOrdering=*/false,
+ Deduced, 0,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -2194,8 +2160,10 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
- TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
case Type::DependentVector: {
@@ -2205,7 +2173,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2221,16 +2191,19 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Note that we use the "array bound" rules here; just like in that
// case, we don't have any particular type for the vector size, but
// we can provide one if necessary.
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
- S.Context.UnsignedIntTy, true,
- Info, Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgSize, S.Context.UnsignedIntTy, true,
+ Info, POK != PartialOrderingKind::None, Deduced,
+ HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2241,9 +2214,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced,
- HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, VA->getSizeExpr(), Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2259,7 +2232,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2275,16 +2250,18 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Note that we use the "array bound" rules here; just like in that
// case, we don't have any particular type for the vector size, but
// we can provide one if necessary.
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
- S.Context.IntTy, true, Info,
- Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgSize, S.Context.IntTy, true, Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
}
if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) {
// Perform deduction on the element types.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, VP->getElementType(), VA->getElementType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2295,9 +2272,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- VA->getSizeExpr(), Info, Deduced,
- HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, VA->getSizeExpr(), Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2321,7 +2298,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on element types.
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
- Deduced, TDF, /*PartialOrdering=*/false,
+ Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
@@ -2334,14 +2313,16 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Check the element type of the matrixes.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, MP->getElementType(), MA->getElementType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
// Try to deduce a matrix dimension.
auto DeduceMatrixArg =
- [&S, &Info, &Deduced, &TemplateParams, &HasDeducedAnyParam](
+ [&S, &Info, &Deduced, &TemplateParams, &HasDeducedAnyParam, POK](
Expr *ParamExpr, const MatrixType *A,
unsigned (ConstantMatrixType::*GetArgDimension)() const,
Expr *(DependentSizedMatrixType::*GetArgDimensionExpr)() const) {
@@ -2378,12 +2359,13 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
ArgConst = (ACM->*GetArgDimension)();
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, ArgConst, S.Context.getSizeType(),
- /*ArrayBound=*/true, Info, Deduced, HasDeducedAnyParam);
+ /*ArrayBound=*/true, Info, POK != PartialOrderingKind::None,
+ Deduced, HasDeducedAnyParam);
}
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, (ADM->*GetArgDimensionExpr)(), Info,
- Deduced, HasDeducedAnyParam);
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
};
if (auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
@@ -2407,7 +2389,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
// Perform deduction on the pointer type.
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
- Info, Deduced, TDF, /*PartialOrdering=*/false,
+ Info, Deduced, TDF,
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
/*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2418,9 +2402,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (!NTTP)
return TemplateDeductionResult::Success;
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- ASA->getAddrSpaceExpr(), Info,
- Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
}
if (isTargetAddressSpace(A.getAddressSpace())) {
@@ -2432,8 +2416,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (auto Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ASP->getPointeeType(),
S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2445,7 +2430,8 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, ArgAddressSpace, S.Context.IntTy, true,
- Info, Deduced, HasDeducedAnyParam);
+ Info, POK != PartialOrderingKind::None, Deduced,
+ HasDeducedAnyParam);
}
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2465,9 +2451,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
ArgSize = IA->getNumBits();
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
- S.Context.IntTy, true, Info,
- Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, ArgSize, S.Context.IntTy, true, Info,
+ POK != PartialOrderingKind::None, Deduced, HasDeducedAnyParam);
}
if (const auto *IA = A->getAs<DependentBitIntType>()) {
@@ -2498,8 +2484,9 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
if (PIT->hasSelectedType()) {
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, PIT->getSelectedType(), A, Info, Deduced, TDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ POK != PartialOrderingKind::None ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
}
return TemplateDeductionResult::IncompletePack;
}
@@ -2511,7 +2498,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
static TemplateDeductionResult
DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
const TemplateArgument &P, TemplateArgument A,
- TemplateDeductionInfo &Info,
+ TemplateDeductionInfo &Info, bool PartialOrdering,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
bool *HasDeducedAnyParam) {
// If the template argument is a pack expansion, perform template argument
@@ -2528,17 +2515,21 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (A.getKind() == TemplateArgument::Type)
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
- HasDeducedAnyParam);
+ PartialOrdering ? PartialOrderingKind::NonCall
+ : PartialOrderingKind::None,
+ /*DeducedFromArrayBound=*/false, HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
case TemplateArgument::Template:
+ // PartialOrdering does not matter here, since template specializations are
+ // not being deduced.
if (A.getKind() == TemplateArgument::Template)
return DeduceTemplateArguments(
S, TemplateParams, P.getAsTemplate(), A.getAsTemplate(), Info,
- /*DefaultArguments=*/{}, Deduced, HasDeducedAnyParam);
+ /*DefaultArguments=*/{}, /*PartialOrdering=*/false, Deduced,
+ HasDeducedAnyParam);
Info.FirstArg = P;
Info.SecondArg = A;
return TemplateDeductionResult::NonDeducedMismatch;
@@ -2589,20 +2580,20 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
case TemplateArgument::Integral:
case TemplateArgument::Expression:
case TemplateArgument::StructuralValue:
- return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
- DeducedTemplateArgument(A),
- A.getNonTypeTemplateArgumentType(),
- Info, Deduced, HasDeducedAnyParam);
+ return DeduceNonTypeTemplateArgument(
+ S, TemplateParams, NTTP, DeducedTemplateArgument(A),
+ A.getNonTypeTemplateArgumentType(), Info, PartialOrdering, Deduced,
+ HasDeducedAnyParam);
case TemplateArgument::NullPtr:
- return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
- A.getNullPtrType(), Info, Deduced,
- HasDeducedAnyParam);
+ return DeduceNullPtrTemplateArgument(
+ S, TemplateParams, NTTP, A.getNullPtrType(), Info, PartialOrdering,
+ Deduced, HasDeducedAnyParam);
case TemplateArgument::Declaration:
return DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, A.getAsDecl(), A.getParamTypeForDecl(),
- Info, Deduced, HasDeducedAnyParam);
+ Info, PartialOrdering, Deduced, HasDeducedAnyParam);
case TemplateArgument::Null:
case TemplateArgument::Type:
@@ -2674,8 +2665,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
ArrayRef<TemplateArgument> As,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool NumberOfArgumentsMustMatch, PackFold PackFold,
- bool *HasDeducedAnyParam) {
+ bool NumberOfArgumentsMustMatch, bool PartialOrdering,
+ PackFold PackFold, bool *HasDeducedAnyParam) {
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Ps, As);
// C++0x [temp.deduct.type]p9:
@@ -2712,7 +2703,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
if (PackFold == PackFold::ArgumentToParameter)
std::swap(Pi, Ai);
if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
- Deduced, HasDeducedAnyParam);
+ PartialOrdering, Deduced,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2744,7 +2736,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
std::swap(Pi, Ai);
// Deduce template arguments from the pattern.
if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pi, Ai, Info,
- Deduced, HasDeducedAnyParam);
+ PartialOrdering, Deduced,
+ HasDeducedAnyParam);
Result != TemplateDeductionResult::Success)
return Result;
@@ -2768,7 +2761,8 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
bool NumberOfArgumentsMustMatch) {
return ::DeduceTemplateArguments(
*this, TemplateParams, Ps, As, Info, Deduced, NumberOfArgumentsMustMatch,
- PackFold::ParameterToArgument, /*HasDeducedAnyParam=*/nullptr);
+ /*PartialOrdering=*/false, PackFold::ParameterToArgument,
+ /*HasDeducedAnyParam=*/nullptr);
}
/// Determine whether two template arguments are the same.
@@ -3292,7 +3286,7 @@ FinishTemplateArgumentDeduction(
SmallVector<TemplateArgument, 4> SugaredConvertedInstArgs,
CanonicalConvertedInstArgs;
if (S.CheckTemplateArgumentList(
- Template, Partial->getLocation(), InstArgs, false,
+ Template, Partial->getLocation(), InstArgs, /*DefaultArgs=*/{}, false,
SugaredConvertedInstArgs, CanonicalConvertedInstArgs,
/*UpdateArgsWithConversions=*/true, &ConstraintsNotSatisfied))
return ConstraintsNotSatisfied
@@ -3439,7 +3433,8 @@ DeduceTemplateArguments(Sema &S, T *Partial,
if (TemplateDeductionResult Result = ::DeduceTemplateArguments(
S, Partial->getTemplateParameters(),
Partial->getTemplateArgs().asArray(), TemplateArgs, Info, Deduced,
- /*NumberOfArgumentsMustMatch=*/false, PackFold::ParameterToArgument,
+ /*NumberOfArgumentsMustMatch=*/false, /*PartialOrdering=*/true,
+ PackFold::ParameterToArgument,
/*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -3591,8 +3586,8 @@ TemplateDeductionResult Sema::SubstituteExplicitTemplateArguments(
return TemplateDeductionResult::InstantiationDepth;
if (CheckTemplateArgumentList(FunctionTemplate, SourceLocation(),
- ExplicitTemplateArgs, true, SugaredBuilder,
- CanonicalBuilder,
+ ExplicitTemplateArgs, /*DefaultArgs=*/{}, true,
+ SugaredBuilder, CanonicalBuilder,
/*UpdateArgsWithConversions=*/false) ||
Trap.hasErrorOccurred()) {
unsigned Index = SugaredBuilder.size();
@@ -4245,7 +4240,7 @@ ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
TemplateDeductionInfo Info(Ovl->getNameLoc());
TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ PartialOrderingKind::None, /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr);
if (Result != TemplateDeductionResult::Success)
continue;
@@ -4432,7 +4427,7 @@ static TemplateDeductionResult DeduceFromInitializerList(
llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits());
if (auto Result = DeduceNonTypeTemplateArgument(
S, TemplateParams, NTTP, llvm::APSInt(Size), T,
- /*ArrayBound=*/true, Info, Deduced,
+ /*ArrayBound=*/true, Info, /*PartialOrdering=*/false, Deduced,
/*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -4478,7 +4473,7 @@ static TemplateDeductionResult DeduceTemplateArgumentsFromCallArgument(
Sema::OriginalCallArg(OrigParamType, DecomposedParam, ArgIdx, ArgType));
return DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, ParamType, ArgType, Info, Deduced, TDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ PartialOrderingKind::None, /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr);
}
@@ -4803,7 +4798,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
// Deduce template arguments from the function type.
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
*this, TemplateParams, FunctionType, ArgFunctionType, Info, Deduced,
- TDF, /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ TDF, PartialOrderingKind::None, /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -4985,7 +4980,7 @@ TemplateDeductionResult Sema::DeduceTemplateArguments(
if (TemplateDeductionResult Result = DeduceTemplateArgumentsByTypeMatch(
*this, TemplateParams, P, A, Info, Deduced, TDF,
- /*PartialOrdering=*/false, /*DeducedFromArrayBound=*/false,
+ PartialOrderingKind::None, /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr);
Result != TemplateDeductionResult::Success)
return Result;
@@ -5123,9 +5118,9 @@ static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
TemplateArgs.addArgument(TypeLoc.getArgLoc(I));
llvm::SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
- if (S.CheckTemplateArgumentList(Concept, SourceLocation(), TemplateArgs,
- /*PartialTemplateArgs=*/false,
- SugaredConverted, CanonicalConverted))
+ if (S.CheckTemplateArgumentList(
+ Concept, SourceLocation(), TemplateArgs, /*DefaultArgs=*/{},
+ /*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted))
return true;
MultiLevelTemplateArgumentList MLTAL(Concept, CanonicalConverted,
/*Final=*/false);
@@ -5276,7 +5271,8 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *Init, QualType &Result,
if (auto TDK = DeduceTemplateArgumentsFromCallArgument(
*this, TemplateParamsSt.get(), 0, TemplArg, Init->getType(),
Init->Classify(getASTContext()), Init, Info, Deduced,
- OriginalCallArgs, /*Decomposed=*/true,
+ OriginalCallArgs,
+ /*Decomposed=*/true,
/*ArgIdx=*/0, /*TDF=*/0);
TDK != TemplateDeductionResult::Success) {
if (TDK == TemplateDeductionResult::Inconsistent) {
@@ -5304,8 +5300,8 @@ Sema::DeduceAutoType(TypeLoc Type, Expr *Init, QualType &Result,
if (auto TDK = DeduceTemplateArgumentsFromCallArgument(
*this, TemplateParamsSt.get(), 0, FuncParam, Init->getType(),
Init->Classify(getASTContext()), Init, Info, Deduced,
- OriginalCallArgs, /*Decomposed=*/false, /*ArgIdx=*/0, /*TDF=*/0,
- FailedTSC);
+ OriginalCallArgs,
+ /*Decomposed=*/false, /*ArgIdx=*/0, /*TDF=*/0, FailedTSC);
TDK != TemplateDeductionResult::Success)
return DeductionFailed(TDK);
}
@@ -5644,7 +5640,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
llvm::SmallBitVector HasDeducedParam(Args2.size());
if (DeduceTemplateArguments(
S, TemplateParams, Args2.data(), Args2.size(), Args1.data(),
- Args1.size(), Info, Deduced, TDF_None, /*PartialOrdering=*/true,
+ Args1.size(), Info, Deduced, TDF_None, PartialOrderingKind::Call,
/*HasDeducedAnyParam=*/nullptr,
&HasDeducedParam) != TemplateDeductionResult::Success)
return false;
@@ -5666,13 +5662,13 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
ArrayRef<TemplateArgument> DeducedArgs) {
return ::DeduceForEachType(
S, TemplateParams, Args2.data(), Args2.size(), Args1.data(),
- Args1.size(), Info, Deduced,
- /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ Args1.size(), Info, Deduced, PartialOrderingKind::Call,
+ /*FinishingDeduction=*/true,
[&](Sema &S, TemplateParameterList *, int ParamIdx,
int ArgIdx, QualType P, QualType A,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool) {
+ PartialOrderingKind) {
// As a provisional fix for a core issue that does not
// exist yet, only check the consistency of parameters
// which participated in deduction. We still try to
@@ -5692,8 +5688,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
// of the conversion function templates are used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, Proto2->getReturnType(), Proto1->getReturnType(),
- Info, Deduced, TDF_None,
- /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ Info, Deduced, TDF_None, PartialOrderingKind::Call,
+ /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
@@ -5727,8 +5723,8 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
// is used.
if (DeduceTemplateArgumentsByTypeMatch(
S, TemplateParams, FD2->getType(), FD1->getType(), Info, Deduced,
- TDF_AllowCompatibleFunctionType,
- /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ TDF_AllowCompatibleFunctionType, PartialOrderingKind::Call,
+ /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
@@ -5758,12 +5754,12 @@ static bool isAtLeastAsSpecializedAs(Sema &S, SourceLocation Loc,
Proto2->getParamTypes().size(),
Proto1->getParamTypes().data(),
Proto1->getParamTypes().size(), Info, Deduced,
- /*PartialOrdering=*/true, /*FinishingDeduction=*/true,
+ PartialOrderingKind::Call, /*FinishingDeduction=*/true,
[&](Sema &S, TemplateParameterList *, int ParamIdx,
int ArgIdx, QualType P, QualType A,
TemplateDeductionInfo &Info,
SmallVectorImpl<DeducedTemplateArgument> &Deduced,
- bool) {
+ PartialOrderingKind) {
return ::CheckDeductionConsistency(
S, FTD, ArgIdx, P, A, DeducedArgs,
/*CheckConsistency=*/true);
@@ -6212,7 +6208,7 @@ static bool isAtLeastAsSpecializedAs(Sema &S, QualType T1, QualType T2,
Deduced.resize(P2->getTemplateParameters()->size());
if (DeduceTemplateArgumentsByTypeMatch(
S, P2->getTemplateParameters(), T2, T1, Info, Deduced, TDF_None,
- /*PartialOrdering=*/true, /*DeducedFromArrayBound=*/false,
+ PartialOrderingKind::Call, /*DeducedFromArrayBound=*/false,
/*HasDeducedAnyParam=*/nullptr) != TemplateDeductionResult::Success)
return false;
@@ -6471,8 +6467,8 @@ bool Sema::isMoreSpecializedThanPrimary(
}
bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
- TemplateParameterList *P, TemplateDecl *AArg, SourceLocation Loc,
- bool IsDeduced) {
+ TemplateParameterList *P, TemplateDecl *AArg,
+ const DefaultArguments &DefaultArgs, SourceLocation Loc, bool IsDeduced) {
// C++1z [temp.arg.template]p4: (DR 150)
// A template template-parameter P is at least as specialized as a
// template template-argument A if, given the following rewrite to two
@@ -6520,8 +6516,9 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
// If the rewrite produces an invalid type, then P is not at least as
// specialized as A.
SmallVector<TemplateArgument, 4> SugaredPArgs;
- if (CheckTemplateArgumentList(AArg, Loc, PArgList, false, SugaredPArgs,
- PArgs, /*UpdateArgsWithConversions=*/true,
+ if (CheckTemplateArgumentList(AArg, Loc, PArgList, DefaultArgs, false,
+ SugaredPArgs, PArgs,
+ /*UpdateArgsWithConversions=*/true,
/*ConstraintsNotSatisfied=*/nullptr,
/*PartialOrderTTP=*/true) ||
Trap.hasErrorOccurred())
@@ -6546,6 +6543,7 @@ bool Sema::isTemplateTemplateParameterAtLeastAsSpecializedAs(
// currently implemented as a special case elsewhere.
if (::DeduceTemplateArguments(*this, A, AArgs, PArgs, Info, Deduced,
/*NumberOfArgumentsMustMatch=*/false,
+ /*PartialOrdering=*/true,
IsDeduced ? PackFold::ArgumentToParameter
: PackFold::ParameterToArgument,
/*HasDeducedAnyParam=*/nullptr) !=
diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
index a12d2eff1d2c8..b1872333ff0a1 100644
--- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -3879,10 +3879,10 @@ TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(
// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
- if (SemaRef.CheckTemplateArgumentList(InstClassTemplate, D->getLocation(),
- InstTemplateArgs, false,
- SugaredConverted, CanonicalConverted,
- /*UpdateArgsWithConversions=*/true))
+ if (SemaRef.CheckTemplateArgumentList(
+ InstClassTemplate, D->getLocation(), InstTemplateArgs,
+ /*DefaultArgs=*/{}, false, SugaredConverted, CanonicalConverted,
+ /*UpdateArgsWithConversions=*/true))
return nullptr;
// Figure out where to insert this class template explicit specialization
@@ -3987,10 +3987,10 @@ Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(
// Check that the template argument list is well-formed for this template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
- if (SemaRef.CheckTemplateArgumentList(InstVarTemplate, D->getLocation(),
- VarTemplateArgsInfo, false,
- SugaredConverted, CanonicalConverted,
- /*UpdateArgsWithConversions=*/true))
+ if (SemaRef.CheckTemplateArgumentList(
+ InstVarTemplate, D->getLocation(), VarTemplateArgsInfo,
+ /*DefaultArgs=*/{}, false, SugaredConverted, CanonicalConverted,
+ /*UpdateArgsWithConversions=*/true))
return nullptr;
// Check whether we've already seen a declaration of this specialization.
@@ -4255,6 +4255,7 @@ TemplateDeclInstantiator::InstantiateClassTemplatePartialSpecialization(
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
if (SemaRef.CheckTemplateArgumentList(
ClassTemplate, PartialSpec->getLocation(), InstTemplateArgs,
+ /*DefaultArgs=*/{},
/*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted))
return nullptr;
@@ -4366,9 +4367,10 @@ TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(
// Check that the template argument list is well-formed for this
// class template.
SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
- if (SemaRef.CheckTemplateArgumentList(
- VarTemplate, PartialSpec->getLocation(), InstTemplateArgs,
- /*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted))
+ if (SemaRef.CheckTemplateArgumentList(VarTemplate, PartialSpec->getLocation(),
+ InstTemplateArgs, /*DefaultArgs=*/{},
+ /*PartialTemplateArgs=*/false,
+ SugaredConverted, CanonicalConverted))
return nullptr;
// Check these arguments are valid for a template partial specialization.
diff --git a/clang/test/SemaTemplate/cwg2398.cpp b/clang/test/SemaTemplate/cwg2398.cpp
index 6fe1bd3d4f165..1d9747276fbe0 100644
--- a/clang/test/SemaTemplate/cwg2398.cpp
+++ b/clang/test/SemaTemplate/cwg2398.cpp
@@ -65,26 +65,20 @@ namespace class_template {
template <class T3> struct B;
template <template <class T4> class TT1, class T5> struct B<TT1<T5>>;
- // new-note at -1 {{partial specialization matches}}
template <class T6, class T7> struct B<A<T6, T7>> {};
- // new-note at -1 {{partial specialization matches}}
template struct B<A<int>>;
- // new-error at -1 {{ambiguous partial specialization}}
} // namespace class_template
namespace class_template_func {
template <class T1, class T2 = float> struct A {};
template <template <class T4> class TT1, class T5> void f(TT1<T5>);
- // new-note at -1 {{candidate function}}
-
template <class T6, class T7> void f(A<T6, T7>) {};
- // new-note at -1 {{candidate function}}
void g() {
- f(A<int>()); // new-error {{call to 'f' is ambiguous}}
+ f(A<int>());
}
} // namespace class_template_func
@@ -326,6 +320,48 @@ namespace classes {
// expected-error at -1 {{no matching function for call}}
}
} // namespace packs
+ namespace nested {
+ template <class T1, int V1, int V2> struct A {
+ using type = T1;
+ static constexpr int v1 = V1, v2 = V2;
+ };
+
+ template <template <class T1> class TT1> auto f(TT1<int>) {
+ return TT1<float>();
+ }
+
+ template <template <class T2, int V3> class TT2> auto g(TT2<double, 1>) {
+ // new-note at -1 {{too few template arguments for class template 'A'}}
+ // old-note at -2 {{template template argument has different template parameters}}
+ return f(TT2<int, 2>());
+ }
+
+ using B = decltype(g(A<double, 1, 3>()));
+ // expected-error at -1 {{no matching function for call}}
+
+ using X = B::type; // expected-error {{undeclared identifier 'B'}}
+ using X = float;
+ static_assert(B::v1 == 2); // expected-error {{undeclared identifier 'B'}}
+ static_assert(B::v2 == 3); // expected-error {{undeclared identifier 'B'}}
+ }
+ namespace defaulted {
+ template <class T1, class T2 = T1*> struct A {
+ using type = T2;
+ };
+
+ template <template <class> class TT> TT<float> f(TT<int>);
+ // new-note at -1 {{deduced type 'A<[...], (default) int *>' of 1st parameter does not match adjusted type 'A<[...], double *>' of argument [with TT = A]}}
+ // old-note at -2 2{{template template argument has different template parameters}}
+
+ using X = int*; // new-note {{previous definition is here}}
+ using X = decltype(f(A<int>()))::type;
+ // new-error at -1 {{different types ('decltype(f(A<int>()))::type' (aka 'float *') vs 'int *')}}
+ // old-error at -2 {{no matching function for call}}
+
+ using Y = double*;
+ using Y = decltype(f(A<int, double*>()))::type;
+ // expected-error at -1 {{no matching function for call}}
+ } // namespace defaulted
} // namespace classes
namespace regression1 {
diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp
index d8af5abce7cee..35e43da6005c7 100644
--- a/clang/tools/libclang/CIndex.cpp
+++ b/clang/tools/libclang/CIndex.cpp
@@ -1557,6 +1557,9 @@ bool CursorVisitor::VisitTemplateName(TemplateName Name, SourceLocation Loc) {
return Visit(MakeCursorTemplateRef(
Name.getAsSubstTemplateTemplateParmPack()->getParameterPack(), Loc,
TU));
+
+ case TemplateName::DeducedTemplate:
+ llvm_unreachable("DeducedTemplate shouldn't appear in source");
}
llvm_unreachable("Invalid TemplateName::Kind!");
More information about the cfe-commits
mailing list