Teach the dynamic-cast machinery how to cast collection element types.

rjmccall · rjmccall · commit 232a314a9fa9 · 2016-07-23T10:30:10.000-07:00
diff --git a/include/swift/SIL/DynamicCasts.h b/include/swift/SIL/DynamicCasts.h
@@ -39,6 +39,16 @@ enum class DynamicCastFeasibility {
   WillFail,
 };
 
+static inline DynamicCastFeasibility
+atWorst(DynamicCastFeasibility feasibility, DynamicCastFeasibility worstCase) {
+  return (feasibility > worstCase ? worstCase : feasibility);
+}
+
+static inline DynamicCastFeasibility
+atBest(DynamicCastFeasibility feasibility, DynamicCastFeasibility bestCase) {
+  return (feasibility < bestCase ? bestCase : feasibility);
+}
+
 /// Classify the feasibility of a dynamic cast.  The source and target
 /// types should be unlowered formal types.
 DynamicCastFeasibility classifyDynamicCast(
diff --git a/lib/SIL/DynamicCasts.cpp b/lib/SIL/DynamicCasts.cpp
@@ -19,12 +19,6 @@
 using namespace swift;
 using namespace Lowering;
 
-static DynamicCastFeasibility weakenSuccess(DynamicCastFeasibility v) {
-  if (v == DynamicCastFeasibility::WillSucceed)
-    return DynamicCastFeasibility::MaySucceed;
-  return v;
-}
-
 static unsigned getAnyMetatypeDepth(CanType type) {
   unsigned depth = 0;
   while (auto metatype = dyn_cast<AnyMetatypeType>(type)) {
@@ -183,6 +177,14 @@ bool swift::isError(Module *M, CanType Ty) {
   return false;
 }
 
+/// Given that a type is not statically known to be an optional type, check whether
+/// it might dynamically be an optional type.
+static bool canDynamicallyBeOptionalType(CanType type) {
+  assert(!type.getAnyOptionalObjectType());
+  return (isa<ArchetypeType>(type) || type.isExistentialType())
+      && !type.isAnyClassReferenceType();
+}
+
 /// Try to classify the dynamic-cast relationship between two types.
 DynamicCastFeasibility
 swift::classifyDynamicCast(Module *M,
@@ -195,21 +197,30 @@ swift::classifyDynamicCast(Module *M,
   auto sourceObject = source.getAnyOptionalObjectType();
   auto targetObject = target.getAnyOptionalObjectType();
 
-  // A common level of optionality doesn't affect the feasibility.
+  // A common level of optionality doesn't affect the feasibility,
+  // except that we can't fold things to failure because nil inhabits
+  // both types.
   if (sourceObject && targetObject) {
-    return classifyDynamicCast(M, sourceObject, targetObject);
+    return atWorst(classifyDynamicCast(M, sourceObject, targetObject),
+                   DynamicCastFeasibility::MaySucceed);
 
-  // Nor does casting to a more optional type.
+  // Casting to a more optional type follows the same rule unless we
+  // know that the source cannot dynamically be an optional value,
+  // in which case we'll always just cast and inject into an optional.
   } else if (targetObject) {
-    return classifyDynamicCast(M, source, targetObject,
-                               /* isSourceTypeExact */ false,
-                               isWholeModuleOpts);
+    auto result = classifyDynamicCast(M, source, targetObject,
+                                      /* isSourceTypeExact */ false,
+                                      isWholeModuleOpts);
+    if (canDynamicallyBeOptionalType(source))
+      result = atWorst(result, DynamicCastFeasibility::MaySucceed);
+    return result;
 
   // Casting to a less-optional type can always fail.
   } else if (sourceObject) {
-    return weakenSuccess(classifyDynamicCast(M, sourceObject, target,
-                                             /* isSourceTypeExact */ false,
-                                             isWholeModuleOpts));
+    return atBest(classifyDynamicCast(M, sourceObject, target,
+                                      /* isSourceTypeExact */ false,
+                                      isWholeModuleOpts),
+                  DynamicCastFeasibility::MaySucceed);
   }
   assert(!sourceObject && !targetObject);
 
@@ -472,6 +483,40 @@ swift::classifyDynamicCast(Module *M,
     return DynamicCastFeasibility::MaySucceed;
   }
 
+  // Check for a viable collection cast.
+  if (auto sourceStruct = dyn_cast<BoundGenericStructType>(source)) {
+    if (auto targetStruct = dyn_cast<BoundGenericStructType>(target)) {
+
+      // Both types have to be the same kind of collection.
+      auto typeDecl = sourceStruct->getDecl();
+      if (typeDecl == targetStruct->getDecl()) {
+        auto sourceArgs = sourceStruct.getGenericArgs();
+        auto targetArgs = targetStruct.getGenericArgs();
+
+        // Note that we can never say that a collection cast is impossible:
+        // a cast can always succeed on an empty collection.
+
+        // Arrays and sets.
+        if (typeDecl == M->getASTContext().getArrayDecl() ||
+            typeDecl == M->getASTContext().getSetDecl()) {
+          auto valueFeasibility =
+            classifyDynamicCast(M, sourceArgs[0], targetArgs[0]);
+          return atWorst(valueFeasibility,
+                         DynamicCastFeasibility::MaySucceed);
+
+        // Dictionaries.
+        } else if (typeDecl == M->getASTContext().getDictionaryDecl()) {
+          auto keyFeasibility =
+            classifyDynamicCast(M, sourceArgs[0], targetArgs[0]);
+          auto valueFeasibility =
+            classifyDynamicCast(M, sourceArgs[1], targetArgs[1]);
+          return atWorst(atBest(keyFeasibility, valueFeasibility),
+                         DynamicCastFeasibility::MaySucceed);
+        }
+      }
+    }
+  }
+
   return DynamicCastFeasibility::WillFail;
 }
 
diff --git a/stdlib/public/core/ArrayCast.swift b/stdlib/public/core/ArrayCast.swift
@@ -16,6 +16,13 @@
 //
 //===----------------------------------------------------------------------===//
 
+@_silgen_name("_swift_arrayDownCastIndirect")
+public func _arrayDownCastIndirect<SourceValue, TargetValue>(
+  _ source: UnsafePointer<Array<SourceValue>>,
+  _ target: UnsafeMutablePointer<Array<TargetValue>>) {
+  target.initialize(to: _arrayForceCast(source.pointee))
+}
+
 /// Implements `source as! [TargetElement]`.
 ///
 /// - Note: When SourceElement and TargetElement are both bridged verbatim, type
@@ -52,6 +59,18 @@ extension Optional {
   }
 }
 
+@_silgen_name("_swift_arrayDownCastConditionalIndirect")
+public func _arrayDownCastConditionalIndirect<SourceValue, TargetValue>(
+  _ source: UnsafePointer<Array<SourceValue>>,
+  _ target: UnsafeMutablePointer<Array<TargetValue>>
+) -> Bool {
+  if let result: Array<TargetValue> = _arrayConditionalCast(source.pointee) {
+    target.initialize(to: result)
+    return true
+  }
+  return false
+}
+
 /// Implements `source as? [TargetElement]`: convert each element of
 /// `source` to a `TargetElement` and return the resulting array, or
 /// return `nil` if any element fails to convert.
diff --git a/stdlib/public/core/HashedCollections.swift.gyb b/stdlib/public/core/HashedCollections.swift.gyb
@@ -1313,6 +1313,13 @@ public func _setBridgeToObjectiveC<SwiftValue, ObjCValue>(
 
 #endif
 
+@_silgen_name("_swift_setDownCastIndirect")
+public func _setDownCastIndirect<SourceValue, TargetValue>(
+  _ source: UnsafePointer<Set<SourceValue>>,
+  _ target: UnsafeMutablePointer<Set<TargetValue>>) {
+  target.initialize(to: _setDownCast(source.pointee))
+}
+
 /// Implements a forced downcast.  This operation should have O(1) complexity.
 ///
 /// The cast can fail if bridging fails.  The actual checks and bridging can be
@@ -1342,6 +1349,18 @@ public func _setDownCast<BaseValue, DerivedValue>(_ source: Set<BaseValue>)
   return _setDownCastConditional(source)!
 }
 
+@_silgen_name("_swift_setDownCastConditionalIndirect")
+public func _setDownCastConditionalIndirect<SourceValue, TargetValue>(
+  _ source: UnsafePointer<Set<SourceValue>>,
+  _ target: UnsafeMutablePointer<Set<TargetValue>>
+) -> Bool {
+  if let result: Set<TargetValue> = _setDownCastConditional(source.pointee) {
+    target.initialize(to: result)
+    return true
+  }
+  return false
+}
+
 /// Implements a conditional downcast.
 ///
 /// If the cast fails, the function returns `nil`.  All checks should be
@@ -2249,6 +2268,14 @@ public func _dictionaryBridgeToObjectiveC<
 }
 #endif
 
+@_silgen_name("_swift_dictionaryDownCastIndirect")
+public func _dictionaryDownCastIndirect<SourceKey, SourceValue,
+                                        TargetKey, TargetValue>(
+  _ source: UnsafePointer<Dictionary<SourceKey, SourceValue>>,
+  _ target: UnsafeMutablePointer<Dictionary<TargetKey, TargetValue>>) {
+  target.initialize(to: _dictionaryDownCast(source.pointee))
+}
+
 /// Implements a forced downcast.  This operation should have O(1) complexity.
 ///
 /// The cast can fail if bridging fails.  The actual checks and bridging can be
@@ -2293,6 +2320,20 @@ public func _dictionaryDownCast<BaseKey, BaseValue, DerivedKey, DerivedValue>(
   return _dictionaryDownCastConditional(source)!
 }
 
+@_silgen_name("_swift_dictionaryDownCastConditionalIndirect")
+public func _dictionaryDownCastConditionalIndirect<SourceKey, SourceValue,
+                                                   TargetKey, TargetValue>(
+  _ source: UnsafePointer<Dictionary<SourceKey, SourceValue>>,
+  _ target: UnsafeMutablePointer<Dictionary<TargetKey, TargetValue>>
+) -> Bool {
+  if let result: Dictionary<TargetKey, TargetValue>
+       = _dictionaryDownCastConditional(source.pointee) {
+    target.initialize(to: result)
+    return true
+  }
+  return false
+}
+
 /// Implements a conditional downcast.
 ///
 /// If the cast fails, the function returns `nil`.  All checks should be
diff --git a/stdlib/public/runtime/Casting.cpp b/stdlib/public/runtime/Casting.cpp
@@ -2148,6 +2148,133 @@ static bool tryDynamicCastBoxedSwiftValue(OpaqueValue *dest,
 }
 #endif
 
+/// Nominal type descriptor for Swift.Array.
+extern "C" const NominalTypeDescriptor _TMnSa;
+
+/// Nominal type descriptor for Swift.Dictionary.
+extern "C" const NominalTypeDescriptor _TMnVs10Dictionary;
+
+/// Nominal type descriptor for Swift.Set.
+extern "C" const NominalTypeDescriptor _TMnVs3Set;
+
+SWIFT_CC(swift)
+extern "C"
+void _swift_arrayDownCastIndirect(OpaqueValue *destination,
+                                  OpaqueValue *source,
+                                  const Metadata *sourceValueType,
+                                  const Metadata *targetValueType);
+
+SWIFT_CC(swift)
+extern "C"
+bool _swift_arrayDownCastConditionalIndirect(OpaqueValue *destination,
+                                             OpaqueValue *source,
+                                             const Metadata *sourceValueType,
+                                             const Metadata *targetValueType);
+
+SWIFT_CC(swift)
+extern "C"
+void _swift_setDownCastIndirect(OpaqueValue *destination,
+                                OpaqueValue *source,
+                                const Metadata *sourceValueType,
+                                const Metadata *targetValueType);
+
+SWIFT_CC(swift)
+extern "C"
+bool _swift_setDownCastConditionalIndirect(OpaqueValue *destination,
+                                           OpaqueValue *source,
+                                           const Metadata *sourceValueType,
+                                           const Metadata *targetValueType);
+
+SWIFT_CC(swift)
+extern "C"
+void _swift_dictionaryDownCastIndirect(OpaqueValue *destination,
+                                       OpaqueValue *source,
+                                       const Metadata *sourceKeyType,
+                                       const Metadata *sourceValueType,
+                                       const Metadata *targetKeyType,
+                                       const Metadata *targetValueType);
+
+SWIFT_CC(swift)
+extern "C"
+bool _swift_dictionaryDownCastConditionalIndirect(OpaqueValue *destination,
+                                                  OpaqueValue *source,
+                                            const Metadata *sourceKeyType,
+                                            const Metadata *sourceValueType,
+                                            const Metadata *targetKeyType,
+                                            const Metadata *targetValueType);
+
+static bool _dynamicCastStructToStruct(OpaqueValue *destination,
+                                       OpaqueValue *source,
+                                       const StructMetadata *sourceType,
+                                       const StructMetadata *targetType,
+                                       DynamicCastFlags flags) {
+  if (sourceType == targetType)
+    return _succeed(destination, source, sourceType, flags);
+
+  // The two types have to be instantiations of the same type.
+  auto descriptor = sourceType->Description.get();
+  if (descriptor != targetType->Description.get())
+    return _fail(source, sourceType, targetType, flags);
+
+  auto sourceArgs = sourceType->getGenericArgs();
+  auto targetArgs = targetType->getGenericArgs();
+
+  bool result;
+
+  // Arrays.
+  if (descriptor == &_TMnSa) {
+    if (flags & DynamicCastFlags::Unconditional) {
+      _swift_arrayDownCastIndirect(source, destination,
+                                   sourceArgs[0], targetArgs[0]);
+      result = true;
+    } else {
+      result =
+        _swift_arrayDownCastConditionalIndirect(source, destination,
+                                                sourceArgs[0], targetArgs[0]);
+    }
+
+  // Dictionaries.
+  } else if (descriptor == &_TMnVs10Dictionary) {
+    if (flags & DynamicCastFlags::Unconditional) {
+      _swift_dictionaryDownCastIndirect(source, destination,
+                                        sourceArgs[0], sourceArgs[1],
+                                        targetArgs[0], targetArgs[1]);
+      result = true;
+    } else {
+      result =
+        _swift_dictionaryDownCastConditionalIndirect(source, destination,
+                                        sourceArgs[0], sourceArgs[1],
+                                        targetArgs[0], targetArgs[1]);
+    }
+
+  // Sets.
+  } else if (descriptor == &_TMnVs10Dictionary) {
+    if (flags & DynamicCastFlags::Unconditional) {
+      _swift_setDownCastIndirect(source, destination,
+                                 sourceArgs[0], targetArgs[0]);
+      result = true;
+    } else {
+      result =
+        _swift_setDownCastConditionalIndirect(source, destination,
+                                              sourceArgs[0], targetArgs[0]);
+    }
+
+  // Other struct types don't support dynamic covariance for now.
+  } else {
+    return _fail(source, sourceType, targetType, flags);
+  }
+
+  // The intrinsics above never consume the source value.
+  bool shouldDestroySource =
+    result ? flags & DynamicCastFlags::TakeOnSuccess
+           : flags & DynamicCastFlags::DestroyOnFailure;
+  if (shouldDestroySource) {
+    sourceType->vw_destroy(source);
+  }
+
+  return result;
+}
+
 /// Perform a dynamic cast to an arbitrary type.
 SWIFT_RT_ENTRY_VISIBILITY
 bool swift::swift_dynamicCast(OpaqueValue *dest,
@@ -2307,6 +2434,16 @@ bool swift::swift_dynamicCast(OpaqueValue *dest,
       break;
     }
 
+    case MetadataKind::Struct:
+      // Collection casts.
+      if (targetType->getKind() == MetadataKind::Struct) {
+        return _dynamicCastStructToStruct(dest, src,
+                                          cast<StructMetadata>(srcType),
+                                          cast<StructMetadata>(targetType),
+                                          flags);
+      }
+      break;
+
     case MetadataKind::ExistentialMetatype:
     case MetadataKind::Enum:
     case MetadataKind::Optional:
@@ -2316,7 +2453,6 @@ bool swift::swift_dynamicCast(OpaqueValue *dest,
     case MetadataKind::ErrorObject:
     case MetadataKind::Metatype:
     case MetadataKind::Opaque:
-    case MetadataKind::Struct:
     case MetadataKind::Tuple:
       break;
     }
diff --git a/test/Interpreter/collection_casts.swift b/test/Interpreter/collection_casts.swift
