Take the IUO-ness of a parameter declaration into account in ranking.

Normally we wouldn't need this because we do not allow overloading by
parameter optionality. In this case, though, we import two Objective-C
methods that end up getting renamed to the same name in Swift, one of
which has a nullability annotation and the other of which doesn't.

Before IUOs were removed from the type system, we would have failed a
subtype test when ranking overloads, but now that subtype test passes
because we're comparing two optionals of the same type. So the change
here is to compare the optionality of the parameters and reject cases
where we are testing whether a plain optional is a subtype of
something declared to be an IUO.

Fixes rdar://problem/38719575.

Author: rudkx

lib/Sema/CSRanking.cpp

@@ -384,6 +384,21 @@ static Type getAdjustedParamType(const AnyFunctionType::Param &param) {
   return param.getType();
 }
 
+// Is a particular parameter of a function or subscript declaration
+// declared to be an IUO?
+static bool paramIsIUO(Decl *decl, int paramNum) {
+  if (auto *fn = dyn_cast<AbstractFunctionDecl>(decl)) {
+    auto *paramList =
+        fn->getParameterList(fn->getDeclContext()->isTypeContext());
+    auto *param = paramList->get(paramNum);
+    return param->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
+  }
+
+  auto *subscript = cast<SubscriptDecl>(decl);
+  auto *index = subscript->getIndices()->get(paramNum);
+  return index->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>();
+}
+
 /// \brief Determine whether the first declaration is as "specialized" as
 /// the second declaration.
 ///
@@ -676,6 +691,17 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
             continue;
           }
 
+          // Emulate behavior from when IUO was a type, where IUOs
+          // were considered subtypes of plain optionals, but not
+          // vice-versa.  This wouldn't normally happen, but there are
+          // cases where we can rename imported APIs so that we have a
+          // name collision, and where the parameter type(s) are the
+          // same except for details of the kind of optional declared.
+          auto param1IsIUO = paramIsIUO(decl1, param1);
+          auto param2IsIUO = paramIsIUO(decl2, param2);
+          if (param2IsIUO && !param1IsIUO)
+            return false;
+
           if (!maybeAddSubtypeConstraint(params1[param1], params2[param2]))
             return false;
 

test/Constraints/Inputs/disambiguate_iuo_param.h

@@ -0,0 +1,9 @@
+@import Foundation;
+
+@interface NSObject (NSMyTest)
+- (BOOL)isEqualTo:(nullable id)object;
+@end
+
+@interface Obj : NSObject
+- (BOOL)isEqualToObject:(id)value;
+@end

test/Constraints/disambiguate_iuo_param.swift

@@ -0,0 +1,11 @@
+// RUN: %empty-directory(%t)
+// RUN: %build-clang-importer-objc-overlays
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk-nosource -I %t) -import-objc-header %S/Inputs/disambiguate_iuo_param.h %s -emit-ir | %FileCheck %s
+// -module-name objc_ir -I %S/Inputs/custom-modules -emit-ir -g -o - -primary-file %s | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+// CHECK: define {{.*}} @main
+// CHECK: load {{.*}}, {{.*}}@"\01L_selector(isEqualToObject:)"
+let c = Obj()
+_ = c.isEqual(to: c)