[SPI Test] Extend and update SPI tests

Author: xymus

test/SPI/Inputs/spi_helper.swift

@@ -14,7 +14,29 @@ func internalFunc() {}
   @_spi(HelperSPI) public init() { print("SPIStruct.init") }
   @_spi(HelperSPI) public func spiMethod() { print("SPIStruct.spiMethod") }
   @_spi(HelperSPI) public var spiVar = "text"
-  //@_spi(HelperSPI) public subscript(index: Int) -> String { return spiVar } // TODO SPI support for subscripts
+
+  @_spi(HelperSPI) public var spiComputedVar: Int {
+    get { return 42 }
+    set {}
+  }
+
+  @_spi(HelperSPI) public var spiComputedVarInherit: Int {
+    @_spi(HelperSPI) get { return 42 }
+    @_spi(HelperSPI) set {}
+  }
+  @_spi(HelperSPI) public subscript(index: Int) -> String { return spiVar }
+
+  public func spiInherit() {}
+  @_spi(DifferentSPI) public func spiDontInherit() {}
+}
+
+public extension SPIStruct {
+  func spiExtensionHidden() {}
+  @_spi(HelperSPI) func spiExtension() {}
+}
+
+@_spi(HelperSPI) public extension SPIStruct {
+  func spiExtensionInherited() {}
 }
 
 @_spi(HelperSPI) public class SPIClass {

test/SPI/local_spi_decls.swift

@@ -18,30 +18,30 @@ private class PrivateClass {} // expected-note 2 {{type declared here}}
 @_spi(S) public protocol SPIProtocol {} // expected-note {{type declared here}}
 
 @_spi(S) public func useOfSPITypeOk(_ p0: SPIProtocol, p1: SPIClass) -> SPIClass { fatalError() } // OK
-public func useOfSPITypeInvalid() -> SPIClass { fatalError() } // expected-error {{function cannot be declared public because its result uses an internal type}} // TODO misleading "internal" message
-@_spi(S) public func spiUseOfInternalType() -> InternalClass { fatalError() } // expected-error{{function cannot be declared '@_spi' because its result uses an internal type without a compatible '@_spi'}}
-@_spi(S) public func spiUseOfPrivateType(_ a: PrivateClass)  { fatalError() } // expected-error{{function cannot be declared public because its parameter uses a private type}}
+public func useOfSPITypeInvalid() -> SPIClass { fatalError() } // expected-error {{function cannot be declared public because its result uses an '@_spi' type}}
+@_spi(S) public func spiUseOfInternalType() -> InternalClass { fatalError() } // expected-error{{function cannot be declared '@_spi' because its result uses an internal type}}
+@_spi(S) public func spiUseOfPrivateType(_ a: PrivateClass)  { fatalError() } // expected-error{{function cannot be declared '@_spi' because its parameter uses a private type}}
 
 @inlinable
-func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is internal and cannot be referenced from an '@inlinable' function}}
-  spiFunc() // expected-error {{global function 'spiFunc()' is internal and cannot be referenced from an '@inlinable' function}}
-  _ = SPIClass() // expected-error {{class 'SPIClass' is internal and cannot be referenced from an '@inlinable' function}}
+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}}
 }
 
 @_spi(S) public struct SPIStruct {} // expected-note 2 {{struct 'SPIStruct' is not '@usableFromInline' or public}}
 
 @frozen public struct FrozenStruct {
-  @_spi(S) public var asdf = SPIStruct() // expected-error {{struct 'SPIStruct' is internal and cannot be referenced from a property initializer in a '@frozen' type}}
-  var asdf = SPIStruct() // expected-error {{struct 'SPIStruct' is internal and cannot be referenced from a property initializer in a '@frozen' type}}
+  @_spi(S) public var asdf = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
+  var asdf = SPIStruct() // expected-error {{struct 'SPIStruct' is '@_spi' and cannot be referenced from a property initializer in a '@frozen' type}}
 }
 
 private protocol PrivateProtocol {} // expected-note {{type declared here}}
 
 @_spi(S) public class BadSubclass : InternalClass {} // expected-error{{class cannot be declared public because its superclass is internal}}
 @_spi(S) public class OkSPISubclass : SPIClass {} // OK
-public class BadPublicClass : SPIClass {} // expected-error {{class cannot be declared public because its superclass is internal}}
+public class BadPublicClass : SPIClass {} // expected-error {{class cannot be declared public because its superclass is '@_spi'}}
 @_spi(S) public class BadSPIClass : PrivateClass {} // expected-error {{class cannot be declared public because its superclass is private}}
 
 @_spi(s) public func genFunc<T: PrivateProtocol>(_ t: T) {} // expected-error {{global function cannot be declared public because its generic parameter uses a private type}}
-public func genFuncBad<T: SPIProtocol>(_ t: T) {} // expected-error {{global function cannot be declared public because its generic parameter uses an internal type}}
+public func genFuncBad<T: SPIProtocol>(_ t: T) {} // expected-error {{global function cannot be declared public because its generic parameter uses an '@_spi' type}}
 @_spi(S) public func genFuncSPI<T: SPIProtocol>(_ t: T) {} // OK

test/SPI/private_swiftinterface.swift

