Remove unsafe_wrap

Author: Jakob Nybo Andersen

CHANGELOG.md

@@ -8,13 +8,16 @@ not be mentioned here, because they do not impact how the package is to be used.
 ### Breaking changes
 * Removed the `Unsafe` trait type:
     - Instead of `MutableMemoryView(::Unsafe, ::MemoryView)`, use
-      `unsafe_wrap(MutableMemoryView, ::MemoryView)`
+      `unsafe_from_parts(::MemoryRef, ::Int)`
     - Using the inner constructor `MemoryView{T, M}(::Unsafe, ::MemoryRef{T}, ::Int)`
       was never documented API and is now removed.
 
 * `MemoryView(::SubArray)` now accepts fewer subarray types. However, it is unlikely
   that any instance that is now no longer accepted worked previously, so it is
-  unlikely to be breaking in practice. 
+  unlikely to be breaking in practice.
+
+## Other
+* `parentindices` now works correctly for zero-sized structs.
 
 ## 0.3.5
 * Add method `MemoryKind{::Type{<:MemoryView}}`

src/MemoryViews.jl

@@ -111,8 +111,8 @@ julia> view = unsafe_from_parts(ref, 3)
  3
 ```
 """
-function unsafe_from_parts(ref::MemoryRef{T}, len::Int) where {T}
-    return MemoryView{T, Mutable}(unsafe, ref, len)
+function unsafe_from_parts(ref::MemoryRef, len::Int)
+    return unsafe_new_memoryview(Mutable, ref, len)
 end
 
 _get_mutability(::MemoryView{T, M}) where {T, M} = M
@@ -123,17 +123,6 @@ function ImmutableMemoryView(x::MemoryView)
     return unsafe_new_memoryview(Immutable, x.ref, x.len)
 end
 
-"""
-    unsafe_wrap(MutableMemoryView, x::MemoryView)
-
-Convert a memory view into a mutable memory view.
-Note that it may cause undefined behaviour, if supposedly immutable data
-is observed to be mutated.
-"""
-function Base.unsafe_wrap(::Type{MutableMemoryView}, x::MemoryView{T}) where {T}
-    return unsafe_new_memoryview(Mutable, x.ref, x.len)
-end
-
 # Constructors that allows users to specify eltype explicitly, e.g.
 # ImmutableMemoryView{UInt8}([0x01])
 # With mutability specified

src/basic.jl

@@ -30,7 +30,8 @@ end
     function Base.parentindices(x::MemoryView)
         elz = Base.elsize(x)
         return if iszero(elz)
-            (1:(x.len),)
+            offset = Int(x.ref.ptr_or_offset)
+            ((1 + offset):(x.len + offset),)
         else
             byte_offset = pointer(x.ref) - pointer(x.ref.mem)
             elem_offset = div(byte_offset % UInt, elz % UInt) % Int
@@ -112,21 +113,21 @@ function Base.getindex(v::MemoryView{T, M}, idx::AbstractUnitRange) where {T, M}
     isempty(idx) && return unsafe_new_memoryview(M, memoryref(v.ref.mem), 0)
     @boundscheck checkbounds(v, idx)
     newref = @inbounds memoryref(v.ref, Int(first(idx))::Int)
-    return typeof(v)(unsafe, newref, Int(length(idx))::Int)
+    return unsafe_new_memoryview(M, newref, Int(length(idx))::Int)
 end
 
-function Base.getindex(v::MemoryView, idx::UnitRange{UInt})
-    isempty(idx) && return typeof(v)(unsafe, memoryref(v.ref.mem), 0)
+function Base.getindex(v::MemoryView{T, M}, idx::UnitRange{UInt}) where {T, M}
+    isempty(idx) && return unsafe_new_memoryview(M, v.ref, 0)
     @boundscheck checkbounds(v, idx)
     newref = @inbounds memoryref(v.ref, first(idx) % Int)
-    return typeof(v)(unsafe, newref, length(idx) % Int)
+    return unsafe_new_memoryview(M, newref, length(idx) % Int)
 end
 
 # Faster method, because we don't need to create a new memoryref, and also don't
 # need to handle the empty case.
-function Base.getindex(v::MemoryView, idx::Base.OneTo)
+function Base.getindex(v::MemoryView{T, M}, idx::Base.OneTo) where {T, M}
     @boundscheck checkbounds(v, idx)
-    return typeof(v)(unsafe, v.ref, last(idx))
+    return unsafe_new_memoryview(M, v.ref, last(idx))
 end
 
 Base.getindex(v::MemoryView, ::Colon) = v

src/experimental.jl

@@ -93,6 +93,9 @@ If `v` is empty or already aligned, `a` will be empty.
 If no elements of `v` is aligned, `b` will be empty and `a` will be equal to `v`.
 The element type of `v` must be a bitstype.
 
+!!! warning
+    When using this function, make sure to `GC.@preserve v`, to make sure Julia
+    does not move `v` in memory.
 
 # Examples:
 ```

test/runtests.jl

@@ -41,7 +41,7 @@ MUT_BACKINGS = Any[
     @testset "Unsafe mutability" begin
         v = [1.0, 2.0, 3.0]
         m = ImmutableMemoryView(v)
-        m2 = unsafe_wrap(MutableMemoryView, m)
+        m2 = unsafe_from_parts(m.ref, 3)
         m2[2] = 5.0
         @test v == [1.0, 5.0, 3.0]
     end