From 2fcb863b2b278e0b73c5381f41eb579bea82f2e2 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Tue, 11 Jan 2011 22:21:24 +0000 Subject: [PATCH] Implement partial ordering of class template partial specializations and function templates that contain variadic templates. This involves three small-ish changes: (1) When transforming a pack expansion, if the transformed argument still contains unexpanded parameter packs, build a pack expansion. This can happen during the substitution that occurs into class template partial specialiation template arguments during partial ordering. (2) When performing template argument deduction where the argument is a pack expansion, match against the pattern of that pack expansion. (3) When performing template argument deduction against a non-pack parameter, or a non-expansion template argument, deduction fails if the argument itself is a pack expansion (C++0x [temp.deduct.type]p22). llvm-svn: 123279 --- clang/lib/Sema/SemaTemplateDeduction.cpp | 37 ++++++++++++++++--- clang/lib/Sema/TreeTransform.h | 12 ++++++ .../temp.variadic/partial-ordering.cpp | 30 +++++++++++++++ .../temp.deduct/temp.deduct.partial/p12.cpp | 27 ++++++++++++++ .../temp.deduct/temp.deduct.type/p22.cpp | 14 +++++++ 5 files changed, 114 insertions(+), 6 deletions(-) create mode 100644 clang/test/CXX/temp/temp.decls/temp.variadic/partial-ordering.cpp create mode 100644 clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p12.cpp create mode 100644 clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p22.cpp diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 6d0db4a54131..dcc1ada3e874 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -80,7 +80,7 @@ static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, - const TemplateArgument &Arg, + TemplateArgument Arg, TemplateDeductionInfo &Info, llvm::SmallVectorImpl &Deduced); @@ -677,6 +677,13 @@ DeduceTemplateArguments(Sema &S, if (ArgIdx >= NumArgs) return Sema::TDK_NonDeducedMismatch; + if (isa(Args[ArgIdx])) { + // C++0x [temp.deduct.type]p22: + // If the original function parameter associated with A is a function + // parameter pack and the function parameter associated with P is not + // a function parameter pack, then template argument deduction fails. + return Sema::TDK_NonDeducedMismatch; + } if (Sema::TemplateDeductionResult Result = DeduceTemplateArguments(S, TemplateParams, @@ -814,6 +821,12 @@ DeduceTemplateArguments(Sema &S, QualType Param = S.Context.getCanonicalType(ParamIn); QualType Arg = S.Context.getCanonicalType(ArgIn); + // If the argument type is a pack expansion, look at its pattern. + // This isn't explicitly called out + if (const PackExpansionType *ArgExpansion + = dyn_cast(Arg)) + Arg = ArgExpansion->getPattern(); + if (PartialOrdering) { // C++0x [temp.deduct.partial]p5: // Before the partial ordering is done, certain transformations are @@ -1273,9 +1286,15 @@ static Sema::TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, const TemplateArgument &Param, - const TemplateArgument &Arg, + TemplateArgument Arg, TemplateDeductionInfo &Info, llvm::SmallVectorImpl &Deduced) { + // If the template argument is a pack expansion, perform template argument + // deduction against the pattern of that expansion. This only occurs during + // partial ordering. + if (Arg.isPackExpansion()) + Arg = Arg.getPackExpansionPattern(); + switch (Param.getKind()) { case TemplateArgument::Null: assert(false && "Null template argument in parameter list"); @@ -1448,11 +1467,17 @@ DeduceTemplateArguments(Sema &S, return NumberOfArgumentsMustMatch? Sema::TDK_NonDeducedMismatch : Sema::TDK_Success; + if (Args[ArgIdx].isPackExpansion()) { + // FIXME: We follow the logic of C++0x [temp.deduct.type]p22 here, + // but applied to pack expansions that are template arguments. + return Sema::TDK_NonDeducedMismatch; + } + // Perform deduction for this Pi/Ai pair. if (Sema::TemplateDeductionResult Result - = DeduceTemplateArguments(S, TemplateParams, - Params[ParamIdx], Args[ArgIdx], - Info, Deduced)) + = DeduceTemplateArguments(S, TemplateParams, + Params[ParamIdx], Args[ArgIdx], + Info, Deduced)) return Result; // Move to the next argument. @@ -1792,7 +1817,7 @@ FinishTemplateArgumentDeduction(Sema &S, return Sema::TDK_SubstitutionFailure; } } - + // Form the template argument list from the deduced template arguments. TemplateArgumentList *DeducedArgumentList = TemplateArgumentList::CreateCopy(S.Context, Builder.data(), diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index bc1ac1e6ae9b..e63cc7da7c75 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -2327,6 +2327,12 @@ bool TreeTransform::TransformExprs(Expr **Inputs, if (Out.isInvalid()) return true; + if (Out.get()->containsUnexpandedParameterPack()) { + Out = RebuildPackExpansion(Out.get(), Expansion->getEllipsisLoc()); + if (Out.isInvalid()) + return true; + } + if (ArgChanged) *ArgChanged = true; Outputs.push_back(Out.get()); @@ -2847,6 +2853,12 @@ bool TreeTransform::TransformTemplateArguments(InputIterator First, if (getDerived().TransformTemplateArgument(Pattern, Out)) return true; + if (Out.getArgument().containsUnexpandedParameterPack()) { + Out = getDerived().RebuildPackExpansion(Out, Ellipsis); + if (Out.getArgument().isNull()) + return true; + } + Outputs.addArgument(Out); } diff --git a/clang/test/CXX/temp/temp.decls/temp.variadic/partial-ordering.cpp b/clang/test/CXX/temp/temp.decls/temp.variadic/partial-ordering.cpp new file mode 100644 index 000000000000..2e85c18fff42 --- /dev/null +++ b/clang/test/CXX/temp/temp.decls/temp.variadic/partial-ordering.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +// Various tests related to partial ordering of variadic templates. +template struct tuple; + +template +struct X1 { + static const unsigned value = 0; +}; + +template +struct X1 > { + static const unsigned value = 1; +}; + +template +struct X1 > { + static const unsigned value = 2; +}; + +template +struct X1 > { + static const unsigned value = 3; +}; + +int check0[X1>::value == 0? 1 : -1]; +int check1[X1>::value == 2? 1 : -1]; +int check2[X1>::value == 1? 1 : -1]; +int check3[X1>::value == 2? 1 : -1]; +int check4[X1>::value == 3? 1 : -1]; diff --git a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p12.cpp b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p12.cpp new file mode 100644 index 000000000000..116810082d9f --- /dev/null +++ b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.partial/p12.cpp @@ -0,0 +1,27 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +// Note: Partial ordering of function templates containing template +// parameter packs is independent of the number of deduced arguments +// for those template parameter packs. +template struct Tuple { }; +template int &g(Tuple); // #1 +template float &g(Tuple); // #2 +template double &g(Tuple); // #3 + +void test_g() { + int &ir1 = g(Tuple<>()); + float &fr1 = g(Tuple()); + double &dr1 = g(Tuple()); + double &dr2 = g(Tuple()); +} + +template int &h(int (*)(Types ...)); // #1 +template float &h(int (*)(T1, Types ...)); // #2 +template double &h(int (*)(T1, Types& ...)); // #3 + +void test_h() { + int &ir1 = h((int(*)())0); + float &fr1 = h((int(*)(int, float))0); + double &dr1 = h((int(*)(int, float&))0); + double &dr2 = h((int(*)(int))0); +} diff --git a/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p22.cpp b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p22.cpp new file mode 100644 index 000000000000..4326a691cb2e --- /dev/null +++ b/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p22.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -std=c++0x -fsyntax-only -verify %s + +// If the original function parameter associated with A is a function +// parameter pack and the function parameter associated with P is not +// a function parameter pack, then template argument deduction fails. +template int& f(Args ... args); +template float& f(T1 a1, Args ... args); +template double& f(T1 a1, T2 a2); + +void test_f() { + int &ir1 = f(); + float &fr1 = f(1, 2, 3); + double &dr1 = f(1, 2); +}