[Sema] An SPI protocol requirement must have a default implementation

Author: xymus

include/swift/AST/DiagnosticsSema.def

@@ -1705,6 +1705,10 @@ ERROR(spi_attribute_on_non_public,none,
       "cannot be declared '@_spi' because only public and open "
       "declarations can be '@_spi'",
       (AccessLevel, DescriptiveDeclKind))
+ERROR(spi_attribute_on_protocol_requirement,none,
+      "protocol requirement %0 cannot be declared '@_spi' without "
+      "a default implementation in a protocol extension",
+      (DeclName))
 
 // Opaque return types
 ERROR(opaque_type_invalid_constraint,none,

lib/Sema/TypeCheckAttr.cpp

@@ -862,13 +862,52 @@ void AttributeChecker::visitSetterAccessAttr(
 
 void AttributeChecker::visitSPIAccessControlAttr(SPIAccessControlAttr *attr) {
   if (auto VD = dyn_cast<ValueDecl>(D)) {
+    // VD must be public or open to use an @_spi attribute.
     auto declAccess = VD->getFormalAccess();
     if (declAccess < AccessLevel::Public) {
       diagnoseAndRemoveAttr(attr,
                             diag::spi_attribute_on_non_public,
                             declAccess,
                             D->getDescriptiveKind());
     }
+
+    // If VD is a public protocol requirement it can be SPI only if there's
+    // a default implementation.
+    if (auto protocol = dyn_cast<ProtocolDecl>(D->getDeclContext())) {
+      auto implementations = TypeChecker::lookupMember(
+                                             D->getDeclContext(),
+                                             protocol->getDeclaredType(),
+                                             VD->createNameRef(),
+                                             NameLookupFlags::ProtocolMembers);
+      bool hasDefaultImplementation = llvm::any_of(implementations,
+        [&](const LookupResultEntry &entry) {
+          auto entryDecl = entry.getValueDecl();
+          auto DC = entryDecl->getDeclContext();
+          auto extension = dyn_cast<ExtensionDecl>(DC);
+
+          // The implementation must be defined in the same module in
+          // an unconstrained extension.
+          if (!extension ||
+              extension->getParentModule() != protocol->getParentModule() ||
+              extension->isConstrainedExtension())
+            return false;
+
+          // For computed properties and subscripts, check that the default
+          // implementation defines `set` if the protocol declares it.
+          if (auto protoStorage = dyn_cast<AbstractStorageDecl>(VD))
+            if (auto entryStorage = dyn_cast<AbstractStorageDecl>(entryDecl))
+              if (protoStorage->getAccessor(AccessorKind::Set) &&
+                  !entryStorage->getAccessor(AccessorKind::Set))
+                return false;
+
+          return true;
+        });
+
+      if (!hasDefaultImplementation)
+        diagnoseAndRemoveAttr(attr,
+                              diag::spi_attribute_on_protocol_requirement,
+                              VD->getName());
+    }
   }
 }
 

test/SPI/protocol_requirement.swift

@@ -0,0 +1,71 @@
+// Test limitations on SPI protocol requirements.
+
+// RUN: %target-typecheck-verify-swift
+
+// Reject SPI protocol requirements without a default implementation.
+public protocol PublicProtoRejected {
+  @_spi(Private) // expected-error{{protocol requirement 'reqWithoutDefault()' cannot be declared '@_spi' without a default implementation in a protocol extension}}
+  func reqWithoutDefault()
+
+  @_spi(Private) // expected-error{{protocol requirement 'property' cannot be declared '@_spi' without a default implementation in a protocol extension}}
+  var property: Int { get set }
+
+  @_spi(Private) // expected-error{{protocol requirement 'propertyWithoutSetter' cannot be declared '@_spi' without a default implementation in a protocol extension}}
+  var propertyWithoutSetter: Int { get set }
+
+  @_spi(Private) // expected-error{{protocol requirement 'subscript(_:)' cannot be declared '@_spi' without a default implementation in a protocol extension}}
+  subscript(index: Int) -> Int { get set }
+
+  @_spi(Private) // expected-error{{protocol requirement 'init()' cannot be declared '@_spi' without a default implementation in a protocol extension}}
+  init()
+
+  @_spi(Private) // expected-error{{'@_spi' attribute cannot be applied to this declaration}}
+  associatedtype T
+}
+
+extension PublicProtoRejected {
+  @_spi(Private)
+  public var propertyWithoutSetter: Int { get { return 42 } }
+}
+
+extension PublicProtoRejected where Self : Equatable {
+  @_spi(Private)
+  public func reqWithoutDefault() {
+    // constrainted implementation
+  }
+}
+
+// Accept SPI protocol requirements with an implementation.
+public protocol PublicProto {
+  @_spi(Private)
+  func reqWithDefaultImplementation()
+
+  @_spi(Private)
+  var property: Int { get set }
+
+  @_spi(Private)
+  subscript(index: Int) -> Int { get set }
+
+  @_spi(Private)
+  init()
+}
+
+extension PublicProto {
+  @_spi(Private)
+  public func reqWithDefaultImplementation() { }
+
+  @_spi(Private)
+  public var property: Int {
+    get { return 42 }
+    set { }
+  }
+
+  @_spi(Private)
+  public subscript(index: Int) -> Int {
+    get { return 42 }
+    set { }
+  }
+
+  @_spi(Private)
+  public init() { }
+}