Sema: Tweak abstract witness inference priority again

We used to do attempt things in this order:

- abstract witnesses, defaults, generic parameters

I tried this but it broke things:

- generic parameters, abstract witnesses, defaults

Hoping this sticks:

- abstract witnesses, generic parameters, defaults

Fixes rdar://123262178.

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -2389,6 +2389,7 @@ Type AssociatedTypeInference::computeFixedTypeWitness(
     // any fix this associated type to a concrete type.
     for (auto conformance : getPeerConformances(conformance)) {
       auto *conformedProto = conformance->getProtocol();
+
       auto sig = conformedProto->getGenericSignature();
 
       // FIXME: The RequirementMachine will assert on re-entrant construction.
@@ -2704,35 +2705,40 @@ void AssociatedTypeInference::collectAbstractTypeWitnesses(
     if (system.hasResolvedTypeWitness(assocType->getName()))
       continue;
 
-    // If we find a default type definition, feed it to the system.
-    if (const auto &typeWitness = computeDefaultTypeWitness(assocType)) {
-      bool preferred = (typeWitness->getDefaultedAssocType()->getDeclContext()
-                        == conformance->getProtocol());
-      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;
+    bool found = false;
 
-            if (gp->getName() == assocType->getName()) {
-              system.addTypeWitness(assocType->getName(),
-                                    dc->mapTypeIntoContext(gp),
-                                    /*preferred=*/true);
-            }
+    // 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);
+            found = true;
+            break;
           }
         }
       }
     }
 
+    if (!found) {
+      // If we find a default type definition, feed it to the system.
+      if (const auto &typeWitness = computeDefaultTypeWitness(assocType)) {
+        bool preferred = (typeWitness->getDefaultedAssocType()->getDeclContext()
+                          == conformance->getProtocol());
+        system.addDefaultTypeWitness(typeWitness->getType(),
+                                     typeWitness->getDefaultedAssocType(),
+                                     preferred);
+      }
+    }
   }
 }
 

test/decl/protocol/req/associated_type_generic_param.swift

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

test/decl/protocol/req/associated_type_inference_fixed_type_experimental_inference.swift

@@ -212,7 +212,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 => (unresolved), [[EQUIV_CLASS:0x[0-9a-f]+]]
+  // CHECK-NEXT: A => A (preferred), [[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'}}
@@ -221,7 +221,7 @@ do {
   // CHECK-NEXT: }
   struct Conformer3: P17c {}
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer4<A> to P17d: {
-  // CHECK-NEXT: A => Int (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
+  // CHECK-NEXT: A => A (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: B => Int (preferred), [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: }
   struct Conformer4<A>: P17d {}

test/decl/protocol/req/rdar123262178.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 protocol P {
+  associatedtype A = Never
+}
+
+public struct G<A>: P {}
+
+public struct ConcreteA {}
+
+public protocol Q: P where Self.A == ConcreteA {}
+
+extension G: Q where A == ConcreteA {}