AST: TypeMatcher should walk into ProtocolCompositionTypes

Author: slavapestov

include/swift/AST/TypeMatcher.h

@@ -303,7 +303,33 @@ class TypeMatcher {
     TRIVIAL_CASE(SILFunctionType)
     TRIVIAL_CASE(SILBlockStorageType)
     TRIVIAL_CASE(SILBoxType)
-    TRIVIAL_CASE(ProtocolCompositionType)
+
+    bool visitProtocolCompositionType(CanProtocolCompositionType firstProtocolComposition,
+                                      Type secondType,
+                                      Type sugaredFirstType) {
+      if (auto secondProtocolComposition = secondType->getAs<ProtocolCompositionType>()) {
+        auto firstMembers = firstProtocolComposition->getMembers();
+        auto secondMembers = secondProtocolComposition->getMembers();
+
+        if (firstMembers.size() == secondMembers.size()) {
+          for (unsigned i : indices(firstMembers)) {
+            auto firstMember = firstMembers[i];
+            auto secondMember = secondMembers[i];
+
+            // FIXME: We lose sugar here, because the sugared type might have a different
+            // number of members, or the members might appear in a different order.
+            if (!this->visit(CanType(firstMember), secondMember, firstMember)) {
+              return false;
+            }
+          }
+
+          return true;
+        }
+      }
+
+      return mismatch(firstProtocolComposition.getPointer(), secondType,
+                      sugaredFirstType);
+    }
 
     bool visitParameterizedProtocolType(CanParameterizedProtocolType firstParametrizedProto,
                                         Type secondType,

test/Generics/unify_protocol_composition.swift

@@ -0,0 +1,20 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
+
+class C<T> {}
+
+protocol P0 {}
+
+protocol P1 {
+  associatedtype T where T == C<U> & P0
+  associatedtype U
+}
+
+protocol P2 {
+  associatedtype T where T == C<Int> & P0
+}
+
+// CHECK-LABEL: .P3@
+// CHECK-NEXT: Requirement signature: <Self where Self.[P3]T : P1, Self.[P3]T : P2>
+protocol P3 {
+  associatedtype T : P1 & P2 where T.U == Int
+}