[Constraint solver] Declarations with IUOs don’t have effective overload types

A declaration with an implicitly-unwrapped optional essentially has two
effective overload types, because the result might be optional or it might
have been forced. Disable computation of the effective overload type in this
case.

Author: DougGregor

lib/Sema/ConstraintSystem.cpp

@@ -1488,6 +1488,11 @@ Type ConstraintSystem::getEffectiveOverloadType(const OverloadChoice &overload,
   if (isa<TypeDecl>(decl))
     return Type();
 
+  // Declarations returning unwrapped optionals don't have a single effective
+  // type.
+  if (decl->getAttrs().hasAttribute<ImplicitlyUnwrappedOptionalAttr>())
+    return Type();
+
   // Retrieve the interface type.
   auto type = decl->getInterfaceType();
   if (!type) {

test/Constraints/common_type.swift

@@ -7,6 +7,9 @@ struct X {
 
   subscript(_: Int) -> String { return "" }
   subscript(_: Double) -> String { return "" }
+
+  func iuo(_: Int) -> Int! { return 0 }
+  func iuo(_: Double) -> Int! { return 0 }
 }
 
 struct Y {
@@ -15,6 +18,9 @@ struct Y {
 
   subscript(_: Int) -> Substring { return "" }
   subscript(_: Double) -> Substring { return "" }
+
+  func iuo(_: Int) -> Double! { return 0 }
+  func iuo(_: Double) -> Double! { return 0 }
 }
 
 func f(_: Int) -> X { return X() }
@@ -29,11 +35,16 @@ func testCallCommonType() {
 }
 
 func testSubscriptCommonType() {
-  // FIXME: This will work once we have more filtering of subscripts.
   // CHECK: subscript_expr
   // CHECK: overload set choice binding $T{{[0-9]+}} := (Int) -> X
-  // CHECK-NOT: (common result type for $T{{[0-9]+}} is String)
+  // CHECK: (common result type for $T{{[0-9]+}} is String)
   // CHECK: (overload set choice binding $T{{[0-9]+}} := (Double) -> Y)
-  // CHECK-NOT: (common result type for $T{{[0-9]+}} is Substring)
+  // CHECK: (common result type for $T{{[0-9]+}} is Substring)
   _ = f(0)[0]
 }
+
+func testCommonTypeIUO() {
+  // CHECK: overload set choice binding $T{{[0-9]+}} := (Int) -> X
+  // CHECK-NOT: common result type
+    _ = f(0).iuo(0)
+}