Merge pull request #71548 from slavapestov/assoc-type-regression-fixes-3

Sema: Restore old behavior of generic parameters with associated type inference

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -2440,29 +2440,6 @@ AssociatedTypeInference::computeAbstractTypeWitness(
 void AssociatedTypeInference::collectAbstractTypeWitnesses(
     TypeWitnessSystem &system,
     ArrayRef<AssociatedTypeDecl *> unresolvedAssocTypes) const {
-  // Look for suitably-named generic parameters first, before we go digging
-  // through same-type requirements of protocols.
-  if (auto genericSig = dc->getGenericSignatureOfContext()) {
-    for (auto *const assocType : unresolvedAssocTypes) {
-      // Ignore the generic parameters for AsyncIteratorProtocol.Failure and
-      // AsyncSequence.Failure.
-      if (isAsyncIteratorProtocolFailure(assocType))
-        continue;
-
-      for (auto *gp : genericSig.getInnermostGenericParams()) {
-        // Packs cannot witness associated type requirements.
-        if (gp->isParameterPack())
-          continue;
-
-        if (gp->getName() == assocType->getName()) {
-          system.addTypeWitness(assocType->getName(),
-                                dc->mapTypeIntoContext(gp),
-                                /*preferred=*/true);
-        }
-      }
-    }
-  }
-
   auto considerProtocolRequirements = [&](ProtocolDecl *conformedProto) {
     // FIXME: The RequirementMachine will assert on re-entrant construction.
     // We should find a more principled way of breaking this cycle.
@@ -2515,7 +2492,28 @@ void AssociatedTypeInference::collectAbstractTypeWitnesses(
       system.addDefaultTypeWitness(typeWitness->getType(),
                                    typeWitness->getDefaultedAssocType(),
                                    preferred);
+    } else {
+      // As a last resort, look for a generic parameter that matches the name
+      // of the associated type.
+      if (auto genericSig = dc->getGenericSignatureOfContext()) {
+        // Ignore the generic parameters for AsyncIteratorProtocol.Failure and
+        // AsyncSequence.Failure.
+        if (!isAsyncIteratorProtocolFailure(assocType)) {
+          for (auto *gp : genericSig.getInnermostGenericParams()) {
+            // Packs cannot witness associated type requirements.
+            if (gp->isParameterPack())
+              continue;
+
+            if (gp->getName() == assocType->getName()) {
+              system.addTypeWitness(assocType->getName(),
+                                    dc->mapTypeIntoContext(gp),
+                                    /*preferred=*/true);
+            }
+          }
+        }
+      }
     }
+
   }
 }
 

test/decl/protocol/req/associated_type_generic_param.swift

@@ -1,10 +1,11 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
-// RUN: not %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
 
 protocol P {
   associatedtype A = Int
 }
 
 struct S<A>: P {}
 
-let x: String.Type = S<String>.A.self
+// This is unfortunate but it is the behavior of Swift 5.10.
+let x: Int.Type = S<String>.A.self

test/decl/protocol/req/associated_type_inference_fixed_type_experimental_inference.swift

@@ -214,7 +214,7 @@ do {
   // CHECK-NEXT: }
   struct Conformer1: P17a {} // expected-error {{type 'Conformer1' does not conform to protocol 'P17a'}}
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer2<A> to P17b: {
-  // CHECK-NEXT: A => A (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
+  // CHECK-NEXT: A => (unresolved), [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: B => (unresolved)
   // CHECK-NEXT: }
   struct Conformer2<A>: P17b {} // expected-error {{type 'Conformer2<A>' does not conform to protocol 'P17b'}}
@@ -223,7 +223,7 @@ do {
   // CHECK-NEXT: }
   struct Conformer3: P17c {}
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer4<A> to P17d: {
-  // CHECK-NEXT: A => A (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
+  // CHECK-NEXT: A => Int (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: B => Int (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: }
   struct Conformer4<A>: P17d {}
@@ -645,7 +645,7 @@ protocol P37b {
 }
 do {
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer1<C> to P37b: {
-  // CHECK-NEXT: C => C (preferred),
+  // CHECK-NEXT: C => Self.B.A (preferred),
   // CHECK-NEXT: }
   struct Conformer1<C>: P37b {
     struct Inner: P37a { typealias A = C }

test/decl/protocol/req/associated_type_inference_stdlib_3.swift

@@ -1,6 +1,8 @@
-// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: not %target-typecheck-verify-swift -enable-experimental-associated-type-inference
 // RUN: not %target-typecheck-verify-swift -disable-experimental-associated-type-inference
 
+// FIXME: Get this passing with -enable-experimental-associated-type-inference again.
+
 struct FooIterator<T: Sequence>: IteratorProtocol {
   typealias Element = T.Element
 

test/decl/protocol/req/rdar122587432.swift

@@ -0,0 +1,14 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+public struct S<Element: Hashable> {
+  public typealias A = [Element: Int]
+}
+
+extension S: Sequence {
+  public func makeIterator() -> A.Iterator {
+    fatalError()
+  }
+}
+
+let x: (key: String, value: Int).Type = S<String>.Element.self