pure static

[Meta]

On Monday, 6 January 2014 at 20:35:39 UTC, bearophile wrote:
> Currently this compiles because arr gets copied (or moved) 
> (another less visible write of arr happens at the point of its 
> initialization, it gets written by its init):
>
>
> int[5] foo() pure {
>     int[5] arr;
>     return arr;
> }
> void main() {}
>
>
> Currently even this function compiles, despite it's not 
> actually pure, because arr contains garbage (and it's garbage 
> that leaks information from other function stack frames, so 
> it's a security hazard), so in theory a good compiler should 
> disallow this:
>
> int[5] foo() pure {
>     int[5] arr = void;
>     return arr;
> }
> void main() {}
>
>
>
> On the other hand I think a strongly pure function like this 
> could be accepted, avoiding the final copy of the result (the 
> result contains a pointer to static data. Here the static data 
> is an array, but returning a pointer to a static struct is 
> equally valid):
>
> int[] foo() pure {
>     pure static int[5] arr;
>     return arr;
> }
> void main() {}
>
>
> "pure static" data means that 'arr' get cleaned (overwritten by 
> its init) at the entry of the function foo (just like for 
> not-static variables), to keep the function referentially 
> transparent.
>
> So this is forbidden:
>
> pure static int[5] arr = void;
>
>
> A smart compiler can even see arr is fully assigned inside the 
> function and optimize away the first clear of the array:
>
> int[] foo() pure {
>     pure static int[5] arr; // optimized as =void
>     foreach (immutable int i, ref r; arr)
>         r = i;
>     return arr;
> }
> void main() {}
>
>
> Bye,
> bearophile

Why not just return arr.dup instead? You're returning a slice of 
a stack-allocated array, so of course you shouldn't write code 
like this.