[TypeChecker] Treat tuples specially while validating checked casts

Based on the checked cast behavior don't warn about unrelated
casts between tuples unless their sizes or labels differ.

Resolves: rdar://problem/56436235

Author: xedin

lib/Sema/TypeCheckConstraints.cpp

@@ -4175,6 +4175,29 @@ CheckedCastKind TypeChecker::typeCheckCheckedCast(Type fromType,
     }
   }
 
+  if (auto toTuple = toType->getAs<TupleType>()) {
+    if (auto fromTuple = fromType->getAs<TupleType>()) {
+      if (fromTuple->getNumElements() != toTuple->getNumElements())
+        return failed();
+
+      for (unsigned i = 0, n = toTuple->getNumElements(); i != n; ++i) {
+        const auto &fromElt = fromTuple->getElement(i);
+        const auto &toElt = toTuple->getElement(i);
+
+        if (fromElt.getName() != toElt.getName())
+          return failed();
+
+        auto result = checkElementCast(fromElt.getType(), toElt.getType(),
+                                       CheckedCastKind::ValueCast);
+
+        if (result == CheckedCastKind::Unresolved)
+          return result;
+      }
+
+      return CheckedCastKind::ValueCast;
+    }
+  }
+
   assert(!toType->isAny() && "casts to 'Any' should've been handled above");
   assert(!toType->isAnyObject() &&
          "casts to 'AnyObject' should've been handled above");

test/Constraints/casts.swift

@@ -222,3 +222,19 @@ func compare<T>(_: T, _: T) {} // expected-note {{'compare' declared here}}
 func compare<T>(_: T?, _: T?) {}
 
 _ = nil? as? Int?? // expected-error {{nil literal cannot be the source of a conditional cast}}
+
+func test_tuple_casts_no_warn() {
+  struct Foo {}
+
+  let arr: [(Any, Any)] = [(Foo(), Foo())]
+  let tup: (Any, Any) = (Foo(), Foo())
+
+  _ = arr as! [(Foo, Foo)] // Ok
+  _ = tup as! (Foo, Foo) // Ok
+
+  _ = 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}}
+}