Test-patch for https://reviews.llvm.org/D134128 alternative

[erichkeane]

Summary

See the direction< It causes a number of partial-specialization problems (Class template partial specialization is not more specialized than the primary template),but I suspect I'm instantiating a concept I shouldnt be elsewhere as well.

[erichkeane]

Failures I saw:

FAIL: Clang :: CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp (9218 of 17395)
******************** TEST 'Clang :: CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /localdisk2/ekeane1/workspaces/delayed-concepts/build/bin/clang -cc1 -internal-isystem /localdisk2/ekeane1/workspaces/delayed-concepts/build/lib/clang/16.0.0/include -nostdsysteminc -std=c++2a -x c++ -verify /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 19: class template partial specialization is not more specialized than the primary template
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 89: class template partial specialization is not more specialized than the primary template
error: 'note' diagnostics expected but not seen:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 3 (directive at /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp:4): similar constraint expressions not considered equivalen
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 7 (directive at /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp:8): similar constraint expression here
error: 'note' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 16: template is declared here
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp Line 83: template is declared here
6 errors generated.

--

********************
FAIL: Clang :: CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp (11341 of 17395)
******************** TEST 'Clang :: CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /localdisk2/ekeane1/workspaces/delayed-concepts/build/bin/clang -cc1 -internal-isystem /localdisk2/ekeane1/workspaces/delayed-concepts/build/lib/clang/16.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++20 /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp Line 97: class template partial specialization is not more specialized than the primary template
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp Line 99: class template partial specialization is not more specialized than the primary template
error: 'note' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp Line 95: template is declared here
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp Line 95: template is declared here
4 errors generated.

--

********************
FAIL: Clang :: CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp (12212 of 17395)
******************** TEST 'Clang :: CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /localdisk2/ekeane1/workspaces/delayed-concepts/build/bin/clang -cc1 -internal-isystem /localdisk2/ekeane1/workspaces/delayed-concepts/build/lib/clang/16.0.0/include -nostdsysteminc -std=c++2a -x c++ -verify /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp Line 18: variable template partial specialization is not more specialized than the primary template
error: 'note' diagnostics expected but not seen:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp Line 3 (directive at /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp:4): similar constraint expressions not considered equivalent
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp Line 7 (directive at /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp:8): similar constraint expression here
error: 'note' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp Line 15: template is declared here
4 errors generated.

--

********************
FAIL: Clang :: SemaTemplate/concepts-GH53354.cpp (17193 of 17395)
******************** TEST 'Clang :: SemaTemplate/concepts-GH53354.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   /localdisk2/ekeane1/workspaces/delayed-concepts/build/bin/clang -cc1 -internal-isystem /localdisk2/ekeane1/workspaces/delayed-concepts/build/lib/clang/16.0.0/include -nostdsysteminc -std=c++20 -verify /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/SemaTemplate/concepts-GH53354.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/SemaTemplate/concepts-GH53354.cpp Line 20: class template partial specialization is not more specialized than the primary template
error: 'note' diagnostics seen but not expected:
  File /localdisk2/ekeane1/workspaces/delayed-concepts/clang/test/SemaTemplate/concepts-GH53354.cpp Line 16: template is declared here
2 errors generated.

--

********************
                                                                                                    -- Testing: 17395 tests, 96 workers --
********************
Failed Tests (4):
  Clang :: CXX/temp/temp.constr/temp.constr.order/class-template-partial-specializations.cpp
  Clang :: CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp
  Clang :: CXX/temp/temp.decls/temp.fct/temp.func.order/p6.cpp
  Clang :: SemaTemplate/concepts-GH53354.cpp

As you can see, they are all about the same symptom, so I'm just hoping we need to change how we instantiate that constraint slightly? Maybe we should still instantiate when doing partial-specialization application, and this causes it to skip? Or maybe the 'other side' needs constraints to stop being instantiated?

clang/include/clang/Sema/Sema.h