@@ -8,6 +8,7 @@
 // RUN: %FileCheck -check-prefix=CHECK-HELPER %s < %t/SPIHelper.swiftinterface
 // CHECK-HELPER-NOT: HelperSPI
 // CHECK-HELPER-NOT: @_spi
+// RUN: %target-swift-frontend -emit-module %t/SPIHelper.swiftinterface -emit-module-path %t/SPIHelper-from-public-swiftinterface.swiftmodule -swift-version 5 -module-name SPIHelper -enable-library-evolution
 
 /// Test the textual interfaces generated from this test.
 // RUN: %target-swift-frontend -typecheck %s -emit-module-interface-path %t/main.swiftinterface -emit-private-module-interface-path %t/main.private.swiftinterface -enable-library-evolution -swift-version 5 -I %t
@@ -34,10 +35,13 @@ public func foo() {}
 // CHECK-PUBLIC-NOT: localSPIFunc()
 
 // SPI declarations
-@_spi(MySPI) public class SPIClassLocal {}
+@_spi(MySPI) public class SPIClassLocal {
 // CHECK-PRIVATE: @_spi(MySPI) public class SPIClassLocal
 // CHECK-PUBLIC-NOT: class SPIClassLocal
 
+  public init() {}
+}
+
 @_spi(MySPI) public extension SPIClassLocal {
 // CHECK-PRIVATE: @_spi(MySPI) extension SPIClassLocal
 // CHECK-PUBLIC-NOT: extension SPIClassLocal
@@ -46,9 +50,19 @@ public func foo() {}
   // CHECK-PRIVATE: @_spi(MySPI) public func extensionMethod
   // CHECK-PUBLIC-NOT: func extensionMethod
 
-  func internalExtensionMethod() {}
+  internal func internalExtensionMethod() {}
   // CHECK-PRIVATE-NOT: internalExtensionMethod
   // CHECK-PUBLIC-NOT: internalExtensionMethod
+
+  func inheritedSPIExtensionMethod() {}
+  // CHECK-PRIVATE: inheritedSPIExtensionMethod
+  // CHECK-PUBLIC-NOT: inheritedSPIExtensionMethod
+}
+
+public extension SPIClassLocal {
+  internal func internalExtensionMethode1() {}
+  // CHECK-PRIVATE-NOT: internalExtensionMethod1
+  // CHECK-PUBLIC-NOT: internalExtensionMethod1
 }
 
 class InternalClassLocal {}

test/SPI/public_client.swift

@@ -29,9 +29,9 @@ SPIEnum().spiMethod() // expected-error {{use of unresolved identifier}}
 
 var ps = PublicStruct()
 let _ = PublicStruct(alt_init: 1) // expected-error {{argument passed to call that takes no arguments}}
-ps.spiMethod() // expected-error {{'spiMethod' is inaccessible due to 'internal' protection level}} // TODO SPI specific diagnostics and suggest SPI to import
-ps.spiVar = "write" // expected-error {{'spiVar' is inaccessible due to 'internal' protection level}}
-print(ps.spiVar) // expected-error {{'spiVar' is inaccessible due to 'internal' protection level}}
+ps.spiMethod() // expected-error {{'spiMethod' is inaccessible due to '@_spi' protection level}} // TODO SPI specific diagnostics and suggest SPI to import
+ps.spiVar = "write" // expected-error {{'spiVar' is inaccessible due to '@_spi' protection level}}
+print(ps.spiVar) // expected-error {{'spiVar' is inaccessible due to '@_spi' protection level}}
 
 otherApiFunc() // expected-error {{use of unresolved identifier}}
 

test/SPI/spi_client.swift

@@ -30,6 +30,11 @@ print(c.spiVar)
 
 let s = SPIStruct()
 s.spiMethod()
+s.spiInherit()
+s.spiDontInherit() // expected-error {{'spiDontInherit' is inaccessible due to '@_spi' protection level}}
+s.spiExtensionHidden()
+s.spiExtension()
+s.spiExtensionInherited()
 s.spiVar = "write"
 print(s.spiVar)
 
@@ -45,10 +50,13 @@ print(ps.spiVar)
 otherApiFunc() // expected-error {{use of unresolved identifier}}
 
 public func publicUseOfSPI(param: SPIClass) -> SPIClass {} // expected-error 2{{cannot use class 'SPIClass' here; it is an SPI imported from 'SPIHelper'}}
+// expected-error@-1 {{function cannot be declared public because its parameter uses an '@_spi' type}}
 public func publicUseOfSPI2() -> [SPIClass] {} // expected-error {{cannot use class 'SPIClass' here; it is an SPI imported from 'SPIHelper'}}
+// expected-error@-1 {{function cannot be declared public because its result uses an '@_spi' type}}
 
 @inlinable
-func inlinable() -> SPIClass { // expected-error {{class 'SPIClass' is imported as SPI; it cannot be referenced from an '@inlinable' function}}
-  spiFunc() // expected-error {{global function 'spiFunc()' is imported as SPI; it cannot be referenced from an '@inlinable' function}}
-  _ = SPIClass() // expected-error {{class 'SPIClass' is imported as SPI; it cannot be referenced from an '@inlinable' function}}
+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}}
 }