remove pyconvert_and_del, since it is now possible for the return value to alias the input

Author: Christopher Doris

src/abstract/collection.jl

@@ -7,7 +7,7 @@ function _pyconvert_rule_iterable(ans::Vector{T0}, it::Py, ::Type{T1}) where {T0
         pydel!(it)
         return pyconvert_return(ans)
     end
-    x = @pyconvert_and_del(T1, x_)
+    x = @pyconvert(T1, x_)
     if x isa T0
         push!(ans, x)
         @goto again
@@ -33,7 +33,7 @@ function _pyconvert_rule_iterable(ans::Set{T0}, it::Py, ::Type{T1}) where {T0,T1
         pydel!(it)
         return pyconvert_return(ans)
     end
-    x = @pyconvert_and_del(T1, x_)
+    x = @pyconvert(T1, x_)
     if x isa T0
         push!(ans, x)
         @goto again
@@ -60,8 +60,8 @@ function _pyconvert_rule_mapping(ans::Dict{K0,V0}, x::Py, it::Py, ::Type{K1}, ::
         return pyconvert_return(ans)
     end
     v_ = pygetitem(x, k_)
-    k = @pyconvert_and_del(K1, k_)
-    v = @pyconvert_and_del(V1, v_)
+    k = @pyconvert(K1, k_)
+    v = @pyconvert(V1, v_)
     if k isa K0 && v isa V0
         push!(ans, k => v)
         @goto again
@@ -101,7 +101,7 @@ function pyconvert_rule_iterable(::Type{T}, xs::Py) where {T<:Tuple}
         else
             return pyconvert_unconverted()
         end
-        z = @pyconvert_and_del(t, x)
+        z = @pyconvert(t, x)
         push!(zs, z)
     end
     return length(zs) < length(ts) ? pyconvert_unconverted() : pyconvert_return(T(zs))
@@ -116,7 +116,7 @@ for N in 0:16
         n = pylen(xs)
         n == $N || return pyconvert_unconverted()
         $((
-            :($z = @pyconvert_and_del($T, pytuple_getitem(xs, $(i-1))))
+            :($z = @pyconvert($T, pytuple_getitem(xs, $(i-1))))
             for (i, T, z) in zip(1:N, Ts, zs)
         )...)
         return pyconvert_return(($(zs...),))
@@ -127,12 +127,12 @@ for N in 0:16
         n = pylen(xs)
         n ≥ $N || return pyconvert_unconverted()
         $((
-            :($z = @pyconvert_and_del($T, pytuple_getitem(xs, $(i-1))))
+            :($z = @pyconvert($T, pytuple_getitem(xs, $(i-1))))
             for (i, T, z) in zip(1:N, Ts, zs)
         )...)
         vs = V[]
         for i in $(N+1):n
-            v = @pyconvert_and_del(V, pytuple_getitem(xs, i-1))
+            v = @pyconvert(V, pytuple_getitem(xs, i-1))
             push!(vs, v)
         end
         return pyconvert_return(($(zs...), vs...))
@@ -149,14 +149,14 @@ function pyconvert_rule_iterable(::Type{R}, x::Py, ::Type{Pair{K0,V0}}=Utils._ty
         pydel!(k_)
         return pyconvert_unconverted()
     end
-    k = @pyconvert_and_del(K1, k_)
+    k = @pyconvert(K1, k_)
     v_ = unsafe_pynext(it)
     if pyisnull(v_)
         pydel!(it)
         pydel!(v_)
         return pyconvert_unconverted()
     end
-    v = @pyconvert_and_del(V1, v_)
+    v = @pyconvert(V1, v_)
     z_ = unsafe_pynext(it)
     pydel!(it)
     if pyisnull(z_)

src/concrete/code.jl

@@ -42,7 +42,7 @@ function pyeval(::Type{T}, code, globals, locals=nothing) where {T}
     globals_, locals_ = _pyeval_args(globals, locals)
     ans = pybuiltins.eval(code, globals_, locals_)
     pydel!(locals_)
-    return T == Py ? ans : pyconvert_and_del(T, ans)
+    return T == Py ? ans : pyconvert(T, ans)
 end
 pyeval(code, globals, locals=nothing) = pyeval(Py, code, globals, locals)
 export pyeval
@@ -57,7 +57,7 @@ _pyexec_ans(::Type{Nothing}, globals, locals) = nothing
     for i in 1:n
         v = Symbol(:ans, i)
         push!(vars, v)
-        push!(code, :($v = pyconvert_and_del($(types.parameters[i]), pygetitem(locals, $(string(names[i]))))))
+        push!(code, :($v = pyconvert($(types.parameters[i]), pygetitem(locals, $(string(names[i]))))))
     end
     push!(code, :(return $(NamedTuple{names, types})(($(vars...),))))
     return Expr(:block, code...)

src/concrete/datetime.jl

@@ -66,18 +66,18 @@ end
 function pyconvert_rule_date(::Type{Date}, x::Py)
     # datetime is a subtype of date, but we shouldn't convert datetime to Date since it's lossy
     pyisinstance(x, pydatetimetype) && return pyconvert_unconverted()
-    year = pyconvert_and_del(Int, x.year)
-    month = pyconvert_and_del(Int, x.month)
-    day = pyconvert_and_del(Int, x.day)
+    year = pyconvert(Int, x.year)
+    month = pyconvert(Int, x.month)
+    day = pyconvert(Int, x.day)
     pyconvert_return(Date(year, month, day))
 end
 
 function pyconvert_rule_time(::Type{Time}, x::Py)
     pytime_isaware(x) && return pyconvert_unconverted()
-    hour = pyconvert_and_del(Int, x.hour)
-    minute = pyconvert_and_del(Int, x.minute)
-    second = pyconvert_and_del(Int, x.second)
-    microsecond = pyconvert_and_del(Int, x.microsecond)
+    hour = pyconvert(Int, x.hour)
+    minute = pyconvert(Int, x.minute)
+    second = pyconvert(Int, x.second)
+    microsecond = pyconvert(Int, x.microsecond)
     return pyconvert_return(Time(hour, minute, second, div(microsecond, 1000), mod(microsecond, 1000)))
 end
 
@@ -86,9 +86,9 @@ function pyconvert_rule_datetime(::Type{DateTime}, x::Py)
     # compute the time since _base_datetime
     # this accounts for fold
     d = x - _base_pydatetime
-    days = pyconvert_and_del(Int, d.days)
-    seconds = pyconvert_and_del(Int, d.seconds)
-    microseconds = pyconvert_and_del(Int, d.microseconds)
+    days = pyconvert(Int, d.days)
+    seconds = pyconvert(Int, d.seconds)
+    microseconds = pyconvert(Int, d.microseconds)
     pydel!(d)
     iszero(mod(microseconds, 1000)) || return pyconvert_unconverted()
     return pyconvert_return(_base_datetime + Millisecond(div(microseconds, 1000) + 1000 * (seconds + 60 * 60 * 24 * days)))

src/concrete/fraction.jl

@@ -6,8 +6,8 @@ export pyfraction
 
 # works for any collections.abc.Rational
 function pyconvert_rule_fraction(::Type{R}, x::Py, ::Type{Rational{T0}}=Utils._type_lb(R), ::Type{Rational{T1}}=Utils._type_ub(R)) where {R<:Rational,T0,T1}
-    a = @pyconvert_and_del(Utils._typeintersect(Integer, T1), x.numerator)
-    b = @pyconvert_and_del(Utils._typeintersect(Integer, T1), x.denominator)
+    a = @pyconvert(Utils._typeintersect(Integer, T1), x.numerator)
+    b = @pyconvert(Utils._typeintersect(Integer, T1), x.denominator)
     a, b = promote(a, b)
     T2 = Utils._promote_type_bounded(T0, typeof(a), typeof(b), T1)
     pyconvert_return(Rational{T2}(a, b))

src/jlwrap/array.jl

@@ -2,15 +2,15 @@ const pyjlarraytype = pynew()
 
 function pyjl_getaxisindex(x::AbstractUnitRange{<:Integer}, k::Py)
     if pyisslice(k)
-        a = @pyconvert_and_del Union{Int,Nothing} k.start begin
+        a = @pyconvert Union{Int,Nothing} k.start begin
             errset(pybuiltins.TypeError, "slice components must be integers")
             pythrow()
         end
-        b = @pyconvert_and_del Union{Int,Nothing} k.step begin
+        b = @pyconvert Union{Int,Nothing} k.step begin
             errset(pybuiltins.TypeError, "slice components must be integers")
             pythrow()
         end
-        c = @pyconvert_and_del Union{Int,Nothing} k.stop begin
+        c = @pyconvert Union{Int,Nothing} k.stop begin
             errset(pybuiltins.TypeError, "slice components must be integers")
             pythrow()
         end

src/jlwrap/dict.jl

@@ -23,7 +23,7 @@ pyjldict_delitem(x::AbstractDict, k::Py) = (delete!(x, pyconvert(keytype(x), k))
 
 function pyjldict_update(x::AbstractDict, items_::Py)
     for item_ in items_
-        (k, v) = pyconvert_and_del(Tuple{keytype(x), valtype(x)}, item_)
+        (k, v) = pyconvert(Tuple{keytype(x), valtype(x)}, item_)
         x[k] = v
     end
     Py(nothing)

src/jlwrap/vector.jl

@@ -53,7 +53,7 @@ end
 
 function pyjlvector_extend(x::AbstractVector, vs_::Py)
     for v_ in vs_
-        v = pyconvert_and_del(eltype(x), v_)
+        v = pyconvert(eltype(x), v_)
         push!(x, v)
     end
     Py(nothing)

src/pywrap/PyArray.jl

@@ -193,15 +193,15 @@ function PyArraySource_ArrayInterface(x::Py)
     d = x.__array_interface__
     # offset
     # TODO: how is the offset measured?
-    offset = pyconvert_and_del(Int, @py d.get("offset", 0))
+    offset = pyconvert(Int, @py d.get("offset", 0))
     offset == 0 || error("not supported: non-zero offset")
     # mask
     @py("mask" in d) && error("not supported: mask")
     # data
     data = @py d.get("data")
     if pyistuple(data)
-        ptr = Ptr{Cvoid}(pyconvert_and_del(UInt, data[0]))
-        readonly = pyconvert_and_del(Bool, data[1])
+        ptr = Ptr{Cvoid}(pyconvert(UInt, data[0]))
+        readonly = pyconvert(Bool, data[1])
         pydel!(data)
         handle = Py((x, d))
     else
@@ -268,7 +268,7 @@ pyarray_typestrdescr_to_type(ts::String, descr::Py) = begin
 end
 
 function pyarray_get_R(src::PyArraySource_ArrayInterface)
-    typestr = pyconvert_and_del(String, src.dict["typestr"])
+    typestr = pyconvert(String, src.dict["typestr"])
     descr = @py @jl(src.dict).get("descr")
     R = pyarray_typestrdescr_to_type(typestr, descr)::DataType
     pydel!(descr)
@@ -279,15 +279,15 @@ pyarray_get_ptr(src::PyArraySource_ArrayInterface, ::Type{R}) where {R} = Ptr{R}
 
 pyarray_get_N(src::PyArraySource_ArrayInterface) = Int(@py jllen(@jl(src.dict)["shape"]))
 
-pyarray_get_size(src::PyArraySource_ArrayInterface, ::Val{N}) where {N} = pyconvert_and_del(NTuple{N,Int}, src.dict["shape"])
+pyarray_get_size(src::PyArraySource_ArrayInterface, ::Val{N}) where {N} = pyconvert(NTuple{N,Int}, src.dict["shape"])
 
 function pyarray_get_strides(src::PyArraySource_ArrayInterface, ::Val{N}, ::Type{R}, size::NTuple{N,Int}) where {R,N}
     @py strides = @jl(src.dict).get("strides")
     if pyisnone(strides)
         pydel!(strides)
         return Utils.size_to_cstrides(sizeof(R), size)
     else
-        return pyconvert_and_del(NTuple{N,Int}, strides)
+        return pyconvert(NTuple{N,Int}, strides)
     end
 end
 
@@ -434,7 +434,7 @@ pyarray_load(::Type{R}, p::Ptr{R}) where {R} = unsafe_load(p)
 pyarray_load(::Type{T}, p::Ptr{UnsafePyObject}) where {T} = begin
     u = unsafe_load(p)
     o = u.ptr == C_NULL ? pynew(Py(nothing)) : pynew(incref(u.ptr))
-    T == Py ? o : pyconvert_and_del(T, o)
+    T == Py ? o : pyconvert(T, o)
 end
 
 pyarray_store!(p::Ptr{R}, x::R) where {R} = unsafe_store!(p, x)

src/pywrap/PyDict.jl

@@ -34,20 +34,20 @@ function Base.iterate(x::PyDict{K,V}, it::Py=pyiter(x)) where {K,V}
     k_ = unsafe_pynext(it)
     pyisnull(k_) && return nothing
     v_ = pygetitem(x, k_)
-    k = pyconvert_and_del(K, k_)
-    v = pyconvert_and_del(V, v_)
+    k = pyconvert(K, k_)
+    v = pyconvert(V, v_)
     return (k => v, it)
 end
 
 function Base.iterate(x::Base.KeySet{K,PyDict{K,V}}, it::Py=pyiter(x.dict)) where {K,V}
     k_ = unsafe_pynext(it)
     pyisnull(k_) && return nothing
-    k = pyconvert_and_del(K, k_)
+    k = pyconvert(K, k_)
     return (k, it)
 end
 
 function Base.getindex(x::PyDict{K,V}, k) where {K,V}
-    return pyconvert_and_del(V, pygetitem(x, convert(K, k)))
+    return pyconvert(V, pygetitem(x, convert(K, k)))
 end
 
 function Base.setindex!(x::PyDict{K,V}, v, k) where {K,V}

src/pywrap/PyIO.jl

@@ -126,13 +126,13 @@ function Base.eof(io::PyIO)
     end
 end
 
-Base.fd(io::PyIO) = pyconvert_and_del(Int, @py io.fileno())
+Base.fd(io::PyIO) = pyconvert(Int, @py io.fileno())
 
-Base.isreadable(io::PyIO) = pyconvert_and_del(Bool, @py io.readable())
+Base.isreadable(io::PyIO) = pyconvert(Bool, @py io.readable())
 
-Base.iswritable(io::PyIO) = pyconvert_and_del(Bool, @py io.writable())
+Base.iswritable(io::PyIO) = pyconvert(Bool, @py io.writable())
 
-Base.isopen(io::PyIO) = !pyconvert_and_del(Bool, @py io.closed)
+Base.isopen(io::PyIO) = !pyconvert(Bool, @py io.closed)
 
 function Base.unsafe_write(io::PyIO, ptr::Ptr{UInt8}, n::UInt)
     ntodo = n
@@ -235,11 +235,11 @@ function Base.position(io::PyIO)
     putobuf(io)
     if io.text
         if isempty(io.ibuf)
-            return pyconvert_and_del(Int, @py io.tell())
+            return pyconvert(Int, @py io.tell())
         else
             error("`position(io)` text PyIO streams only implemented for empty input buffer (e.g. do `read(io, length(io.ibuf))` first)")
         end
     else
-        return pyconvert_and_del(Int, @py io.tell()) - length(io.ibuf)
+        return pyconvert(Int, @py io.tell()) - length(io.ibuf)
     end
 end

src/pywrap/PyIterable.jl

@@ -23,7 +23,7 @@ function Base.iterate(x::PyIterable{T}, it::Py=pyiter(x)) where {T}
         pydel!(it)
         return nothing
     else
-        return (pyconvert_and_del(T, y), it)
+        return (pyconvert(T, y), it)
     end
 end
 

src/pywrap/PyList.jl

@@ -29,7 +29,7 @@ Base.size(x::PyList) = (length(x),)
 
 Base.@propagate_inbounds function Base.getindex(x::PyList{T}, i::Int) where {T}
     @boundscheck checkbounds(x, i)
-    return pyconvert_and_del(T, @py x[@jl(i-1)])
+    return pyconvert(T, @py x[@jl(i-1)])
 end
 
 Base.@propagate_inbounds function Base.setindex!(x::PyList{T}, v, i::Int) where {T}
@@ -67,19 +67,19 @@ end
 
 Base.@propagate_inbounds function Base.pop!(x::PyList{T}) where {T}
     @boundscheck (isempty(x) && throw(BoundsError(x)))
-    return pyconvert_and_del(T, @py x.pop())
+    return pyconvert(T, @py x.pop())
 end
 
 if isdefined(Base, :popat!)
     Base.@propagate_inbounds function Base.popat!(x::PyList{T}, i::Integer) where {T}
         @boundscheck checkbounds(x, i)
-        return pyconvert_and_del(T, @py x.pop(@jl(i-1)))
+        return pyconvert(T, @py x.pop(@jl(i-1)))
     end
 end
 
 Base.@propagate_inbounds function Base.popfirst!(x::PyList{T}) where {T}
     @boundscheck checkbounds(x, 1)
-    return pyconvert_and_del(T, @py x.pop(0))
+    return pyconvert(T, @py x.pop(0))
 end
 
 function Base.reverse!(x::PyList)

src/pywrap/PyPandasDataFrame.jl

@@ -29,8 +29,8 @@ pyconvert_rule_pandasdataframe(::Type{PyPandasDataFrame}, x::Py) = pyconvert_ret
 ### Show
 
 function Base.show(io::IO, mime::MIME"text/plain", df::PyPandasDataFrame)
-    nrows = pyconvert_and_del(Int, @py df.shape[0])
-    ncols = pyconvert_and_del(Int, @py df.shape[1])
+    nrows = pyconvert(Int, @py df.shape[0])
+    ncols = pyconvert(Int, @py df.shape[1])
     printstyled(io, nrows, '×', ncols, ' ', typeof(df), '\n', bold=true)
     pyshow(io, mime, df)
 end

src/pywrap/PySet.jl

@@ -33,7 +33,7 @@ function Base.iterate(x::PySet{T}, it::Py=pyiter(x)) where {T}
         pydel!(it)
         return nothing
     else
-        return (pyconvert_and_del(T, y), it)
+        return (pyconvert(T, y), it)
     end
 end
 
@@ -69,7 +69,7 @@ end
 
 Base.@propagate_inbounds function Base.pop!(x::PySet{T}) where {T}
     @boundscheck (isempty(x) && throw(ArgumentError("set must be non-empty")))
-    return pyconvert_and_del(T, @py x.pop())
+    return pyconvert(T, @py x.pop())
 end
 
 function Base.pop!(x::PySet, v)