Sema: Remove 'inferred result type requires explicit coercion' diagnostic

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -7344,16 +7344,6 @@ WARNING(backdeployed_opaque_result_not_supported,none,
 // MARK: Implicit opening of existential types
 //------------------------------------------------------------------------------
 
-ERROR(result_requires_explicit_coercion,none,
-      "inferred result type %0 requires explicit coercion due to "
-      "loss of generic requirements",
-      (Type))
-
-NOTE(candidate_result_requires_explicit_coercion,none,
-     "inferred result type %0 requires explicit coercion due to "
-     "loss of generic requirements",
-     (Type))
-
 ERROR(concurrency_task_to_thread_model_custom_executor,none,
       "custom executors are not permitted within %0", (StringRef))
 ERROR(concurrency_task_to_thread_model_async_main,none,

include/swift/Sema/CSFix.h

@@ -3410,40 +3410,6 @@ class IgnoreDefaultExprTypeMismatch : public AllowArgumentMismatch {
   }
 };
 
-class AddExplicitExistentialCoercion final : public ConstraintFix {
-  Type ErasedResultType;
-
-  AddExplicitExistentialCoercion(ConstraintSystem &cs, Type erasedResultTy,
-                                 ConstraintLocator *locator,
-                                 FixBehavior fixBehavior)
-      : ConstraintFix(cs, FixKind::AddExplicitExistentialCoercion, locator,
-                      fixBehavior),
-        ErasedResultType(erasedResultTy) {}
-
-public:
-  std::string getName() const override {
-    return "add explicit existential type coercion";
-  }
-
-  bool diagnose(const Solution &solution, bool asNote = false) const override;
-
-  static bool
-  isRequired(ConstraintSystem &cs, Type resultTy,
-             ArrayRef<std::pair<TypeVariableType *, OpenedArchetypeType *>>
-                 openedExistentials,
-             ConstraintLocatorBuilder locator);
-
-  static bool
-  isRequired(ConstraintSystem &cs, Type resultTy,
-             llvm::function_ref<llvm::Optional<Type>(TypeVariableType *)>
-                 findExistentialType,
-             ConstraintLocatorBuilder locator);
-
-  static AddExplicitExistentialCoercion *create(ConstraintSystem &cs,
-                                                Type resultTy,
-                                                ConstraintLocator *locator);
-};
-
 class RenameConflictingPatternVariables final
     : public ConstraintFix,
       private llvm::TrailingObjects<RenameConflictingPatternVariables,

lib/Sema/CSDiagnostics.cpp

@@ -9124,61 +9124,6 @@ bool DefaultExprTypeMismatch::diagnoseAsError() {
   return true;
 }
 
-bool MissingExplicitExistentialCoercion::diagnoseAsError() {
-  auto diagnostic = emitDiagnostic(diag::result_requires_explicit_coercion,
-                                   ErasedResultType);
-  fixIt(diagnostic);
-  return true;
-}
-
-bool MissingExplicitExistentialCoercion::diagnoseAsNote() {
-  auto diagnostic = emitDiagnostic(
-      diag::candidate_result_requires_explicit_coercion, ErasedResultType);
-  fixIt(diagnostic);
-  return true;
-}
-
-bool MissingExplicitExistentialCoercion::fixItRequiresParens() const {
-  auto anchor = getAsExpr(getRawAnchor());
-
-  // If it's a member reference an an existential metatype, let's
-  // use the parent "call" expression.
-  if (auto *UDE = dyn_cast_or_null<UnresolvedDotExpr>(anchor))
-    anchor = findParentExpr(UDE);
-
-  if (!anchor)
-    return false;
-
-  const auto &solution = getSolution();
-  return llvm::any_of(
-      solution.OpenedExistentialTypes,
-      [&anchor](const auto &openedExistential) {
-        if (auto openedLoc = simplifyLocatorToAnchor(openedExistential.first)) {
-          return anchor == getAsExpr(openedLoc);
-        }
-        return false;
-      });
-}
-
-void MissingExplicitExistentialCoercion::fixIt(
-    InFlightDiagnostic &diagnostic) const {
-
-  if (ErasedResultType->hasTypeParameter())
-    return;
-
-  bool requiresParens = fixItRequiresParens();
-
-  auto callRange = getSourceRange();
-
-  if (requiresParens)
-    diagnostic.fixItInsert(callRange.Start, "(");
-
-  auto printOpts = PrintOptions::forDiagnosticArguments();
-  diagnostic.fixItInsertAfter(callRange.End,
-                              "as " + ErasedResultType->getString(printOpts) +
-                                  (requiresParens ? ")" : ""));
-}
-
 bool ConflictingPatternVariables::diagnoseAsError() {
   for (auto *var : Vars) {
     emitDiagnosticAt(var->getStartLoc(),

lib/Sema/CSFix.cpp

@@ -2485,259 +2485,6 @@ IgnoreDefaultExprTypeMismatch::create(ConstraintSystem &cs, Type argType,
       IgnoreDefaultExprTypeMismatch(cs, argType, paramType, locator);
 }
 
-bool AddExplicitExistentialCoercion::diagnose(const Solution &solution,
-                                              bool asNote) const {
-  MissingExplicitExistentialCoercion failure(solution, ErasedResultType,
-                                             getLocator(), fixBehavior);
-  return failure.diagnose(asNote);
-}
-
-bool AddExplicitExistentialCoercion::isRequired(
-    ConstraintSystem &cs, Type resultTy,
-    llvm::function_ref<llvm::Optional<Type>(TypeVariableType *)>
-        findExistentialType,
-    ConstraintLocatorBuilder locator) {
-  using ExistentialTypeFinder =
-      llvm::function_ref<llvm::Optional<Type>(TypeVariableType *)>;
-
-  struct CoercionChecker : public TypeWalker {
-    bool RequiresCoercion = false;
-
-    ConstraintSystem &cs;
-    ExistentialTypeFinder GetExistentialType;
-
-    CoercionChecker(ConstraintSystem &cs,
-                    ExistentialTypeFinder getExistentialType)
-        : cs(cs), GetExistentialType(getExistentialType) {}
-
-    Action walkToTypePre(Type componentTy) override {
-      // In cases where result references a member type, we need to check
-      // whether such type would is resolved to concrete or not.
-      if (auto *member = componentTy->getAs<DependentMemberType>()) {
-        auto memberBaseTy = getBaseTypeOfDependentMemberChain(member);
-
-        auto typeVar = memberBaseTy->getAs<TypeVariableType>();
-        if (!typeVar)
-          return Action::SkipChildren;
-
-        // If the base is an opened existential type, let's see whether
-        // erase would produce an existential in this case and if so,
-        // we need to check whether any requirements are going to be lost
-        // in process.
-
-        auto existentialType = GetExistentialType(typeVar);
-        if (!existentialType)
-          return Action::SkipChildren;
-
-        auto erasedMemberTy = typeEraseOpenedExistentialReference(
-            Type(member), *existentialType, typeVar, TypePosition::Covariant);
-
-        // If result is an existential type and the base has `where` clauses
-        // associated with its associated types, the call needs a coercion.
-        if (erasedMemberTy->isExistentialType() &&
-            hasConstrainedAssociatedTypes(member, *existentialType)) {
-          RequiresCoercion = true;
-          return Action::Stop;
-        }
-
-        if (erasedMemberTy->isExistentialType() &&
-             erasedMemberTy->hasTypeParameter()) {
-          RequiresCoercion = true;
-          return Action::Stop;
-        }
-
-        return Action::SkipChildren;
-      }
-
-      // The case where there is a direct access to opened existential type
-      // e.g. `$T` or `[$T]`.
-      if (auto *typeVar = componentTy->getAs<TypeVariableType>()) {
-        if (auto existentialType = GetExistentialType(typeVar)) {
-          RequiresCoercion |= hasAnyConstrainedAssociatedTypes(
-              (*existentialType)->getExistentialLayout());
-          return RequiresCoercion ? Action::Stop : Action::SkipChildren;
-        }
-      }
-
-      return Action::Continue;
-    }
-
-  private:
-    /// Check whether the given member type has any of its associated
-    /// types constrained by requirements associated with the given
-    /// existential type.
-    static bool hasConstrainedAssociatedTypes(DependentMemberType *member,
-                                              Type existentialTy) {
-      auto layout = existentialTy->getExistentialLayout();
-      for (auto *protocol : layout.getProtocols()) {
-        auto requirementSig = protocol->getRequirementSignature();
-        if (hasConstrainedAssociatedTypes(member,
-                                          requirementSig.getRequirements()))
-          return true;
-      }
-      return false;
-    }
-
-    /// Check whether the given member type has any of its associated
-    /// types constrained by the given requirement set.
-    static bool
-    hasConstrainedAssociatedTypes(DependentMemberType *member,
-                                  ArrayRef<Requirement> requirements) {
-      for (const auto &req : requirements) {
-        switch (req.getKind()) {
-        case RequirementKind::SameShape:
-          llvm_unreachable("Same-shape requirement not supported here");
-
-        case RequirementKind::Superclass:
-        case RequirementKind::Conformance:
-        case RequirementKind::Layout: {
-          if (isAnchoredOn(req.getFirstType(), member->getAssocType()))
-            return true;
-          break;
-        }
-
-        case RequirementKind::SameType: {
-          auto lhsTy = req.getFirstType();
-          auto rhsTy = req.getSecondType();
-
-          if (isAnchoredOn(lhsTy, member->getAssocType()) ||
-              isAnchoredOn(rhsTy, member->getAssocType()))
-            return true;
-
-          break;
-        }
-        }
-      }
-
-      return false;
-    }
-
-    /// Check whether any of the protocols mentioned in the given
-    /// existential layout have constraints associated with their
-    /// associated types via a `where` clause, for example:
-    /// `associatedtype A: P where A.B == Int`
-    static bool hasAnyConstrainedAssociatedTypes(ExistentialLayout layout) {
-      for (auto *protocol : layout.getProtocols()) {
-        auto requirementSig = protocol->getRequirementSignature();
-        for (const auto &req : requirementSig.getRequirements()) {
-          switch (req.getKind()) {
-          case RequirementKind::SameShape:
-            llvm_unreachable("Same-shape requirement not supported here");
-
-          case RequirementKind::Conformance:
-          case RequirementKind::Layout:
-          case RequirementKind::Superclass: {
-            if (getMemberChainDepth(req.getFirstType()) > 1)
-              return true;
-            break;
-          }
-
-          case RequirementKind::SameType:
-            auto lhsTy = req.getFirstType();
-            auto rhsTy = req.getSecondType();
-
-            if (getMemberChainDepth(lhsTy) > 1 ||
-                getMemberChainDepth(rhsTy) > 1)
-              return true;
-
-            break;
-          }
-        }
-      }
-      return false;
-    }
-
-    /// Check whether the given type is a dependent member type and
-    /// is anchored on the given associated type e.g. type is `A.B.C`
-    /// and associated type is `A.B`.
-    static bool isAnchoredOn(Type type, AssociatedTypeDecl *assocTy,
-                             unsigned depth = 0) {
-      if (auto *member = type->getAs<DependentMemberType>()) {
-        if (member->getAssocType() == assocTy)
-          return depth > 0;
-
-        return isAnchoredOn(member->getBase(), assocTy, depth + 1);
-      }
-
-      return false;
-    }
-
-    static unsigned getMemberChainDepth(Type type, unsigned currDepth = 0) {
-      if (auto *memberTy = type->getAs<DependentMemberType>())
-        return getMemberChainDepth(memberTy->getBase(), currDepth + 1);
-      return currDepth;
-    }
-
-    static Type getBaseTypeOfDependentMemberChain(DependentMemberType *member) {
-      if (!member->getBase())
-        return member;
-
-      auto base = member->getBase();
-
-      if (auto *DMT = base->getAs<DependentMemberType>())
-        return getBaseTypeOfDependentMemberChain(DMT);
-
-      return base;
-    }
-  };
-
-  // First, let's check whether coercion is already there.
-  if (auto *anchor = getAsExpr(locator.getAnchor())) {
-    // If this is erasure related to `Self`, let's look through
-    // the call, if any.
-    if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor)) {
-      // If this is an implicit `makeIterator` call, let's skip the check.
-      if (UDE->isImplicit() &&
-          cs.getContextualTypePurpose(UDE->getBase()) == CTP_ForEachSequence)
-        return false;
-
-      auto parentExpr = cs.getParentExpr(anchor);
-      if (parentExpr && isa<CallExpr>(parentExpr))
-        anchor = parentExpr;
-    }
-
-    auto *parent = cs.getParentExpr(anchor);
-    // Support both `as` and `as!` coercions.
-    if (parent &&
-        (isa<CoerceExpr>(parent) || isa<ForcedCheckedCastExpr>(parent)))
-      return false;
-  }
-
-  CoercionChecker check(cs, findExistentialType);
-  resultTy.walk(check);
-
-  return check.RequiresCoercion;
-}
-
-bool AddExplicitExistentialCoercion::isRequired(
-    ConstraintSystem &cs, Type resultTy,
-    ArrayRef<std::pair<TypeVariableType *, OpenedArchetypeType *>>
-        openedExistentials,
-    ConstraintLocatorBuilder locator) {
-  return isRequired(
-      cs, resultTy,
-      [&](TypeVariableType *typeVar) -> llvm::Optional<Type> {
-        auto opened =
-            llvm::find_if(openedExistentials, [&typeVar](const auto &entry) {
-              return typeVar == entry.first;
-            });
-
-        if (opened == openedExistentials.end())
-          return llvm::None;
-
-        return opened->second->getExistentialType();
-      },
-      locator);
-}
-
-AddExplicitExistentialCoercion *
-AddExplicitExistentialCoercion::create(ConstraintSystem &cs, Type resultTy,
-                                       ConstraintLocator *locator) {
-  FixBehavior fixBehavior = FixBehavior::Error;
-  return new (cs.getAllocator())
-      AddExplicitExistentialCoercion(cs, resultTy, locator, fixBehavior);
-}
-
 bool RenameConflictingPatternVariables::diagnose(const Solution &solution,
                                                  bool asNote) const {
   ConflictingPatternVariables failure(solution, ExpectedType,

lib/Sema/CSSimplify.cpp

@@ -13015,19 +13015,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyApplicableFnConstraint(
             result2, opened.second->getExistentialType(), opened.first,
             TypePosition::Covariant);
       }
-
-      // If result type has any erased existential types it requires explicit
-      // `as` coercion.
-      if (AddExplicitExistentialCoercion::isRequired(
-              *this, func2->getResult(), openedExistentials, locator)) {
-
-        if (!shouldAttemptFixes())
-          return SolutionKind::Error;
-
-        if (recordFix(AddExplicitExistentialCoercion::create(
-                *this, result2, getConstraintLocator(locator))))
-          return SolutionKind::Error;
-      }
     }
 
     // The result types are equivalent.