[Constraint solver] Fix effective-overload-type for constructors, dynamic Self

Implement support for querying the effective overload type for constructors
and fix a semi-related bug for methods returning dynamic Self, which I
had not accounted for.

Author: DougGregor

lib/Sema/ConstraintSystem.cpp

@@ -1537,12 +1537,27 @@ Type ConstraintSystem::getEffectiveOverloadType(const OverloadChoice &overload,
       type = var->getValueInterfaceType();
       if (doesStorageProduceLValue(var, overload.getBaseType(), useDC))
         type = LValueType::get(type);
-    } else if (isa<FuncDecl>(decl) || isa<EnumElementDecl>(decl)) {
+    } else if (isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl)) {
       if (decl->isInstanceMember() &&
           (!overload.getBaseType() ||
            !overload.getBaseType()->getAnyNominal()))
         return Type();
 
+      // Cope with 'Self' returns.
+      if (!decl->getDeclContext()->getSelfProtocolDecl()) {
+        if ((isa<FuncDecl>(decl) && cast<FuncDecl>(decl)->hasDynamicSelf()) ||
+            (isa<ConstructorDecl>(decl) &&
+             !overload.getBaseType()->getOptionalObjectType())) {
+          if (!overload.getBaseType())
+            return Type();
+
+          Type selfType = overload.getBaseType()->getRValueType()
+              ->getMetatypeInstanceType()
+              ->lookThroughAllOptionalTypes();
+          type = type->replaceCovariantResultType(selfType, 2);
+        }
+      }
+
       type = type->castTo<FunctionType>()->getResult();
     } else {
       return type;

test/Constraints/common_type.swift

@@ -48,3 +48,35 @@ func testCommonTypeIUO() {
   // CHECK-NOT: common result type
     _ = f(0).iuo(0)
 }
+
+struct Z {
+  init(a: Int) { }
+  init(a: Double) { }
+
+  init(b: Int) { }
+  init?(b: Double) { }
+}
+
+func testCommonTypeInit() {
+  // CHECK: common result type for {{.*}} is Z
+  _ = Z(a: 0)
+
+  // CHECK-NOT: common result type
+  _ = Z(b: 0)
+}
+
+class DynamicSelf {
+  func foo(_ a: Int) -> Self { return self }
+  func foo(_ a: Double) -> Self { return self }
+}
+
+class InheritsDynamicSelf: DynamicSelf {
+}
+
+func testCommonTypeDynamicSelf(ds: DynamicSelf, ids: InheritsDynamicSelf) {
+  // CHECK: common result type for {{.*}} is DynamicSelf
+  _ = ds.foo(0)
+  // CHECK: common result type for {{.*}} is InheritsDynamicSelf
+  _ = ids.foo(0)
+}
+