Sema: Fix two problems in the solver's witness type matching logic

If we have an inner generic parameter of the requirement on the LHS,
it can't match anything other than an inner generic parameter on the RHS.

If we have the protocol Self type on the LHS, it can only match
something with the same nominal on the RHS. This should be an exact
match but ideally we would also recursively solve dependnet member
types, etc. Skip this all for now.

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -2035,9 +2035,26 @@ AssociatedTypeInference::getPotentialTypeWitnessesByMatchingTypes(ValueDecl *req
       return true;
     }
 
-    /// FIXME: Recheck the type of Self against the second type?
     bool mismatch(GenericTypeParamType *selfParamType,
                   TypeBase *secondType, Type sugaredFirstType) {
+      if (selfParamType->isEqual(Conformance->getProtocol()->getSelfInterfaceType())) {
+        // A DynamicSelfType always matches the Self parameter.
+        if (secondType->is<DynamicSelfType>())
+          return true;
+
+        // Otherwise, 'Self' should at least have a matching nominal type.
+        if (secondType->getAnyNominal() == Conformance->getType()->getAnyNominal())
+          return true;
+
+        return false;
+      }
+
+      // Any other generic parameter type is an inner generic parameter type
+      // of the requirement. If we're matching it with something that is not a
+      // generic parameter type, we cannot hope to succeed.
+      if (!secondType->is<GenericTypeParamType>())
+        return false;
+
       return true;
     }
   };

test/decl/protocol/req/associated_type_inference_dynamic_self.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {
+  associatedtype A
+
+  func f(_: A) -> Self
+}
+
+class C1: P {
+  func f(_: Int) -> Self {}
+}
+
+class Base {
+  func f(_: String) -> Self {}
+}
+
+class Derived: Base, P {}

test/decl/protocol/req/associated_type_inference_tautology_3.swift

@@ -0,0 +1,20 @@
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+
+// We can't infer anything from 'Self', but we must still validate the
+// binding.
+
+protocol P1 {
+  associatedtype A
+
+  func f(_: Self, _: A)
+}
+
+struct S1: P1 {
+  // Don't consider this f(); A := Float is not a candidate type witness.
+  func f(_: Int, _: Float) {}
+
+  func f(_: S1, _: String) {}
+}
+
+let x: String.Type = S1.A.self

test/decl/protocol/req/associated_type_inference_tautology_4.swift

@@ -0,0 +1,20 @@
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+
+// An inner generic parameter of the protocol requirement should not
+// match against a concrete type in the witness.
+
+protocol P2 {
+  associatedtype A
+  func f<T>(_: T, _: A)
+}
+
+struct S2<A>: P2 {
+  // These are not candiate witnesses for the requirement.
+  func f(_: Float, _: Array<A>) {}
+  func f(_: String, _: Array<A>) {}
+
+  func f<T>(_: T, _: A) {}
+}
+
+let x: Int.Type = S2<Int>.A.self