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

This effectively reverts d0bd026, so
we now look for abstract type witnesses before generic parameters.

In particular, this means we again prefer the default type witness
over a generic parameter if nothing else forces it to be a generic
parameter:

    protocol P { associatedtype A = Int }
    struct S<T>: P {}
    // S.T is always Int

Fixing this properly requires modeling generic parameter bindings as
disjunctions, which is a more disruptive change than I want to take
for now.

Fixes rdar://problem/122587432.

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