Cannot take slice of scope static array in @safe code

[Steven Schveighoffer]

On 2/2/20 1:57 PM, ag0aep6g wrote:
> On 02.02.20 19:49, ag0aep6g wrote:
>> On 02.02.20 19:18, Steven Schveighoffer wrote:
>> I'm not sure if I got it right, but like this?
>>
>>      int*[][] g1;
>>      int*[] g2;
>>      int* g3;
>>
>>      void main() @safe
>>      {
>>          /* An array stored on the stack, of references to heap data: */
>>          int*[3] a1 = [new int, new int, new int];
>>          /* Another such array: */
>>          int*[3] a2 = [new int, new int, new int];
>>          /* An array of those arrays, stored on the stack: */
>>          int*[][2] b = [a1[], a2[]];
>>
>>          g1 = b[]; /* Nope. */
>>          g2 = b[0]; /* Nope. */
>>          g3 = b[0][0]; /* Ok. */
>>      }
> 
> I guess I kinda missed the point there, and what you want is this:
> 
>      scope int*[][] slice = b[];
>      /* ... use `slice` in non-leaky ways ... */
> 
> Which DIP 1000 doesn't allow, because it wouldn't be able to ensure that 
> the references to a1 and a2 don't leak. Yeah, DIP 1000 falls somewhat 
> short.

The simple problem I've had is (I think), I want an array of strings 
that is scope as a parameter (i.e. I won't share any of the addresses of 
those elements outside the function), but the strings themselves are 
strings that are usable anywhere.

I can't figure out where I've seen this, or how to reproduce it (writing 
a simple test seems to work). But I've had it happen to me.

That's the problem with dip1000. It works in most cases, and then you 
get this one tricky case, and you can't figure out how to get around it. 
Or you have to do everything in one expression so the compiler can 
deduce the actual scope-ness of things you aren't allowed to declare. It 
leaves a general feeling of something missed in the design.

-Steve