Merge pull request #10 from Roboneet/update

Updates for 0.7 and 1.0

Author: MikeInnes

REQUIRE

@@ -1 +1 @@
-julia 0.6
+julia 0.7-beta

src/BSON.jl

@@ -2,9 +2,11 @@ module BSON
 
 export bson
 
+using Core: SimpleVector, TypeName
+
 const BSONDict = Dict{Symbol,Any}
 const BSONArray = Vector{Any}
-const Primitive = Union{Void,Bool,Int32,Int64,Float64,String,Vector{UInt8},BSONDict,BSONArray}
+const Primitive = Union{Nothing,Bool,Int32,Int64,Float64,String,Vector{UInt8},BSONDict,BSONArray}
 
 @enum(BSONType::UInt8,
   eof, double, string, document, array, binary, undefined, objectid, boolean,

src/anonymous.jl

@@ -2,21 +2,21 @@
 
 structdata(meth::Method) =
   [meth.module, meth.name, meth.file, meth.line, meth.sig, meth.sparam_syms,
-   meth.ambig, meth.nargs, meth.isva, meth.isstaged,
+   meth.ambig, meth.nargs, meth.isva, meth.nospecialize,
    Base.uncompressed_ast(meth, meth.source)]
 
-initstruct(::Type{Method}) = ccall(:jl_new_method_uninit, Ref{Method}, ())
+initstruct(::Type{Method}) = ccall(:jl_new_method_uninit, Ref{Method}, (Any,), Main)
 
 function newstruct!(meth::Method, mod, name, file, line, sig,
-                    sparam_syms, ambig, nargs, isva, isstaged, ast)
+                    sparam_syms, ambig, nargs, isva, nospecialize, ast)
   meth.module = mod
   meth.name = name
   meth.file = file
   meth.line = line
   meth.sig = sig
   meth.sparam_syms = sparam_syms
   meth.ambig = ambig
-  meth.isstaged = isstaged
+  meth.nospecialize = nospecialize
   meth.nargs = nargs
   meth.isva = isva
   meth.source = ast
@@ -41,17 +41,17 @@ baremodule __deserialized_types__ end
 function newstruct_raw(cache, ::Type{TypeName}, d)
   name = raise_recursive(d[:data][2], cache)
   name = isdefined(__deserialized_types__, name) ? gensym() : name
