[SR-13088] Fix false positive downcast unrelated of types that cannot be statically known

lib/Sema/TypeCheckConstraints.cpp

@@ -3249,6 +3249,11 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
 
   auto checkElementCast = [&](Type fromElt, Type toElt,
                               CheckedCastKind castKind) -> CheckedCastKind {
+    // Let's not emit diagnostic when the element type is erased because
+    // we can't statically know if element is convertible.
+    if (fromElt->isAny() || toElt->isAny())
+      return castKind;
+
     switch (typeCheckCheckedCast(fromElt, toElt, CheckedCastContextKind::None,
                                  dc, SourceLoc(), nullptr, SourceRange())) {
     case CheckedCastKind::Coercion:
@@ -3357,7 +3362,14 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
         const auto &fromElt = fromTuple->getElement(i);
         const auto &toElt = toTuple->getElement(i);
 
-        if (fromElt.getName() != toElt.getName())
+        // We should only perform name validation if both element have a label,
+        // because unlabeled tuple elements can be converted to labeled ones
+        // e.g.
+        // 
+        // let tup: (Any, Any) = (1, 1)
+        // _ = tup as! (a: Int, Int)
+        if ((!fromElt.getName().empty() && !toElt.getName().empty()) &&
+            fromElt.getName() != toElt.getName())
           return failed();
 
         auto result = checkElementCast(fromElt.getType(), toElt.getType(),
@@ -3487,6 +3499,17 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
   bool toExistential = toType->isExistentialType();
   bool fromExistential = fromType->isExistentialType();
 
+  auto genericTypeHasExistentialArgument = [](Type type) {
+    if (auto toGeneric = type->getAs<BoundGenericType>()) {
+      return llvm::any_of(toGeneric->getGenericArgs(), [](Type argumentType) {
+        return argumentType->isExistentialType();
+      });
+    }
+    return false;
+  };
+
+  bool toHasGenericExistential = genericTypeHasExistentialArgument(toType);
+
   bool toRequiresClass;
   if (toType->isExistentialType())
     toRequiresClass = toType->getExistentialLayout().requiresClass();
@@ -3544,7 +3567,16 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
     // Note: we relax the restriction if the type we're casting to is a
     // non-final class because it's possible that we might have a subclass
     // that conforms to the protocol.
-    if (fromExistential && !toExistential) {
+    //
+    // Also, relax the restriction when toType is a bounded generic with
+    // an existential argument because it may have conditional protocol 
+    // conformances. e.g.
+    //
+    //  func encodable(_ value: Encodable) {
+    //    _ = value as! [String : Encodable]
+    //  }
+    //
+    if (fromExistential && (!toExistential && !toHasGenericExistential)) {
       if (auto NTD = toType->getAnyNominal()) {
         if (!toType->is<ClassType>() || NTD->isFinal()) {
           auto protocolDecl =
@@ -3616,10 +3648,10 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
     return CheckedCastKind::ValueCast;
   }
 
-  // If the destination type can be a supertype of the source type, we are
-  // performing what looks like an upcast except it rebinds generic
-  // parameters.
-  if (fromType->isBindableTo(toType))
+  // If it is possible to substitute the generic arguments of source type
+  // with the destination generic archetypes, we are performing what looks
+  // like an upcast except it rebinds generic parameters.
+  if (toType->isBindableTo(fromType))
     return CheckedCastKind::ValueCast;
 
   // Objective-C metaclasses are subclasses of NSObject in the ObjC runtime,

test/Constraints/casts.swift

@@ -235,8 +235,8 @@ func test_tuple_casts_no_warn() {
   _ = arr as! [(Foo, Foo, Foo)] // expected-warning {{cast from '[(Any, Any)]' to unrelated type '[(Foo, Foo, Foo)]' always fails}}
   _ = tup as! (Foo, Foo, Foo) // expected-warning {{cast from '(Any, Any)' to unrelated type '(Foo, Foo, Foo)' always fails}}
 
-  _ = arr as! [(a: Foo, Foo)] // expected-warning {{cast from '[(Any, Any)]' to unrelated type '[(a: Foo, Foo)]' always fails}}
-  _ = tup as! (a: Foo, Foo) // expected-warning {{cast from '(Any, Any)' to unrelated type '(a: Foo, Foo)' always fails}}
+  _ = arr as! [(a: Foo, Foo)] // Ok
+  _ = tup as! (a: Foo, Foo) // Ok
 }
 
 infix operator ^^^
@@ -335,3 +335,76 @@ func test_compatibility_coercions(_ arr: [Int], _ optArr: [Int]?, _ dict: [Strin
   // The array can also be inferred to be [Any].
   _ = ([] ?? []) as Array // expected-warning {{left side of nil coalescing operator '??' has non-optional type '[Any]', so the right side is never used}}
 }
+
+// SR-13088
+protocol JSON { }
+protocol JSONLeaf: JSON {}
+extension Int: JSONLeaf { }
+extension Array: JSON where Element: JSON { }
+
+protocol SR13035Error: Error {}
+class ChildError: SR13035Error {}
+
+protocol AnyC {
+  func foo()
+}
+
+protocol AnyEvent {}
+
+protocol A {
+  associatedtype C: AnyC
+}
+
+protocol EventA: A {
+  associatedtype Event
+}
+
+typealias Container<Namespace>
+  = (event: Namespace.Event, c: Namespace.C) where Namespace: EventA
+
+enum ConcreteA: EventA {
+  struct C: AnyC {
+    func foo() {}
+  }
+
+  enum Event: AnyEvent {
+    case test
+  }
+}
+
+func tests_SR13088_false_positive_always_fail_casts() {
+  // SR-13081
+  let x: JSON = [4] // [4]
+  _ = x as? [Any] // Ok
+
+  // SR-7187
+  let a: [Any] = [String?.some("hello") as Any, String?.none as Any]
+
+  _ = a is [String?] // Ok
+  _ = a as? [String?] // Ok
+
+  // SR-13035
+  func SR13035<SomeError: SR13035Error>(_ mockResult: Result<String, ChildError>, _: Result<String, SomeError>) {
+    let _ = mockResult as? Result<String, SomeError> // Ok
+  }
+
+  func SR13035_1<SomeError: SR13035Error, Child: ChildError>(_ mockResult: Result<String, Child>, _: Result<String, SomeError>) {
+    let _ = mockResult as? Result<String, SomeError> // Ok
+  }
+
+  // SR-11434 and SR-12321
+  func encodable(_ value: Encodable) {
+    _ = value as! [String : Encodable] // Ok
+    _ = value as? [String: Encodable] // Ok
+  }   
+
+  // SR-13025
+  func coordinate(_ event: AnyEvent, from c: AnyC) {
+    switch (event, c) {
+    case let container as Container<ConcreteA>: // OK
+      container.c.foo()
+    default:
+      break
+    }
+  }
+}