public:
   /// \brief Check whether the given declaration's associated constraints are
   /// at least as constrained than another declaration's according to the
   /// partial ordering of constraints.
   ///
   /// \param Result If no error occurred, receives the result of true if D1 is
   /// at least constrained than D2, and false otherwise.
   ///
   /// \returns true if an error occurred, false otherwise.
-  bool IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                              NamedDecl *D2, ArrayRef<const Expr *> AC2,
+  bool IsAtLeastAsConstrained(NamedDecl *D1, MutableArrayRef<const Expr *> AC1,
+                              NamedDecl *D2, MutableArrayRef<const Expr *> AC2,
                               bool &Result);
 
   /// If D1 was not at least as constrained as D2, but would've been if a pair
   /// of atomic constraints involved had been declared in a concept and not
   /// repeated in two separate places in code.
   /// \returns true if such a diagnostic was emitted, false otherwise.
   bool MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1,
       ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2);
bool SubstExprs(ArrayRef<Expr *> Exprs, bool IsCall,
                   const MultiLevelTemplateArgumentList &TemplateArgs,
                   SmallVectorImpl<Expr *> &Outputs);
 
   StmtResult SubstStmt(Stmt *S,
                        const MultiLevelTemplateArgumentList &TemplateArgs);
 
   TemplateParameterList *
   SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
-                      const MultiLevelTemplateArgumentList &TemplateArgs);
+                      const MultiLevelTemplateArgumentList &TemplateArgs,
+                      bool EvaluateConstraints = true);
 
   bool
   SubstTemplateArguments(ArrayRef<TemplateArgumentLoc> Args,
                          const MultiLevelTemplateArgumentList &TemplateArgs,
                          TemplateArgumentListInfo &Outputs);
 
   Decl *SubstDecl(Decl *D, DeclContext *Owner,
                   const MultiLevelTemplateArgumentList &TemplateArgs);

clang/lib/Parse/ParseTemplate.cpp

NamedDecl *Parser::ParseTypeParameter(unsigned Depth, unsigned Position) {
 
   return NewDecl;
 }
 
 /// ParseTemplateTemplateParameter - Handle the parsing of template
 /// template parameters.
 ///
 ///       type-parameter:    [C++ temp.param]
-///         'template' '<' template-parameter-list '>' type-parameter-key
-///                  ...[opt] identifier[opt]
-///         'template' '<' template-parameter-list '>' type-parameter-key
-///                  identifier[opt] = id-expression
+///         template-head type-parameter-key ...[opt] identifier[opt]
+///         template-head type-parameter-key identifier[opt] = id-expression
 ///       type-parameter-key:
 ///         'class'
 ///         'typename'       [C++1z]
