Sema: Move weird ConstructorDecl hack from getEffectiveOverloadType() to simplifyAppliedOverloadsImpl()

Author: slavapestov

lib/Sema/CSSimplify.cpp

@@ -13210,18 +13210,14 @@ bool ConstraintSystem::simplifyAppliedOverloadsImpl(
 
   /// The common result type amongst all function overloads.
   Type commonResultType;
-  auto updateCommonResultType = [&](Type choiceType) {
-    auto markFailure = [&] {
-      commonResultType = ErrorType::get(getASTContext());
-    };
 
-    auto choiceFnType = choiceType->getAs<FunctionType>();
-    if (!choiceFnType)
-      return markFailure();
+  auto markFailure = [&] {
+    commonResultType = ErrorType::get(getASTContext());
+  };
 
+  auto updateCommonResultType = [&](Type choiceResultType) {
     // For now, don't attempt to establish a common result type when there
     // are type parameters.
-    Type choiceResultType = choiceFnType->getResult();
     if (choiceResultType->hasTypeParameter())
       return markFailure();
 
@@ -13359,8 +13355,28 @@ bool ConstraintSystem::simplifyAppliedOverloadsImpl(
             choiceType = objectType;
         }
 
-        // If we have a function type, we can compute a common result type.
-        updateCommonResultType(choiceType);
+        if (auto *choiceFnType = choiceType->getAs<FunctionType>()) {
+          if (isa<ConstructorDecl>(choice.getDecl())) {
+            auto choiceResultType = choice.getBaseType()
+                                        ->getRValueType()
+                                        ->getMetatypeInstanceType();
+
+            if (choiceResultType->getOptionalObjectType()) {
+              hasUnhandledConstraints = true;
+              return true;
+            }
+
+            if (choiceFnType->getResult()->getOptionalObjectType())
+              choiceResultType = OptionalType::get(choiceResultType);
+
+            updateCommonResultType(choiceResultType);
+          } else {
+            updateCommonResultType(choiceFnType->getResult());
+          }
+        } else {
+          markFailure();
+        }
+
         return true;
       });
 

lib/Sema/TypeOfReference.cpp

@@ -2008,25 +2008,9 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
           return Type();
       }
 
-      // Hack for constructors.
       if (isa<ConstructorDecl>(decl) &&
-          !decl->getDeclContext()->getSelfProtocolDecl()) {
-        if (!overload.getBaseType())
-          return Type();
-
-        if (!overload.getBaseType()->getOptionalObjectType()) {
-          // `Int??(0)` if we look through all optional types for `Self`
-          // we'll end up with incorrect type `Int?` for result because
-          // the actual result type is `Int??`.
-          if (overload.getBaseType()
-                  ->getRValueType()
-                  ->getMetatypeInstanceType()
-                  ->getOptionalObjectType())
-            return Type();
-
-          type = type->replaceCovariantResultType(
-              getBaseObjectType(), /*uncurryLevel=*/2);
-        }
+          decl->getDeclContext()->getSelfClassDecl()) {
+        type = type->withCovariantResultType();
       }
 
       // Cope with 'Self' returns.