On Thursday, 31 March 2016 at 13:10:49 UTC, Steven Schveighoffer
wrote:
Voldemort types are what cause the bloat, templates inside
templates aren't as much of a problem.
So here's an idea of other things don't work out: voldemort types
don't have a name that can be said... that could be true in the
mangle too.
We could potentially just hash it to some fixed length. Take the
existing name, SHA1 it, and call the mangle
function_containing_type$that_hash. Demangling the inside is
useless anyway, so we lose nothing from that.
For example, a function foo.bar() returning a voldemort type
might have the mangle:
_D3foo3barv$55ca6286e3e4f4fba5d0448333fa99fc5a404a73
where that's the hash of whatever filth the compiler makes up for
it.
and methods on the voldemort type would start with that too:
_D503foo3barv$55ca6286e3e4f4fba5d0448333fa99fc5a404a735empty
That's getting messy to see as an example, but it took the name
of the function + the voldemort as a whole to be the public name
of the type.
A demangler could scan that for the $ and recognize it as
ugliness and slice it off, printing the name as a somewhat
human-readable
foo.bar().empty
perhaps, so we can see it is a method on the return value of that
function. It isn't completely impossible like demanging a whole
hash; should be short in the binary and readable enough to make
sense of in a stack trace.
I actually recall something like this being done at some point in
the past, but I don't remember the details. I think it just
truncated the name though, it didn't attempt to remain
semi-reversible.
Of course, a chain of voldemort types will still include that
type as a template argument in the next call, so names as a whole
can still be very long, but how long are your chains? I can see
this becoming a 10 KB long name in extreme circumstances (still
yikes) but not megabytes.
And, still, having to run over the names to build the hash is
going to be a memory/speed thing in the compiler, but SHA1ing a
few megabytes isn't as slow as writing it out to disk over and
over again.
Another thing to consider is what my D to Javascript thing did:
abbreviate EVERYTHING in the object file. You can't demangle that
at all, but it leads to much smaller binaries. This probably
isn't that useful for D in general, but might solve Weka's
problem since they can use internal hacks.
