Sema: Look for generic parameters first when inferring an associated type

Previously we did this as a last resort if inference fails. The new
behavior is technically source-breaking, but I suspect nobody
relied on the old behavior.

This can help avoid cycles by eliminating some unnecessary validation work.

Fixes <https://bugs.swift.org/browse/SR-11407>, <rdar://problem/54979757>.

Author: slavapestov

lib/Sema/TypeCheckProtocol.cpp

@@ -3510,20 +3510,37 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
                        AssociatedTypeDecl *assocType) {
   // Conformances constructed by the ClangImporter should have explicit type
   // witnesses already.
-  if (isa<ClangModuleUnit>(Conformance->getDeclContext()->getModuleScopeContext())) {
+  if (isa<ClangModuleUnit>(DC->getModuleScopeContext())) {
     llvm::errs() << "Cannot look up associated type for imported conformance:\n";
     Conformance->getType().dump(llvm::errs());
     assocType->dump(llvm::errs());
     abort();
   }
 
+  // If we fail to find a witness via lookup, check for a generic parameter.
+  auto checkForGenericParameter = [&]() {
+    // If there is a generic parameter of the named type, use that.
+    if (auto genericSig = DC->getGenericSignatureOfContext()) {
+      for (auto gp : genericSig->getInnermostGenericParams()) {
+        if (gp->getName() == assocType->getName()) {
+          if (!checkTypeWitness(DC, Proto, assocType, gp)) {
+            recordTypeWitness(assocType, gp, nullptr);
+            return ResolveWitnessResult::Success;
+          }
+        }
+      }
+    }
+
+    return ResolveWitnessResult::Missing;
+  };
+
   // Look for a member type with the same name as the associated type.
   auto candidates = TypeChecker::lookupMemberType(
       DC, Adoptee, assocType->getName(), NameLookupFlags::ProtocolMembers);
 
   // If there aren't any candidates, we're done.
   if (!candidates) {
-    return ResolveWitnessResult::Missing;
+    return checkForGenericParameter();
   }
 
   // Determine which of the candidates is viable.
@@ -3557,7 +3574,7 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
                      return x.first->getDeclContext()
                         ->getSelfProtocolDecl() == nullptr;
                    }) == nonViable.end())
-    return ResolveWitnessResult::Missing;
+    return checkForGenericParameter();
 
   // If there is a single viable candidate, form a substitution for it.
   if (viable.size() == 1) {

lib/Sema/TypeCheckProtocolInference.cpp

@@ -918,14 +918,6 @@ AssociatedTypeInference::computeAbstractTypeWitness(
       return derivedType;
   }
 
-  // If there is a generic parameter of the named type, use that.
-  if (auto genericSig = dc->getGenericSignatureOfContext()) {
-    for (auto gp : genericSig->getInnermostGenericParams()) {
-      if (gp->getName() == assocType->getName())
-        return dc->mapTypeIntoContext(gp);
-    }
-  }
-
   return Type();
 }
 

stdlib/public/core/NativeSet.swift

@@ -282,6 +282,9 @@ extension _NativeSet {
 }
 
 extension _NativeSet: _SetBuffer {
+  @usableFromInline
+  internal typealias Element = Element
+
   @usableFromInline
   internal typealias Index = Set<Element>.Index
 

test/decl/protocol/req/associated_type_inference_valid.swift

@@ -22,3 +22,35 @@ struct R : P {
   let x: Y? = nil
   func foo(_: Y) {}
 }
+
+// SR-8813
+protocol BaseProtocol {
+  associatedtype Value
+  typealias Closure = () -> Value
+
+  init(closure: Closure)
+}
+
+struct Base<Value>: BaseProtocol {
+  private var closure: Closure?
+
+  init(closure: Closure) {
+    withoutActuallyEscaping(closure) { new in
+      self.closure = new
+    }
+  }
+}
+
+// SR-11407
+protocol _Drivable: AnyObject {
+  typealias Driver = Self
+}
+protocol Configurator {
+  associatedtype Drivable: _Drivable
+  typealias Driver = Drivable.Driver
+  func configure(driver: Driver)
+}
+struct AnyConfigurator<Drivable: _Drivable>: Configurator {
+  private let thing: Driver?
+  func configure(driver: AnyConfigurator.Driver) {}
+}