[Runtime] Handle tuple/tuple dynamic casts that add/remove labels.

Introduce narrow support for tuple/tuple dynamic casts that merely add
or remove labels, but require the element types to match exactly. This
gets us back to allowing the same correct dynamic casts as in Swift
3.0, when labels were completely ignored.

Author: DougGregor

stdlib/public/runtime/Casting.cpp

@@ -2497,6 +2497,51 @@ static bool _dynamicCastStructToStruct(OpaqueValue *destination,
   return result;
 }
 
+static bool _dynamicCastTupleToTuple(OpaqueValue *destination,
+                                     OpaqueValue *source,
+                                     const TupleTypeMetadata *sourceType,
+                                     const TupleTypeMetadata *targetType,
+                                     DynamicCastFlags flags) {
+  assert(sourceType != targetType &&
+         "Caller should handle exact tuple matches");
+
+
+  // Simple case: number of elements mismatches.
+  if (sourceType->NumElements != targetType->NumElements)
+    return _fail(source, sourceType, targetType, flags);
+
+  // Check that the elements line up.
+  const char *sourceLabels = sourceType->Labels;
+  const char *targetLabels = targetType->Labels;
+  for (unsigned i = 0, n = sourceType->NumElements; i != n; ++i) {
+    // Check the label, if there is one.
+    if (sourceLabels && targetLabels && sourceLabels != targetLabels) {
+      const char *sourceSpace = strchr(sourceLabels, ' ');
+      const char *targetSpace = strchr(targetLabels, ' ');
+
+      // If both have labels, and the labels mismatch, we fail.
+      if (sourceSpace && sourceSpace != sourceLabels &&
+          targetSpace && targetSpace != targetLabels) {
+        unsigned sourceLen = sourceSpace - sourceLabels;
+        unsigned targetLen = targetSpace - targetLabels;
+        if (sourceLen != targetLen ||
+            strncmp(sourceLabels, targetLabels, sourceLen) != 0)
+          return _fail(source, sourceType, targetType, flags);
+      }
+
+      sourceLabels = sourceSpace ? sourceSpace + 1 : nullptr;
+      targetLabels = targetSpace ? targetSpace + 1 : nullptr;
+    }
+
+    // Make sure the types match exactly.
+    // FIXME: we should dynamically cast the elements themselves.
+    if (sourceType->getElement(i).Type != targetType->getElement(i).Type)
+      return _fail(source, sourceType, targetType, flags);
+  }
+
+  return _succeed(destination, source, targetType, flags);
+}
+
 /******************************************************************************/
 /****************************** Main Entrypoint *******************************/
 /******************************************************************************/
@@ -2718,6 +2763,15 @@ bool swift::swift_dynamicCast(OpaqueValue *dest,
                                          targetType, flags);
     }
 
+    // If both are tuple types, allow the cast to add/remove labels.
+    if (srcType->getKind() == MetadataKind::Tuple &&
+        targetType->getKind() == MetadataKind::Tuple) {
+      return _dynamicCastTupleToTuple(dest, src,
+                                      cast<TupleTypeMetadata>(srcType),
+                                      cast<TupleTypeMetadata>(targetType),
+                                      flags);
+    }
+
     // Otherwise, we have a failure.
     return _fail(src, srcType, targetType, flags);
   }

test/Interpreter/tuple_casts.swift

@@ -0,0 +1,30 @@
+// RUN: %target-run-simple-swift | %FileCheck %s
+// RUN: %target-build-swift -O %s -o %t/a.out.optimized
+// RUN: %target-run %t/a.out.optimized | %FileCheck %s
+// REQUIRES: executable_test
+
+func anyToIntPoint(_ x: Any) -> (x: Int, y: Int) {
+  return x as! (x: Int, y: Int)
+}
+
+func anyToIntPointOpt(_ x: Any) -> (x: Int, y: Int)? {
+  return x as? (x: Int, y: Int)
+}
+
+func anyToInt2(_ x: Any) -> (Int, Int) {
+  return x as! (Int, Int)
+}
+
+// Labels can be added/removed.
+print("Label add/remove")          // CHECK: Label add/remove
+print(anyToIntPoint((x: 1, y: 2))) // CHECK-NEXT: (1, 2)
+print(anyToIntPoint((3, 4)))       // CHECK-NEXT: (3, 4)
+print(anyToIntPoint((x: 5, 6)))    // CHECK-NEXT: (5, 6)
+print(anyToInt2((1, 2)))           // CHECK-NEXT: (1, 2)
+print(anyToInt2((x: 3, y: 4)))     // CHECK-NEXT: (3, 4)
+print(anyToInt2((x: 5, 6)))        // CHECK-NEXT: (5, 6)
+
+// Labels cannot be wrong.
+print("Wrong labels")                 // CHECK: Wrong labels
+print(anyToIntPointOpt((x: 1, z: 2))) // CHECK-NEXT: nil
+print(anyToIntPointOpt((x: 1, y: 2))) // CHECK-NEXT: Optional((1, 2))