features.swift

// RUN: %empty-directory(%t)

// RUN: %target-swift-emit-module-interface(%t/FeatureTest.swiftinterface) %s -module-name FeatureTest -disable-availability-checking
// RUN: %target-swift-typecheck-module-from-interface(%t/FeatureTest.swiftinterface) -module-name FeatureTest -disable-availability-checking
// RUN: %FileCheck %s < %t/FeatureTest.swiftinterface

// REQUIRES: concurrency

// Ensure that when we emit a Swift interface that makes use of new features,
// the uses of those features are guarded by appropriate #if's that allow older
// compilers to skip over the uses of newer features.

// CHECK: #if compiler(>=5.3) && $SpecializeAttributeWithAvailability
// CHECK: @_specialize(exported: true, kind: full, availability: macOS, introduced: 12; where T == Swift.Int)
// CHECK: public func specializeWithAvailability<T>(_ t: T)
// CHECK: #else
// CHECK: public func specializeWithAvailability<T>(_ t: T)
// CHECK: #endif
@_specialize(exported:true, availability: macOS 12,*;where T == Int)
publicfunc specializeWithAvailability<T>(_ t:T){
}

// CHECK: #if compiler(>=5.3) && $Actors
// CHECK-NEXT: public actor MyActor
// CHECK: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
// CHECK-NEXT: get
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: #endif
publicactorMyActor{
}

// CHECK: #if compiler(>=5.3) && $Actors
// CHECK-NEXT: extension FeatureTest.MyActor
publicextensionMyActor{
 // CHECK-NOT: $Actors
 // CHECK: testFunc
func testFunc()async{}
 // CHECK: }
 // CHECK-NEXT: #endif
}

// CHECK: #if compiler(>=5.3) && $AsyncAwait
// CHECK-NEXT: globalAsync
// CHECK-NEXT: #endif
publicfunc globalAsync()async{}

// CHECK: @_marker public protocol MP {
// CHECK-NEXT: }
@_markerpublicprotocolMP{}

// CHECK: @_marker public protocol MP2 : FeatureTest.MP {
// CHECK-NEXT: }
@_markerpublicprotocolMP2:MP{}

// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
// CHECK: public protocol MP3 : AnyObject, FeatureTest.MP {
// CHECK-NEXT: }
publicprotocolMP3:AnyObject,MP{}

// CHECK: extension FeatureTest.MP2 {
// CHECK-NEXT: func inMP2
extensionMP2{
publicfunc inMP2(){}
}

// CHECK: class OldSchool : FeatureTest.MP {
publicclassOldSchool:MP{
 // CHECK: #if compiler(>=5.3) && $AsyncAwait
 // CHECK-NEXT: takeClass()
 // CHECK-NEXT: #endif
publicfunc takeClass()async{}
}

// CHECK: class OldSchool2 : FeatureTest.MP {
publicclassOldSchool2:MP{
 // CHECK: #if compiler(>=5.3) && $AsyncAwait
 // CHECK-NEXT: takeClass()
 // CHECK-NEXT: #endif
publicfunc takeClass()async{}
}

// CHECK: #if compiler(>=5.3) && $RethrowsProtocol
// CHECK-NEXT: @rethrows public protocol RP
@rethrowspublicprotocolRP{
func f()throws->Bool
}

// CHECK: public struct UsesRP {
publicstructUsesRP{
 // CHECK: #if compiler(>=5.3) && $RethrowsProtocol
 // CHECK-NEXT: public var value: (any FeatureTest.RP)? {
 // CHECK-NOT: #if compiler(>=5.3) && $RethrowsProtocol
 // CHECK: get
publicvarvalue:RP?{
nil
}
}

// CHECK: #if compiler(>=5.3) && $RethrowsProtocol
// CHECK-NEXT: public struct IsRP
publicstructIsRP:RP{
 // CHECK-NEXT: public func f()
publicfunc f()->Bool{}

 // CHECK-NOT: $RethrowsProtocol
 // CHECK-NEXT: public var isF: 
 // CHECK-NEXT: get
publicvarisF:Bool{
f()
}
}

