RFC: Add generic copy stagedfunction for all types

base/expr.jl

@@ -31,8 +31,6 @@ copy(e::Expr) = (n = Expr(e.head);
                  n.args = astcopy(e.args);
                  n.typ = e.typ;
                  n)
-copy(s::SymbolNode) = SymbolNode(s.name, s.typ)
-copy(n::GetfieldNode) = GetfieldNode(n.value, n.name, n.typ)
 
 # copy parts of an AST that the compiler mutates
 astcopy(x::Union(SymbolNode,GetfieldNode,Expr)) = copy(x)

base/linalg/uniformscaling.jl

@@ -12,7 +12,6 @@ ndims(J::UniformScaling) = 2
 getindex(J::UniformScaling, i::Integer,j::Integer) = ifelse(i==j,J.λ,zero(J.λ))
 
 show(io::IO, J::UniformScaling) = print(io, "$(typeof(J))\n$(J.λ)*I")
-copy(J::UniformScaling) = UniformScaling(J.λ)
 
 transpose(J::UniformScaling) = J
 ctranspose(J::UniformScaling) = UniformScaling(conj(J.λ))

base/operators.jl

@@ -170,10 +170,27 @@ widen{T<:Number}(x::T) = convert(widen(T), x)
 
 sizeof(x) = Core.sizeof(x)
 
-# copying immutable things
+# copying immutables is a no-op; mutables create a new object with the same contents
+stagedfunction Base.copy(x)
+    if !x.mutable
+        :x
+    else
+        quote
+            y = ccall(:jl_new_struct_uninit, Any, (Any,), $x)
+            for i in 1:length($(x.names))
+                !isdefined(x, i) && continue
+                fld = getfield(x, i)
+                setfield!(y, i, ifelse(x === fld, y, fld))
+            end
+            y
+        end
+    end
+end
+# Avoid staging for common immutable types
 copy(x::Union(Symbol,Number,AbstractString,Function,Tuple,LambdaStaticData,
               TopNode,QuoteNode,DataType,UnionType)) = x
 
+
 # function pipelining
 |>(x, f::Callable) = f(x)
 

base/process.jl

@@ -100,7 +100,6 @@ end
 
 immutable DevNullStream <: AsyncStream end
 const DevNull = DevNullStream()
-copy(::DevNullStream) = DevNull
 uvhandle(::DevNullStream) = C_NULL
 uvhandle(x::Ptr) = x
 uvtype(::Ptr) = UV_STREAM

base/range.jl

@@ -228,7 +228,7 @@ maximum(r::Range)  = isempty(r) ? error("range must be non-empty") : max(first(r
 ctranspose(r::Range) = [x for _=1, x=r]
 transpose(r::Range) = r'
 
-# Ranges are immutable
+# Ranges are immutable, but the AbstractArray copy method doesn't know that
 copy(r::Range) = r