RequirementMachine: Correct concrete type unification with pack expansion on both sides

Author: slavapestov

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -403,7 +403,7 @@ Type PropertyMap::getTypeForTerm(const MutableTerm &term,
 /// Concrete type terms are written in terms of generic parameter types that
 /// have a depth of 0, and an index into an array of substitution terms.
 ///
-/// See RewriteSystemBuilder::getConcreteSubstitutionSchema().
+/// See RewriteSystemBuilder::getSubstitutionSchemaFromType().
 unsigned RewriteContext::getGenericParamIndex(Type type) {
   auto *paramTy = type->castTo<GenericTypeParamType>();
   assert(paramTy->getDepth() == 0);
@@ -429,6 +429,7 @@ RewriteContext::getRelativeTermForType(CanType typeWitness,
   // Get the substitution S corresponding to τ_0_n.
   unsigned index = getGenericParamIndex(typeWitness->getRootGenericParam());
   result = MutableTerm(substitutions[index]);
+  assert(result.back().getKind() != Symbol::Kind::Shape);
 
   // If the substitution is a term consisting of a single protocol symbol
   // [P], save P for later.
@@ -471,7 +472,7 @@ RewriteContext::getRelativeTermForType(CanType typeWitness,
 }
 
 /// Reverses the transformation performed by
-/// RewriteSystemBuilder::getConcreteSubstitutionSchema().
+/// RewriteSystemBuilder::getSubstitutionSchemaFromType().
 Type PropertyMap::getTypeFromSubstitutionSchema(
     Type schema, ArrayRef<Term> substitutions,
     ArrayRef<GenericTypeParamType *> genericParams,
@@ -481,11 +482,38 @@ Type PropertyMap::getTypeFromSubstitutionSchema(
   if (!schema->hasTypeParameter())
     return schema;
 
-  return schema.transformRec([&](Type t) -> llvm::Optional<Type> {
+  return schema.transformWithPosition(
+      TypePosition::Invariant,
+      [&](Type t, TypePosition pos) -> llvm::Optional<Type> {
     if (t->is<GenericTypeParamType>()) {
       auto index = RewriteContext::getGenericParamIndex(t);
       auto substitution = substitutions[index];
 
+      bool isShapePosition = (pos == TypePosition::Shape);
+      bool isShapeTerm = (substitution.back() == Symbol::forShape(Context));
+      if (isShapePosition != isShapeTerm) {
+        llvm::errs() << "Shape vs. type mixup\n\n";
+        schema.dump(llvm::errs());
+        llvm::errs() << "Substitutions:\n";
+        for (auto otherSubst : substitutions) {
+          llvm::errs() << "- ";
+          otherSubst.dump(llvm::errs());
+          llvm::errs() << "\n";
+        }
+        llvm::errs() << "\n";
+        dump(llvm::errs());
+
+        abort();
+      }
+
+      // Undo the thing where the count type of a PackExpansionType
+      // becomes a shape term.
+      if (isShapeTerm) {
+        MutableTerm mutTerm(substitution.begin(),
+                            substitution.end() - 1);
+        substitution = Term::get(mutTerm, Context);
+      }
+
       // Prepend the prefix of the lookup key to the substitution.
       if (prefix.empty()) {
         // Skip creation of a new MutableTerm in the case where the
@@ -535,17 +563,31 @@ RewriteContext::getRelativeSubstitutionSchemaFromType(
   if (!concreteType->hasTypeParameter())
     return concreteType;
 
-  return CanType(concreteType.transformRec([&](Type t) -> llvm::Optional<Type> {
+  return CanType(concreteType.transformWithPosition(
+      TypePosition::Invariant,
+      [&](Type t, TypePosition pos) -> llvm::Optional<Type> {
+
     if (!t->isTypeParameter())
       return llvm::None;
 
     auto term = getRelativeTermForType(CanType(t), substitutions);
 
-    unsigned newIndex = result.size();
+    // PackExpansionType(pattern=T, count=U) becomes
+    // PackExpansionType(pattern=τ_0_0, count=τ_0_1) with
+    //
+    // τ_0_0 := T
+    // τ_0_1 := U.[shape]
+    if (pos == TypePosition::Shape) {
+      assert(false);
+      term.add(Symbol::forShape(*this));
+    }
+
+    unsigned index = result.size();
+
     result.push_back(Term::get(term, *this));
 
     return CanGenericTypeParamType::get(/*isParameterPack=*/ false,
-                                        /*depth=*/ 0, newIndex,
+                                        /*depth=*/ 0, index,
                                         Context);
   }));
 }
@@ -566,12 +608,26 @@ RewriteContext::getSubstitutionSchemaFromType(CanType concreteType,
   if (!concreteType->hasTypeParameter())
     return concreteType;
 
-  return CanType(concreteType.transformRec([&](Type t) -> llvm::Optional<Type> {
+  return CanType(concreteType.transformWithPosition(
+      TypePosition::Invariant,
+      [&](Type t, TypePosition pos)
+          -> llvm::Optional<Type> {
+
     if (!t->isTypeParameter())
       return llvm::None;
 
+    // PackExpansionType(pattern=T, count=U) becomes
+    // PackExpansionType(pattern=τ_0_0, count=τ_0_1) with
+    //
+    // τ_0_0 := T
+    // τ_0_1 := U.[shape]
+    MutableTerm term = getMutableTermForType(CanType(t), proto);
+    if (pos == TypePosition::Shape)
+      term.add(Symbol::forShape(*this));
+
     unsigned index = result.size();
-    result.push_back(getTermForType(CanType(t), proto));
+
+    result.push_back(Term::get(term, *this));
 
     return CanGenericTypeParamType::get(/*isParameterPack=*/ false,
                                         /*depth=*/0, index,

lib/AST/RequirementMachine/Symbol.h

@@ -57,7 +57,7 @@ class Term;
 /// This transformation allows DependentMemberTypes to be manipulated as
 /// terms, with the actual concrete type structure remaining opaque to
 /// the requirement machine. This transformation is implemented in
-/// RewriteContext::getConcreteSubstitutionSchema().
+/// RewriteContext::getSubstitutionSchemaFromType().
 ///
 /// For example, the superclass requirement
 /// "T : MyClass<U.X, (Int) -> V.A.B>" is denoted with a symbol

lib/AST/RequirementMachine/TypeDifference.cpp

@@ -159,6 +159,9 @@ namespace {
       bool rhsAbstract = rhsType->isTypeParameter();
 
       if (lhsAbstract && rhsAbstract) {
+        // FIXME: same-element requirements
+        assert(lhsType->isParameterPack() == rhsType->isParameterPack());
+
         unsigned lhsIndex = RewriteContext::getGenericParamIndex(lhsType);
         unsigned rhsIndex = RewriteContext::getGenericParamIndex(rhsType);
 

test/Generics/pack-shape-requirements.swift

@@ -107,3 +107,22 @@ func sameTypeDesugar1<each T, each U>(t: repeat each T, u: repeat each U)
 func sameTypeDesugar2<each T: P, each U: P>(t: repeat each T, u: repeat each U)
   where Shape<repeat (each T).A> == Shape<repeat (each U).A> {}
 
+/// More complex example involving concrete type matching in
+/// property map construction
+
+protocol PP {
+  associatedtype A
+}
+
+struct G<each T> {}
+
+// CHECK-LABEL: sameTypeMatch1
+// CHECK-NEXT: <T, each U, each V where T : PP, repeat each U : PP, repeat each V : PP, T.[PP]A == G<repeat (each U).[PP]A>, repeat (each U).[PP]A == (each V).[PP]A>
+func sameTypeMatch1<T: PP, each U: PP, each V: PP>(t: T, u: repeat each U, v: repeat each V)
+  where T.A == G<repeat (each U).A>, T.A == G<repeat (each V).A>,
+        (repeat (each U, each V)) : Any {}
+
+// CHECK-LABEL: sameTypeMatch2
+// CHECK-NEXT: <T, each U, each V where T : PP, repeat each U : PP, (repeat (each U, each V)) : Any, repeat each V : PP, T.[PP]A == (/* shape: each U */ repeat ())>
+func sameTypeMatch2<T: PP, each U: PP, each V: PP>(t: T, u: repeat each U, v: repeat each V)
+  where T.A == Shape<repeat each U>, T.A == Shape<repeat each V> {}