// CHECK: #if compiler(>=5.3) && $RethrowsProtocol
// CHECK-NEXT: public func acceptsRP
publicfunc acceptsRP<T:RP>(_:T){}

// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
// CHECK: extension Swift.Array : FeatureTest.MP where Element : FeatureTest.MP {
extensionArray:FeatureTest.MPwhere Element :FeatureTest.MP{}
// CHECK: }

// CHECK-NOT: #if compiler(>=5.3) && $MarkerProtocol
// CHECK: extension FeatureTest.OldSchool : Swift.UnsafeSendable {
extensionOldSchool:UnsafeSendable{}
// CHECK-NEXT: }


// CHECK: #if compiler(>=5.3) && $AsyncAwait
// CHECK-NEXT: func runSomethingSomewhere
// CHECK-NEXT: #endif
publicfunc runSomethingSomewhere(body:()async->Void){}

// CHECK: #if compiler(>=5.3) && $Sendable
// CHECK-NEXT: func runSomethingConcurrently(body: @Sendable () -> 
// CHECK-NEXT: #endif
publicfunc runSomethingConcurrently(body:@Sendable()->Void){}

// CHECK: #if compiler(>=5.3) && $Actors
// CHECK-NEXT: func stage
// CHECK-NEXT: #endif
publicfunc stage(with actor:MyActor){}

// CHECK: #if compiler(>=5.3) && $AsyncAwait && $Sendable && $InheritActorContext
// CHECK-NEXT: func asyncIsh
// CHECK-NEXT: #endif
publicfunc asyncIsh(@_inheritActorContext operation:@Sendable@escaping()async->Void){}

// CHECK: #if compiler(>=5.3) && $AsyncAwait
// CHECK-NEXT: #if $UnsafeInheritExecutor
// CHECK-NEXT: @_unsafeInheritExecutor public func unsafeInheritExecutor() async
// CHECK-NEXT: #else
// CHECK-NEXT: public func unsafeInheritExecutor() async
// CHECK-NEXT: #endif
// CHECK-NEXT: #endif
@_unsafeInheritExecutor
publicfunc unsafeInheritExecutor()async{}

// CHECK: #if compiler(>=5.3) && $AsyncAwait
// CHECK-NEXT: #if $UnsafeInheritExecutor
// CHECK-NEXT: @_specialize{{.*}}
// CHECK-NEXT: @_unsafeInheritExecutor public func multipleSuppressible<T>(value: T) async
// CHECK-NEXT: #elseif $SpecializeAttributeWithAvailability
// CHECK-NEXT: @_specialize{{.*}}
// CHECK-NEXT: public func multipleSuppressible<T>(value: T) async
// CHECK-NEXT: #else
// CHECK-NEXT: public func multipleSuppressible<T>(value: T) async
// CHECK-NEXT: #endif
// CHECK-NEXT: #endif
@_unsafeInheritExecutor
@_specialize(exported:true, availability: SwiftStdlib 5.1,*;where T == Int)
publicfunc multipleSuppressible<T>(value:T)async{}

// CHECK: #if compiler(>=5.3) && $UnavailableFromAsync
// CHECK-NEXT: @_unavailableFromAsync(message: "Test") public func unavailableFromAsyncFunc()
// CHECK-NEXT: #else
// CHECK-NEXT: public func unavailableFromAsyncFunc()
// CHECK-NEXT: #endif
@_unavailableFromAsync(message:"Test")
publicfunc unavailableFromAsyncFunc(){}

// CHECK: #if compiler(>=5.3) && $NoAsyncAvailability
// CHECK-NEXT: @available(*, noasync, message: "Test")
// CHECK-NEXT: public func noAsyncFunc()
// CHECK-NEXT: #else
// CHECK-NEXT: public func noAsyncFunc()
// CHECK-NEXT: #endif
@available(*, noasync, message:"Test")
publicfunc noAsyncFunc(){}

// CHECK-NOT: extension FeatureTest.MyActor : Swift.Sendable