Runtime: Dynamic casts to subclass existentials

Author: slavapestov

stdlib/public/runtime/Casting.cpp

@@ -411,8 +411,19 @@ static bool _conformsToProtocol(const OpaqueValue *value,
 /// list of conformances.
 static bool _conformsToProtocols(const OpaqueValue *value,
                                  const Metadata *type,
-                                 const ProtocolDescriptorList &protocols,
+                                 const ExistentialTypeMetadata *existentialType,
                                  const WitnessTable **conformances) {
+  if (auto *superclass = existentialType->getSuperclassConstraint()) {
+    if (!swift_dynamicCastMetatype(type, superclass))
+      return false;
+  }
+
+  if (existentialType->isClassBounded()) {
+    if (!Metadata::isAnyKindOfClass(type->getKind()))
+      return false;
+  }
+
+  auto &protocols = existentialType->Protocols;
   for (unsigned i = 0, n = protocols.NumProtocols; i != n; ++i) {
     const ProtocolDescriptor *protocol = protocols[i];
     if (!_conformsToProtocol(value, type, protocol, conformances))
@@ -876,7 +887,7 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
 #if SWIFT_OBJC_INTEROP
       // If the destination type is a set of protocols that SwiftValue
       // implements, we're fine.
-      if (findSwiftValueConformances(targetType->Protocols,
+      if (findSwiftValueConformances(targetType,
                                      destExistential->getWitnessTables())) {
         bool consumeValue = dynamicFlags & DynamicCastFlags::TakeOnSuccess;
         destExistential->Value =
@@ -963,7 +974,7 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
     // container with a class instance to AnyObject. In this case no check is
     // necessary.
     if (srcDynamicType && !_conformsToProtocols(srcDynamicValue, srcDynamicType,
-                              targetType->Protocols,
+                              targetType,
                               destExistential->getWitnessTables()))
       return fallbackForNonDirectConformance();
 
@@ -981,7 +992,7 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
 
     // Check for protocol conformances and fill in the witness tables.
     if (!_conformsToProtocols(srcDynamicValue, srcDynamicType,
-                              targetType->Protocols,
+                              targetType,
                               destExistential->getWitnessTables()))
       return fallbackForNonDirectConformance();
 
@@ -1015,7 +1026,7 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
     assert(targetType->Protocols.NumProtocols == 1);
     const WitnessTable *errorWitness;
     if (!_conformsToProtocols(srcDynamicValue, srcDynamicType,
-                              targetType->Protocols,
+                              targetType,
                               &errorWitness))
       return fallbackForNonDirectConformance();
 
@@ -1052,6 +1063,8 @@ static bool _dynamicCastToExistential(OpaqueValue *dest,
 static const void *
 _dynamicCastUnknownClassToExistential(const void *object,
                                     const ExistentialTypeMetadata *targetType) {
+  // FIXME: check superclass constraint here.
+
   for (unsigned i = 0, e = targetType->Protocols.NumProtocols; i < e; ++i) {
     const ProtocolDescriptor *protocol = targetType->Protocols[i];
 
@@ -1848,18 +1861,14 @@ static bool _dynamicCastMetatypeToExistentialMetatype(OpaqueValue *dest,
         dyn_cast<ExistentialTypeMetadata>(targetInstanceType)) {
     // Check for conformance to all the protocols.
     // TODO: collect the witness tables.
-    auto &protocols = targetInstanceTypeAsExistential->Protocols;
     const WitnessTable **conformance
       = writeDestMetatype ? destMetatype->getWitnessTables() : nullptr;
-    for (unsigned i = 0, n = protocols.NumProtocols; i != n; ++i) {
-      const ProtocolDescriptor *protocol = protocols[i];
-      if (!_conformsToProtocol(nullptr, srcMetatype, protocol, conformance)) {
-        if (flags & DynamicCastFlags::Unconditional)
-          swift_dynamicCastFailure(srcMetatype, targetType);
-        return false;
-      }
-      if (conformance && protocol->Flags.needsWitnessTable())
-        ++conformance;
+    if (!_conformsToProtocols(nullptr, srcMetatype,
+                              targetInstanceTypeAsExistential,
+                              conformance)) {
+      if (flags & DynamicCastFlags::Unconditional)
+        swift_dynamicCastFailure(srcMetatype, targetType);
+      return false;
     }
 
     if (writeDestMetatype)

stdlib/public/runtime/SwiftValue.h

@@ -52,10 +52,10 @@ getValueFromSwiftValue(_SwiftValue *v);
 /// or nil if it is not.
 _SwiftValue *getAsSwiftValue(id object);
 
-/// Find conformances for SwiftValue to the given list of protocols.
+/// Find conformances for SwiftValue to the given existential type.
 ///
 /// Returns true if SwiftValue does conform to all the protocols.
-bool findSwiftValueConformances(const ProtocolDescriptorList &protocols,
+bool findSwiftValueConformances(const ExistentialTypeMetadata *existentialType,
                                 const WitnessTable **tablesBuffer);
 
 } // namespace swift

stdlib/public/runtime/SwiftValue.mm

@@ -213,8 +213,14 @@ static size_t getSwiftValuePayloadAlignMask(const Metadata *type) {
 }
 
 bool
-swift::findSwiftValueConformances(const ProtocolDescriptorList &protocols,
+swift::findSwiftValueConformances(const ExistentialTypeMetadata *existentialType,
                                   const WitnessTable **tablesBuffer) {
+  // _SwiftValue never satisfies a superclass constraint.
+  if (existentialType->getSuperclassConstraint() != nullptr)
+    return false;
+
+  auto &protocols = existentialType->Protocols;
+
   Class cls = nullptr;
 
   // Note that currently we never modify tablesBuffer because

test/Interpreter/subclass_existentials.swift

@@ -444,25 +444,23 @@ SubclassExistentialsTestSuite.test("Failing scalar downcast to subclass existent
   }
 }
 
-// FIXME
-
 SubclassExistentialsTestSuite.test("Failing dynamic downcast to subclass existential") {
   do {
     let baseInt: Base<Int> = Base<Int>(x: 123, y: 321)
 
-    //expectNil(cast(baseInt, to: ((Base<Int>) & P).self))
+    expectNil(cast(baseInt, to: ((Base<Int>) & P).self))
   }
 
   do {
     let r: R = Base<Int>(x: 123, y: 321)
 
-    //expectNil(cast(r, to: ((Base<Int>) & P).self))
+    expectNil(cast(r, to: ((Base<Int>) & P).self))
   }
 
   do {
     let conformsToP = ConformsToP(protocolInit: ())
 
-    //expectNil(cast(conformsToP, to: ((Base<Int>) & P).self))
+    expectNil(cast(conformsToP, to: ((Base<Int>) & P).self))
   }
 }
 

test/Interpreter/subclass_existentials_objc.swift

@@ -0,0 +1,58 @@
+//===--- subclass_existentials.swift --------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: %target-build-swift %s -o %t/a.out -Xfrontend -enable-experimental-subclass-existentials
+// RUN: %target-run %t/a.out
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+//
+
+import StdlibUnittest
+import Foundation
+
+// FIXME: Actually write proper tests here.
+
+func cast<T, U>(_ t: T, to: U.Type) -> U? {
+  return t as? U
+}
+
+protocol CP : class {}
+@objc protocol OP {}
+
+class C {}
+
+class D : C, OP {}
+
+var SubclassExistentialsTestSuite = TestSuite("SubclassExistentials")
+
+SubclassExistentialsTestSuite.test("Metatype self-conformance") {
+  expectFalse(CP.self is AnyObject.Type)
+  expectEqual(OP.self, OP.self as AnyObject.Type)
+
+  expectNil(cast(CP.self, to: AnyObject.Type.self))
+  // FIXME
+  expectNil(cast(OP.self, to: AnyObject.Type.self))
+
+  // FIXME: Sema says 'always true', runtime says false.
+  //
+  // Runtime code had a FIXME in it already, so I think Sema is right.
+  expectFalse(OP.self is AnyObject.Type)
+  expectFalse((C & OP).self is AnyObject.Type)
+  expectFalse((C & OP).self is OP.Type)
+
+  expectTrue(D.self is (C & OP).Type)
+  expectFalse(OP.self is (C & OP).Type)
+}
+
+runAllTests()