[Sema] Eliminate a subscript AnyObject lookup ambiguity

Previously we would always consider an AnyObject
subscript lookup to be ambiguous if there was a
candidate in both a class and protocol, even if
the selectors and types matched. This was due to
the protocol's generic signature preventing the
signatures from being coalesced.

Tweak the logic to strip generic signatures when
comparing for AnyObject lookup, matching what we
do for @objc methods.

Resolves SR-8611.
Resolves rdar://43645564 & rdar://62906344.

Author: hamishknight

lib/Sema/ConstraintSystem.cpp

@@ -216,9 +216,19 @@ getDynamicResultSignature(ValueDecl *decl) {
   }
 
   if (auto asd = dyn_cast<AbstractStorageDecl>(decl)) {
+    auto ty = asd->getInterfaceType();
+
+    // Strip off a generic signature if we have one. This matches the logic
+    // for methods, and ensures that we don't take a protocol's generic
+    // signature into account for a subscript requirement.
+    if (auto *genericFn = ty->getAs<GenericFunctionType>()) {
+      ty = FunctionType::get(genericFn->getParams(), genericFn->getResult(),
+                             genericFn->getExtInfo());
+    }
+
     // Handle properties and subscripts, anchored by the getter's selector.
     return std::make_tuple(asd->isStatic(), asd->getObjCGetterSelector(),
-                           asd->getInterfaceType()->getCanonicalType());
+                           ty->getCanonicalType());
   }
 
   llvm_unreachable("Not a valid @objc member");

test/Constraints/dynamic_lookup.swift

@@ -354,7 +354,11 @@ func dynamicInitCrash(ao: AnyObject.Type) {
   func unambiguousMethodParam(_ x: Int)
 
   subscript(ambiguousSubscript _: Int) -> String { get } // expected-note {{found this candidate}}
-  subscript(unambiguousSubscript _: String) -> Int { get } // expected-note {{found this candidate}}
+  subscript(unambiguousSubscript _: String) -> Int { get }
+
+  subscript(differentSelectors _: Int) -> Int { // expected-note {{found this candidate}}
+    @objc(differentSelector1:) get
+  }
 }
 
 class C1 {
@@ -368,7 +372,11 @@ class C1 {
   @objc func unambiguousMethodParam(_ x: Int) {}
 
   @objc subscript(ambiguousSubscript _: Int) -> Int { return 0 } // expected-note {{found this candidate}}
-  @objc subscript(unambiguousSubscript _: String) -> Int { return 0 } // expected-note {{found this candidate}}
+  @objc subscript(unambiguousSubscript _: String) -> Int { return 0 }
+
+  @objc subscript(differentSelectors _: Int) -> Int { // expected-note {{found this candidate}}
+    @objc(differentSelector2:) get { return 0 }
+  }
 }
 
 class C2 {
@@ -392,9 +400,15 @@ func testAnyObjectAmbiguity(_ x: AnyObject) {
   _ = x[singleCandidate: 0]
 
   _ = x[ambiguousSubscript: 0] // expected-error {{ambiguous use of 'subscript(ambiguousSubscript:)'}}
+  _ = x[ambiguousSubscript: 0] as Int
+  _ = x[ambiguousSubscript: 0] as String
+
+  // SR-8611: Make sure we can coalesce subscripts with the same types and
+  // selectors through AnyObject lookup.
+  _ = x[unambiguousSubscript: ""]
 
-  // FIX-ME(SR-8611): This is currently ambiguous but shouldn't be.
-  _ = x[unambiguousSubscript: ""] // expected-error {{ambiguous use of 'subscript(unambiguousSubscript:)'}}
+  // But not if they have different selectors.
+  _ = x[differentSelectors: 0] // expected-error {{ambiguous use of 'subscript(differentSelectors:)}}
 }
 
 // SR-11648