-NamedDecl *
-Parser::ParseTemplateTemplateParameter(unsigned Depth, unsigned Position) {
+///       template-head:     [C++2a]
+///         'template' '<' template-parameter-list '>'
+///             requires-clause[opt]
+NamedDecl *Parser::ParseTemplateTemplateParameter(unsigned Depth,
+                                                  unsigned Position) {
   assert(Tok.is(tok::kw_template) && "Expected 'template' keyword");
 
   // Handle the template <...> part.
   SourceLocation TemplateLoc = ConsumeToken();
   SmallVector<NamedDecl*,8> TemplateParams;
   SourceLocation LAngleLoc, RAngleLoc;
+  ExprResult OptionalRequiresClauseConstraintER;
   {
     MultiParseScope TemplateParmScope(*this);
     if (ParseTemplateParameters(TemplateParmScope, Depth + 1, TemplateParams,
                                 LAngleLoc, RAngleLoc)) {
       return nullptr;
     }
+    if (TryConsumeToken(tok::kw_requires)) {
+      OptionalRequiresClauseConstraintER =
+          Actions.ActOnRequiresClause(ParseConstraintLogicalOrExpression(
+              /*IsTrailingRequiresClause=*/false));
+      if (!OptionalRequiresClauseConstraintER.isUsable()) {
+        SkipUntil(tok::comma, tok::greater, tok::greatergreater,
+                  StopAtSemi | StopBeforeMatch);
+        return nullptr;
+      }
+    }
   }
 
   // Provide an ExtWarn if the C++1z feature of using 'typename' here is used.
   // Generate a meaningful error if the user forgot to put class before the
   // identifier, comma, or greater. Provide a fixit if the identifier, comma,
   // or greater appear immediately or after 'struct'. In the latter case,
   // replace the keyword with 'class'.
   if (!TryConsumeToken(tok::kw_class)) {
if (Tok.is(tok::identifier)) {
     return nullptr;
   }
 
   // Recover from misplaced ellipsis.
   bool AlreadyHasEllipsis = EllipsisLoc.isValid();
   if (TryConsumeToken(tok::ellipsis, EllipsisLoc))
     DiagnoseMisplacedEllipsis(EllipsisLoc, NameLoc, AlreadyHasEllipsis, true);
 
-  TemplateParameterList *ParamList =
-    Actions.ActOnTemplateParameterList(Depth, SourceLocation(),
-                                       TemplateLoc, LAngleLoc,
-                                       TemplateParams,
-                                       RAngleLoc, nullptr);
+  TemplateParameterList *ParamList = Actions.ActOnTemplateParameterList(
+      Depth, SourceLocation(), TemplateLoc, LAngleLoc, TemplateParams,
+      RAngleLoc, OptionalRequiresClauseConstraintER.get());
 
   // Grab a default argument (if available).
   // Per C++0x [basic.scope.pdecl]p9, we parse the default argument before
   // we introduce the template parameter into the local scope.
   SourceLocation EqualLoc;
   ParsedTemplateArgument DefaultArg;
   if (TryConsumeToken(tok::equal, EqualLoc)) {
     DefaultArg = ParseTemplateTemplateArgument();

clang/lib/Sema/SemaConcept.cpp

static bool subsumes(Sema &S, NamedDecl *DP, ArrayRef<const Expr *> P,
   if (!QNormalized)
     return true;
   const NormalForm QCNF = makeCNF(*QNormalized);
 
   Subsumes = subsumes(PDNF, QCNF, E);
   return false;
 }
 
-bool Sema::IsAtLeastAsConstrained(NamedDecl *D1, ArrayRef<const Expr *> AC1,
-                                  NamedDecl *D2, ArrayRef<const Expr *> AC2,
+bool Sema::IsAtLeastAsConstrained(NamedDecl *D1,
+                                  MutableArrayRef<const Expr *> AC1,
+                                  NamedDecl *D2,
+                                  MutableArrayRef<const Expr *> AC2,
                                   bool &Result) {
   if (AC1.empty()) {
     Result = AC2.empty();
     return false;
   }
   if (AC2.empty()) {
     // TD1 has associated constraints and TD2 does not.
     Result = true;
     return false;
   }
 
   std::pair<NamedDecl *, NamedDecl *> Key{D1, D2};
   auto CacheEntry = SubsumptionCache.find(Key);
   if (CacheEntry != SubsumptionCache.end()) {
     Result = CacheEntry->second;
     return false;
   }
 
+  unsigned Depth1 = CalculateTemplateDepthForConstraints(*this, D1);
+  unsigned Depth2 = CalculateTemplateDepthForConstraints(*this, D2);
+
+  for (size_t I = 0; I != AC1.size() && I != AC2.size(); ++I) {
+    if (Depth2 > Depth1) {
+      AC1[I] = AdjustConstraintDepth(*this, Depth2 - Depth1).
+        TransformExpr(const_cast<Expr*>(AC1[I])).
+        get();
+    } else if (Depth1 > Depth2) {
+      AC2[I] = AdjustConstraintDepth(*this, Depth1 - Depth2).
+        TransformExpr(const_cast<Expr*>(AC2[I])).
+        get();
+    }
+  }
+
   if (subsumes(*this, D1, AC1, D2, AC2, Result,
         [this] (const AtomicConstraint &A, const AtomicConstraint &B) {
           return A.subsumes(Context, B);
         }))
     return true;
   SubsumptionCache.try_emplace(Key, Result);
   return false;
 }

clang/lib/Sema/SemaOverload.cpp

if (FunctionTemplateDecl *BetterTemplate = S.getMoreSpecializedTemplate(
             Cand1.isReversed() ^ Cand2.isReversed()))
       return BetterTemplate == Cand1.Function->getPrimaryTemplate();
   }
 
   //   -— F1 and F2 are non-template functions with the same
   //      parameter-type-lists, and F1 is more constrained than F2 [...],
   if (!Cand1IsSpecialization && !Cand2IsSpecialization &&
       sameFunctionParameterTypeLists(S, Cand1, Cand2)) {
-    Expr *RC1 = Cand1.Function->getTrailingRequiresClause();
-    Expr *RC2 = Cand2.Function->getTrailingRequiresClause();
+    const Expr *RC1 = Cand1.Function->getTrailingRequiresClause();
+    const Expr *RC2 = Cand2.Function->getTrailingRequiresClause();
     if (RC1 && RC2) {
       bool AtLeastAsConstrained1, AtLeastAsConstrained2;
-      if (S.IsAtLeastAsConstrained(Cand1.Function, {RC1}, Cand2.Function, {RC2},
+      if (S.IsAtLeastAsConstrained(Cand1.Function, RC1, Cand2.Function, RC2,
                                    AtLeastAsConstrained1) ||
-          S.IsAtLeastAsConstrained(Cand2.Function, {RC2}, Cand1.Function, {RC1},
+          S.IsAtLeastAsConstrained(Cand2.Function, RC2, Cand1.Function, RC1,
                                    AtLeastAsConstrained2))
         return false;
       if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
         return AtLeastAsConstrained1;
     } else if (RC1 || RC2) {
       return RC1 != nullptr;
     }
   }

clang/lib/Sema/SemaTemplate.cpp

// FIXME: Skip this if the parameters aren't instantiation-dependent.
     InstantiatingTemplate Inst(*this, TemplateLoc, Template, TempParm,
                                Converted, SourceRange(TemplateLoc, RAngleLoc));
     if (Inst.isInvalid())
       return true;
 
     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack, Converted);
     Params = SubstTemplateParams(
         Params, CurContext,
-        MultiLevelTemplateArgumentList(Template, TemplateArgs.asArray()));
+        MultiLevelTemplateArgumentList(Template, TemplateArgs.asArray()),
+        /*EvaluateConstraints=*/false);
     if (!Params)
       return true;
   }
 
   // C++1z [temp.local]p1: (DR1004)
   //   When [the injected-class-name] is used [...] as a template-argument for
   //   a template template-parameter [...] it refers to the class template
   //   itself.

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

TemplateParameterList *InstL
     = TemplateParameterList::Create(SemaRef.Context, L->getTemplateLoc(),
                                     L->getLAngleLoc(), Params,
                                     L->getRAngleLoc(), InstRequiresClause);
   return InstL;
 }
 
 TemplateParameterList *
 Sema::SubstTemplateParams(TemplateParameterList *Params, DeclContext *Owner,
-                          const MultiLevelTemplateArgumentList &TemplateArgs) {
+                          const MultiLevelTemplateArgumentList &TemplateArgs,
+                          bool EvaluateConstraints) {
   TemplateDeclInstantiator Instantiator(*this, Owner, TemplateArgs);
+  Instantiator.setEvaluateConstraints(EvaluateConstraints);
   return Instantiator.SubstTemplateParams(Params);
 }
 
 /// Instantiate the declaration of a class template partial
 /// specialization.
 ///
 /// \param ClassTemplate the (instantiated) class template that is partially
 // specialized by the instantiation of \p PartialSpec.

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

 // RUN:  %clang_cc1 -std=c++2a -frelaxed-template-template-args -verify %s
 
-template<typename T> concept C = T::f();
-// expected-note@-1{{similar constraint}}
+template<typename T> concept C = T::f(); // #C
 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}}
+template<typename T> concept F = T::f(); // #F
+template<template<C> class P> struct S1 { }; // #S1
 
 template<C> struct X { };
 
-template<D> struct Y { }; // expected-note{{'Y' declared here}}
+template<D> struct Y { }; // #Y
 template<typename T> struct Z { };
-template<F> struct W { }; // expected-note{{'W' declared here}}
-
+template<F> struct W { }; // #W
 S1<X> s11;
-S1<Y> s12; // expected-error{{template template argument 'Y' is more constrained than template template parameter 'P'}}
+S1<Y> s12;
+// expected-error@-1 {{template template argument 'Y' is more constrained than template template parameter 'P'}}
+// expected-note@#S1 {{'P' declared here}}
+// expected-note@#Y {{'Y' declared here}}
 S1<Z> s13;
-S1<W> s14; // expected-error{{template template argument 'W' is more constrained than template template parameter 'P'}}
+S1<W> s14;
+// expected-error@-1 {{template template argument 'W' is more constrained than template template parameter 'P'}}
+// expected-note@#S1 {{'P' declared here}}
+// expected-note@#W {{'W' declared here}}
+// expected-note@#F 1-2{{similar constraint expressions not considered equivalent}}
+// expected-note@#C 1-2{{similar constraint}}
 
 template<template<typename> class P> struct S2 { };
 
 S2<X> s21;
 S2<Y> s22;
 S2<Z> s23;
 
 template <template <typename...> class C>
 struct S3;
 
 template <C T>
 using N = typename T::type;
 
 using s31 = S3<N>;
 using s32 = S3<Z>;
+
+template<template<typename T> requires C<T> class P> struct S4 { }; // #S4
+
+S4<X> s41;
+S4<Y> s42;
+// expected-error@-1 {{template template argument 'Y' is more constrained than template template parameter 'P'}}
+// expected-note@#S4 {{'P' declared here}}
+// expected-note@#Y {{'Y' declared here}}
+S4<Z> s43;
+S4<W> s44;
+// expected-error@-1 {{template template argument 'W' is more constrained than template template parameter 'P'}}
+// expected-note@#S4 {{'P' declared here}}
+// expected-note@#W {{'W' declared here}}
+
+template<template<typename T> requires C<T> typename U> struct S5 {
+  template<typename T> static U<T> V;
+};
+
+struct Nothing {};
+
+// FIXME: Wait the standard to clarify the intent.
+template<> template<> Z<Nothing> S5<Z>::V<Nothing>;

clang/test/SemaTemplate/concepts.cpp

namespace P0857R0 {
   void f() {
     auto x = []<bool B> requires B {}; // expected-note {{constraints not satisfied}} expected-note {{false}}
     x.operator()<true>();
     x.operator()<false>(); // expected-error {{no matching member function}}
   }
 
   // FIXME: This is valid under P0857R0.
   template<typename T> concept C = true;
-  template<template<typename T> requires C<T> typename U> struct X {}; // expected-error {{requires 'class'}} expected-error 0+{{}}
+  template<template<typename T> requires C<T> typename U> struct X {};
   template<typename T> requires C<T> struct Y {};
-  X<Y> xy; // expected-error {{no template named 'X'}}
+  X<Y> xy;
 }
 
 namespace PR50306 {
   template<typename T> concept NotInt = sizeof(T) != sizeof(int); // expected-note {{because}}
   template<typename T> void f() {
     [](NotInt auto) {}(T()); // expected-error {{no matching function}} expected-note {{constraints not satisfied}} expected-note {{because}}
   }
   template void f<char>(); // OK