Sema: Prefer generic parameters over defaults and same-type requirements with -enable-experimental-associated-type-inference

Author: slavapestov

lib/Sema/TypeCheckProtocolInference.cpp

@@ -1090,49 +1090,59 @@ AssociatedTypeInference::computeAbstractTypeWitness(
 void AssociatedTypeInference::collectAbstractTypeWitnesses(
     TypeWitnessSystem &system,
     ArrayRef<AssociatedTypeDecl *> unresolvedAssocTypes) const {
-  // First, look at all the protocols the adoptee conforms to and feed the
-  // same-type constraints in their requirement signatures to the system.
-  for (auto *const conformedProto :
-       dc->getSelfNominalTypeDecl()->getAllProtocols(/*sorted=*/true)) {
+  // 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) {
+      for (auto *gp : genericSig.getInnermostGenericParams()) {
+        // Packs cannot witness associated type requirements.
+        if (gp->isParameterPack())
+          continue;
+
+        if (gp->getName() == assocType->getName()) {
+          system.addTypeWitness(assocType->getName(), gp);
+        }
+      }
+    }
+  }
+
+  auto considerProtocolRequirements = [&](ProtocolDecl *conformedProto) {
     // FIXME: The RequirementMachine will assert on re-entrant construction.
     // We should find a more principled way of breaking this cycle.
     if (ctx.isRecursivelyConstructingRequirementMachine(
             conformedProto->getGenericSignature().getCanonicalSignature()) ||
         ctx.isRecursivelyConstructingRequirementMachine(conformedProto) ||
         conformedProto->isComputingRequirementSignature())
-      continue;
+      return;
 
     for (const auto &req :
          conformedProto->getRequirementSignature().getRequirements()) {
-      if (req.getKind() != RequirementKind::SameType) {
-        continue;
-      }
-
-      system.addSameTypeRequirement(req);
+      if (req.getKind() == RequirementKind::SameType)
+        system.addSameTypeRequirement(req);
     }
+  };
+
+
+  // First, look at the conformed protocol for same-type requirements. These
+  // are less likely to cause request cycles.
+  considerProtocolRequirements(conformance->getProtocol());
+
+  // Also look through all other protocols the conforming type conforms to.
+  for (auto *const conformedProto :
+       dc->getSelfNominalTypeDecl()->getAllProtocols(/*sorted=*/true)) {
+    considerProtocolRequirements(conformedProto);
   }
 
   // If the same-type constraints weren't enough to resolve an associated type,
-  // look for more options.
+  // look for default type witnesses.
   for (auto *const assocType : unresolvedAssocTypes) {
-    if (system.hasResolvedTypeWitness(assocType->getName())) {
+    if (system.hasResolvedTypeWitness(assocType->getName()))
       continue;
-    }
 
     // If we find a default type definition, feed it to the system.
     if (const auto &typeWitness = computeDefaultTypeWitness(assocType)) {
       system.addDefaultTypeWitness(typeWitness->getType(),
                                    typeWitness->getDefaultedAssocType());
-    } else {
-      // As a last resort, look for a generic parameter that matches the name
-      // of the associated type.
-      if (auto genericSig = dc->getGenericSignatureOfContext()) {
-        for (auto *gp : genericSig.getInnermostGenericParams()) {
-          if (gp->getName() == assocType->getName()) {
-            system.addTypeWitness(assocType->getName(), gp);
-          }
-        }
-      }
     }
   }
 }

test/decl/protocol/req/associated_type_generic_param.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: not %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

test/decl/protocol/req/associated_type_inference_fixed_type_experimental_inference.swift

@@ -230,8 +230,8 @@ 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: B => (unresolved), [[EQUIV_CLASS]]
+  // CHECK-NEXT: A => A, [[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'}}
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer3 to P17c: {
@@ -240,8 +240,8 @@ do {
   // CHECK-NEXT: }
   struct Conformer3: P17c {}
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer4<A> to P17d: {
-  // CHECK-NEXT: A => Int, [[EQUIV_CLASS:0x[0-9a-f]+]]
-  // CHECK-NEXT: B => Int, [[EQUIV_CLASS]]
+  // CHECK-NEXT: A => A, [[EQUIV_CLASS:0x[0-9a-f]+]]
+  // CHECK-NEXT: B => Int, [[EQUIV_CLASS:0x[0-9a-f]+]]
   // CHECK-NEXT: }
   struct Conformer4<A>: P17d {}
 }
@@ -674,7 +674,7 @@ protocol P37b {
 }
 do {
   // CHECK-LABEL: Abstract type witness system for conformance of Conformer1<C> to P37b: {
-  // CHECK-NEXT: C => Self.B.A,
+  // CHECK-NEXT: C => C,
   // CHECK-NEXT: }
   struct Conformer1<C>: P37b {
     struct Inner: P37a { typealias A = C }