https://github.com/mizvekov created https://github.com/llvm/llvm-project/pull/89807
This patch will finally allow us to mark C++17 support in clang as complete. This is a continuation of the review process from an [old PR in phab](https://reviews.llvm.org/D109496). Recap: The original patch from phab initially contained no workarounds / provisional resolutions for core defects, Though testing by @yxsamliu [here](https://reviews.llvm.org/D109496#3101839) showed problems with some important libraries used in GPU applications, and we ended up reverting it. In order to implement this as a DR and avoid breaking reasonable code that worked before P0522, this patch implements a provisional resolution for CWG2398: When deducing template template parameters against each other, and the argument side names a template specialization, instead of just deducing A, we instead deduce a synthesized template template parameter based on A, but with it's parameters using the template specialization's arguments as defaults. This does not fix all possible regressions introduced by P0522, but it does seem to match in effect an undocumented workaround implemented by GCC. Though it's unconfirmed how closely we match, as I have not received official word regarding this yet. Fixing other regressions will require more extensive changes, some of them would require possibly controversial wording changes, and so is left for future work. The driver flag is deprecated with a warning, and it will not have any effect. @yxsamliu Can you confirm this version avoids any breakages in your setup? CC: @yuanfang-chen @MaskRay @chandlerc @jicama @lichray @AaronBallman >From 873043f6ea08b8828a5e061cf67c70e39b66b8b8 Mon Sep 17 00:00:00 2001 From: Matheus Izvekov <mizve...@gmail.com> Date: Tue, 9 Apr 2024 01:14:28 -0300 Subject: [PATCH] [clang] deprecate frelaxed-template-template-args, make it on by default In order to implement this as a DR and avoid breaking reasonable code that worked before P0522, this patch implements a provisional resolution for CWG2398: When deducing template template parameters against each other, and the argument side names a template specialization, instead of just deducing A, we instead deduce a synthesized template template parameter based on A, but with it's parameters using the template specialization's arguments as defaults. The driver flag is deprecated with a warning, and it will not have any effect. --- .../clang/Basic/DiagnosticDriverKinds.td | 2 +- clang/include/clang/Basic/LangOptions.def | 1 - clang/include/clang/Driver/Options.td | 7 +- clang/lib/Driver/SanitizerArgs.cpp | 9 +- clang/lib/Driver/ToolChains/Clang.cpp | 11 +-- clang/lib/Frontend/InitPreprocessor.cpp | 4 +- clang/lib/Sema/SemaTemplate.cpp | 88 ++++++++--------- clang/lib/Sema/SemaTemplateDeduction.cpp | 99 +++++++++++++++++-- .../temp/temp.arg/temp.arg.template/p3-2a.cpp | 2 +- clang/test/CodeGenCXX/mangle-concept.cpp | 4 +- .../frelaxed-template-template-args.cpp | 5 + clang/test/Lexer/cxx-features.cpp | 5 +- clang/test/SemaTemplate/default-arguments.cpp | 7 +- .../instantiate-template-template-parm.cpp | 17 ++-- clang/test/SemaTemplate/nested-template.cpp | 8 +- clang/test/SemaTemplate/temp_arg_template.cpp | 6 +- .../SemaTemplate/temp_arg_template_cxx1z.cpp | 2 +- clang/www/cxx_status.html | 17 ++-- 18 files changed, 183 insertions(+), 111 deletions(-) create mode 100644 clang/test/Driver/frelaxed-template-template-args.cpp diff --git a/clang/include/clang/Basic/DiagnosticDriverKinds.td b/clang/include/clang/Basic/DiagnosticDriverKinds.td index ed3fd9b1c4a55b..9781fcaa4ff5e9 100644 --- a/clang/include/clang/Basic/DiagnosticDriverKinds.td +++ b/clang/include/clang/Basic/DiagnosticDriverKinds.td @@ -435,7 +435,7 @@ def warn_drv_diagnostics_misexpect_requires_pgo : Warning< def warn_drv_clang_unsupported : Warning< "the clang compiler does not support '%0'">; def warn_drv_deprecated_arg : Warning< - "argument '%0' is deprecated, use '%1' instead">, InGroup<Deprecated>; + "argument '%0' is deprecated%select{|, use '%2' instead}1">, InGroup<Deprecated>; def warn_drv_deprecated_custom : Warning< "argument '%0' is deprecated, %1">, InGroup<Deprecated>; def warn_drv_assuming_mfloat_abi_is : Warning< diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def index 8ef6700ecdc78e..2dfe70f29d7c85 100644 --- a/clang/include/clang/Basic/LangOptions.def +++ b/clang/include/clang/Basic/LangOptions.def @@ -158,7 +158,6 @@ LANGOPT(GNUAsm , 1, 1, "GNU-style inline assembly") LANGOPT(Coroutines , 1, 0, "C++20 coroutines") LANGOPT(CoroAlignedAllocation, 1, 0, "prefer Aligned Allocation according to P2014 Option 2") LANGOPT(DllExportInlines , 1, 1, "dllexported classes dllexport inline methods") -LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments") LANGOPT(ExperimentalLibrary, 1, 0, "enable unstable and experimental library features") LANGOPT(PointerAuthIntrinsics, 1, 0, "pointer authentication intrinsics") diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 922bda721dc780..f907102f7f813b 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -3359,11 +3359,8 @@ defm application_extension : BoolFOption<"application-extension", PosFlag<SetTrue, [], [ClangOption, CC1Option], "Restrict code to those available for App Extensions">, NegFlag<SetFalse>>; -defm relaxed_template_template_args : BoolFOption<"relaxed-template-template-args", - LangOpts<"RelaxedTemplateTemplateArgs">, DefaultFalse, - PosFlag<SetTrue, [], [ClangOption, CC1Option], - "Enable C++17 relaxed template template argument matching">, - NegFlag<SetFalse>>; +def frelaxed_template_template_args : Flag<["-"], "frelaxed-template-template-args">, Flags<[]>; +def fno_relaxed_template_template_args : Flag<["-"], "fno-relaxed-template-template-args">, Flags<[]>; defm sized_deallocation : BoolFOption<"sized-deallocation", LangOpts<"SizedDeallocation">, DefaultFalse, PosFlag<SetTrue, [], [ClangOption, CC1Option], diff --git a/clang/lib/Driver/SanitizerArgs.cpp b/clang/lib/Driver/SanitizerArgs.cpp index 6a4f2548c0bffa..aa416b9844ee1d 100644 --- a/clang/lib/Driver/SanitizerArgs.cpp +++ b/clang/lib/Driver/SanitizerArgs.cpp @@ -797,7 +797,8 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, Arg->claim(); if (LegacySanitizeCoverage != 0 && DiagnoseErrors) { D.Diag(diag::warn_drv_deprecated_arg) - << Arg->getAsString(Args) << "-fsanitize-coverage=trace-pc-guard"; + << Arg->getAsString(Args) << true + << "-fsanitize-coverage=trace-pc-guard"; } continue; } @@ -833,11 +834,11 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, // enabled. if (CoverageFeatures & CoverageTraceBB) D.Diag(clang::diag::warn_drv_deprecated_arg) - << "-fsanitize-coverage=trace-bb" + << "-fsanitize-coverage=trace-bb" << true << "-fsanitize-coverage=trace-pc-guard"; if (CoverageFeatures & Coverage8bitCounters) D.Diag(clang::diag::warn_drv_deprecated_arg) - << "-fsanitize-coverage=8bit-counters" + << "-fsanitize-coverage=8bit-counters" << true << "-fsanitize-coverage=trace-pc-guard"; } @@ -849,7 +850,7 @@ SanitizerArgs::SanitizerArgs(const ToolChain &TC, if ((CoverageFeatures & InsertionPointTypes) && !(CoverageFeatures & InstrumentationTypes) && DiagnoseErrors) { D.Diag(clang::diag::warn_drv_deprecated_arg) - << "-fsanitize-coverage=[func|bb|edge]" + << "-fsanitize-coverage=[func|bb|edge]" << true << "-fsanitize-coverage=[func|bb|edge],[trace-pc-guard|trace-pc],[" "control-flow]"; } diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index e7ccf9a23e7eda..bd6e8292b16830 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -6561,7 +6561,7 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_global_new_delete_hidden)) { D.Diag(diag::warn_drv_deprecated_arg) - << A->getAsString(Args) + << A->getAsString(Args) << true << "-fvisibility-global-new-delete=force-hidden"; } @@ -7288,11 +7288,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, Args.addOptOutFlag(CmdArgs, options::OPT_fassume_unique_vtables, options::OPT_fno_assume_unique_vtables); - // -frelaxed-template-template-args is off by default, as it is a severe - // breaking change until a corresponding change to template partial ordering - // is provided. - Args.addOptInFlag(CmdArgs, options::OPT_frelaxed_template_template_args, - options::OPT_fno_relaxed_template_template_args); + // -frelaxed-template-template-args is deprecated, with no effect. + if (Arg *A = Args.getLastArg(options::OPT_frelaxed_template_template_args, + options::OPT_fno_relaxed_template_template_args)) + D.Diag(diag::warn_drv_deprecated_arg) << A->getAsString(Args) << false; // -fsized-deallocation is off by default, as it is an ABI-breaking change for // most platforms. diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 4f44c3b7b89d4d..1cffd59b91ab80 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -713,8 +713,8 @@ static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, } if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable) Builder.defineMacro("__cpp_aligned_new", "201606L"); - if (LangOpts.RelaxedTemplateTemplateArgs) - Builder.defineMacro("__cpp_template_template_args", "201611L"); + + Builder.defineMacro("__cpp_template_template_args", "201611L"); // C++20 features. if (LangOpts.CPlusPlus20) { diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 4bda31ba67c02d..3a8d58a9352b94 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -8343,58 +8343,52 @@ bool Sema::CheckTemplateTemplateArgument(TemplateTemplateParmDecl *Param, // C++1z [temp.arg.template]p3: (DR 150) // A template-argument matches a template template-parameter P when P // is at least as specialized as the template-argument A. - // FIXME: We should enable RelaxedTemplateTemplateArgs by default as it is a - // defect report resolution from C++17 and shouldn't be introduced by - // concepts. - if (getLangOpts().RelaxedTemplateTemplateArgs) { - // Quick check for the common case: - // If P contains a parameter pack, then A [...] matches P if each of A's - // template parameters matches the corresponding template parameter in - // the template-parameter-list of P. - if (TemplateParameterListsAreEqual( - Template->getTemplateParameters(), Params, false, - TPL_TemplateTemplateArgumentMatch, Arg.getLocation()) && - // If the argument has no associated constraints, then the parameter is - // definitely at least as specialized as the argument. - // Otherwise - we need a more thorough check. - !Template->hasAssociatedConstraints()) - return false; + // Quick check for the common case: + // If P contains a parameter pack, then A [...] matches P if each of A's + // template parameters matches the corresponding template parameter in + // the template-parameter-list of P. + if (TemplateParameterListsAreEqual(Template->getTemplateParameters(), Params, + false, TPL_TemplateTemplateArgumentMatch, + Arg.getLocation()) && + // If the argument has no associated constraints, then the parameter is + // definitely at least as specialized as the argument. + // Otherwise - we need a more thorough check. + !Template->hasAssociatedConstraints()) + return false; - if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template, - Arg.getLocation())) { - // P2113 - // C++20[temp.func.order]p2 - // [...] If both deductions succeed, the partial ordering selects the - // more constrained template (if one exists) as determined below. - SmallVector<const Expr *, 3> ParamsAC, TemplateAC; - Params->getAssociatedConstraints(ParamsAC); - // C++2a[temp.arg.template]p3 - // [...] In this comparison, if P is unconstrained, the constraints on A - // are not considered. - if (ParamsAC.empty()) - return false; + if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template, + Arg.getLocation())) { + // P2113 + // C++20[temp.func.order]p2 + // [...] If both deductions succeed, the partial ordering selects the + // more constrained template (if one exists) as determined below. + SmallVector<const Expr *, 3> ParamsAC, TemplateAC; + Params->getAssociatedConstraints(ParamsAC); + // C++2a[temp.arg.template]p3 + // [...] In this comparison, if P is unconstrained, the constraints on A + // are not considered. + if (ParamsAC.empty()) + return false; - Template->getAssociatedConstraints(TemplateAC); + Template->getAssociatedConstraints(TemplateAC); - bool IsParamAtLeastAsConstrained; - if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC, - IsParamAtLeastAsConstrained)) - return true; - if (!IsParamAtLeastAsConstrained) { - Diag(Arg.getLocation(), - diag::err_template_template_parameter_not_at_least_as_constrained) - << Template << Param << Arg.getSourceRange(); - Diag(Param->getLocation(), diag::note_entity_declared_at) << Param; - Diag(Template->getLocation(), diag::note_entity_declared_at) - << Template; - MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC, Template, - TemplateAC); - return true; - } - return false; + bool IsParamAtLeastAsConstrained; + if (IsAtLeastAsConstrained(Param, ParamsAC, Template, TemplateAC, + IsParamAtLeastAsConstrained)) + return true; + if (!IsParamAtLeastAsConstrained) { + Diag(Arg.getLocation(), + diag::err_template_template_parameter_not_at_least_as_constrained) + << Template << Param << Arg.getSourceRange(); + Diag(Param->getLocation(), diag::note_entity_declared_at) << Param; + Diag(Template->getLocation(), diag::note_entity_declared_at) << Template; + MaybeEmitAmbiguousAtomicConstraintsDiagnostic(Param, ParamsAC, Template, + TemplateAC); + return true; } - // FIXME: Produce better diagnostics for deduction failures. + return false; } + // FIXME: Produce better diagnostics for deduction failures. return !TemplateParameterListsAreEqual(Template->getTemplateParameters(), Params, diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 0b6375001f5326..890d6bff9f4073 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -507,10 +507,62 @@ static TemplateDeductionResult DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, DeducedTemplateArgument(New), T, Info, Deduced); } +static NamedDecl *DeduceTemplateArguments(Sema &S, NamedDecl *A, + TemplateArgument Default) { + switch (A->getKind()) { + case Decl::TemplateTypeParm: { + auto *T = cast<TemplateTypeParmDecl>(A); + // FIXME: DefaultArgument can't represent a pack. + if (T->isParameterPack()) + return A; + auto *R = TemplateTypeParmDecl::Create( + S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(), + T->getDepth(), T->getIndex(), T->getIdentifier(), + T->wasDeclaredWithTypename(), /*ParameterPack=*/false, + T->hasTypeConstraint()); + R->setDefaultArgument( + S.Context.getTrivialTypeSourceInfo(Default.getAsType())); + if (R->hasTypeConstraint()) { + auto *C = R->getTypeConstraint(); + R->setTypeConstraint(C->getConceptReference(), + C->getImmediatelyDeclaredConstraint()); + } + return R; + } + case Decl::NonTypeTemplateParm: { + auto *T = cast<NonTypeTemplateParmDecl>(A); + // FIXME: DefaultArgument can't represent a pack. + if (T->isParameterPack()) + return A; + auto *R = NonTypeTemplateParmDecl::Create( + S.Context, A->getDeclContext(), SourceLocation(), SourceLocation(), + T->getDepth(), T->getIndex(), T->getIdentifier(), T->getType(), + /*ParameterPack=*/false, T->getTypeSourceInfo()); + R->setDefaultArgument(Default.getAsExpr()); + 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, TemplateArgumentLoc(Default, TemplateArgumentLocInfo())); + return R; + } + default: + llvm_unreachable("Unexpected Decl Kind"); + } +} + static TemplateDeductionResult DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, TemplateName Param, TemplateName Arg, TemplateDeductionInfo &Info, + ArrayRef<TemplateArgument> DefaultArguments, SmallVectorImpl<DeducedTemplateArgument> &Deduced) { TemplateDecl *ParamDecl = Param.getAsTemplateDecl(); if (!ParamDecl) { @@ -519,13 +571,45 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, return TemplateDeductionResult::Success; } - if (TemplateTemplateParmDecl *TempParam - = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { + if (auto *TempParam = dyn_cast<TemplateTemplateParmDecl>(ParamDecl)) { // If we're not deducing at this depth, there's nothing to deduce. if (TempParam->getDepth() != Info.getDeducedDepth()) return TemplateDeductionResult::Success; - DeducedTemplateArgument NewDeduced(S.Context.getCanonicalTemplateName(Arg)); + 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(Arg.getKind() == TemplateName::Template); + 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] = + DeduceTemplateArguments(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))); + } + } + DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context, Deduced[TempParam->getIndex()], NewDeduced); @@ -604,7 +688,8 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams, // Perform template argument deduction for the template name. if (auto Result = - DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info, Deduced); + DeduceTemplateArguments(S, TemplateParams, TNP, TNA, Info, + SA->template_arguments(), Deduced); Result != TemplateDeductionResult::Success) return Result; // Perform template argument deduction on each template @@ -630,7 +715,8 @@ DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams, // Perform template argument deduction for the template name. if (auto Result = DeduceTemplateArguments( S, TemplateParams, TP->getTemplateName(), - TemplateName(SA->getSpecializedTemplate()), Info, Deduced); + TemplateName(SA->getSpecializedTemplate()), Info, + SA->getTemplateArgs().asArray(), Deduced); Result != TemplateDeductionResult::Success) return Result; @@ -2320,7 +2406,8 @@ DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams, case TemplateArgument::Template: if (A.getKind() == TemplateArgument::Template) return DeduceTemplateArguments(S, TemplateParams, P.getAsTemplate(), - A.getAsTemplate(), Info, Deduced); + A.getAsTemplate(), Info, + /*DefaultArguments=*/{}, Deduced); Info.FirstArg = P; Info.SecondArg = A; return TemplateDeductionResult::NonDeducedMismatch; diff --git a/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp b/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp index f586069638614b..342ffba53dbfaf 100644 --- a/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp +++ b/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++2a -frelaxed-template-template-args -verify %s +// RUN: %clang_cc1 -std=c++2a -verify %s template<typename T> concept C = T::f(); // #C template<typename T> concept D = C<T> && T::g(); diff --git a/clang/test/CodeGenCXX/mangle-concept.cpp b/clang/test/CodeGenCXX/mangle-concept.cpp index bbd2cf6555e3ec..e9c46d87635abb 100644 --- a/clang/test/CodeGenCXX/mangle-concept.cpp +++ b/clang/test/CodeGenCXX/mangle-concept.cpp @@ -1,5 +1,5 @@ -// RUN: %clang_cc1 -verify -frelaxed-template-template-args -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s -fclang-abi-compat=latest | FileCheck %s -// RUN: %clang_cc1 -verify -frelaxed-template-template-args -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s -fclang-abi-compat=16 | FileCheck %s --check-prefix=CLANG16 +// RUN: %clang_cc1 -verify -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s -fclang-abi-compat=latest | FileCheck %s +// RUN: %clang_cc1 -verify -std=c++20 -emit-llvm -triple %itanium_abi_triple -o - %s -fclang-abi-compat=16 | FileCheck %s --check-prefix=CLANG16 // expected-no-diagnostics namespace test1 { diff --git a/clang/test/Driver/frelaxed-template-template-args.cpp b/clang/test/Driver/frelaxed-template-template-args.cpp new file mode 100644 index 00000000000000..dd6265ba8375eb --- /dev/null +++ b/clang/test/Driver/frelaxed-template-template-args.cpp @@ -0,0 +1,5 @@ +// RUN: %clang -fsyntax-only -frelaxed-template-template-args %s 2>&1 | FileCheck --check-prefix=CHECK-ON %s +// RUN: %clang -fsyntax-only -fno-relaxed-template-template-args %s 2>&1 | FileCheck --check-prefix=CHECK-OFF %s + +// CHECK-ON: warning: argument '-frelaxed-template-template-args' is deprecated [-Wdeprecated] +// CHECK-OFF: warning: argument '-fno-relaxed-template-template-args' is deprecated [-Wdeprecated] diff --git a/clang/test/Lexer/cxx-features.cpp b/clang/test/Lexer/cxx-features.cpp index baaa9d4434e9b7..728de96a9695e3 100644 --- a/clang/test/Lexer/cxx-features.cpp +++ b/clang/test/Lexer/cxx-features.cpp @@ -7,7 +7,6 @@ // RUN: %clang_cc1 -std=c++2c -fcxx-exceptions -fsized-deallocation -verify %s // -// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -frelaxed-template-template-args -DRELAXED_TEMPLATE_TEMPLATE_ARGS=1 -verify %s // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -DCONCEPTS_TS=1 -verify %s // RUN: %clang_cc1 -std=c++14 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation // RUN: %clang_cc1 -std=c++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s @@ -231,9 +230,7 @@ #error "wrong value for __cpp_nontype_template_args" #endif -#if defined(RELAXED_TEMPLATE_TEMPLATE_ARGS) \ - ? check(template_template_args, 0, 0, 0, 201611, 201611, 201611, 201611) \ - : check(template_template_args, 0, 0, 0, 0, 0, 0, 0) +#if check(template_template_args, 201611, 201611, 201611, 201611, 201611, 201611, 201611) #error "wrong value for __cpp_template_template_args" #endif diff --git a/clang/test/SemaTemplate/default-arguments.cpp b/clang/test/SemaTemplate/default-arguments.cpp index a850d273ccba51..d5d9687cc90f49 100644 --- a/clang/test/SemaTemplate/default-arguments.cpp +++ b/clang/test/SemaTemplate/default-arguments.cpp @@ -112,15 +112,14 @@ template<typename T, template<typename> class X = T::template apply> int array4[is_same<X4<add_pointer>, X4<add_pointer, add_pointer::apply> >::value? 1 : -1]; -template<int> struct X5 {}; // expected-note{{has a different type 'int'}} +template<int> struct X5 {}; template<long> struct X5b {}; template<typename T, - template<T> class B = X5> // expected-error{{template template argument has different}} \ - // expected-note{{previous non-type template parameter}} + template<T> class B = X5> struct X6 {}; X6<int> x6a; -X6<long> x6b; // expected-note{{while checking a default template argument}} +X6<long> x6b; X6<long, X5b> x6c; diff --git a/clang/test/SemaTemplate/instantiate-template-template-parm.cpp b/clang/test/SemaTemplate/instantiate-template-template-parm.cpp index a70c7e8b081a41..39aeeb1c1a6a32 100644 --- a/clang/test/SemaTemplate/instantiate-template-template-parm.cpp +++ b/clang/test/SemaTemplate/instantiate-template-template-parm.cpp @@ -20,30 +20,29 @@ apply<add_reference, int>::type ir = i; apply<add_reference, float>::type fr = i; // expected-error{{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'int'}} // Template template parameters -template<int> struct B; // expected-note{{has a different type 'int'}} +template<int> struct B; -template<typename T, - template<T Value> class X> // expected-error{{cannot have type 'float'}} \ - // expected-note{{with type 'long'}} +template<typename T, + template<T Value> class X> // expected-error{{cannot have type 'float'}} struct X0 { }; X0<int, B> x0b1; X0<float, B> x0b2; // expected-note{{while substituting}} -X0<long, B> x0b3; // expected-error{{template template argument has different template parameters}} +X0<long, B> x0b3; -template<template<int V> class TT> // expected-note{{parameter with type 'int'}} +template<template<int V> class TT> struct X1 { }; template<typename T, template<T V> class TT> struct X2 { - X1<TT> x1; // expected-error{{has different template parameters}} + X1<TT> x1; }; template<int V> struct X3i { }; -template<long V> struct X3l { }; // expected-note{{different type 'long'}} +template<long V> struct X3l { }; X2<int, X3i> x2okay; -X2<long, X3l> x2bad; // expected-note{{instantiation}} +X2<long, X3l> x2okay2; template <typename T, template <T, T> class TT, class R = TT<1, 2> > struct Comp { diff --git a/clang/test/SemaTemplate/nested-template.cpp b/clang/test/SemaTemplate/nested-template.cpp index efbde2076b9fa1..5bd388d4dff3d7 100644 --- a/clang/test/SemaTemplate/nested-template.cpp +++ b/clang/test/SemaTemplate/nested-template.cpp @@ -112,18 +112,16 @@ template struct X1<int>::B<bool>; // Template template parameters template<typename T> struct X2 { - template<template<class U, T Value> class> // expected-error{{cannot have type 'float'}} \ - // expected-note{{previous non-type template}} + template<template<class U, T Value> class> // expected-error{{cannot have type 'float'}} struct Inner { }; }; -template<typename T, - int Value> // expected-note{{template non-type parameter}} +template<typename T, int Value> struct X2_arg; X2<int>::Inner<X2_arg> x2i1; X2<float> x2a; // expected-note{{instantiation}} -X2<long>::Inner<X2_arg> x2i3; // expected-error{{template template argument has different}} +X2<long>::Inner<X2_arg> x2i3; namespace PR10896 { template<typename TN> diff --git a/clang/test/SemaTemplate/temp_arg_template.cpp b/clang/test/SemaTemplate/temp_arg_template.cpp index 3c2697329212e9..a7236669276aa3 100644 --- a/clang/test/SemaTemplate/temp_arg_template.cpp +++ b/clang/test/SemaTemplate/temp_arg_template.cpp @@ -5,11 +5,11 @@ template<template<typename T> class X> struct A; // expected-note 2{{previous te template<template<typename T, int I> class X> struct B; // expected-note{{previous template template parameter is here}} -template<template<int I> class X> struct C; // expected-note 2{{previous non-type template parameter with type 'int' is here}} +template<template<int I> class X> struct C; // expected-note {{previous non-type template parameter with type 'int' is here}} template<class> struct X; // expected-note{{too few template parameters in template template argument}} template<int N> struct Y; // expected-note{{template parameter has a different kind in template argument}} -template<long N> struct Ylong; // expected-note{{template non-type parameter has a different type 'long' in template argument}} +template<long N> struct Ylong; template<const int &N> struct Yref; // expected-note{{template non-type parameter has a different type 'const int &' in template argument}} namespace N { @@ -26,7 +26,7 @@ A<Y> *a4; // expected-error{{template template argument has different template p A<TooMany> *a5; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} B<X> *a6; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} C<Y> *a7; -C<Ylong> *a8; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} +C<Ylong> *a8; C<Yref> *a9; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}} template<typename T> void f(int); diff --git a/clang/test/SemaTemplate/temp_arg_template_cxx1z.cpp b/clang/test/SemaTemplate/temp_arg_template_cxx1z.cpp index 03ef78f8cf14e1..372a00efc601e4 100644 --- a/clang/test/SemaTemplate/temp_arg_template_cxx1z.cpp +++ b/clang/test/SemaTemplate/temp_arg_template_cxx1z.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z -frelaxed-template-template-args %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s // expected-note@temp_arg_template_cxx1z.cpp:* 1+{{}} diff --git a/clang/www/cxx_status.html b/clang/www/cxx_status.html index c233171e63c811..db20719603672c 100755 --- a/clang/www/cxx_status.html +++ b/clang/www/cxx_status.html @@ -916,7 +916,7 @@ <h2 id="cxx17">C++17 implementation status</h2> You can use Clang in C++17 mode with the <code>-std=c++17</code> option (use <code>-std=c++1z</code> in Clang 4 and earlier).</p> -<details open> +<details> <summary>List of features and minimum Clang version with support</summary> <table width="689" border="1" cellspacing="0"> @@ -1133,8 +1133,8 @@ <h2 id="cxx17">C++17 implementation status</h2> <!-- Issaquah 2016 papers --> <tr> <td>Matching template template parameters to compatible arguments</td> - <td><a href="https://wg21.link/p0522r0";>P0522R0</a></td> - <td class="partial" align="center">Partial <a href="#p0522">(10)</a></td> + <td><a href="https://wg21.link/p0522r0";>P0522R0</a> (<a href="#dr">DR</a>)</td> + <td class="full" align="center">Clang 4 <a href="#p0522">(10)</a></td> </tr> <tr> <td>Removing deprecated dynamic exception specifications</td> @@ -1162,13 +1162,10 @@ <h2 id="cxx17">C++17 implementation status</h2> reverse construction order in that ABI. This is not fully supported during constant expression evaluation until Clang 12. </span><br> -<span id="p0522">(10): Despite being the resolution to a Defect Report, this -feature is disabled by default in all language versions, and can be enabled -explicitly with the flag <tt>-frelaxed-template-template-args</tt> in Clang 4 -onwards. -The change to the standard lacks a corresponding change for template partial -ordering, resulting in ambiguity errors for reasonable and previously-valid -code. This issue is expected to be rectified soon. +<span id="p0522">(10): Prior to Clang 19, this feature is not enabled by +default, but can be enabled with <tt>-frelaxed-template-template-args</tt>. +Starting from Clang 19, the flag is deprecated and will be removed in a future +version. </span> </p> </details> _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
