safe.swift

// RUN: %target-typecheck-verify-swift -strict-memory-safety

// The feature flag should be enabled.
#if !hasFeature(StrictMemorySafety)
#error("Strict memory safety is not enabled!")
#endif


@unsafe
func unsafeFunction(){}

@unsafe
structUnsafeType{}

func f(){
unsafe unsafeFunction()
}

func g(){
unsafe unsafeFunction()
}

func h(_:UnsafeType){
// expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
unsafeFunction() // expected-note{{reference to unsafe global function 'unsafeFunction()'}}

 // okay
unsafe unsafeFunction()

 // expected-warning@+1{{no unsafe operations occur within 'unsafe' expression}}
unsafe g()
}

func rethrowing(body:(UnsafeType)throws->Void)rethrows{}

classHasStatics{
staticinternalfunc f(_:UnsafeType){}


}

@unsafe
func unsafeInt()->Int{5}

structHasProperties{
varcomputed:Int{
unsafe unsafeInt()
}

@unsafevarcomputedUnsafe:Int{
unsafe unsafeInt()
}

staticvarblah:Int={
unsafe unsafeInt()
}()

@unsafestaticvarblahUnsafe:Int={
unsafe unsafeInt()
}()
}

protocolP{}

extensionInt:@unsafeP{}

func acceptP(_:someP){}

func testConformance(i:Int){
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
acceptP(i) // expected-note{{'@unsafe' conformance of 'Int' to protocol 'P' involves unsafe code}}
}

func returnsOpaqueP()->someP{
5 // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 // expected-note@-1{{'@unsafe' conformance of 'Int' to protocol 'P' involves unsafe code}}
}

func returnsExistentialP()->anyP{
5 // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 // expected-note@-1{{'@unsafe' conformance of 'Int' to protocol 'P' involves unsafe code}}
}

// FIXME: Should work even if the IteratorProtocol conformance is safe
structUnsafeAsSequence:@unsafeSequence,@unsafeIteratorProtocol{
@unsafemutatingfunc next()->Int?{nil}
}

func testUnsafeAsSequenceForEach(){
letuas=UnsafeAsSequence()

 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{12-12=unsafe }}
for_in uas {} // expected-note{{conformance}}
 // expected-warning@-1{{for-in loop uses unsafe constructs but is not marked with 'unsafe'}}{{documentation-file=strict-memory-safety}}{{7-7=unsafe }}

for_in unsafe uas{} // expected-warning{{for-in loop uses unsafe constructs but is not marked with 'unsafe'}}{{documentation-file=strict-memory-safety}}{{7-7=unsafe }}

forunsafe _ in unsafe uas{} // okay
}

func testForInUnsafeAmbiguity(_ integers:[Int]){
forunsafein integers {
 _ = unsafe
}
forunsafe:Intin integers {
 _ = unsafe
}
}

structUnsafeIterator:@unsafeIteratorProtocol{
@unsafemutatingfunc next()->Int?{nil}
}

structSequenceWithUnsafeIterator:Sequence{
func makeIterator()->UnsafeIterator{UnsafeIterator()}
}

func testUnsafeIteratorForEach(){
letswui=SequenceWithUnsafeIterator()

for_in swui {} // expected-warning{{for-in loop uses unsafe constructs but is not marked with 'unsafe'}}{{7-7=unsafe }}
forunsafe _ in swui {} // okay, it's only the iterator that's unsafe
}

classMyRange{
@unsafeinit(unchecked bounds:Range<Int>){}

convenienceinit(_ bounds:Range<Int>){
 // bounds check
self.init(unchecked: bounds) // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 // expected-note@-1{{reference to unsafe initializer 'init(unchecked:)'}}
}
}

func casting(value:Any, i:Int){
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 _ = value as?UnsafeType // expected-note{{reference to unsafe type 'UnsafeType'}}
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 _ = value as!UnsafeType // expected-note{{reference to unsafe type 'UnsafeType'}}

 _ = unsafe value as?UnsafeType
 _ = unsafe value as!UnsafeType

 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 _ = i asanyP // expected-note{{'@unsafe' conformance of 'Int' to protocol 'P' involves unsafe code}}
}

func metatypes(){
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
let _:Any.Type=UnsafeType.self // expected-note{{reference to unsafe type 'UnsafeType'}}

let _:Any.Type=unsafe UnsafeType.self
}

func testKeyPath(){
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}
 _ = \HasProperties.computedUnsafe // expected-note{{reference to unsafe property 'computedUnsafe'}}

 _ = unsafe \HasProperties.computedUnsafe
}

