Merge pull request #41958 from slavapestov/type-matcher-opaque-archetype

AST: TypeMatcher needs to recurse into OpaqueTypeArchetypeTypes

Author: slavapestov

include/swift/AST/TypeMatcher.h

@@ -181,9 +181,8 @@ class TypeMatcher {
 
     bool visitReferenceStorageType(CanReferenceStorageType firstStorage,
                                    Type secondType, Type sugaredFirstType) {
-      auto _secondStorage = secondType->getCanonicalType();
-      if (firstStorage->getKind() == _secondStorage->getKind()) {
-        auto secondStorage = cast<ReferenceStorageType>(_secondStorage);
+      if (firstStorage->getKind() == secondType->getDesugaredType()->getKind()) {
+        auto secondStorage = secondType->castTo<ReferenceStorageType>();
         return this->visit(firstStorage.getReferentType(),
                            secondStorage->getReferentType(),
                            sugaredFirstType->castTo<ReferenceStorageType>()
@@ -195,9 +194,8 @@ class TypeMatcher {
 
     bool visitNominalType(CanNominalType firstNominal,
                           Type secondType, Type sugaredFirstType) {
-      auto _secondNominal = secondType->getCanonicalType();
-      if (firstNominal->getKind() == _secondNominal->getKind()) {
-        auto secondNominal = cast<NominalType>(_secondNominal);
+      if (firstNominal->getKind() == secondType->getDesugaredType()->getKind()) {
+        auto secondNominal = secondType->castTo<NominalType>();
         if (firstNominal->getDecl() != secondNominal->getDecl())
           return mismatch(firstNominal.getPointer(), secondNominal,
                           sugaredFirstType);
@@ -216,9 +214,8 @@ class TypeMatcher {
 
     bool visitAnyMetatypeType(CanAnyMetatypeType firstMeta,
                               Type secondType, Type sugaredFirstType) {
-      auto _secondMeta = secondType->getCanonicalType();
-      if (firstMeta->getKind() == _secondMeta->getKind()) {
-        auto secondMeta = cast<AnyMetatypeType>(_secondMeta);
+      if (firstMeta->getKind() == secondType->getDesugaredType()->getKind()) {
+        auto secondMeta = secondType->castTo<AnyMetatypeType>();
         return this->visit(firstMeta.getInstanceType(),
                            secondMeta->getInstanceType(),
                            sugaredFirstType->castTo<AnyMetatypeType>()
@@ -229,7 +226,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,

lib/AST/RequirementMachine/Symbol.cpp

@@ -658,6 +658,8 @@ void Symbol::dump(llvm::raw_ostream &out) const {
 
   PrintOptions opts;
   opts.AlternativeTypeNames = &substitutionNames;
+  opts.OpaqueReturnTypePrinting =
+      PrintOptions::OpaqueReturnTypePrintingMode::StableReference;
 
   switch (getKind()) {
   case Kind::Name:

test/Generics/opaque_archetype_concrete_requirement.swift

@@ -77,5 +77,5 @@ protocol HasRecursiveP {
 
 extension HasRecursiveP where T == DefinesRecursiveP.T {}
 // expected-error@-1 {{cannot build rewrite system for generic signature; rule length limit exceeded}}
-// expected-note@-2 {{failed rewrite rule is τ_0_0.[HasRecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[concrete: ((((((((((some RecursiveP).T).T).T).T).T).T).T).T).T).T] => τ_0_0.[HasRecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T]}}
+// expected-note@-2 {{failed rewrite rule is τ_0_0.[HasRecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[concrete: (((((((((@_opaqueReturnTypeOf("$s37opaque_archetype_concrete_requirement17DefinesRecursivePV1tQrvp", 0) __.T).T).T).T).T).T).T).T).T).T] => τ_0_0.[HasRecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T].[RecursiveP:T]}}
 

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)
+  }
+}