[Sema] compat warning of using deduced type in non-type template parameter

[inclyc]

Summary

Seems we are missing C++20 compatibility warning of using deduced type
(e.g. some template class) as a non-type template parameter. Before this
patch the following code crashes clang.

template<class>
struct DC {};

template<DC s> // using deduced type, but considered as "auto" type
auto test() {}

It triggered warn_cxx14_compat_template_nontype_parm_auto_type. However
there is no such "auto" type at all.

Using deduced type within non-type template parameter was introduced in
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0732r2.pdf.

This patch create a new compatibility diagnostic message for this.

Fixes: https://github.com/llvm/llvm-project/issues/57643

[inclyc]

clang/test/SemaCXX/template-nontype-args-compat.cpp

1

I cannot find other tests of compatibility warnings though. Is it necessary to add such tests here? (in subsequent patches)

[mizvekov]

clang/lib/Sema/SemaTemplate.cpp

1535–1545

This largely duplicates the effort from D132990

Your patch will also fix the crash fixed by D132990, and I even suggested there also handling deduced template specializations.

Two points about this change though:

• The new diagnosticis too generic and does not explain what the user did wrong.
• Please test for each case of AutoType and DeducedTemplateSpecializationType explicitly, and llvm_unreachable on anything else, so that when a new kind of DeducedType is added, we handle it with an appropriate message. This goes with the first bullet, if you know what each case is, you can produce more explanatory diagnostics.

clang/docs/ReleaseNotes.rst

- Fix a crash when attempting to default a virtual constexpr non-special member
   function in a derived class. This fixes
   `Issue 57431 <https://github.com/llvm/llvm-project/issues/57431>`_
 - Fix a crash where we attempt to define a deleted destructor. This fixes
   `Issue 57516 <https://github.com/llvm/llvm-project/issues/57516>`_
 - Fix ``__builtin_assume_aligned`` crash when the 1st arg is array type. This fixes
   `Issue 57169 <https://github.com/llvm/llvm-project/issues/57169>`_
 - Clang configuration files are now read through the virtual file system
   rather than the physical one, if these are different.
+- Fix `Issue 57643 <https://github.com/llvm/llvm-project/issues/57643>`_.
+  Missing C++20 compatibility warning of deduced type as non-type template
+  parameters.
 
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - Clang will now correctly diagnose as ill-formed a constant expression where an
   enum without a fixed underlying type is set to a value outside the range of
   the enumeration's values. Due to the extended period of time this bug was
   present in major C++ implementations (including Clang), this error has the

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_not_structural_rvalue_ref_field : Note<
   "of rvalue reference type">;
 def note_not_structural_subobject : Note<
   "%0 is not a structural type because it has a "
   "%select{non-static data member|base class}1 of non-structural type %2">;
 def warn_cxx17_compat_template_nontype_parm_type : Warning<
   "non-type template parameter of type %0 is incompatible with "
   "C++ standards before C++20">,
   DefaultIgnore, InGroup<CXXPre20Compat>;
+def warn_cxx17_compat_template_nontype_parm_deduced_class : Warning<
+  "non-type template parameters declared with %0 are incompatible with C++ "
+  "standards before C++20">,
+  DefaultIgnore, InGroup<CXXPre20Compat>;
 def warn_cxx14_compat_template_nontype_parm_auto_type : Warning<
   "non-type template parameters declared with %0 are incompatible with C++ "
   "standards before C++17">,
   DefaultIgnore, InGroup<CXXPre17Compat>;
 def err_template_param_default_arg_redefinition : Error<
   "template parameter redefines default argument">;
 def err_template_param_default_arg_inconsistent_redefinition : Error<
   "template parameter default argument is inconsistent with previous definition">;

clang/lib/Sema/SemaTemplate.cpp

auto CheckValidDeclSpecifiers = [this, &D] {
 
     if (DS.isNoreturnSpecified())
       EmitDiag(DS.getNoreturnSpecLoc());
   };
 
   CheckValidDeclSpecifiers();
 
   if (TInfo->getType()->isUndeducedType()) {
+    if (TInfo->getType()->getContainedAutoType()) {
+      // template<auto xx>
       Diag(D.getIdentifierLoc(),
            diag::warn_cxx14_compat_template_nontype_parm_auto_type)
           << QualType(TInfo->getType()->getContainedAutoType(), 0);
+    } else {
+      // template<DeducedClass dc>
+      Diag(D.getIdentifierLoc(),
+           diag::warn_cxx17_compat_template_nontype_parm_deduced_class)
+          << TInfo->getType();
+    }
   }
 
   assert(S->isTemplateParamScope() &&
          "Non-type template parameter not in template parameter scope!");
   bool Invalid = false;
 
   QualType T = CheckNonTypeTemplateParameterType(TInfo, D.getIdentifierLoc());
   if (T.isNull()) {

clang/test/SemaCXX/template-nontype-args-compat.cpp

+// RUN: %clang_cc1 -fsyntax-only -Wpre-c++20-compat -std=c++20 -verify=cpp20 %s 
+
+namespace DeducedClass {
+template<class>
+struct DC {};
+
+template<DC s> // cpp20-warning{{non-type template parameters declared with 'DC' are incompatible with C++ standards before C++20}}
+auto test() {}
+} // namespace DeducedClass