[clang] deprecate frelaxed-template-template-args, make it on by default

[mizvekov]

Summary

A resolution to the ambiguity issue created by P0522, which is a DR solving
CWG 150, did not come as expected.

There is reasonable code in the wild which would be affected by this,
so we implement a workaround to disambiguate those cases:
We pick as the more specialized partial specialization the one
which has the first template argument of template specialization type
with a smaller number of arguments.

The driver flag is deprecated with a warning, and it will not have any effect.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

.

[mizvekov]

.

[mizvekov]

.

[rsmith]

clang/www/cxx_status.html

816–817

We should list this as implemented in Clang 4, with a footnote saying that until Clang 14 you need to pass an additional flag, like we do for char8_t: https://clang.llvm.org/cxx_status.html#p0482

[mizvekov]

• Clarify that P0522 was implemented in Clang 4, explain in footnote.
• Add DR link.
• C++17 section goes all green, so we fold it!

[rsmith]

Thanks, let's land this and see how it goes.

[mizvekov]

rebase, one last CI run.

[yaxunl]

This caused regression in Thrust:

/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/detail/type_traits/pointer_traits.h:178:20: error: ambiguous partial specializations of 'pointer_element<thrust::pointer<void, thrust::detail::seq_t>>'
  typedef typename pointer_element<Ptr>::type    element_type;
                   ^
/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/detail/raw_pointer_cast.h:27:26: note: in instantiation of template class 'thrust::detail::pointer_traits<thrust::pointer<void, thrust::detail::seq_t>>' requested here
typename thrust::detail::pointer_traits<Pointer>::raw_pointer
                         ^
/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/system/hip/detail/malloc_and_free.h:79:18: note: while substituting deduced template arguments into function template 'raw_pointer_cast' [with Pointer = thrust::pointer<void, thrust::detail::seq_t>]
        result = thrust::raw_pointer_cast(thrust::malloc(thrust::seq, n));
                 ^
/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/detail/type_traits/pointer_traits.h:40:10: note: partial specialization matches [with Ptr = thrust::pointer, Arg1 = void, Arg2 = thrust::detail::seq_t]
  struct pointer_element<Ptr<Arg1,Arg2> >
         ^
/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/detail/type_traits/pointer_traits.h:46:10: note: partial specialization matches [with Ptr = thrust::pointer, Arg1 = void, Arg2 = thrust::detail::seq_t, Arg3 = thrust::use_default]
  struct pointer_element<Ptr<Arg1,Arg2,Arg3> >
         ^
/long_pathname_so_that_rpms_can_package_the_debug_info/data/driver/rocThrust/thrust/../thrust/detail/type_traits/pointer_traits.h:52:10: note: partial specialization matches [with Ptr = thrust::pointer, Arg1 = void, Arg2 = thrust::detail::seq_t, Arg3 = thrust::use_default, Arg4 = thrust::use_default]
  struct pointer_element<Ptr<Arg1,Arg2,Arg3,Arg4> >

This seems to match the removed documentation about "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." However, since it was removed, does that mean there will be no changes for template partial ordering?

[mizvekov]

Thanks for reporting this!

This change in the standard was worked a long time ago, and there was some expectation that there would be follow up work to add new partial ordering rules so that reasonable code would keep working. But the person behind that effort stopped participating in the process, so this fell into the cracks.

We tried with this patch here to see if the rules would just work out as intended. Another option, which I believe is what GCC does, is to not do the DR part and apply it only to c++17 and later.
However the breakage example you posted seems to be from a CUDA library which is not usable in the GCC ecosystem, is that correct? And that this library might be modern and used with newer standard as well?

If that is the case, the GCC solution might not be good for us anyway, and the simplest thing would be to just implement some new rules.

[mizvekov]

Feel free to revert it if this is blocking you. I don't seem to find a way to do it via web interface, so I need more time to have access to a machine that can do it

[yaxunl]

In D109496#3103963, @mizvekov wrote:

Thanks for reporting this!

