[Requirement Machine] Fix the order of requirements that involve pack elements.

Author: hborla

lib/AST/GenericSignature.cpp

@@ -794,10 +794,6 @@ int swift::compareDependentTypes(Type type1, Type type2) {
   // Fast-path check for equality.
   if (type1->isEqual(type2)) return 0;
 
-  // Packs are always ordered after scalar type parameters.
-  if (type1->isParameterPack() != type2->isParameterPack())
-    return type2->isParameterPack() ? -1 : +1;
-
   // Ordering is as follows:
   // - Generic params
   auto gp1 = type1->getAs<GenericTypeParamType>();
@@ -942,7 +938,12 @@ void GenericSignature::verify(ArrayRef<Requirement> reqts) const {
           llvm::errs() << "\n";
           abort();
         }
-        if (compareDependentTypes(firstType, secondType) >= 0) {
+        // FIXME: Same-element rewrite rules are of the form [element].T => U,
+        // which turns into a same-type requirement repeat U == each T. The
+        // pack element must always be on the left side of the rule, so type
+        // parameters can appear out of order in the final same-type requirement.
+        if (firstType->isParameterPack() == secondType->isParameterPack() &&
+            compareDependentTypes(firstType, secondType) >= 0) {
           llvm::errs() << "Out-of-order type parameters: ";
           reqt.dump(llvm::errs());
           llvm::errs() << "\n";

lib/AST/RequirementMachine/Term.cpp

@@ -135,30 +135,17 @@ static llvm::Optional<int> shortlexCompare(const Symbol *lhsBegin,
                                            RewriteContext &ctx) {
   // First, compare the number of name and pack element symbols.
   unsigned lhsNameCount = 0;
-  unsigned lhsPackElementCount = 0;
   for (auto *iter = lhsBegin; iter != lhsEnd; ++iter) {
     if (iter->getKind() == Symbol::Kind::Name)
       ++lhsNameCount;
-
-    if (iter->getKind() == Symbol::Kind::PackElement)
-      ++lhsPackElementCount;
   }
 
   unsigned rhsNameCount = 0;
-  unsigned rhsPackElementCount = 0;
   for (auto *iter = rhsBegin; iter != rhsEnd; ++iter) {
     if (iter->getKind() == Symbol::Kind::Name)
       ++rhsNameCount;
-
-    if (iter->getKind() == Symbol::Kind::PackElement)
-      ++rhsPackElementCount;
   }
 
-  // A term with more pack element symbols orders after a term with
-  // fewer pack element symbols.
-  if (lhsPackElementCount != rhsPackElementCount)
-    return lhsPackElementCount > rhsPackElementCount ? 1 : -1;
-
   // A term with more name symbols orders after a term with fewer name symbols.
   if (lhsNameCount != rhsNameCount)
     return lhsNameCount > rhsNameCount ? 1 : -1;

test/Generics/parameter-pack-requirements.swift

@@ -154,7 +154,7 @@ func dependentSameElementConcrete<each C: Collection>(
 ) where repeat (each C).Element == Int {}
 
 // CHECK-LABEL: dependentSameElementGeneric
-// CHECK-NEXT: Generic signature: <each C, Element where repeat Element == (each C).[Sequence]Element, repeat each C : Collection>
+// CHECK-NEXT: Generic signature: <each C, Element where repeat each C : Collection, repeat Element == (each C).[Sequence]Element>
 func dependentSameElementGeneric<each C: Collection, Element>(
   _: repeat each C
 ) where repeat (each C).Element == Element {}