[CSFix] Create a fix for checked cast that always fail and existential to CFType

Author: LucianoPAlmeida

include/swift/Sema/CSFix.h

@@ -316,11 +316,19 @@ enum class FixKind : uint8_t {
   /// succeed.
   AllowNoopCheckedCast,
 
+  /// Warn about special runtime case where statically known
+  /// checked cast from existentials to CFType always succeed.
+  AllowNoopExistentialToCFTypeCheckedCast,
+
   /// Allow a runtime checked cast where at compile time the from is
   /// convertible, but runtime does not support such convertions. e.g.
   /// function type casts.
   AllowUnsupportedRuntimeCheckedCast,
 
+  /// Allow a runtime checked cast where it is known at compile time
+  /// always fails.
+  AllowCheckedCastToUnrelated,
+
   /// Allow reference to a static member on a protocol metatype
   /// even though result type of the reference doesn't conform
   /// to an expected protocol.
@@ -2789,6 +2797,31 @@ class AllowNoopCheckedCast final : public CheckedCastContextualMismatchWarning {
   }
 };
 
+class AllowNoopExistentialToCFTypeCheckedCast final
+    : public CheckedCastContextualMismatchWarning {
+  AllowNoopExistentialToCFTypeCheckedCast(ConstraintSystem &cs, Type fromType,
+                                          Type toType, CheckedCastKind kind,
+                                          ConstraintLocator *locator)
+      : CheckedCastContextualMismatchWarning(
+            cs, FixKind::AllowNoopExistentialToCFTypeCheckedCast, fromType,
+            toType, kind, locator) {}
+
+public:
+  std::string getName() const override {
+    return "checked cast from existential to CFType always succeeds";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowNoopExistentialToCFTypeCheckedCast *
+  attempt(ConstraintSystem &cs, Type fromType, Type toType,
+          CheckedCastKind kind, ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowNoopExistentialToCFTypeCheckedCast;
+  }
+};
+
 class AllowUnsupportedRuntimeCheckedCast final
     : public CheckedCastContextualMismatchWarning {
   AllowUnsupportedRuntimeCheckedCast(ConstraintSystem &cs, Type fromType,
@@ -2816,6 +2849,29 @@ class AllowUnsupportedRuntimeCheckedCast final
   }
 };
 
+class AllowCheckedCastToUnrelated final
+    : public CheckedCastContextualMismatchWarning {
+  AllowCheckedCastToUnrelated(ConstraintSystem &cs, Type fromType, Type toType,
+                              CheckedCastKind kind, ConstraintLocator *locator)
+      : CheckedCastContextualMismatchWarning(
+            cs, FixKind::AllowCheckedCastToUnrelated, fromType, toType, kind,
+            locator) {}
+
+public:
+  std::string getName() const override { return "checked cast always fails"; }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static AllowCheckedCastToUnrelated *attempt(ConstraintSystem &cs,
+                                              Type fromType, Type toType,
+                                              CheckedCastKind kind,
+                                              ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::AllowCheckedCastToUnrelated;
+  }
+};
+
 class AllowInvalidStaticMemberRefOnProtocolMetatype final
     : public ConstraintFix {
   AllowInvalidStaticMemberRefOnProtocolMetatype(ConstraintSystem &cs,

lib/Sema/CSDiagnostics.cpp

@@ -3035,10 +3035,8 @@ bool ContextualFailure::tryTypeCoercionFixIt(
     }
   }
 
-  CheckedCastKind Kind =
-      TypeChecker::typeCheckCheckedCast(fromType, toType,
-                                        CheckedCastContextKind::None, getDC(),
-                                        SourceLoc(), nullptr, SourceRange());
+  CheckedCastKind Kind = TypeChecker::typeCheckCheckedCast(
+      fromType, toType, CheckedCastContextKind::None, getDC());
 
   if (Kind != CheckedCastKind::Unresolved) {
     bool canUseAs = Kind == CheckedCastKind::Coercion ||
@@ -7982,7 +7980,7 @@ bool CoercibleOptionalCheckedCastFailure::diagnoseConditionalCastExpr() const {
   return true;
 }
 
-bool NoopCheckedCast::diagnoseIfExpr() const {
+bool NoopCheckedCast::diagnoseIsExpr() const {
   auto *expr = getAsExpr<IsExpr>(CastExpr);
   if (!expr)
     return false;
@@ -8028,7 +8026,7 @@ bool NoopCheckedCast::diagnoseForcedCastExpr() const {
 }
 
 bool NoopCheckedCast::diagnoseAsError() {
-  if (diagnoseIfExpr())
+  if (diagnoseIsExpr())
     return true;
 
   if (diagnoseForcedCastExpr())
@@ -8040,6 +8038,11 @@ bool NoopCheckedCast::diagnoseAsError() {
   llvm_unreachable("Shouldn't reach here");
 }
 
+bool NoopExistentialToCFTypeCheckedCast::diagnoseAsError() {
+  emitDiagnostic(diag::isa_is_foreign_check, getToType());
+  return true;
+}
+
 bool CoercibleOptionalCheckedCastFailure::diagnoseAsError() {
   if (diagnoseIfExpr())
     return true;
@@ -8062,6 +8065,42 @@ bool UnsupportedRuntimeCheckedCastFailure::diagnoseAsError() {
   return true;
 }
 
+bool CheckedCastToUnrelatedFailure::diagnoseAsError() {
+  const auto toType = getToType();
+  auto *sub = CastExpr->getSubExpr()->getSemanticsProvidingExpr();
+  // FIXME: This literal diagnostics needs to be revisited by a proposal
+  // to unify casting semantics for literals.
+  // https://bugs.swift.org/browse/SR-12093
+  auto &ctx = getASTContext();
+  auto *dc = getDC();
+  if (isa<LiteralExpr>(sub)) {
+    auto *protocol = TypeChecker::getLiteralProtocol(ctx, sub);
+    // Special handle for literals conditional checked cast when they can
+    // be statically coerced to the cast type.
+    if (protocol && TypeChecker::conformsToProtocol(toType, protocol,
+                                                    dc->getParentModule())) {
+      emitDiagnostic(diag::literal_conditional_downcast_to_coercion, toType);
+      return true;
+    }
+  }
+
+  emitDiagnostic(diag::downcast_to_unrelated, getFromType(), toType)
+      .highlight(getFromRange())
+      .highlight(getToRange());
+  // If we're referring to a function with a return value (not Void) then
+  // emit a fix-it suggesting to add `()` to call the function
+  if (auto DRE = dyn_cast<DeclRefExpr>(sub)) {
+    if (auto FD = dyn_cast<FuncDecl>(DRE->getDecl())) {
+      if (!FD->getResultInterfaceType()->isVoid()) {
+        emitDiagnostic(diag::downcast_to_unrelated_fixit,
+                       FD->getBaseIdentifier())
+            .fixItInsertAfter(sub->getEndLoc(), "()");
+      }
+    }
+  }
+  return true;
+}
+
 bool InvalidWeakAttributeUse::diagnoseAsError() {
   auto *pattern =
       dyn_cast_or_null<NamedPattern>(getAnchor().dyn_cast<Pattern *>());

lib/Sema/CSDiagnostics.h

@@ -2574,13 +2574,25 @@ class NoopCheckedCast final : public CheckedCastBaseFailure {
   bool diagnoseAsError() override;
 
 private:
-  bool diagnoseIfExpr() const;
+  bool diagnoseIsExpr() const;
 
   bool diagnoseForcedCastExpr() const;
 
   bool diagnoseConditionalCastExpr() const;
 };
 
+/// Warn situations where the compiler can statically know a runtime
+/// checked cast always succeed.
+class NoopExistentialToCFTypeCheckedCast final : public CheckedCastBaseFailure {
+public:
+  NoopExistentialToCFTypeCheckedCast(const Solution &solution, Type fromType,
+                                     Type toType, CheckedCastKind kind,
+                                     ConstraintLocator *locator)
+      : CheckedCastBaseFailure(solution, fromType, toType, kind, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Warn situations where the compiler can statically know a runtime
 /// check is not supported.
 class UnsupportedRuntimeCheckedCastFailure final
@@ -2594,6 +2606,18 @@ class UnsupportedRuntimeCheckedCastFailure final
   bool diagnoseAsError() override;
 };
 
+/// Emit a warning when compiler can detect that checked cast would fail at
+/// runtime based on statically known types.
+class CheckedCastToUnrelatedFailure final : public CheckedCastBaseFailure {
+public:
+  CheckedCastToUnrelatedFailure(const Solution &solution, Type fromType,
+                                Type toType, CheckedCastKind kind,
+                                ConstraintLocator *locator)
+      : CheckedCastBaseFailure(solution, fromType, toType, kind, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnose situations when static member reference has invalid result
 /// type which disqualifies it from being used on a protocol metatype base.
 ///

lib/Sema/CSFix.cpp

@@ -152,8 +152,7 @@ CoerceToCheckedCast *CoerceToCheckedCast::attempt(ConstraintSystem &cs,
     return nullptr;
 
   const auto castKind = TypeChecker::typeCheckCheckedCast(
-      fromType, toType, CheckedCastContextKind::Coercion, cs.DC,
-      SourceLoc(), coerceExpr->getSubExpr(), SourceRange());
+      fromType, toType, CheckedCastContextKind::Coercion, cs.DC);
 
   // Invalid cast.
   if (castKind == CheckedCastKind::Unresolved)
@@ -1999,6 +1998,33 @@ bool AllowNoopCheckedCast::diagnose(const Solution &solution,
   return warning.diagnose(asNote);
 }
 
+AllowNoopExistentialToCFTypeCheckedCast *
+AllowNoopExistentialToCFTypeCheckedCast::attempt(ConstraintSystem &cs,
+                                                 Type fromType, Type toType,
+                                                 CheckedCastKind kind,
+                                                 ConstraintLocator *locator) {
+  if (!isExpr<IsExpr>(locator->getAnchor()))
+    return nullptr;
+
+  if (!fromType->isExistentialType())
+    return nullptr;
+
+  const auto *cls = toType->getAs<ClassType>();
+  if (!(cls && cls->getDecl()->getForeignClassKind() ==
+                   ClassDecl::ForeignKind::CFType))
+    return nullptr;
+
+  return new (cs.getAllocator()) AllowNoopExistentialToCFTypeCheckedCast(
+      cs, fromType, toType, kind, locator);
+}
+
+bool AllowNoopExistentialToCFTypeCheckedCast::diagnose(const Solution &solution,
+                                                       bool asNote) const {
+  NoopExistentialToCFTypeCheckedCast warning(
+      solution, getFromType(), getToType(), CastKind, getLocator());
+  return warning.diagnose(asNote);
+}
+
 // Although function types maybe compile-time convertible because
 // compiler can emit thunks at SIL to handle the conversion when
 // required, only convertions that are supported by the runtime are
@@ -2041,6 +2067,26 @@ bool AllowUnsupportedRuntimeCheckedCast::diagnose(const Solution &solution,
   return failure.diagnose(asNote);
 }
 
+AllowCheckedCastToUnrelated *
+AllowCheckedCastToUnrelated::attempt(ConstraintSystem &cs, Type fromType,
+                                     Type toType, CheckedCastKind kind,
+                                     ConstraintLocator *locator) {
+  // Explicit optional-to-optional casts always succeed because a nil
+  // value of any optional type can be cast to any other optional type.
+  if (fromType->getOptionalObjectType() && toType->getOptionalObjectType()) {
+    return nullptr;
+  }
+  return new (cs.getAllocator())
+      AllowCheckedCastToUnrelated(cs, fromType, toType, kind, locator);
+}
+
+bool AllowCheckedCastToUnrelated::diagnose(const Solution &solution,
+                                           bool asNote) const {
+  CheckedCastToUnrelatedFailure warning(solution, getFromType(), getToType(),
+                                        CastKind, getLocator());
+  return warning.diagnose(asNote);
+}
+
 bool AllowInvalidStaticMemberRefOnProtocolMetatype::diagnose(
     const Solution &solution, bool asNote) const {
   InvalidMemberRefOnProtocolMetatype failure(solution, getLocator());