I believe UnsafeRawPointer is a subtype of any UnsafePointer<T> type, so
UnsafePointer<T>’s are always implicitly convertible to UnsafeRawPointers.
So even the following compiles:
import Foundation
func f(_ a:UnsafeRawPointer)
{
}
let data = Data(bytes: [1, 2, 3, 4])
data.withUnsafeBytes{ (ptr:UnsafePointer<Range<Int>>) in f(ptr) }
So annotate ptr with its actual type, and it should just work.
On Fri, Jun 30, 2017 at 10:57 AM, Daniel Dunbar via swift-users <
swift-users@swift.org> wrote:
>
> > On Jun 30, 2017, at 7:40 AM, Martin R via swift-users <
> swift-users@swift.org> wrote:
> >
> > I have a C function
> >
> > void myfunc(const void *ptr);
> >
> > which is imported to Swift as
> >
> > func myfunc(_ ptr: UnsafeRawPointer!)
> >
> > This compiles and runs without problems:
> >
> > let data = Data(bytes: [1, 2, 3, 4])
> > data.withUnsafeBytes { (ptr) in myfunc(ptr) } // (A)
> >
> > and the type of `ptr` is inferred as `UnsafePointer<Void>`. But adding
> an explicit type
> > annotation produces a compiler warning:
>
> How do you know the inferred type is `UnsafePointer<Void>`? I think it is
> more likely it is `UnsafePointer<UInt8>`, and the following compiles:
> ```
> let data = Data(bytes: [1, 2, 3, 4])
> data.withUnsafeBytes { (ptr: UnsafePointer<UInt8>) in
> myfunc(ptr)
> }
> ```
>
> - Daniel
>
> >
> > data.withUnsafeBytes { (ptr: UnsafePointer<Void>) in myfunc(ptr) } //
> (B)
> > // warning: UnsafePointer<Void> has been replaced by UnsafeRawPointer
> >
> > which is understandable in the view of "SE-0107 UnsafeRawPointer API".
> >
> > The "Fix-it" replaces `UnsafePointer<Void>` by `UnsafeRawPointer`, and
> that does not
> > compile anymore:
> >
> > data.withUnsafeBytes { (ptr: UnsafeRawPointer) in myfunc(ptr) } // (C)
> > // error: cannot convert value of type 'Void' to closure result type
> '_'
> >
> > because there is no `withUnsafeBytes()` method taking a
> `(UnsafeRawPointer)->ResultType`
> > closure.
> >
> >
> > My questions are:
> >
> > 1. Why are (A) and (B) treated differently?
> >
> > 2. Is (A) "legal", or should one use some non-void pointer
> >
> > data.withUnsafeBytes { (ptr: UnsafePointer<Int8>) in myfunc(ptr) } //
> (D)
> >
> > (which feels wrong to me because it is converted back to a void
> pointer when
> > calling the function).
> >
> > 3. Or should there be a `withUnsafeRawPointer()` method which makes (C)
> compile as
> >
> > data.withUnsafeRawBytes { (ptr: UnsafeRawPointer) in myfunc(ptr) }
> >
> > This would also allow to access the data at byte offsets more easily,
> e.g.
> >
> > data.withUnsafeRawBytes { ptr in
> > let u16 = ptr.load(fromByteOffset: 4, as: UInt16.self)
> > }
> >
> > Does that makes sense?
> >
> > Regards, Martin
> >
> >
> >
> >
> >
> >
> >
> >
> >
> > _______________________________________________
> > swift-users mailing list
> > swift-users@swift.org
> > https://lists.swift.org/mailman/listinfo/swift-users
>
> _______________________________________________
> swift-users mailing list
> swift-users@swift.org
> https://lists.swift.org/mailman/listinfo/swift-users
>
_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
