Merge pull request JuliaLang#8560 from JuliaLang/sk/deepcopyr

deepcopy: recurse through immutable objects with mutable fields.

NEWS.md

@@ -55,8 +55,9 @@ Library improvements
 
  * New `Nullable` type for missing data ([#8152]).
 
- * New ordschur and ordschur! functions for sorting a schur factorization by the eigenvalues
+ * New `ordschur` and `ordschur!` functions for sorting a schur factorization by the eigenvalues.
 
+ * `deepcopy` recurses through immutable types and makes copies of their mutable fields ([#8560]).
 
 Julia v0.3.0 Release Notes
 ==========================

base/deepcopy.jl

@@ -27,20 +27,23 @@ function deepcopy_internal(x, stackdict::ObjectIdDict)
 end
 
 function _deepcopy_t(x, T::DataType, stackdict::ObjectIdDict)
- if T.names===() || !T.mutable
-  return x
- end
- ret = ccall(:jl_new_struct_uninit, Any, (Any,), T)
- stackdict[x] = ret
- for i in 1:length(T.names)
- if isdefined(x,i)
- ret.(i) = deepcopy_internal(x.(i), stackdict)
+ isbits(T) | isempty(T.names) && return x
+ if T.mutable
+  y = ccall(:jl_new_struct_uninit, Any, (Any,), T)
+  stackdict[x] = y
+  for i in 1:length(T.names)
+  if isdefined(x,i)
+  y.(i) = deepcopy_internal(x.(i), stackdict)
+ end
  end
+ else
+ fields = Any[deepcopy_internal(x.(i), stackdict) for i in 1:length(T.names)]
+ y = ccall(:jl_new_structv, Any, (Any, Ptr{Void}, Uint32),
+ T, pointer(fields), length(fields))
  end
- return ret
+ return y::T
 end
 
-
 function deepcopy_internal(x::Array, stackdict::ObjectIdDict)
  if haskey(stackdict, x)
  return stackdict[x]

doc/stdlib/base.rst

@@ -219,7 +219,7 @@ All Objects
 
 .. function:: deepcopy(x)
 
- Create a deep copy of ``x``: everything is copied recursively, resulting in a fully independent object. For example, deep-copying an array produces a new array whose elements are deep-copies of the original elements.
+ Create a deep copy of ``x``: everything is copied recursively, resulting in a fully independent object. For example, deep-copying an array produces a new array whose elements are deep copies of the original elements. Calling `deepcopy` on an object should generally have the same effect as serializing and then deserializing it.
 
  As a special case, functions can only be actually deep-copied if they are anonymous, otherwise they are just copied. The difference is only relevant in the case of closures, i.e. functions which may contain hidden internal references.