Sema: Change associated type inference handling of generic parameters

Instead of eagerly binding a generic parameter to an abstract type witness,
introduce them as disjunctions.

Fixes rdar://problem/122587432.

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -980,7 +980,6 @@ class AssociatedTypeInference {
 
   /// Infer associated type witnesses for the given associated type.
   InferredAssociatedTypesByWitnesses inferTypeWitnessesViaAssociatedType(
-                   const llvm::SetVector<AssociatedTypeDecl *> &allUnresolved,
                    AssociatedTypeDecl *assocType);
 
   /// Infer associated type witnesses for all relevant value requirements.
@@ -1679,8 +1678,7 @@ AssociatedTypeInference::inferTypeWitnessesViaValueWitnesses(
       if (assocTypes.count(assocType) == 0)
         continue;
 
-      auto reqInferred = inferTypeWitnessesViaAssociatedType(assocTypes,
-                                                             assocType);
+      auto reqInferred = inferTypeWitnessesViaAssociatedType(assocType);
       if (!reqInferred.empty())
         result.push_back({req, std::move(reqInferred)});
 
@@ -1828,10 +1826,12 @@ static Type removeSelfParam(ValueDecl *value, Type type) {
 
 InferredAssociatedTypesByWitnesses
 AssociatedTypeInference::inferTypeWitnessesViaAssociatedType(
-                   const llvm::SetVector<AssociatedTypeDecl *> &allUnresolved,
                    AssociatedTypeDecl *assocType) {
   InferredAssociatedTypesByWitnesses result;
 
+  LLVM_DEBUG(llvm::dbgs() << "Considering associated type:\n";
+             assocType->dump(llvm::dbgs()));
+
   // Check if this associated type is actually fixed to a fully concrete type by
   // a same-type requirement in a protocol that our conforming type conforms to.
   //
@@ -1856,6 +1856,34 @@ AssociatedTypeInference::inferTypeWitnessesViaAssociatedType(
     }
   }
 
+  // Look for a generic parameter with the same name as this associated type.
+  if (ctx.LangOpts.EnableExperimentalAssociatedTypeInference) {
+    // Ignore the generic parameters for AsyncIteratorProtocol.Failure and
+    // AsyncSequence.Failure.
+    if (!isAsyncIteratorProtocolFailure(assocType)) {
+      if (auto genericSig = dc->getGenericSignatureOfContext()) {
+        for (auto *gp : genericSig.getInnermostGenericParams()) {
+          // Packs cannot witness associated type requirements.
+          if (gp->isParameterPack())
+            continue;
+
+          if (gp->getName() == assocType->getName()) {
+            auto witnessType = dc->mapTypeIntoContext(gp);
+
+            // Add this result.
+            InferredAssociatedTypesByWitness inferred;
+            inferred.Witness = gp->getDecl();
+            inferred.Inferred.push_back({assocType, witnessType});
+            result.push_back(std::move(inferred));
+
+            LLVM_DEBUG(llvm::dbgs() << "Candidate generic parameter:\n";
+                       gp->dump(llvm::dbgs()));
+          }
+        }
+      }
+    }
+  }
+
   // Form the default name _Default_Foo.
   DeclNameRef defaultName;
   {
@@ -2440,29 +2468,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.

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