serialize doesn't preserve identity of Expr.args

[tmptrash]

It looks like julia doesn't store references correctly. For example, in this snippet, T.a is a reference to block/quote of a function. So, after deserializing, this reference will be broken. Look at the example:

type T
    e::Expr
    a::Array{Any,1}
end

ex = :(function f() return true end)
t  = T(ex, ex.args[2].args) # a refers to function's block
io = open("file.dat", "w")
serialize(io, t)
close(io)

io = open("file.dat")
t1 = deserialize(io)
t1.e.args[2].args === t1.a # false, but should be true, no?
close(io)

This issue is related to this one.

[yuyichao]

I don't think it is possible to do this. In fact deserialize shouldn't create any aliasing with the original input.

[JeffBezanson]

No, this is about shared references within an object. We can handle this in some cases, but not all. For efficiency, we don't track the args array of an Expr separately. @tmptrash how did this come up? I don't think it should be necessary to persist an Expr and its args array and then mutate them. That seems very strange to me.

[yuyichao]

Ahh, I didn't realize the RHS of the === is using t1 and not t.

[tmptrash]

It comes from my backup mechanism. I have to save application state in a file from time to time, because of these crashes. So, after crash it may recover itself from last backup and continue working. I use special tree-like structures (types) for storing all the references inside my AST. This is something like AST meta data (where all variables are, where all functions are and so on).

P.S. For now, i'm thinking about rewriting my code and this meta data types especially, to support numeric indexes instead of references.

[JeffBezanson]

Shared references to Exprs should work. Is it possible to avoid separately referencing the Expr args arrays?

[tmptrash]

As i understand, I may serialize ex.args[x] instead of ex.args[x].args. Is it correct? If yes, then it's possible to rewrite my code in this way, thanks.