AST: TypeMatcher needs to recurse into OpaqueTypeArchetypeTypes

Fixes https://bugs.swift.org/browse/SR-16040.

Author: slavapestov

include/swift/AST/TypeMatcher.h

@@ -229,7 +229,41 @@ class TypeMatcher {
     }
 
     TRIVIAL_CASE(ModuleType)
-    TRIVIAL_CASE(ArchetypeType)
+
+    bool visitArchetypeType(CanArchetypeType firstArchetype,
+                            Type secondType,
+                            Type sugaredFirstType) {
+      if (auto firstOpaqueArchetype = dyn_cast<OpaqueTypeArchetypeType>(firstArchetype)) {
+        if (auto secondOpaqueArchetype = secondType->getAs<OpaqueTypeArchetypeType>()) {
+          if (firstOpaqueArchetype->getDecl() == secondOpaqueArchetype->getDecl()) {
+            auto firstSubMap = firstOpaqueArchetype->getSubstitutions();
+            auto secondSubMap = secondOpaqueArchetype->getSubstitutions();
+            assert(firstSubMap.getReplacementTypes().size() ==
+                   secondSubMap.getReplacementTypes().size());
+
+            for (unsigned i : indices(firstSubMap.getReplacementTypes())) {
+              auto firstSubstType = firstSubMap.getReplacementTypes()[i];
+              auto secondSubstType = secondSubMap.getReplacementTypes()[i];
+
+              if (!this->visit(firstSubstType->getCanonicalType(),
+                               secondSubstType, firstSubstType))
+                return false;
+            }
+
+            return true;
+          }
+        }
+      }
+
+      // FIXME: Once OpenedArchetypeType stores substitutions, do something
+      // similar to the above.
+
+      if (firstArchetype->isEqual(secondType))
+        return true;
+
+
+      return mismatch(firstArchetype.getPointer(), secondType, sugaredFirstType);
+    }
 
     bool visitDynamicSelfType(CanDynamicSelfType firstDynamicSelf,
                               Type secondType,

test/Generics/sr16040.swift

@@ -0,0 +1,44 @@
+// RUN: %target-swift-frontend -typecheck %s -disable-availability-checking -debug-generic-signatures 2>&1 | %FileCheck %s
+
+public protocol View {
+  associatedtype Body : View
+  var body: Body { get }
+}
+
+public struct Text : View {
+  public init(_: String) {}
+  public var body: Self { return self }
+}
+
+public protocol DisplayableValue {}
+
+public protocol SingleValueDisplay: View {
+  associatedtype DisplayedValue
+  init (_ singleValue: DisplayedValue)
+  var displayedValue: DisplayedValue { get }
+}
+
+// CHECK-LABEL: .RawDisplayableValue@
+// CHECK-NEXT: Requirement signature: <Self where Self : DisplayableValue, Self == Self.[RawDisplayableValue]RawDisplay.[SingleValueDisplay]DisplayedValue, Self.[RawDisplayableValue]RawDisplay : SingleValueDisplay>
+public protocol RawDisplayableValue: DisplayableValue {
+  associatedtype RawDisplay: SingleValueDisplay
+    where RawDisplay.DisplayedValue == Self
+}
+
+// CHECK-LABEL: .RawTextDisplayableValue@
+// CHECK-NEXT: Requirement signature: <Self where Self : CustomStringConvertible, Self : RawDisplayableValue, Self.[RawDisplayableValue]RawDisplay == RawTextDisplay<Self>>
+public protocol RawTextDisplayableValue: RawDisplayableValue
+  where Self: CustomStringConvertible,
+        RawDisplay == RawTextDisplay<Self> { }
+
+public struct RawTextDisplay <Value: CustomStringConvertible>: SingleValueDisplay {
+  public var displayedValue: Value
+  
+  public init (_ singleValue: Value) {
+    self.displayedValue = singleValue
+  }
+  
+  public var body: some View {
+    Text(displayedValue.description)
+  }
+}