[Sema] Accept use of SPI in inlinable SPI declarations

rdar://63978500
rdar://63189125

Author: xymus

lib/Sema/ResilienceDiagnostics.cpp

@@ -71,10 +71,10 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
   if (D->getDeclContext()->isLocalContext())
     return false;
 
-  // Public non-SPI declarations are OK.
+  // Public declarations or SPI used from SPI are OK.
   if (D->getFormalAccessScope(/*useDC=*/nullptr,
                               Kind.allowUsableFromInline).isPublic() &&
-      !D->isSPI())
+      !(D->isSPI() && !DC->getInnermostDeclarationDeclContext()->isSPI()))
     return false;
 
   auto &Context = DC->getASTContext();
@@ -149,14 +149,15 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
 
 static bool diagnoseDeclExportability(SourceLoc loc, const ValueDecl *D,
                                       const SourceFile &userSF,
+                                      const DeclContext *userDC,
                                       FragileFunctionKind fragileKind) {
   assert(fragileKind.kind != FragileFunctionKind::None);
 
   auto definingModule = D->getModuleContext();
 
-  bool isImplementationOnly =
-    userSF.isImportedImplementationOnly(definingModule);
-  if (!isImplementationOnly && !userSF.isImportedAsSPI(D))
+  auto originKind = getDisallowedOriginKind(
+      D, userSF, userDC->getInnermostDeclarationDeclContext());
+  if (originKind == DisallowedOriginKind::None)
     return false;
 
   // TODO: different diagnostics
@@ -165,7 +166,7 @@ static bool diagnoseDeclExportability(SourceLoc loc, const ValueDecl *D,
                      D->getDescriptiveKind(), D->getName(),
                      static_cast<unsigned>(fragileKind.kind),
                      definingModule->getName(),
-                     static_cast<unsigned>(!isImplementationOnly));
+                     static_cast<unsigned>(originKind));
   return true;
 }
 
@@ -234,7 +235,7 @@ TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
     return false;
 
   const ValueDecl *D = declRef.getDecl();
-  if (diagnoseDeclExportability(loc, D, *userSF, fragileKind))
+  if (diagnoseDeclExportability(loc, D, *userSF, DC, fragileKind))
     return true;
   if (diagnoseGenericArgumentsExportability(loc, declRef.getSubstitutions(),
                                             *userSF, DC)) {

test/SPI/local_spi_decls.swift

@@ -7,14 +7,17 @@
 // RUN: %target-typecheck-verify-swift -I %t -verify-ignore-unknown -swift-version 5
 
 // SPI declarations
-@_spi(MySPI) public func spiFunc() {} // expected-note {{global function 'spiFunc()' is not '@usableFromInline' or public}}
+@_spi(MySPI) public func spiFunc() {} // expected-note 2 {{global function 'spiFunc()' is not '@usableFromInline' or public}}
 @_spi(+) public func invalidSPIName() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 @_spi(🤔) public func emojiNamedSPI() {}
 @_spi() public func emptyParensSPI() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 @_spi(set) public func keywordSPI() {} // expected-error {{expected an SPI identifier as subject of the '@_spi' attribute}}
 
-@_spi(S) public class SPIClass {} // expected-note 3 {{type declared here}}
-  // expected-note @-1 2 {{class 'SPIClass' is not '@usableFromInline' or public}}
+@_spi(S) public class SPIClass { // expected-note 5 {{type declared here}}
+  // expected-note @-1 3 {{class 'SPIClass' is not '@usableFromInline' or public}}
+  // expected-note @-2 {{class 'SPIClass' is not public}}
+  public init() {}
+}
 class InternalClass {} // expected-note 2 {{type declared here}}
 private class PrivateClass {} // expected-note 2 {{type declared here}}
 
@@ -31,13 +34,22 @@ func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is '@_spi' a
   _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
 }
 
-@_spi(S) public struct SPIStruct {} // expected-note 2 {{struct 'SPIStruct' is not '@usableFromInline' or public}}
+@_spi(S) public struct SPIStruct { // expected-note 2 {{struct 'SPIStruct' is not '@usableFromInline' or public}}
+  public init() {}
+}
 
 @frozen public struct FrozenStruct {
   @_spi(S) public var spiInFrozen = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
   // expected-error @-1 {{stored property 'spiInFrozen' cannot be declared '@_spi' in a '@frozen' struct}}
 
-  var asdf = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  var spiTypeInFrozen = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  private var spiTypeInFrozen1: SPIClass // expected-error {{cannot use class 'SPIClass' here; it is SPI}}
+}
+
+@_spi(S)
+@frozen public struct SPIFrozenStruct {
+  var spiTypeInFrozen = SPIStruct()
+  private var spiTypeInFrozen1: SPIClass
 }
 
 private protocol PrivateProtocol {} // expected-note {{type declared here}}
@@ -81,3 +93,22 @@ public struct NestedParent {
     public struct Nested { }
     let nested: Nested
 }
+
+public func publicFuncWithDefaultValue(_ p: SPIClass = SPIClass()) {} // expected-error {{cannot use class 'SPIClass' here; it is SPI}}
+// expected-error @-1 {{class 'SPIClass' is '@_spi' and cannot be referenced from a default argument value}}
+
+@_spi(S)
+public func spiFuncWithDefaultValue(_ p: SPIClass = SPIClass()) {}
+
+@inlinable
+public func inlinablePublic() {
+  spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+  let _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+}
+
+@_spi(S)
+@inlinable
+public func inlinableSPI() {
+  spiFunc()
+  let _ = SPIClass()
+}

test/SPI/private_swiftinterface.swift

@@ -162,6 +162,18 @@ extension IOIPublicStruct : LocalPublicProto {}
 // CHECK-PRIVATE-NOT: IOIPublicStruct
 // CHECK-PUBLIC-NOT: IOIPublicStruct
 
+@_spi(S)
+@frozen public struct SPIFrozenStruct {
+// CHECK-PRIVATE: struct SPIFrozenStruct
+// CHECK-PUBLIC-NOT: SPIFrozenStruct
+
+  var spiTypeInFrozen = SPIStruct()
+  // CHECK-PRIVATE: @_spi(S) internal var spiTypeInFrozen
+
+  private var spiTypeInFrozen1: SPIClass
+  // CHECK-PRIVATE: @_spi(S) private var spiTypeInFrozen1
+}
+
 // The dummy conformance should be only in the private swiftinterface for
 // SPI extensions.
 @_spi(LocalSPI)

test/SPI/spi_client.swift

@@ -53,8 +53,16 @@ public func publicUseOfSPI(param: SPIClass) -> SPIClass {} // expected-error 2{{
 public func publicUseOfSPI2() -> [SPIClass] {} // expected-error {{cannot use class 'SPIClass' here; it is an SPI imported from 'SPIHelper'}}
 
 @inlinable
-func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
+public func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
   spiFunc() // expected-error {{global function 'spiFunc()' is '@_spi' and cannot be referenced from an '@inlinable' function}}
   _ = SPIClass() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
   _ = [SPIClass]() // expected-error {{class 'SPIClass' is '@_spi' and cannot be referenced from an '@inlinable' function}}
 }
+
+@_spi(S)
+@inlinable
+public func inlinable() -> SPIClass {
+  spiFunc()
+  _ = SPIClass()
+  _ = [SPIClass]()
+}