-  tn = ccall(:jl_new_typename_in, Ref{TypeName}, (Any, Any),
+  tn = ccall(:jl_new_typename_in, Ref{Core.TypeName}, (Any, Any),
              name, __deserialized_types__)
   cache[d] = tn
   names, super, parameters, types, has_instance,
     abstr, mutabl, ninitialized = map(x -> raise_recursive(x, cache), d[:data][3:end-1])
   tn.names = names
-  ndt = ccall(:jl_new_datatype, Any, (Any, Any, Any, Any, Any, Cint, Cint, Cint),
-              tn, super, parameters, names, types,
+  ndt = ccall(:jl_new_datatype, Any, (Any, Any, Any, Any, Any, Any, Cint, Cint, Cint),
+              tn, tn.module, super, parameters, names, types,
               abstr, mutabl, ninitialized)
   ty = tn.wrapper = ndt.name.wrapper
-  ccall(:jl_set_const, Void, (Any, Any, Any), tn.module, tn.name, ty)
+  ccall(:jl_set_const, Cvoid, (Any, Any, Any), tn.module, tn.name, ty)
   if has_instance && !isdefined(ty, :instance)
     # use setfield! directly to avoid `fieldtype` lowering expecting to see a Singleton object already on ty
     Core.setfield!(ty, :instance, ccall(:jl_new_struct, Any, (Any, Any...), ty))
@@ -64,7 +64,7 @@ function newstruct_raw(cache, ::Type{TypeName}, d)
     tn.mt.max_args = maxa
     for def in defs
       isdefined(def, :sig) || continue
-      ccall(:jl_method_table_insert, Void, (Any, Any, Ptr{Void}), tn.mt, def, C_NULL)
+      ccall(:jl_method_table_insert, Cvoid, (Any, Any, Ptr{Cvoid}), tn.mt, def, C_NULL)
     end
   end
   return tn

src/extensions.jl

@@ -17,11 +17,11 @@ tags[:svec] = d -> Core.svec(d[:data]...)
 
 ref(path::Symbol...) = BSONDict(:tag => "ref", :path => Base.string.([path...]))
 
-resolve(fs) = reduce((m, f) -> getfield(m, Symbol(f)), Main, fs)
+resolve(fs) = reduce((m, f) -> getfield(m, Symbol(f)), fs; init = Main)
 
 tags[:ref] = d -> resolve(d[:path])
 
-modpath(x::Module) = x == Main ? [] : [modpath(module_parent(x))..., module_name(x)]
+modpath(x::Module) = x == Main ? [] : [modpath(parentmodule(x))..., nameof(x)]
 
 ismutable(::Type{Module}) = false
 lower(m::Module) = ref(modpath(m)...)
@@ -56,22 +56,26 @@ tags[:unionall] = d -> UnionAll(d[:var], d[:body])
 lower(x::Vector{Any}) = copy(x)
 lower(x::Vector{UInt8}) = x
 
+reinterpret_(::Type{T}, x) where T =
+  T[reinterpret(T, x)...]
+
 function lower(x::Array)
-  ndims(x) == 1 && !isbits(eltype(x)) && return Any[x...]
+  ndims(x) == 1 && !isbitstype(eltype(x)) && return Any[x...]
   BSONDict(:tag => "array", :type => eltype(x), :size => Any[size(x)...],
-           :data => isbits(eltype(x)) ? reinterpret(UInt8, reshape(x, :)) : Any[x...])
+           :data => isbitstype(eltype(x)) ? reinterpret_(UInt8, reshape(x, :)) : Any[x...])
 end
 
 tags[:array] = d ->
-  isbits(d[:type]) ?
-    reshape(reinterpret(d[:type], d[:data]), d[:size]...) :
+  isbitstype(d[:type]) ?
+    reshape(reinterpret_(d[:type], d[:data]), d[:size]...) :
     Array{d[:type]}(reshape(d[:data], d[:size]...))
 
 # Structs
 
-isprimitive(T) = nfields(T) == 0 && T.size > 0
+isprimitive(T) = fieldcount(T) == 0 && T.size > 0
 
-structdata(x) = isprimitive(typeof(x)) ? reinterpret(UInt8, [x]) : Any[getfield(x, f) for f in fieldnames(x)]
+structdata(x) = isprimitive(typeof(x)) ? reinterpret_(UInt8, [x]) :
+    Any[getfield(x, f) for f in fieldnames(typeof(x))]
 
 function lower(x)
   BSONDict(:tag => "struct", :type => typeof(x), :data => structdata(x))
@@ -82,15 +86,15 @@ initstruct(T) = ccall(:jl_new_struct_uninit, Any, (Any,), T)
 function newstruct!(x, fs...)
   for (i, f) = enumerate(fs)
     f = convert(fieldtype(typeof(x),i), f)
-    ccall(:jl_set_nth_field, Void, (Any, Csize_t, Any), x, i-1, f)
+    ccall(:jl_set_nth_field, Nothing, (Any, Csize_t, Any), x, i-1, f)
   end
   return x
 end
 
 function newstruct(T, xs...)
-  if isbits(T)
+  if isbitstype(T)
     flds = Any[convert(fieldtype(T, i), x) for (i,x) in enumerate(xs)]
-    return ccall(:jl_new_structv, Any, (Any,Ptr{Void},UInt32), T, flds, length(flds))
+    return ccall(:jl_new_structv, Any, (Any,Ptr{Cvoid},UInt32), T, flds, length(flds))
   else
     newstruct!(initstruct(T), xs...)
   end
@@ -102,7 +106,7 @@ function newstruct_raw(cache, T, d)
   return newstruct!(x, fs...)
 end
 
-newprimitive(T, data) = reinterpret(T, data)[1]
+newprimitive(T, data) = reinterpret_(T, data)[1]
 
 tags[:struct] = d ->
   isprimitive(d[:type]) ?

src/read.jl

@@ -1,5 +1,5 @@
 jtype(tag) =
-  tag == null ? Void :
+  tag == null ? Nothing :
   tag == boolean ? Bool :
   tag == int32 ? Int32 :
   tag == int64 ? Int64 :
@@ -66,7 +66,7 @@ const tags = Dict{Symbol,Function}()
 
 const raise = Dict{Symbol,Function}()
 
-function _raise_recursive(d::Associative, cache)
+function _raise_recursive(d::AbstractDict, cache)
   if haskey(d, :tag) && haskey(tags, Symbol(d[:tag]))
     cache[d] = tags[Symbol(d[:tag])](applychildren!(x -> raise_recursive(x, cache), d))
   else
@@ -75,10 +75,10 @@ function _raise_recursive(d::Associative, cache)
   end
 end
 
-function raise_recursive(d::Associative, cache)
+function raise_recursive(d::AbstractDict, cache)
   haskey(cache, d) && return cache[d]
   haskey(d, :tag) && haskey(raise, Symbol(d[:tag])) && return raise[Symbol(d[:tag])](d, cache)
-  _raise_recursive(d::Associative, cache)
+  _raise_recursive(d::AbstractDict, cache)
 end
 
 function raise_recursive(v::BSONArray, cache)
@@ -88,7 +88,7 @@ end
 
 raise_recursive(x, cache) = x
 
-raise_recursive(x) = raise_recursive(x, ObjectIdDict())
+raise_recursive(x) = raise_recursive(x, IdDict())
 
 parse(io::IO) = backrefs!(parse_doc(io))
 parse(path::String) = open(parse, path)

src/write.jl

@@ -1,4 +1,4 @@
-bson_type(::Void) = null
+bson_type(::Nothing) = null
 bson_type(::Bool) = boolean
 bson_type(::Int32) = int32
 bson_type(::Int64) = int64
@@ -8,7 +8,7 @@ bson_type(::Vector{UInt8}) = binary
 bson_type(::BSONDict) = document
 bson_type(::BSONArray) = array
 
-bson_primitive(io::IO, ::Void) = return
+bson_primitive(io::IO, ::Nothing) = return
 bson_primitive(io::IO, x::Union{Bool,Int32,Int64,Float64}) = write(io, x)
 bson_primitive(io::IO, x::Float64) = write(io, x)
 bson_primitive(io::IO, x::Vector{UInt8}) = write(io, Int32(length(x)), 0x00, x)
@@ -43,7 +43,7 @@ lower(x::Primitive) = x
 
 import Base: RefValue
 
-ismutable(T) = !isbits(T)
+ismutable(T) = !isbitstype(T)
 ismutable(::Type{String}) = false
 
 typeof_(x) = typeof(x)
@@ -67,19 +67,19 @@ end
 stripref(x::RefValue) = stripref(x.x)
 stripref(x) = applychildren!(stripref, x)
 
-function lower_recursive(x)
-  cache = ObjectIdDict()
+function lower_recursive(y)
+  cache = IdDict()
   backrefs = []
-  x = _lower_recursive(x, cache, backrefs).x
+  x = _lower_recursive(y, cache, backrefs).x
   isempty(backrefs) || (x[:_backrefs] = Any[x.x for x in backrefs])
   foreach((ix) -> (ix[2].x = BSONDict(:tag=>"backref",:ref=>ix[1])), enumerate(backrefs))
   return stripref(x)
 end
 
 # Interface
 
-bson(io::IO, doc::Associative) = bson_primitive(io, lower_recursive(doc))
+bson(io::IO, doc::AbstractDict) = bson_primitive(io, lower_recursive(doc))
 
-bson(path::String, doc::Associative) = open(io -> bson(io, doc), path, "w")
+bson(path::String, doc::AbstractDict) = open(io -> bson(io, doc), path, "w")
 
 bson(path::String; kws...) = bson(path, Dict(kws))

test/runtests.jl

@@ -1,5 +1,5 @@
 using BSON
-using Base.Test
+using Test
 
 roundtrip_equal(x) = BSON.roundtrip(x) == x