mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
cbc0ec3b88
These are tests that fail in the next commit without this flag. This does not add -verify-ignore-unrelated to all tests with -verify, only the ones that would fail without it. This is NFC since this flag is currently a no-op.
360 lines
18 KiB
Swift
360 lines
18 KiB
Swift
// RUN: %empty-directory(%t)
|
|
|
|
// RUN: %gyb -DOPT_KIND=None %s -o %t/pointer_conversion.swift
|
|
// RUN: %line-directive %t/pointer_conversion.swift -- %target-swift-frontend -typecheck -verify -verify-ignore-unrelated %t/pointer_conversion.swift
|
|
|
|
// RUN: %gyb -DOPT_KIND=Optional %s -o %t/pointer_conversion_opt.swift
|
|
// RUN: %line-directive %t/pointer_conversion_opt.swift -- %target-swift-frontend -typecheck -verify -verify-ignore-unrelated %t/pointer_conversion_opt.swift
|
|
|
|
// RUN: %gyb -DOPT_KIND=ImplicitlyUnwrappedOptional %s -o %t/pointer_conversion_iuo.swift
|
|
// RUN: %line-directive %t/pointer_conversion_iuo.swift -- %target-swift-frontend -typecheck -verify -verify-ignore-unrelated %t/pointer_conversion_iuo.swift
|
|
|
|
%{
|
|
if OPT_KIND == 'Optional':
|
|
suffix='?'
|
|
elif OPT_KIND == 'ImplicitlyUnwrappedOptional':
|
|
suffix='!'
|
|
else:
|
|
suffix=''
|
|
}%
|
|
|
|
class C {}
|
|
class D {}
|
|
|
|
func takesMutablePointer(_ x: UnsafeMutablePointer<Int>${suffix}) {}
|
|
func takesMutableVoidPointer(_ x: UnsafeMutableRawPointer${suffix}) {}
|
|
func takesMutableRawPointer(_ x: UnsafeMutableRawPointer${suffix}) {}
|
|
func takesMutableInt8Pointer(_ x: UnsafeMutablePointer<Int8>${suffix}) {}
|
|
func takesMutableArrayPointer(_ x: UnsafeMutablePointer<[Int]>${suffix}) {}
|
|
@discardableResult
|
|
func takesConstPointer(_ x: UnsafePointer<Int>${suffix}) -> Character { return "x" }
|
|
func takesConstInt8Pointer(_ x: UnsafePointer<Int8>${suffix}) {}
|
|
func takesConstUInt8Pointer(_ x: UnsafePointer<UInt8>${suffix}) {}
|
|
func takesConstVoidPointer(_ x: UnsafeRawPointer${suffix}) {}
|
|
func takesConstRawPointer(_ x: UnsafeRawPointer${suffix}) {}
|
|
|
|
func mutablePointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
cp: UnsafePointer<Int>) {
|
|
takesMutablePointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesMutablePointer(p)
|
|
takesMutablePointer(cp) // expected-error{{cannot convert value of type 'UnsafePointer<Int>' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesMutablePointer(&i)
|
|
takesMutablePointer(&f) // expected-error{{cannot convert value of type 'UnsafeMutablePointer<Float>' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Float' and 'Int') are expected to be equal}}
|
|
takesMutablePointer(i) // expected-error{{cannot convert value of type 'Int' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
takesMutablePointer(f) // expected-error{{cannot convert value of type 'Float' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
var ii: [Int] = [0, 1, 2]
|
|
var ff: [Float] = [0, 1, 2]
|
|
takesMutablePointer(&ii)
|
|
takesMutablePointer(&ff) // expected-error{{cannot convert value of type 'UnsafeMutablePointer<Float>' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Float' and 'Int') are expected to be equal}}
|
|
takesMutablePointer(ii) // expected-error{{cannot convert value of type '[Int]' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
takesMutablePointer(ff) // expected-error{{cannot convert value of type '[Float]' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
|
|
takesMutableArrayPointer(&i) // expected-error{{cannot convert value of type 'UnsafeMutablePointer<Int>' to expected argument type 'UnsafeMutablePointer<[Int]>'}}
|
|
//expected-note@-1 {{arguments to generic parameter 'Pointee' ('Int' and '[Int]') are expected to be equal}}
|
|
takesMutableArrayPointer(&ii)
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafeMutablePointer<Int> = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = &ii // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
_ = x
|
|
}
|
|
|
|
func mutableVoidPointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
cp: UnsafePointer<Int>,
|
|
fp: UnsafeMutablePointer<Float>) {
|
|
takesMutableVoidPointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesMutableVoidPointer(p)
|
|
takesMutableVoidPointer(fp)
|
|
takesMutableVoidPointer(cp) // expected-error{{cannot convert value of type 'UnsafePointer<Int>' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesMutableVoidPointer(&i)
|
|
takesMutableVoidPointer(&f)
|
|
takesMutableVoidPointer(i) // expected-error{{cannot convert value of type 'Int' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableVoidPointer(f) // expected-error{{cannot convert value of type 'Float' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
var ii: [Int] = [0, 1, 2]
|
|
var dd: [CInt] = [1, 2, 3]
|
|
var ff: [Int] = [0, 1, 2]
|
|
takesMutableVoidPointer(&ii)
|
|
takesMutableVoidPointer(&dd)
|
|
takesMutableVoidPointer(&ff)
|
|
takesMutableVoidPointer(ii) // expected-error{{cannot convert value of type '[Int]' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableVoidPointer(ff) // expected-error{{cannot convert value of type '[Int]' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafeMutableRawPointer = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = p // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Int>' to type 'UnsafeMutableRawPointer'}}
|
|
x = &ii // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
_ = x
|
|
}
|
|
|
|
func mutableRawPointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
cp: UnsafePointer<Int>,
|
|
fp: UnsafeMutablePointer<Float>,
|
|
rp: UnsafeRawPointer) {
|
|
takesMutableRawPointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesMutableRawPointer(p)
|
|
takesMutableRawPointer(fp)
|
|
takesMutableRawPointer(cp) // expected-error{{cannot convert value of type 'UnsafePointer<Int>' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableRawPointer(rp) // expected-error{{cannot convert value of type 'UnsafeRawPointer' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesMutableRawPointer(&i)
|
|
takesMutableRawPointer(&f)
|
|
takesMutableRawPointer(i) // expected-error{{cannot convert value of type 'Int' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableRawPointer(f) // expected-error{{cannot convert value of type 'Float' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
var ii: [Int] = [0, 1, 2]
|
|
var dd: [CInt] = [1, 2, 3]
|
|
var ff: [Int] = [0, 1, 2]
|
|
takesMutableRawPointer(&ii)
|
|
takesMutableRawPointer(&dd)
|
|
takesMutableRawPointer(&ff)
|
|
takesMutableRawPointer(ii) // expected-error{{cannot convert value of type '[Int]' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableRawPointer(ff) // expected-error{{cannot convert value of type '[Int]' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafeMutableRawPointer = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = p // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Int>' to type 'UnsafeMutableRawPointer'}}
|
|
x = &ii //expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
_ = x
|
|
}
|
|
|
|
func constPointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
cp: UnsafePointer<Int>) {
|
|
takesConstPointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesConstPointer(p)
|
|
takesConstPointer(cp)
|
|
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesConstPointer(&i)
|
|
takesConstPointer(&f) // expected-error{{cannot convert value of type 'UnsafePointer<Float>' to expected argument type 'UnsafePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Float' and 'Int') are expected to be equal}}
|
|
var ii: [Int] = [0, 1, 2]
|
|
var ff: [Float] = [0, 1, 2]
|
|
takesConstPointer(&ii)
|
|
takesConstPointer(&ff) // expected-error{{cannot convert value of type 'UnsafePointer<Float>' to expected argument type 'UnsafePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Float' and 'Int') are expected to be equal}}
|
|
takesConstPointer(ii)
|
|
takesConstPointer(ff) // expected-error{{cannot convert value of type 'UnsafePointer<Float>' to expected argument type 'UnsafePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Float' and 'Int') are expected to be equal}}
|
|
takesConstPointer([0, 1, 2])
|
|
// <rdar://problem/22308330> QoI: CSDiags doesn't handle array -> pointer impl conversions well
|
|
takesConstPointer([0.0, 1.0, 2.0])
|
|
// expected-error@-1 3 {{cannot convert value of type 'Double' to expected element type 'Int'}}
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafePointer<Int> = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = ii // expected-error{{cannot assign value of type '[Int]' to type 'UnsafePointer<Int>'}}
|
|
x = p // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Int>' to type 'UnsafePointer<Int>'}}
|
|
}
|
|
|
|
func constVoidPointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
fp: UnsafeMutablePointer<Float>,
|
|
cp: UnsafePointer<Int>,
|
|
cfp: UnsafePointer<Float>) {
|
|
takesConstVoidPointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesConstVoidPointer(p)
|
|
takesConstVoidPointer(fp)
|
|
takesConstVoidPointer(cp)
|
|
takesConstVoidPointer(cfp)
|
|
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesConstVoidPointer(&i)
|
|
takesConstVoidPointer(&f)
|
|
var ii: [Int] = [0, 1, 2]
|
|
var ff: [Float] = [0, 1, 2]
|
|
takesConstVoidPointer(&ii)
|
|
takesConstVoidPointer(&ff)
|
|
takesConstVoidPointer(ii)
|
|
takesConstVoidPointer(ff)
|
|
|
|
takesConstVoidPointer([0, 1, 2])
|
|
takesConstVoidPointer([0.0, 1.0, 2.0])
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafeRawPointer = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = ii // expected-error{{cannot assign value of type '[Int]' to type 'UnsafeRawPointer'}}
|
|
x = p // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Int>' to type 'UnsafeRawPointer'}}
|
|
x = fp // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Float>' to type 'UnsafeRawPointer'}}
|
|
x = cp // expected-error{{cannot assign value of type 'UnsafePointer<Int>' to type 'UnsafeRawPointer'}}
|
|
x = cfp // expected-error{{cannot assign value of type 'UnsafePointer<Float>' to type 'UnsafeRawPointer'}}
|
|
_ = x
|
|
}
|
|
|
|
func constRawPointerArguments(_ p: UnsafeMutablePointer<Int>,
|
|
fp: UnsafeMutablePointer<Float>,
|
|
cp: UnsafePointer<Int>,
|
|
cfp: UnsafePointer<Float>,
|
|
mrp: UnsafeMutableRawPointer) {
|
|
takesConstRawPointer(nil)
|
|
% if not suffix:
|
|
// expected-error@-2 {{'nil' is not compatible with expected argument type}}
|
|
% end
|
|
|
|
takesConstRawPointer(p)
|
|
takesConstRawPointer(fp)
|
|
takesConstRawPointer(cp)
|
|
takesConstRawPointer(cfp)
|
|
takesConstRawPointer(mrp)
|
|
|
|
var i: Int = 0
|
|
var f: Float = 0
|
|
takesConstRawPointer(&i)
|
|
takesConstRawPointer(&f)
|
|
var ii: [Int] = [0, 1, 2]
|
|
var ff: [Float] = [0, 1, 2]
|
|
takesConstRawPointer(&ii)
|
|
takesConstRawPointer(&ff)
|
|
takesConstRawPointer(ii)
|
|
takesConstRawPointer(ff)
|
|
|
|
takesConstRawPointer([0, 1, 2])
|
|
takesConstRawPointer([0.0, 1.0, 2.0])
|
|
|
|
// We don't allow these conversions outside of function arguments.
|
|
var x: UnsafeRawPointer = &i // expected-error {{'&' may only be used to pass an argument to inout parameter}}
|
|
x = ii // expected-error{{cannot assign value of type '[Int]' to type 'UnsafeRawPointer'}}
|
|
x = p // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Int>' to type 'UnsafeRawPointer'}}
|
|
x = fp // expected-error{{cannot assign value of type 'UnsafeMutablePointer<Float>' to type 'UnsafeRawPointer'}}
|
|
x = cp // expected-error{{cannot assign value of type 'UnsafePointer<Int>' to type 'UnsafeRawPointer'}}
|
|
x = cfp // expected-error{{cannot assign value of type 'UnsafePointer<Float>' to type 'UnsafeRawPointer'}}
|
|
_ = x
|
|
}
|
|
|
|
func stringArguments(_ s: String) {
|
|
var s = s
|
|
takesConstVoidPointer(s)
|
|
takesConstRawPointer(s)
|
|
takesConstInt8Pointer(s)
|
|
takesConstUInt8Pointer(s)
|
|
takesConstPointer(s) // expected-error{{cannot convert value of type 'String' to expected argument type 'UnsafePointer<Int>'}}
|
|
|
|
takesMutableVoidPointer(s) // expected-error{{cannot convert value of type 'String' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableRawPointer(s) // expected-error{{cannot convert value of type 'String' to expected argument type 'UnsafeMutableRawPointer'}}
|
|
takesMutableInt8Pointer(s) // expected-error{{cannot convert value of type 'String' to expected argument type 'UnsafeMutablePointer<Int8>'}}
|
|
takesMutableInt8Pointer(&s) // expected-error{{cannot convert value of type 'UnsafeMutablePointer<String>' to expected argument type 'UnsafeMutablePointer<Int8>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('String' and 'Int8') are expected to be equal}}
|
|
takesMutablePointer(s) // expected-error{{cannot convert value of type 'String' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
takesMutablePointer(&s) // expected-error{{cannot convert value of type 'UnsafeMutablePointer<String>' to expected argument type 'UnsafeMutablePointer<Int>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('String' and 'Int') are expected to be equal}}
|
|
}
|
|
|
|
|
|
func optionality(_ op: UnsafeMutablePointer<Float>?) {
|
|
takesMutableVoidPointer(op)
|
|
% if not suffix:
|
|
// expected-error@-2 {{value of optional type 'UnsafeMutablePointer<Float>?' must be unwrapped}}
|
|
// expected-note@-3{{coalesce}}
|
|
// expected-note@-4{{force-unwrap}}
|
|
% end
|
|
|
|
takesConstVoidPointer(op)
|
|
% if not suffix:
|
|
// expected-error@-2 {{value of optional type 'UnsafeMutablePointer<Float>?' must be unwrapped}}
|
|
// expected-note@-3{{coalesce}}
|
|
// expected-note@-4{{force-unwrap}}
|
|
% end
|
|
}
|
|
|
|
func pointerArithmetic(_ x: UnsafeMutablePointer<Int>, y: UnsafeMutablePointer<Int>,
|
|
i: Int) {
|
|
_ = x + i
|
|
_ = x - y
|
|
}
|
|
|
|
func genericPointerArithmetic<T>(_ x: UnsafeMutablePointer<T>, i: Int, t: T) -> UnsafeMutablePointer<T> {
|
|
let p = x + i
|
|
p.initialize(to: t)
|
|
}
|
|
|
|
func passPointerToClosure(_ f: (UnsafeMutablePointer<Int>) -> Int) -> Int { }
|
|
|
|
func pointerInClosure(_ f: (UnsafePointer<Int>) -> Int) -> Int {
|
|
return passPointerToClosure { f($0) }
|
|
}
|
|
|
|
struct NotEquatable {}
|
|
|
|
func arrayComparison(_ x: [NotEquatable], y: [NotEquatable], p: UnsafeMutablePointer<NotEquatable>) {
|
|
var x = x
|
|
// Don't allow implicit array-to-pointer conversions in operators.
|
|
// There is a note attached to declaration - requirement from conditional conformance of '[NotEquatable]' to 'Equatable'
|
|
let a: Bool = x == y // expected-error{{operator function '==' requires that 'NotEquatable' conform to 'Equatable'}}
|
|
let _: Bool = p == &x // Allowed!
|
|
}
|
|
|
|
func addressConversion(p: UnsafeMutablePointer<Int>, x: Int) {
|
|
var x = x
|
|
let _: Bool = p == &x
|
|
}
|
|
|
|
// <rdar://problem/19478919> QoI: poor error: '&' used with non-inout argument of type 'UnsafeMutablePointer<Int32>'
|
|
func f19478919() {
|
|
var viewport: Int = 1 // intentionally incorrect type, not Int32
|
|
func GLKProject(_ a : UnsafeMutablePointer<Int32>) {}
|
|
GLKProject(&viewport) // expected-error {{cannot convert value of type 'UnsafeMutablePointer<Int>' to expected argument type 'UnsafeMutablePointer<Int32>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Int' and 'Int32') are expected to be equal}}
|
|
|
|
func GLKProjectUP(_ a : UnsafePointer<Int32>) {}
|
|
func UP_Void(_ a : UnsafeRawPointer) {}
|
|
func UMP_Void(_ a : UnsafeMutableRawPointer) {}
|
|
UP_Void(&viewport)
|
|
UMP_Void(&viewport)
|
|
|
|
let cst = 42 // expected-note 2 {{change 'let' to 'var' to make it mutable}}
|
|
UP_Void(&cst) // expected-error {{cannot pass immutable value as inout argument: 'cst' is a 'let' constant}}
|
|
UMP_Void(&cst) // expected-error {{cannot pass immutable value as inout argument: 'cst' is a 'let' constant}}
|
|
}
|
|
|
|
// <rdar://problem/23202128> QoI: Poor diagnostic with let vs. var passed to C function
|
|
func f23202128() {
|
|
func UP(_ p: UnsafePointer<Int32>) {}
|
|
func UMP(_ p: UnsafeMutablePointer<Int32>) {}
|
|
|
|
let pipe: [Int32] = [0, 0] // expected-note {{change 'let' to 'var' to make it mutable}}}}
|
|
UMP(&pipe) // expected-error {{cannot pass immutable value as inout argument: 'pipe' is a 'let' constant}}
|
|
|
|
var pipe2: [Int] = [0, 0]
|
|
UMP(&pipe2) // expected-error {{cannot convert value of type 'UnsafeMutablePointer<Int>' to expected argument type 'UnsafeMutablePointer<Int32>'}}
|
|
// expected-note@-1 {{arguments to generic parameter 'Pointee' ('Int' and 'Int32') are expected to be equal}}
|
|
|
|
|
|
UP(pipe) // ok
|
|
UP(&pipe) // expected-error {{'&' is not allowed passing array value as 'UnsafePointer<Int32>' argument}} {{6-7=}}
|
|
}
|
|
|
|
func takesRawBuffer(_ b: UnsafeRawBufferPointer) {}
|
|
|
|
// <rdar://problem/29586888> UnsafeRawBufferPointer range subscript is inconsistent with Collection.
|
|
func f29586888(b: UnsafeRawBufferPointer) {
|
|
takesRawBuffer(b[1..<2]) // expected-error {{'subscript(_:)' is unavailable: use 'UnsafeRawBufferPointer(rebasing:)' to convert a slice into a zero-based raw buffer.}}
|
|
let slice = b[1..<2]
|
|
takesRawBuffer(slice) // expected-error {{cannot convert value of type 'UnsafeRawBufferPointer.SubSequence' (aka 'Slice<UnsafeRawBufferPointer>') to expected argument type 'UnsafeRawBufferPointer'}}
|
|
}
|