Merge pull request #9090 from slavapestov/enable-subclass-existentials

Enable subclass existentials

Author: slavapestov

CHANGELOG.md

@@ -21,6 +21,70 @@ CHANGELOG
 Swift 4.0
 ---------
 
+* [SE-0156][]
+
+  Protocol composition types can now contain one or more class type terms,
+  forming a class-constrained protocol composition.
+
+  For example:
+
+  ```swift
+  protocol Paintable {
+    func paint()
+  }
+
+  class Canvas {
+    var origin: CGPoint
+  }
+
+  class Wall : Canvas, Paintable {
+    func paint() { ... }
+  }```
+
+  func render(_: Canvas & Paintable) { ... }
+
+  render(Wall())
+  ```
+
+  Note that class-constrained protocol compositions can be written and
+  used in both Swift 3 and Swift 4 mode.
+
+  Generated headers for Swift APIs will map class-constrained protocol
+  compositions to Objective-C protocol-qualified class types in both
+  Swift 3 and Swift 4 mode (for instance, `NSSomeClass & SomeProto &
+  OtherProto` in Swift becomes `NSSomeClass <SomeProto, OtherProto>`
+  in Objective-C).
+
+  Objective-C APIs which use protocol-qualified class types differ in
+  behavior when imported by a module compiled in Swift 3 mode and
+  Swift 4 mode. In Swift 3 mode, these APIs will continue to import as
+  protocol compositions without a class constraint
+  (eg, `SomeProto & OtherProto`).
+
+  In Swift 4 mode, protocol-qualified class types import as
+  class-constrained protocol compositions, for a more faithful mapping
+  of APIs from Objective-C to Swift.
+
+  Note that the current implementation of class-constrained protocol
+  compositions lacks three features outlined in the Swift evolution proposal:
+
+  - In the evolution proposal, a class-constrained is permitted to contain
+    two different classes as long as one is a superclass of the other.
+    The current implementation only allows multiple classes to appear in
+    the composition if they are identical.
+
+  - In the evolution proposal, associated type and class inheritance clauses
+    are generalized to allow class-constrained protocol compositions. The
+    current implementation does not allow this.
+
+  - In the evolution proposal, protocol inheritance clauses are allowed to
+    contain a class, placing a requirement that all conforming types are
+    a subclass of the given class. The current implementation does not
+    allow this.
+
+  These missing aspects of the proposal can be introduced in a future
+  release without breaking source compatibility with existing code.
+
 * [SE-0142][]
 
   Protocols and associated types can now contain `where` clauses that

include/swift/Basic/LangOptions.h

@@ -165,9 +165,6 @@ namespace swift {
     /// optimized custom allocator, so that memory debugging tools can be used.
     bool UseMalloc = false;
 
-    /// \brief Enable classes to appear in protocol composition types.
-    bool EnableExperimentalSubclassExistentials = false;
-
     /// \brief Enable experimental property behavior feature.
     bool EnableExperimentalPropertyBehaviors = false;
 

include/swift/Option/FrontendOptions.td

@@ -274,10 +274,6 @@ def enable_experimental_deserialization_recovery :
   Flag<["-"], "enable-experimental-deserialization-recovery">,
   HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;
 
-def enable_experimental_subclass_existentials : Flag<["-"],
-  "enable-experimental-subclass-existentials">,
-  HelpText<"Enable classes to appear in protocol composition types">;
-
 def enable_cow_existentials : Flag<["-"], "enable-cow-existentials">,
   HelpText<"Enable the copy-on-write existential implementation">;
 

lib/ClangImporter/ImportType.cpp

@@ -883,10 +883,8 @@ namespace {
             } else {
               SmallVector<Type, 4> memberTypes;
 
-              if (Impl.SwiftContext.LangOpts.EnableExperimentalSubclassExistentials) {
-                if (auto superclassType = typeParam->getSuperclass())
-                  memberTypes.push_back(superclassType);
-              }
+              if (auto superclassType = typeParam->getSuperclass())
+                memberTypes.push_back(superclassType);
 
               for (auto protocolDecl : typeParam->getConformingProtocols())
                 memberTypes.push_back(protocolDecl->getDeclaredType());
@@ -1029,9 +1027,7 @@ namespace {
       // Swift 3 compatibility -- don't import subclass existentials
       if (!type->qual_empty() &&
           (importedType->isAnyObject() ||
-           (!Impl.SwiftContext.isSwiftVersion3() &&
-            Impl.SwiftContext.LangOpts.EnableExperimentalSubclassExistentials))) {
-
+           !Impl.SwiftContext.isSwiftVersion3())) {
         SmallVector<Type, 4> members;
         if (!importedType->isAnyObject())
           members.push_back(importedType);

lib/Frontend/CompilerInvocation.cpp

@@ -910,9 +910,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
   Opts.EnableExperimentalKeyPaths |=
     Args.hasArg(OPT_enable_experimental_keypaths);
 
-  Opts.EnableExperimentalSubclassExistentials |=
-    Args.hasArg(OPT_enable_experimental_subclass_existentials);
-
   Opts.EnableClassResilience |=
     Args.hasArg(OPT_enable_class_resilience);
 

lib/Sema/TypeCheckType.cpp

@@ -3100,8 +3100,7 @@ Type TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     if (!ty || ty->hasError()) return ty;
 
     auto nominalDecl = ty->getAnyNominal();
-    if (TC.Context.LangOpts.EnableExperimentalSubclassExistentials &&
-        nominalDecl && isa<ClassDecl>(nominalDecl)) {
+    if (nominalDecl && isa<ClassDecl>(nominalDecl)) {
       if (checkSuperclass(tyR->getStartLoc(), ty))
         continue;
 

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/Demangle.cpp

@@ -149,15 +149,42 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
   }
   case MetadataKind::Existential: {
     auto exis = static_cast<const ExistentialTypeMetadata *>(type);
-    NodePointer proto_list = Dem.createNode(Node::Kind::ProtocolList);
-    NodePointer type_list = Dem.createNode(Node::Kind::TypeList);
-
-    proto_list->addChild(type_list, Dem);
+    NodePointer proto_list;
 
     std::vector<const ProtocolDescriptor *> protocols;
     protocols.reserve(exis->Protocols.NumProtocols);
     for (unsigned i = 0, e = exis->Protocols.NumProtocols; i < e; ++i)
       protocols.push_back(exis->Protocols[i]);
+
+    if (exis->getSuperclassConstraint()) {
+      // If there is a superclass constraint, we mangle it specially.
+      proto_list = Dem.createNode(Node::Kind::ProtocolListWithClass);
+    } else if (exis->isClassBounded()) {
+      // Check if the class constraint is implied by any of our
+      // protocols.
+      bool requiresClassImplicit = false;
+
+      for (auto *protocol : protocols) {
+        if (protocol->Flags.getClassConstraint()
+            == ProtocolClassConstraint::Class)
+          requiresClassImplicit = true;
+      }
+
+      // If it was implied, we don't do anything special.
+      if (requiresClassImplicit)
+        proto_list = Dem.createNode(Node::Kind::ProtocolList);
+      // If the existential type has an explicit AnyObject constraint,
+      // we must mangle it as such.
+      else
+        proto_list = Dem.createNode(Node::Kind::ProtocolListWithAnyObject);
+    } else {
+      // Just a simple composition of protocols.
+      proto_list = Dem.createNode(Node::Kind::ProtocolList);
+    }
+
+    NodePointer type_list = Dem.createNode(Node::Kind::TypeList);
+
+    proto_list->addChild(type_list, Dem);
 
     // Sort the protocols by their mangled names.
     // The ordering in the existential type metadata is by metadata pointer,
@@ -198,7 +225,12 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
       assert(protocolNode->getChild(0)->getKind() == Node::Kind::Protocol);
       type_list->addChild(protocolNode, Dem);
     }
-    
+
+    if (auto *superclass = exis->getSuperclassConstraint()) {
+      auto superclassNode = _swift_buildDemanglingForMetadata(superclass, Dem);
+      proto_list->addChild(superclassNode, Dem);
+    }
+
     return proto_list;
   }
   case MetadataKind::ExistentialMetatype: {

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/ClangImporter/objc_bridging_generics.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -parse-as-library -verify -enable-experimental-subclass-existentials -swift-version 4 %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -parse-as-library -verify -swift-version 4 %s
 
 // REQUIRES: objc_interop
 

test/ClangImporter/objc_bridging_generics_swift3.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -parse-as-library -verify -enable-experimental-subclass-existentials -swift-version 3 %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -parse-as-library -verify -swift-version 3 %s
 
 // REQUIRES: objc_interop
 

test/ClangImporter/subclass_existentials.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify -o - -primary-file %s -swift-version 4 -enable-experimental-subclass-existentials
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify -o - -primary-file %s -swift-version 4
 
 // REQUIRES: objc_interop
 

test/ClangImporter/subclass_existentials_ir.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir -o - -primary-file %s -swift-version 4 -enable-experimental-subclass-existentials
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir -o - -primary-file %s -swift-version 4
 
 // REQUIRES: objc_interop
 

test/ClangImporter/subclass_existentials_swift3.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify -o - -primary-file %s -enable-experimental-subclass-existentials -swift-version 3
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify -o - -primary-file %s -swift-version 3
 
 // REQUIRES: objc_interop
 

test/IRGen/objc_type_encoding.swift

@@ -1,6 +1,6 @@
 // RUN: rm -rf %t && mkdir -p %t
 // RUN: %build-irgen-test-overlays
-// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) %s -emit-ir -disable-objc-attr-requires-foundation-module -enable-experimental-subclass-existentials | %FileCheck %s -check-prefix=CHECK-%target-os
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) %s -emit-ir -disable-objc-attr-requires-foundation-module | %FileCheck %s -check-prefix=CHECK-%target-os
 
 // REQUIRES: CPU=x86_64
 // REQUIRES: objc_interop

test/IRGen/subclass_existentials.sil

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -primary-file %s -emit-ir -enable-experimental-subclass-existentials | %FileCheck %s --check-prefix=CHECK-%target-runtime --check-prefix=CHECK
+// RUN: %target-swift-frontend -primary-file %s -emit-ir | %FileCheck %s --check-prefix=CHECK-%target-runtime --check-prefix=CHECK
 
 sil_stage canonical
 

test/IRGen/type_layout_reference_storage.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir -enable-experimental-subclass-existentials %s | %FileCheck %s --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK
+// RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil -emit-ir %s | %FileCheck %s --check-prefix=CHECK-%target-ptrsize --check-prefix=CHECK
 
 class C {}
 protocol P: class {}

test/IRGen/type_layout_reference_storage_objc.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir %s -enable-experimental-subclass-existentials | %FileCheck %s
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-ir %s | %FileCheck %s
 // REQUIRES: objc_interop
 
 import Foundation