This change in the standard was worked a long time ago, and there was some expectation that there would be follow up work to add new partial ordering rules so that reasonable code would keep working. But the person behind that effort stopped participating in the process, so this fell into the cracks.

We tried with this patch here to see if the rules would just work out as intended. Another option, which I believe is what GCC does, is to not do the DR part and apply it only to c++17 and later.
However the breakage example you posted seems to be from a CUDA library which is not usable in the GCC ecosystem, is that correct? And that this library might be modern and used with newer standard as well?

If that is the case, the GCC solution might not be good for us anyway, and the simplest thing would be to just implement some new rules.

The regression happens with rocThrust, which is CUDA Thrust ported to HIP language. However, I think the same issue would happen to CUDA Thrust.

These libraries need to work with C++17, therefore it is better to implement some new rules.

[yaxunl]

In D109496#3103978, @mizvekov wrote:

Feel free to revert it if this is blocking you. I don't seem to find a way to do it via web interface, so I need more time to have access to a machine that can do it

I will revert it since it is blocking us. Thanks.

[mizvekov]

Implement workaround.

[mizvekov]

.

clang/include/clang/Basic/DiagnosticDriverKinds.td

def warn_drv_empty_joined_argument : Warning<
   "joined argument expects additional value: '%0'">,
   InGroup<UnusedCommandLineArgument>;
 def warn_drv_diagnostics_hotness_requires_pgo : Warning<
   "argument '%0' requires profile-guided optimization information">,
   InGroup<UnusedCommandLineArgument>;
 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_assuming_mfloat_abi_is : Warning<
   "unknown platform, assuming -mfloat-abi=%0">;
 def warn_ignoring_ftabstop_value : Warning<
   "ignoring invalid -ftabstop value '%0', using default value %1">;
 def warn_drv_overriding_flag_option : Warning<
   "overriding '%0' option with '%1'">,
   InGroup<DiagGroup<"overriding-t-option">>;
 def warn_drv_treating_input_as_cxx : Warning<

clang/include/clang/Basic/LangOptions.def

 LANGOPT(RTTIData          , 1, 1, "emit run-time type information data")
 LANGOPT(MSBitfields       , 1, 0, "Microsoft-compatible structure layout")
 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
 LANGOPT(NoBuiltin         , 1, 0, "disable builtin functions")
 LANGOPT(NoMathBuiltin     , 1, 0, "disable math builtin functions")
 LANGOPT(GNUAsm            , 1, 1, "GNU-style inline assembly")
 LANGOPT(Coroutines        , 1, 0, "C++20 coroutines")
 LANGOPT(DllExportInlines  , 1, 1, "dllexported classes dllexport inline methods")
-LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
 
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 
 COMPATIBLE_LANGOPT(RecoveryAST, 1, 1, "Preserve expressions in AST when encountering errors")
 COMPATIBLE_LANGOPT(RecoveryASTType, 1, 1, "Preserve the type in recovery expressions")
 
 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
 LANGOPT(POSIXThreads      , 1, 0, "POSIX thread support")

