[Conformance checking] Allow generic parameter when inferring type witnesses.

As part of type witness inference, allow us to infer a generic parameter
as the type witness for an associated type, when the associated type has
the same name as the generic parameter.

We likely want the more-general rule that generic parameters are always
visible as members of their enclosing type, but I'll tackle that separately.
This works around an order dependency that affected the source
compatibility suite.

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -1022,8 +1022,6 @@ matchWitness(TypeChecker &tc,
                                    std::get<1>(types))) {
         return *result;
       }
-
-      // FIXME: Consider default arguments here?
     }
 
     // If the witness is 'throws', the requirement must be.
@@ -4276,7 +4274,6 @@ void ConformanceChecker::resolveTypeWitnesses() {
   SWIFT_DEFER { Conformance->setState(initialState); };
 
   for (auto assocType : Proto->getAssociatedTypeMembers()) {
-
     // If we already have a type witness, do nothing.
     if (Conformance->hasTypeWitness(assocType))
       continue;
@@ -4599,6 +4596,24 @@ void ConformanceChecker::resolveTypeWitnesses() {
           continue;
         }
 
+        // If there is a generic parameter of the named type, use that.
+        if (auto gpList = DC->getGenericParamsOfContext()) {
+          GenericTypeParamDecl *foundGP = nullptr;
+          for (auto gp : *gpList) {
+            if (gp->getName() == assocType->getName()) {
+              foundGP = gp;
+              break;
+            }
+          }
+
+          if (foundGP) {
+            auto gpType = DC->mapTypeIntoContext(
+                            foundGP->getDeclaredInterfaceType());
+            typeWitnesses.insert(assocType, {gpType, reqDepth});
+            continue;
+          }
+        }
+
         // The solution is incomplete.
         recordMissing();
         return;

test/decl/protocol/req/associated_type_inference.swift

@@ -195,9 +195,9 @@ public protocol Thenable {
     func then(_ success: (_: T) -> T) -> Self
 }
 
-public class CorePromise<T> : Thenable { // expected-error{{type 'CorePromise<T>' does not conform to protocol 'Thenable'}}
-    public func then(_ success: @escaping (_ t: T, _: CorePromise<T>) -> T) -> Self {
-        return self.then() { (t: T) -> T in
+public class CorePromise<U> : Thenable { // expected-error{{type 'CorePromise<U>' does not conform to protocol 'Thenable'}}
+    public func then(_ success: @escaping (_ t: U, _: CorePromise<U>) -> U) -> Self {
+        return self.then() { (t: U) -> U in // expected-error{{contextual closure type '(U, CorePromise<U>) -> U' expects 2 arguments, but 1 was used in closure body}}
             return success(t: t, self)
         }
     }
@@ -390,3 +390,13 @@ protocol P13 {
 struct S13 : P13 { // expected-error{{type 'S13' does not conform to protocol 'P13'}}
   func foo(arg: inout Int) {}
 }
+
+// "Infer" associated type from generic parameter.
+protocol P14 {
+  associatedtype Value
+}
+
+struct P14a<Value>: P14 { }
+
+struct P14b<Value> { }
+extension P14b: P14 { }