Policy for exposing range structs

[Adam D. Ruppe via Digitalmars-d]

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.