availability_weak_linking.swift

// RUN: %empty-directory(%t)
// RUN: cp -R %S/Inputs/FakeUnavailableObjCFramework.framework %t
// RUN: %target-clang -dynamiclib %S/Inputs/FakeUnavailableObjCFramework.m -fmodules -F %t -framework Foundation -o %t/FakeUnavailableObjCFramework.framework/FakeUnavailableObjCFramework
// RUN: %target-codesign %t/FakeUnavailableObjCFramework.framework/FakeUnavailableObjCFramework
// RUN: %target-build-swift-dylib(%t/%target-library-name(FakeUnavailableSwiftDylib)) -emit-module -emit-module-path %t/FakeUnavailableSwiftDylib.swiftmodule %S/Inputs/FakeUnavailableSwiftDylib.swift
// RUN: %target-codesign %t/%target-library-name(FakeUnavailableSwiftDylib)
// RUN: %target-build-swift %t/%target-library-name(FakeUnavailableSwiftDylib) -I %t -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework
// RUN: %target-build-swift -O %t/%target-library-name(FakeUnavailableSwiftDylib) -I %t -F %t %s -o %t/UseWeaklinkedUnavailableObjCFramework.opt

// These tests emulate deploying back to an older OS where newer APIs are not
// available by linking to an Objective-C framework where APIs have been
// annotated to only be available in the far future (version 1066.0 of all
// platforms) and then moving the framework aside so that it can't be found
// at run time.
// RUN: mv %t/FakeUnavailableObjCFramework.framework %t/FakeUnavailableObjCFramework-MovedAside.framework
// RUN: mv %t/%target-library-name(FakeUnavailableSwiftDylib) %t/%target-library-name(FakeUnavailableSwiftDylib)-MovedAside

// RUN: %target-codesign %t/UseWeaklinkedUnavailableObjCFramework
// RUN: %target-codesign %t/UseWeaklinkedUnavailableObjCFramework.opt
// RUN: %target-run %t/UseWeaklinkedUnavailableObjCFramework | %FileCheck %s
// RUN: %target-run %t/UseWeaklinkedUnavailableObjCFramework.opt | %FileCheck %s

// REQUIRES: objc_interop
// REQUIRES: executable_test

import StdlibUnittest


import FakeUnavailableObjCFramework
import FakeUnavailableSwiftDylib
import Foundation

// CHECK: Running
print("Running...")

func useUnavailableObjCGlobal(){
if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letg= UnavailableObjCGlobalVariable
_blackHole(g)
}
}

useUnavailableObjCGlobal()

@objc
classClassConformingToUnavailableObjCProtocol:NSObject,UnavailableObjCProtocol{
func someMethod(){
print("Executed ClassConformingToUnavailableObjCProtocol.someMethod()")
}
}

func useClassConformingToUnavailableObjCProtocol(){
leto=ClassConformingToUnavailableObjCProtocol()
 o.someMethod()

if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letoAsUP:UnavailableObjCProtocol= o asUnavailableObjCProtocol
 oAsUP.someMethod()
}
}

// CHECK-NEXT: Executed ClassConformingToUnavailableObjCProtocol.someMethod()
useClassConformingToUnavailableObjCProtocol()

@objc
classClassThatWillBeExtendedToConformToUnavailableObjCProtocol:NSObject{
}

extensionClassThatWillBeExtendedToConformToUnavailableObjCProtocol:UnavailableObjCProtocol{
func someMethod(){
print("Executed ClassThatWillBeExtendedToConformToUnavailableObjCProtocol.someMethod()")
}
}

func useClassThatWillBeExtendedToConformToUnavailableObjCProtocol(){
leto=ClassThatWillBeExtendedToConformToUnavailableObjCProtocol()
 o.someMethod()

if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letoAsUP:UnavailableObjCProtocol= o asUnavailableObjCProtocol
 oAsUP.someMethod()
}
}

// CHECK-NEXT: Executed ClassThatWillBeExtendedToConformToUnavailableObjCProtocol.someMethod()
useClassThatWillBeExtendedToConformToUnavailableObjCProtocol()

