[Requirement Machine] Use element symbols for concrete same-element requirements.

Author: hborla

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -308,20 +308,6 @@ bool RequirementMachine::isReducedType(Type type) const {
       if (!component->hasTypeParameter())
         return Action::SkipChildren;
 
-      if (auto *expansion = component->getAs<PackExpansionType>()) {
-        auto pattern = expansion->getPatternType();
-        auto shape = expansion->getCountType();
-        if (!Self.isReducedType(pattern))
-          return Action::Stop;
-
-        auto reducedShape =
-            Self.getReducedShape(shape, Self.getGenericParams());
-        if (reducedShape->getCanonicalType() != CanType(shape))
-          return Action::Stop;
-
-        return Action::SkipChildren;
-      }
-
       if (!component->isTypeParameter())
         return Action::Continue;
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -625,7 +625,8 @@ void RewriteSystem::verifyRewriteRules(ValidityPolicy policy) const {
       }
 
       if (index != 0) {
-        ASSERT_RULE(symbol.getKind() != Symbol::Kind::GenericParam);
+        ASSERT_RULE(symbol.getKind() != Symbol::Kind::GenericParam ||
+                    lhs[index - 1].getKind() == Symbol::Kind::PackElement);
       }
 
       if (!rule.isRHSSimplified() &&

lib/AST/RequirementMachine/RuleBuilder.cpp

@@ -367,6 +367,7 @@ void RuleBuilder::addRequirement(const Requirement &req,
 
   case RequirementKind::SameType: {
     auto otherType = CanType(req.getSecondType());
+    auto elementSymbol = Symbol::forPackElement(Context);
 
     if (!otherType->isTypeParameter()) {
       // A concrete same-type requirement T == C<X, Y> becomes a
@@ -380,6 +381,16 @@ void RuleBuilder::addRequirement(const Requirement &req,
                    : Context.getSubstitutionSchemaFromType(
                         otherType, proto, result));
 
+      // If 'T' is a parameter pack, this is a same-element
+      // requirement that becomes the following rewrite rule:
+      //
+      //   [element].T.[concrete: C<X, Y>] => [element].T
+      if (subjectType->isParameterPack()) {
+        llvm::SmallVector<Symbol, 3> subjectSymbols{elementSymbol};
+        subjectSymbols.append(subjectTerm.begin(), subjectTerm.end());
+        subjectTerm = MutableTerm(std::move(subjectSymbols));
+      }
+
       constraintTerm = subjectTerm;
       constraintTerm.add(Symbol::forConcreteType(otherType, result, Context));
       break;
@@ -393,7 +404,6 @@ void RuleBuilder::addRequirement(const Requirement &req,
 
     if (subjectType->isParameterPack() != otherType->isParameterPack()) {
       // This is a same-element requirement.
-      auto elementSymbol = Symbol::forPackElement(Context);
       llvm::SmallVector<Symbol, 3> symbols{elementSymbol};
 
       if (subjectType->isParameterPack()) {
@@ -580,4 +590,4 @@ void RuleBuilder::collectPackShapeRules(ArrayRef<GenericTypeParamType *> generic
       }
     }
   }
-}
+}