func takesAutoclosure<T>(_ body:@autoclosure()->T){}

func testAutoclosure(){
 // expected-warning@+1{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{3-3=unsafe }}
takesAutoclosure(unsafeFunction()) // expected-note{{reference to unsafe global function 'unsafeFunction()'}}

unsafe takesAutoclosure(unsafeFunction())

takesAutoclosure(unsafe unsafeFunction())
}

// Parsing of `unsafe` expressions.
func testUnsafePositionError()->Int{
return3+ unsafe unsafeInt() // expected-error{{'unsafe' cannot appear to the right of a non-assignment operator}}
}

enumColor{
case red
}

func acceptBools(_:Bool, _:Bool){}

func acceptBoolsUnsafeLabel(unsafe _:Bool, _:Bool){}

func unsafe(_:Int){}

func unsafeFun(){
varunsafe=true
 unsafe =false
 unsafe.toggle()
 _ =[unsafe]
 _ ={ unsafe }
acceptBools(unsafe, unsafe)
acceptBoolsUnsafeLabel(unsafe: unsafe, unsafe)

letcolor:Color
 // expected-warning@+1{{no unsafe operations occur within 'unsafe' expression}}{{11-18=}}
 color = unsafe .red
 _ = color

if unsafe {}
}

func moreUnsafeFunc(unsafe:[Int]){
let _:[Int]=unsafe[]
 // expected-warning@-1{{no unsafe operations occur within 'unsafe' expression}}

 _ =unsafe[1]

 _ ="\(unsafe)"
}

func yetMoreUnsafeFunc(unsafe:()->Void){
unsafe()

 _ =unsafe()
 // expected-warning@-1{{no unsafe operations occur within 'unsafe' expression}}
}

// @safe suppresses unsafe-type-related diagnostics on an entity
structMyArray<Element>{
@safefunc withUnsafeBufferPointer<R, E>(
 _ body:(UnsafeBufferPointer<Element>)throws(E)->R
)throws(E)->R{
return unsafe trybody(.init(start:nil, count:0))
}
}

extensionUnsafeBufferPointer{
@unsafevarunsafeCount:Int{17}
@safevarsafeCount:Int{ unsafe unsafeCount }
}

func testMyArray(ints:MyArray<Int>){
 ints.withUnsafeBufferPointer{ buffer in
letbufferCopy= unsafe buffer
 _ = unsafe bufferCopy

print(buffer.safeCount)
unsafe print(buffer.unsafeCount)
}
}

func testUnsafeLHS(){
@unsafevarvalue:Int=0
 unsafe value =switch unsafe value {
case0:1
default:0
}
}

@safe
structUnsafeWrapTest{
varpointer:UnsafeMutablePointer<Int>?

func test(){
iflet pointer { // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{19-19= = unsafe pointer}}
 // expected-note@-1{{reference to property 'pointer' involves unsafe type 'UnsafeMutablePointer<Int>'}}
 _ = unsafe pointer
}
}

func otherTest(pointer:UnsafeMutablePointer<Int>?){
iflet pointer { // expected-warning{{expression uses unsafe constructs but is not marked with 'unsafe'}}{{19-19= = unsafe pointer}}
 // expected-note@-1{{reference to parameter 'pointer' involves unsafe type 'UnsafeMutablePointer<Int>}}
 _ = unsafe pointer
}
}
}

@safe@unsafe
structConfusedStruct{} // expected-error{{struct 'ConfusedStruct' cannot be both '@safe' and '@unsafe'}}

@unsafe
structUnsafeContainingUnspecified{
typealiasA=Int

func getA()->A{0}

@safe
structY{
varvalue:Int
}

func f(){
 _ =Y(value:5)
}
}


@unsafefunc f(x:UnsafeContainingUnspecified){
leta=unsafe x.getA()
 _ = a
}

extensionSlice{
 // Make sure we aren't diagnosing the 'defer' as unsafe.
publicfunc withContiguousMutableStorageIfAvailable<R, Element>(
 _ body:(_ buffer:inoutUnsafeMutableBufferPointer<Element>)throws->R
)rethrows->R?where Base ==UnsafeMutableBufferPointer<Element>{
tryunsafe base.withContiguousStorageIfAvailable{ buffer in
letstart=unsafe base.baseAddress?.advanced(by: startIndex)
varslice=unsafe UnsafeMutableBufferPointer(start: start, count: count)
defer{
}
returntryunsafe body(&slice)
}
}
}