// We need to gracefully handle ObjC protocols missing availability annotations
// because it is quite common in frameworks. (Historically, for Objective-C,
// missing availability annotations on protocols has not been problematic
// because Objective-C protocol metadata is compiled into any code that
// references it -- it is not weakly linked.)

@objc
classClassConformingToUnannotatedUnavailableObjCProtocol:NSObject,UnannotatedUnavailableObjCProtocol{
func someMethod(){
print("Executed ClassConformingToUnannotatedUnavailableObjCProtocol.someMethod()")
}
}

func useClassConformingToUnannotatedUnavailableObjCProtocol(){
leto=ClassConformingToUnannotatedUnavailableObjCProtocol()
 o.someMethod()

letoAsUP:UnannotatedUnavailableObjCProtocol=(o asAnyObject)as!UnannotatedUnavailableObjCProtocol
 oAsUP.someMethod()
}

// CHECK-NEXT: Executed ClassConformingToUnannotatedUnavailableObjCProtocol.someMethod()
// CHECK-NEXT: Executed ClassConformingToUnannotatedUnavailableObjCProtocol.someMethod()
useClassConformingToUnannotatedUnavailableObjCProtocol()

func printClassMetadataViaGeneric<T>()->T{
print("\(T.self)")
fatalError("This should never be called")
}

func useUnavailableObjCClass(){
if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
leto=UnavailableObjCClass()
 o.someMethod()
}

foriin0..<getInt(5){
if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
leto:UnavailableObjCClass=printClassMetadataViaGeneric()
_blackHole(o)
}
}

classSomeClass{}
letsomeObject:AnyObject=_opaqueIdentity(SomeClass()asAnyObject)

foriin0..<getInt(5){
if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letisUnavailable= someObject is UnavailableObjCClass
_blackHole(isUnavailable)
}
}

foriin0..<getInt(5){
if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letasUnavailable= someObject as?UnavailableObjCClass
_blackHole(asUnavailable)
}
}
}

@available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0,*)
func wrapUnavailableFunction(){
someFunction()
}

useUnavailableObjCClass()

// Allow extending a weakly-linked class to conform to a protocol.
protocolSomeSwiftProtocol{}
@available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*)
extensionUnavailableObjCClass:SomeSwiftProtocol{
}
@available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*)
extensionUnavailableSwiftClass:SomeSwiftProtocol{
}

func checkSwiftProtocolConformance(){
 // Make sure the runtime doesn't crash in the presence of a conformance
 // record for a class that doesn't exist at runtime.
letx:Any=42
_blackHole(x as?SomeSwiftProtocol)
}

checkSwiftProtocolConformance()

classClassConformingToUnavailableSwiftProtocol:UnavailableSwiftProtocol{
func someMethod(){
print("Executed ClassConformingToUnavailableSwiftProtocol.someMethod()")
}
}

func useClassConformingToUnavailableSwiftProtocol(){
leto=ClassConformingToUnavailableSwiftProtocol()
 o.someMethod()

if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letoAsUP:UnavailableSwiftProtocol= o asUnavailableSwiftProtocol
 oAsUP.someMethod()
}
}

// CHECK-NEXT: Executed ClassConformingToUnavailableSwiftProtocol.someMethod()
useClassConformingToUnavailableSwiftProtocol()

classClassThatWillBeExtendedToConformToUnavailableSwiftProtocol{
}

extensionClassThatWillBeExtendedToConformToUnavailableSwiftProtocol:UnavailableSwiftProtocol{
func someMethod(){
print("Executed ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol.someMethod()")
}
}

func useClassThatWillBeExtendedToConformToUnavailableSwiftProtocol(){
leto=ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol()
 o.someMethod()

if #available(OSX 1066.0, iOS 1066.0, watchOS 1066.0, tvOS 1066.0, visionOS 1066.0,*){
letoAsUP:UnavailableSwiftProtocol= o asUnavailableSwiftProtocol
 oAsUP.someMethod()
}
}

// CHECK-NEXT: Executed ClassThatWillBeExtendedToConformToUnavailableSwiftProtocol.someMethod()
useClassThatWillBeExtendedToConformToUnavailableSwiftProtocol()

// CHECK-NEXT: Done
print("Done")