fix serializer for compat with 1.0 for saved functions

Author: JeffBezanson

stdlib/Serialization/src/Serialization.jl

@@ -30,7 +30,7 @@ Serializer(io::IO) = Serializer{typeof(io)}(io)
 ## serializing values ##
 
 const n_int_literals = 33
-const n_reserved_slots = 25
+const n_reserved_slots = 24
 const n_reserved_tags = 12
 
 const TAGS = Any[
@@ -65,7 +65,7 @@ const TAGS = Any[
     :sub_int, :mul_int, :add_float, :sub_float, :new, :mul_float, :bitcast, :start, :done, :next,
     :indexed_iterate, :getfield, :meta, :eq_int, :slt_int, :sle_int, :ne_int, :push_loc, :pop_loc,
     :pop, :arrayset, :arrayref, :apply_type, :inbounds, :getindex, :setindex!, :Core, :!, :+,
-    :Base, :static_parameter, :convert, :colon, Symbol("#self#"), Symbol(""), :tuple,
+    :Base, :static_parameter, :convert, :colon, Symbol("#self#"), Symbol("#temp#"), :tuple, Symbol(""),
 
     fill(:_reserved_, n_reserved_slots)...,
 
@@ -75,7 +75,7 @@ const TAGS = Any[
 
 @assert length(TAGS) == 255
 
-const ser_version = 7 # do not make changes without bumping the version #!
+const ser_version = 8 # do not make changes without bumping the version #!
 
 const NTAGS = length(TAGS)
 
@@ -411,7 +411,9 @@ function serialize(s::AbstractSerializer, linfo::Core.MethodInstance)
     isa(linfo.def, Module) || error("can only serialize toplevel MethodInstance objects")
     writetag(s.io, METHODINSTANCE_TAG)
     serialize(s, linfo.uninferred)
+    serialize(s, nothing)  # for backwards compat
     serialize(s, linfo.sparam_vals)
+    serialize(s, Any)  # for backwards compat
     serialize(s, linfo.specTypes)
     serialize(s, linfo.def)
     nothing
@@ -915,7 +917,13 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
     file = deserialize(s)::Symbol
     line = deserialize(s)::Int32
     sig = deserialize(s)::Type
-    slot_syms = deserialize(s)::String
+    syms = deserialize(s)
+    if syms isa SimpleVector
+        # < v1.2
+        _ambig = deserialize(s)
+    else
+        slot_syms = syms::String
+    end
     nargs = deserialize(s)::Int32
     isva = deserialize(s)::Bool
     template = deserialize(s)
@@ -926,14 +934,17 @@ function deserialize(s::AbstractSerializer, ::Type{Method})
         meth.file = file
         meth.line = line
         meth.sig = sig
-        meth.slot_syms = slot_syms
         meth.nargs = nargs
         meth.isva = isva
         if template !== nothing
             # TODO: compress template
             meth.source = template::CodeInfo
             meth.pure = template.pure
+            if !@isdefined(slot_syms)
+                slot_syms = ccall(:jl_compress_argnames, Ref{String}, (Any,), meth.source.slotnames)
+            end
         end
+        meth.slot_syms = slot_syms
         if generator !== nothing
             linfo = ccall(:jl_new_method_instance_uninit, Ref{Core.MethodInstance}, ())
             linfo.specTypes = Tuple
@@ -954,12 +965,66 @@ function deserialize(s::AbstractSerializer, ::Type{Core.MethodInstance})
     linfo = ccall(:jl_new_method_instance_uninit, Ref{Core.MethodInstance}, (Ptr{Cvoid},), C_NULL)
     deserialize_cycle(s, linfo)
     linfo.uninferred = deserialize(s)::CodeInfo
+    tag = Int32(read(s.io, UInt8)::UInt8)
+    if tag != UNDEFREF_TAG
+        # for reading files prior to v1.2
+        handle_deserialize(s, tag)
+    end
     linfo.sparam_vals = deserialize(s)::SimpleVector
+    _rettype = deserialize(s)  # for backwards compat
     linfo.specTypes = deserialize(s)
     linfo.def = deserialize(s)::Module
     return linfo
 end
 
+function deserialize(s::AbstractSerializer, ::Type{Core.LineInfoNode})
+    _meth = deserialize(s)
+    if _meth isa Module
+        # pre v1.2, skip
+        _meth = deserialize(s)
+    end
+    return Core.LineInfoNode(_meth::Symbol, deserialize(s)::Symbol, deserialize(s)::Int, deserialize(s)::Int)
+end
+
+function deserialize(s::AbstractSerializer, ::Type{CodeInfo})
+    ci = ccall(:jl_new_code_info_uninit, Ref{CodeInfo}, ())
+    deserialize_cycle(s, ci)
+    ci.code = deserialize(s)::Vector{Any}
+    ci.codelocs = deserialize(s)::Vector{Int32}
+    _x = deserialize(s)
+    if _x isa Array || _x isa Int
+        pre_12 = false
+        ci.ssavaluetypes = _x
+    else
+        pre_12 = true
+        # < v1.2
+        ci.method_for_inference_limit_heuristics = _x
+        ci.ssavaluetypes = deserialize(s)
+        ci.linetable = deserialize(s)
+    end
+    ci.ssaflags = deserialize(s)
+    if pre_12
+        ci.slotflags = deserialize(s)
+    else
+        ci.method_for_inference_limit_heuristics = deserialize(s)
+        ci.linetable = deserialize(s)
+    end
+    ci.slotnames = deserialize(s)
+    if !pre_12
+        ci.slotflags = deserialize(s)
+        ci.slottypes = deserialize(s)
+        ci.rettype = deserialize(s)
+        ci.parent = deserialize(s)
+        ci.min_world = deserialize(s)
+        ci.max_world = deserialize(s)
+    end
+    ci.inferred = deserialize(s)
+    ci.inlineable = deserialize(s)
+    ci.propagate_inbounds = deserialize(s)
+    ci.pure = deserialize(s)
+    return ci
+end
+
 function deserialize_array(s::AbstractSerializer)
     slot = s.counter; s.counter += 1
     d1 = deserialize(s)

stdlib/Serialization/test/runtests.jl

@@ -1,6 +1,6 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Test, Random, Serialization
+using Test, Random, Serialization, Base64
 
 # Check that serializer hasn't gone out-of-frame
 @test Serialization.sertag(Symbol) == 1
@@ -551,3 +551,9 @@ let f = tempname(), x = [rand(2,2), :x, "hello"]
     @test deserialize(f) == x
     rm(f)
 end
+
+# a serialized function from v1.0/v1.1
+let f_data = "N0pMBwQAAAA0MxMAAAAAAAAAAAEFIyM1IzYiAAAAABBYH04BBE1haW6bRCIAAAAAIgAAAABNTEy+AQIjNRUAI+AjAQAAAAAAAAAfTgEETWFpbkQBAiM1AQdSRVBMWzNdvxBTH04BBE1haW6bRAMAAAAzLAAARkYiAAAAAE7BTBsVRuIWA1YkH04BBE1haW5EAQEq4SXhFgNWJB9OAQRNYWluRJ0o4CXiFgFVKOEVAAbiAQAAAAEAAAABAAAATuIVRuA0EAEMTGluZUluZm9Ob2RlH04BBE1haW6bRB9OAQRNYWluRAECIzUBB1JFUExbM13g3xXfFeIAAAAVRuKifX5MTExMTuIp"
+    f = deserialize(IOBuffer(base64decode(f_data)))
+    @test f(10,3) == 23
+end