move Serializer to stdlib (JuliaLang#25628)

base/deprecated.jl

@@ -979,6 +979,11 @@ end
 @deprecate_moved randjump "Random" true true
 @deprecate_moved GLOBAL_RNG "Random" false true
 
+@deprecate_moved serialize "Serialization" true true
+@deprecate_moved deserialize "Serialization" true true
+@deprecate_moved AbstractSerializer "Serialization" true true
+@deprecate_moved SerializationState "Serialization" true true
+
 # 24595
 @deprecate falses(A::AbstractArray) falses(size(A))
 @deprecate trues(A::AbstractArray) trues(size(A))

base/dict.jl

@@ -55,8 +55,6 @@ function show(io::IO, t::AbstractDict{K,V}) where V where K
  end
 end
 
-abstract type AbstractSerializer end
-
 # Dict
 
 # These can be changed, to trade off better performance for space

base/exports.jl

@@ -8,7 +8,6 @@ export
  StackTraces,
  Sys,
  Libc,
- Serializer,
  Docs,
  Markdown,
  Threads,
@@ -83,8 +82,6 @@ export
  RoundNearestTiesUp,
  RoundToZero,
  RoundUp,
- AbstractSerializer,
- SerializationState,
  Set,
  Some,
  StepRange,
@@ -835,7 +832,6 @@ export
  close,
  connect,
  countlines,
- deserialize,
  eachline,
  eof,
  fd,
@@ -886,7 +882,6 @@ export
  seekend,
  seekstart,
  send,
- serialize,
  skip,
  skipchars,
  take!,

base/loading.jl

@@ -561,7 +561,7 @@ function create_expr_cache(input::String, output::String, concrete_deps::typeof(
  rm(output, force=true) # Remove file if it exists
  code_object = """
  while !eof(STDIN)
- eval(Main, deserialize(STDIN))
+ eval(Main, Meta.parse(chop(readuntil(STDIN, '\\0'))))
  end
  """
  io = open(pipeline(detach(`$(julia_cmd()) -O0
@@ -572,26 +572,28 @@ function create_expr_cache(input::String, output::String, concrete_deps::typeof(
  "w", STDOUT)
  in = io.in
  try
- serialize(in, quote
+ write(in, """
+ begin
  empty!(Base.LOAD_PATH)
- append!(Base.LOAD_PATH, $LOAD_PATH)
+ append!(Base.LOAD_PATH, $(repr(LOAD_PATH)))
  empty!(Base.LOAD_CACHE_PATH)
- append!(Base.LOAD_CACHE_PATH, $LOAD_CACHE_PATH)
+ append!(Base.LOAD_CACHE_PATH, $(repr(LOAD_CACHE_PATH)))
  empty!(Base.DL_LOAD_PATH)
- append!(Base.DL_LOAD_PATH, $DL_LOAD_PATH)
+ append!(Base.DL_LOAD_PATH, $(repr(DL_LOAD_PATH)))
  empty!(Base._concrete_dependencies)
- append!(Base._concrete_dependencies, $concrete_deps)
+ append!(Base._concrete_dependencies, $(repr(concrete_deps)))
  Base._track_dependencies[] = true
- end)
+ end\0
+ """)
  source = source_path(nothing)
  if source !== nothing
- serialize(in, quote
- task_local_storage()[:SOURCE_PATH] = $(source)
- end)
+ write(in, """
+ task_local_storage()[:SOURCE_PATH] = $(repr(source))\0
+ """)
  end
- serialize(in, :(Base.include(Base.__toplevel__, $(abspath(input)))))
+ write(in, "Base.include(Base.__toplevel__, $(repr(abspath(input))))\0")
  if source !== nothing
- serialize(in, :(delete!(task_local_storage(), :SOURCE_PATH)))
+ write(in, "delete!(task_local_storage(), :SOURCE_PATH)\0")
  end
  close(in)
  catch ex

base/pkg/entry.jl

@@ -581,8 +581,7 @@ end
 
 function build(pkg::AbstractString, build_file::AbstractString, errfile::AbstractString)
  # To isolate the build from the running Julia process, we execute each build.jl file in
- # a separate process. Errors are serialized to errfile for later reporting.
- # TODO: serialize the same way the load cache does, not with strings
+ # a separate process. Errors are written to errfile for later reporting.
  LOAD_PATH = filter(x -> x isa AbstractString, Base.LOAD_PATH)
  code = """
  empty!(Base.LOAD_PATH)
@@ -603,8 +602,8 @@ function build(pkg::AbstractString, build_file::AbstractString, errfile::Abstrac
  ------------------------------------------------------------
  # Build failed for \$pkg
  \""" exception=err,catch_backtrace()
- serialize(f, pkg)
- serialize(f, err)
+ write(f, pkg); write(f, 0x00)
+ write(f, sprint(showerror, err)); write(f, 0x00)
  end
  end
  """
@@ -636,8 +635,8 @@ function build!(pkgs::Vector, errs::Dict, seen::Set=Set())
  mktemp() do errfile, f
  build!(pkgs, seen, errfile)
  while !eof(f)
- pkg = deserialize(f)
- err = deserialize(f)
+ pkg = chop(readuntil(f, '\0'))
+ err = chop(readuntil(f, '\0'))
  errs[pkg] = err
  end
  end

base/precompile.jl

@@ -1190,7 +1190,6 @@ precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{UInt8}
 precompile(Tuple{typeof(Core.Compiler.length), Tuple{Core.Compiler.Const, DataType, Core.Compiler.Const}})
 precompile(Tuple{typeof(Core.Compiler.getindex), Tuple{Core.Compiler.Const, DataType, Core.Compiler.Const}, Int64})
 precompile(Tuple{typeof(Base.unsafe_write), Base.TCPSocket, Base.RefValue{Int32}, Int64})
-precompile(Tuple{typeof(Base.Serializer.write_as_tag), Base.TCPSocket, Int32})
 precompile(Tuple{typeof(Base.copyto!), Array{Any, 1}, Base.MethodList})
 precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{UInt64, UInt64}, UInt64})
 precompile(Tuple{typeof(Base.unique), Array{Symbol, 1}})
@@ -1203,7 +1202,6 @@ precompile(Tuple{typeof(Base.rehash!), Base.Dict{UInt64, Nothing}, Int64})
 precompile(Tuple{typeof(Base.ht_keyindex2!), Base.Dict{UInt64, Nothing}, UInt64})
 precompile(Tuple{typeof(Base._setindex!), Base.Dict{UInt64, Nothing}, Nothing, UInt64, Int64})
 precompile(Tuple{typeof(Base.ht_keyindex), Base.Dict{WeakRef, Any}, TypeName})
-precompile(Tuple{typeof(Base.Serializer.object_number), TypeName})
 precompile(Tuple{typeof(Base.isassigned), Array{Union{Tuple{Any, Int64}, Tuple{Tuple{}, Any, Bool}}, 1}, Int64})
 precompile(Tuple{typeof(Base.uvfinalize), Base.TCPSocket})
 precompile(Tuple{typeof(Base.close), Base.TCPSocket})
@@ -1292,7 +1290,6 @@ precompile(Tuple{typeof(Base.put_unbuffered), Base.Channel{Int64}, Int64})
 precompile(Tuple{typeof(Base.put!), Base.Channel{Int64}, Int64})
 precompile(Tuple{typeof(Base._delete!), Base.Dict{Any, Any}, Int64})
 precompile(Tuple{typeof(Base.write), Base.TCPSocket, Array{Int64, 1}})
-precompile(Tuple{typeof(Base.Serializer.serialize_array_data), Base.TCPSocket, Array{Int64, 1}})
 precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.InsertionSortAlg, Base.Order.ForwardOrdering})
 precompile(Tuple{typeof(Base.Sort.partition!), Array{Int64, 1}, Int64, Int64, Base.Order.ForwardOrdering})
 precompile(Tuple{typeof(Base.sort!), Array{Int64, 1}, Int64, Int64, Base.Sort.QuickSortAlg, Base.Order.ForwardOrdering})
@@ -1455,43 +1452,6 @@ precompile(Tuple{typeof(Base.require), Symbol})
 precompile(Tuple{typeof(Base.resize!), Array{Base.Condition, 1}, Int64})
 precompile(Tuple{typeof(Base.resize!), Array{Tuple{String, Float64}, 1}, Int64})
 precompile(Tuple{typeof(Base.resize!), Array{UInt8, 1}, Int32})
-precompile(Tuple{typeof(Base.Serializer.deserialize_array), Base.Serializer.SerializationState{Base.PipeEndpoint}})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.PipeEndpoint})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{Int64}})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{QuoteNode}})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{String}})
-precompile(Tuple{typeof(Base.Serializer.deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Type{UInt64}})
-precompile(Tuple{typeof(Base.Serializer.deserialize_cycle), Base.Serializer.SerializationState{Base.PipeEndpoint}, Expr})
-precompile(Tuple{typeof(Base.Serializer.deserialize_datatype), Base.Serializer.SerializationState{Base.PipeEndpoint}})
-precompile(Tuple{typeof(Base.Serializer.deserialize_expr), Base.Serializer.SerializationState{Base.PipeEndpoint}, Int64})
-precompile(Tuple{typeof(Base.Serializer.handle_deserialize), Base.Serializer.SerializationState{Base.PipeEndpoint}, Int32})
-precompile(Tuple{typeof(Base.Serializer.serialize_any), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Array{Any, 1}})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Array{String, 1}})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Bool})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Expr})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Int64})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Module})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, SimpleVector})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, String})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Symbol})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Tuple{Int64}})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Tuple{Symbol, UInt64}})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
-precompile(Tuple{typeof(Base.Serializer.serialize), Base.Serializer.SerializationState{Base.Pipe}, UInt64})
-precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, Expr})
-precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
-precompile(Tuple{typeof(Base.Serializer.serialize_cycle), Base.Serializer.SerializationState{Base.Pipe}, UInt64})
-precompile(Tuple{typeof(Base.Serializer.serialize_cycle_header), Base.Serializer.SerializationState{Base.Pipe}, QuoteNode})
-precompile(Tuple{typeof(Base.Serializer.serialize_mod_names), Base.Serializer.SerializationState{Base.Pipe}, Module})
-precompile(Tuple{typeof(Base.Serializer.serialize_type), Base.Serializer.SerializationState{Base.Pipe}, DataType})
-precompile(Tuple{typeof(Base.Serializer.serialize_type_data), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}, Bool})
-precompile(Tuple{typeof(Base.Serializer.serialize_typename), Base.Serializer.SerializationState{Base.Pipe}, TypeName})
-precompile(Tuple{typeof(Base.Serializer.should_send_whole_type), Base.Serializer.SerializationState{Base.Pipe}, Type{Any}})
-precompile(Tuple{typeof(Base.Serializer.write_as_tag), Base.Pipe, Int32})
 precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, Base.Condition}, Base.Condition, Symbol})
 precompile(Tuple{typeof(Base._setindex!), Base.Dict{Symbol, Base.Condition}, Base.Condition, Symbol, Int64})
 precompile(Tuple{typeof(Base.setindex!), Base.Dict{Symbol, UInt64}, UInt64, Symbol})

base/stacktraces.jl

@@ -7,7 +7,6 @@ module StackTraces
 
 
 import Base: hash, ==, show
-import Base.Serializer: serialize, deserialize
 using Base.Printf: @printf
 using Base: coalesce
 
@@ -96,29 +95,6 @@ function hash(frame::StackFrame, h::UInt)
  h = hash(frame.inlined, h)
 end
 
-# provide a custom serializer that skips attempting to serialize the `outer_linfo`
-# which is likely to contain complex references, types, and module references
-# that may not exist on the receiver end
-function serialize(s::AbstractSerializer, frame::StackFrame)
- Serializer.serialize_type(s, typeof(frame))
- serialize(s, frame.func)
- serialize(s, frame.file)
- write(s.io, frame.line)
- write(s.io, frame.from_c)
- write(s.io, frame.inlined)
- write(s.io, frame.pointer)
-end
-
-function deserialize(s::AbstractSerializer, ::Type{StackFrame})
- func = deserialize(s)
- file = deserialize(s)
- line = read(s.io, Int)
- from_c = read(s.io, Bool)
- inlined = read(s.io, Bool)
- pointer = read(s.io, UInt64)
- return StackFrame(func, file, line, nothing, from_c, inlined, pointer)
-end
-
 
 """
  lookup(pointer::Union{Ptr{Cvoid}, UInt}) -> Vector{StackFrame}

base/sysimg.jl

@@ -410,9 +410,6 @@ include("Enums.jl")
 using .Enums
 
 # concurrency and parallelism
-include("serialize.jl")
-using .Serializer
-import .Serializer: serialize, deserialize
 include("channels.jl")
 
 # utilities - timing, help, edit
@@ -509,6 +506,7 @@ Base.require(:Base64)
 Base.require(:CRC32c)
 Base.require(:Dates)
 Base.require(:DelimitedFiles)
+Base.require(:Serialization)
 Base.require(:Distributed)
 Base.require(:FileWatching)
 Base.require(:Future)
@@ -533,6 +531,7 @@ Base.require(:Unicode)
  @deprecate_binding Dates root_module(:Dates) true ", run `using Dates` instead"
  @deprecate_binding Distributed root_module(:Distributed) true ", run `using Distributed` instead"
  @deprecate_binding Random root_module(:Random) true ", run `using Random` instead"
+ @deprecate_binding Serializer root_module(:Serialization) true ", run `using Serialization` instead"
 
  # PR #25249
  @deprecate_binding SparseArrays root_module(:SparseArrays) true ", run `using SparseArrays` instead"

doc/src/base/base.md

@@ -93,7 +93,6 @@ Base.Libc
 Base.Markdown
 Base.Meta
 Base.Pkg
-Base.Serializer
 Base.StackTraces
 Base.Sys
 Base.Threads

doc/src/base/io-network.md

@@ -32,9 +32,6 @@ Base.isreadonly
 Base.iswritable
 Base.isreadable
 Base.isopen
-Base.Serializer.serialize
-Base.Serializer.deserialize
-Base.Serializer.writeheader
 Base.Grisu.print_shortest
 Base.fd
 Base.redirect_stdout

stdlib/Distributed/src/Distributed.jl

@@ -9,7 +9,7 @@ module Distributed
 
 # imports for extension
 import Base: getindex, wait, put!, take!, fetch, isready, push!, length,
- hash, ==, connect, kill, serialize, deserialize, close, showerror
+ hash, ==, connect, kill, close, showerror
 
 # imports for use
 using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connected,
@@ -18,7 +18,10 @@ using Base: Process, Semaphore, JLOptions, AnyDict, buffer_writes, wait_connecte
  AsyncGenerator, acquire, release, invokelatest,
  shell_escape_posixly, uv_error, coalesce, notnothing
 
-# NOTE: clusterserialize.jl imports additional symbols from Base.Serializer for use
+using Serialization
+import Serialization: serialize, deserialize
+
+# NOTE: clusterserialize.jl imports additional symbols from Serialization for use
 
 export
  @spawn,

stdlib/Distributed/src/clusterserialize.jl

@@ -1,10 +1,10 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Base.Serializer: serialize_cycle, deserialize_cycle, writetag,
-  __deserialized_types__, serialize_typename, deserialize_typename,
-  TYPENAME_TAG, reset_state, serialize_type
+using Serialization: serialize_cycle, deserialize_cycle, writetag,
+ __deserialized_types__, serialize_typename, deserialize_typename,
+ TYPENAME_TAG, reset_state, serialize_type
 
-import Base.Serializer: object_number, lookup_object_number, remember_object
+import Serialization: object_number, lookup_object_number, remember_object
 
 mutable struct ClusterSerializer{I<:IO} <: AbstractSerializer
  io::I

stdlib/Distributed/src/messages.jl

@@ -76,7 +76,7 @@ struct JoinCompleteMsg <: AbstractMsg
 end
 
 # Avoiding serializing AbstractMsg containers results in a speedup
-# of approximately 10%. Can be removed once module Serializer
+# of approximately 10%. Can be removed once module Serialization
 # has been suitably improved.
 
 const msgtypes = Any[CallWaitMsg, IdentifySocketAckMsg, IdentifySocketMsg,