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

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/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