clang/include/clang/Driver/Options.td

 def fobjc_call_cxx_cdtors : Flag<["-"], "fobjc-call-cxx-cdtors">, Group<clang_ignored_f_Group>;
 defm objc_exceptions : BoolFOption<"objc-exceptions",
   LangOpts<"ObjCExceptions">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option], "Enable Objective-C exceptions">, NegFlag<SetFalse>>;
 defm application_extension : BoolFOption<"application-extension",
   LangOpts<"AppExt">, DefaultFalse,
   PosFlag<SetTrue, [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, [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, [CC1Option], "Enable C++14 sized global deallocation functions">,
   NegFlag<SetFalse>>;
 defm aligned_allocation : BoolFOption<"aligned-allocation",
   LangOpts<"AlignedAllocation">, Default<cpp17.KeyPath>,
   PosFlag<SetTrue, [], "Enable C++17 aligned allocation functions">,
   NegFlag<SetFalse>, BothFlags<[CC1Option]>>;

clang/lib/Driver/SanitizerArgs.cpp

if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
       int LegacySanitizeCoverage;
       if (Arg->getNumValues() == 1 &&
           !StringRef(Arg->getValue(0))
                .getAsInteger(0, LegacySanitizeCoverage)) {
         CoverageFeatures = 0;
         Arg->claim();
         if (LegacySanitizeCoverage != 0) {
           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;
       }
       CoverageFeatures |= parseCoverageFeatures(D, Arg);
 
       // Disable coverage and not claim the flags if there is at least one
       // non-supporting sanitizer.
       if (!(AllAddedKinds & ~AllRemove & ~setGroupBits(SupportsCoverage))) {
SanitizerArgs::SanitizerArgs(const ToolChain &TC,
   if ((CoverageFeatures & CoverageBB) && (CoverageFeatures & CoverageEdge))
     D.Diag(clang::diag::err_drv_argument_not_allowed_with)
         << "-fsanitize-coverage=bb"
         << "-fsanitize-coverage=edge";
   // Basic block tracing and 8-bit counters require some type of coverage
   // 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";
 
   int InsertionPointTypes = CoverageFunc | CoverageBB | CoverageEdge;
   int InstrumentationTypes = CoverageTracePC | CoverageTracePCGuard |
                              CoverageInline8bitCounters |
                              CoverageInlineBoolFlag;
   if ((CoverageFeatures & InsertionPointTypes) &&
       !(CoverageFeatures & InstrumentationTypes)) {
     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]";
   }
 
   // trace-pc w/o func/bb/edge implies edge.
   if (!(CoverageFeatures & InsertionPointTypes)) {
     if (CoverageFeatures &
         (CoverageTracePC | CoverageTracePCGuard | CoverageInline8bitCounters |
          CoverageInlineBoolFlag))

clang/lib/Driver/ToolChains/Clang.cpp

if (A) {
     }
   }
 
   // C++ "sane" operator new.
   if (!Args.hasFlag(options::OPT_fassume_sane_operator_new,
                     options::OPT_fno_assume_sane_operator_new))
     CmdArgs.push_back("-fno-assume-sane-operator-new");
 
-  // -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.
-  if (Args.hasFlag(options::OPT_frelaxed_template_template_args,
-                   options::OPT_fno_relaxed_template_template_args, false))
-    CmdArgs.push_back("-frelaxed-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.
   if (Args.hasFlag(options::OPT_fsized_deallocation,
                    options::OPT_fno_sized_deallocation, false))
     CmdArgs.push_back("-fsized-deallocation");
 
   // -faligned-allocation is on by default in C++17 onwards and otherwise off

clang/lib/Driver/ToolChains/CommonArgs.cpp

 
 void tools::checkAMDGPUCodeObjectVersion(const Driver &D,
                                          const llvm::opt::ArgList &Args) {
   const unsigned MinCodeObjVer = 2;
   const unsigned MaxCodeObjVer = 4;
 
   // Emit warnings for legacy options even if they are overridden.
   if (Args.hasArg(options::OPT_mno_code_object_v3_legacy))
-    D.Diag(diag::warn_drv_deprecated_arg) << "-mno-code-object-v3"
-                                          << "-mcode-object-version=2";
+    D.Diag(diag::warn_drv_deprecated_arg)
+        << "-mno-code-object-v3" << true << "-mcode-object-version=2";
 
   if (Args.hasArg(options::OPT_mcode_object_v3_legacy))
-    D.Diag(diag::warn_drv_deprecated_arg) << "-mcode-object-v3"
-                                          << "-mcode-object-version=3";
+    D.Diag(diag::warn_drv_deprecated_arg)
+        << "-mcode-object-v3" << true << "-mcode-object-version=3";
 
   if (auto *CodeObjArg = getAMDGPUCodeObjectArgument(D, Args)) {
     if (CodeObjArg->getOption().getID() ==
         options::OPT_mcode_object_version_EQ) {
       unsigned CodeObjVer = MaxCodeObjVer;
       auto Remnant =
           StringRef(CodeObjArg->getValue()).getAsInteger(0, CodeObjVer);
       if (Remnant || CodeObjVer < MinCodeObjVer || CodeObjVer > MaxCodeObjVer)

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus17) {
     Builder.defineMacro("__cpp_nontype_template_args",
                         "201411L"); // (not latest)
     Builder.defineMacro("__cpp_fold_expressions", "201603L");
     Builder.defineMacro("__cpp_guaranteed_copy_elision", "201606L");
     Builder.defineMacro("__cpp_nontype_template_parameter_auto", "201606L");
   }
   if (LangOpts.AlignedAllocation && !LangOpts.AlignedAllocationUnavailable)
     Builder.defineMacro("__cpp_aligned_new", "201606L");
-  if (LangOpts.RelaxedTemplateTemplateArgs)
-    Builder.defineMacro("__cpp_template_template_args", "201611L");
+
 
   // C++20 features.
   if (LangOpts.CPlusPlus20) {
     //Builder.defineMacro("__cpp_aggregate_paren_init", "201902L");
     Builder.defineMacro("__cpp_concepts", "201907L");
     Builder.defineMacro("__cpp_conditional_explicit", "201806L");
     //Builder.defineMacro("__cpp_consteval", "201811L");
     Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");

clang/lib/Sema/SemaTemplate.cpp

if (!isa<ClassTemplateDecl>(Template) &&
     Diag(Arg.getLocation(), diag::err_template_arg_not_valid_template);
     Diag(Template->getLocation(), diag::note_template_arg_refers_here_func)
       << Template;
   }
 
   // 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;
+  if (TemplateParameterListsAreEqual(Template->getTemplateParameters(), Params,
+                                     false, TPL_TemplateTemplateArgumentMatch,
+                                     Arg.getLocation()) &&
 
-    if (isTemplateTemplateParameterAtLeastAsSpecializedAs(Params, Template,
-                                                          Arg.getLocation())) {
-      // C++2a[temp.func.order]p2
-      //   [...] If both deductions succeed, the partial ordering selects the
-      //   more constrained template as described by the rules in
-      //   [temp.constr.order].
-      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);
-      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;
-    }
-    // FIXME: Produce better diagnostics for deduction failures.
-  }
+      Diag(Template->getLocation(), diag::note_entity_declared_at) << Template;
 
   return !TemplateParameterListsAreEqual(Template->getTemplateParameters(),
                                          Params,
                                          true,
                                          TPL_TemplateTemplateArgumentMatch,
                                          Arg.getLocation());
 }
 

clang/lib/Sema/SemaTemplateDeduction.cpp

 /// \param PS1 the first class template partial specialization
 ///
 /// \param PS2 the second class template partial specialization
 ///
 /// \returns the more specialized class template partial specialization. If
 /// neither partial specialization is more specialized, returns NULL.
 ClassTemplatePartialSpecializationDecl *
 Sema::getMoreSpecializedPartialSpecialization(
-                                  ClassTemplatePartialSpecializationDecl *PS1,
-                                  ClassTemplatePartialSpecializationDecl *PS2,
-                                              SourceLocation Loc) {
-  QualType PT1 = PS1->getInjectedSpecializationType();
-  QualType PT2 = PS2->getInjectedSpecializationType();
-
+    ClassTemplatePartialSpecializationDecl *PS2, SourceLocation Loc) {
+  {
+    QualType PT1 = PS1->getInjectedSpecializationType(),
+             PT2 = PS2->getInjectedSpecializationType();
     TemplateDeductionInfo Info(Loc);
-  bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info);
-  bool Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
-
-  if (!Better1 && !Better2)
-      return nullptr;
-  if (Better1 && Better2) {
+    bool Better1 = isAtLeastAsSpecializedAs(*this, PT1, PT2, PS2, Info),
+         Better2 = isAtLeastAsSpecializedAs(*this, PT2, PT1, PS1, Info);
+    if (Better1 != Better2)
+      return Better1 ? PS1 : PS2;
+  }
+  {
     llvm::SmallVector<const Expr *, 3> AC1, AC2;
     PS1->getAssociatedConstraints(AC1);
     PS2->getAssociatedConstraints(AC2);
-    bool AtLeastAsConstrained1, AtLeastAsConstrained2;
-    if (IsAtLeastAsConstrained(PS1, AC1, PS2, AC2, AtLeastAsConstrained1))
+    bool Better1, Better2;
+    if (IsAtLeastAsConstrained(PS1, AC1, PS2, AC2, Better1))
       return nullptr;
-    if (IsAtLeastAsConstrained(PS2, AC2, PS1, AC1, AtLeastAsConstrained2))
-      return nullptr;
-    if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
+    if (IsAtLeastAsConstrained(PS2, AC2, PS1, AC1, Better2))
       return nullptr;
-    return AtLeastAsConstrained1 ? PS1 : PS2;
-  }
-
+    if (Better1 != Better2)
       return Better1 ? PS1 : PS2;
   }
+  {
+    // This is a workaround for the ambiguity issues created by
+    // P0522, which is the resolution of CWG 150.
+    // Pick as the more specialized partial specialization the one
+    // which has the first template argument of template specialization type
+    // with a smaller number of arguments.
+    auto As1 = PS1->getTemplateArgs().asArray(),
+         As2 = PS2->getTemplateArgs().asArray();
+    assert(As1.size() == As2.size());
+    for (int I = 0; I < As1.size(); ++I) {
+      const auto &A1 = As1[I], &A2 = As2[I];
+      if (A1.getKind() == TemplateArgument::ArgKind::Type &&
+          A2.getKind() == TemplateArgument::ArgKind::Type) {
+        const auto *AT1 = dyn_cast<TemplateSpecializationType>(
+                       A1.getAsType()->getCanonicalTypeInternal()),
+                   *AT2 = dyn_cast<TemplateSpecializationType>(
+                       A2.getAsType()->getCanonicalTypeInternal());
+        if (AT1 && AT2 && AT1->getNumArgs() != AT2->getNumArgs())
+          return AT1->getNumArgs() < AT2->getNumArgs() ? PS1 : PS2;
+      }
+    }
+  }
+  return nullptr;
+}
 
 bool Sema::isMoreSpecializedThanPrimary(
     ClassTemplatePartialSpecializationDecl *Spec, TemplateDeductionInfo &Info) {
   ClassTemplateDecl *Primary = Spec->getSpecializedTemplate();
   QualType PrimaryT = Primary->getInjectedClassNameSpecialization();
   QualType PartialT = Spec->getInjectedSpecializationType();
   if (!isAtLeastAsSpecializedAs(*this, PartialT, PrimaryT, Primary, Info))
     return false;

clang/test/CXX/temp/temp.arg/temp.arg.template/p3-2a.cpp

-// 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();
 // expected-note@-1{{similar constraint}}
 template<typename T> concept D = C<T> && T::g();
 template<typename T> concept F = T::f();
 // expected-note@-1{{similar constraint expressions not considered equivalent}}
 template<template<C> class P> struct S1 { }; // expected-note 2{{'P' declared here}}
 

clang/test/Driver/frelaxed-template-template-args.cpp

+// 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]

clang/test/Lexer/cxx-features.cpp

 // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
 // RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++20 -fcxx-exceptions -fsized-deallocation -verify %s
 // RUN: %clang_cc1 -std=c++2b -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 -fcoroutines-ts -DNO_EXCEPTIONS -DCOROUTINES -verify -fsized-deallocation %s
 // RUN: %clang_cc1 -std=c++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
 // RUN: %clang_cc1 -std=c++2a -fno-char8_t -DNO_EXCEPTIONS -DNO_CHAR8_T -verify -fsized-deallocation %s
 
 // expected-no-diagnostics
 

 #error "wrong value for __cpp_structured_bindings"
 #endif
 
 #if check(nontype_template_args, 0, 0, 0, 201411, 201411, 201411)
 // FIXME: 201911 in C++20
 #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) \
-    : check(template_template_args, 0, 0, 0, 0, 0, 0)
+#if check(template_template_args, 201611, 201611, 201611, 201611, 201611, 201611)
 #error "wrong value for __cpp_template_template_args"
 #endif
 
 // --- C++14 features ---
 
 #if check(binary_literals, 0, 0, 201304, 201304, 201304, 201304)
 #error "wrong value for __cpp_binary_literals"
 #endif

clang/test/SemaTemplate/default-arguments.cpp

struct add_pointer {
   };
 };
 
 template<typename T, template<typename> class X = T::template apply>
   struct X4;
 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;
 
 
 template<template<class> class X = B<int> > struct X7; // expected-error{{must be a class template}}
 
 namespace PR9643 {
   template<typename T> class allocator {};
   template<typename T, typename U = allocator<T> > class vector {};

clang/test/SemaTemplate/instantiate-template-template-parm.cpp

 };
 
 int i;
 apply<add_pointer, int>::type ip = &i;
 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<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> x2bad;
 
 template <typename T, template <T, T> class TT, class R = TT<1, 2> >
 struct Comp {
   typedef R r1;
   template <T x, T y> struct gt {
     static const bool result = x > y;
   };
   typedef gt<2, 1> r2;

clang/test/SemaTemplate/nested-template.cpp

 struct X1 {
   template<typename, bool = false> struct B { };
 };
 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>
   class Foo {
 
   public:
     void foo() {}
   private:

clang/test/SemaTemplate/temp_arg_template.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 template<template<typename T> class X> struct A; // expected-note 2{{previous template template parameter is here}}
 
 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 {
   template<class> struct Z;
 }
 template<class, class> struct TooMany; // expected-note{{too many template parameters in template template argument}}
 
 
 A<X> *a1; 
 A<N::Z> *a2;
 A< ::N::Z> *a3;
 
 A<Y> *a4; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
 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);
 
 A<f> *a9; // expected-error{{must be a class template}}
 
 // Evil digraph '<:' is parsed as '[', expect error.
 A<::N::Z> *a10;

clang/test/SemaTemplate/temp_arg_template_cxx1z.cpp

-// 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+{{}}
 
 template<template<int> typename> struct Ti;
 template<template<int...> typename> struct TPi;
 template<template<int, int...> typename> struct TiPi;
 template<template<int..., int...> typename> struct TPiPi; // FIXME: Why is this not ill-formed?
 

clang/www/cxx_status.html

 <h2 id="cxx17">C++17 implementation status</h2>
 
 <p>Clang 5 and later implement all the features of the
 <a href="https://www.iso.org/standard/68564.html">ISO C++ 2017 standard</a>.</p>
 
 <p>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">
  <tr>
     <th>Language Feature</th>
     <th>C++17 Proposal</th>
     <th>Available in Clang?</th>
  </tr>
</tr>
     <tr>
       <td>Separate variable and condition for <tt>if</tt> and <tt>switch</tt></td>
       <td><a href="https://wg21.link/p0305r1">P0305R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <!-- 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>
       <td><a href="https://wg21.link/p0003r5">P0003R5</a></td>
       <td class="full" align="center">Clang 4</td>
     </tr>
     <tr>
       <td>Pack expansions in <em>using-declarations</em></td>

 <span id="p0145">(9): Under the MS ABI, function parameters are destroyed from
 left to right in the callee. As a result, function parameters in calls to
 <tt>operator&lt;&lt;</tt>, <tt>operator&gt;&gt;</tt>, <tt>operator-&gt;*</tt>,
 <tt>operator&amp;&amp;</tt>, <tt>operator||</tt>, and <tt>operator,</tt>
 functions using expression syntax are no longer guaranteed to be destroyed in
 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 14, this feature is not enabled by
+default, but can be enabled with <tt>-frelaxed-template-template-args</tt>.
+Starting from Clang 14, the flag is deprecated and will be removed in a future
+version.
 </span>
 </p>
 </details>
 
 <h2 id="cxx20">C++20 implementation status</h2>
 
 <p>Clang has support for some of the features of the
 <a href="https://www.iso.org/standard/79358.html">ISO C++ 2020 standard</a>.</p>