On Sun, May 16, 2021 at 04:40:53PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
> This works also,
> 
> ```
> import std.stdio:writeln;
> 
> int [] fun(){
> 	int[3]s=[1,2,3];
> 	int[] r=s;
> 	return r;
> }
> 
> void main(){
> 	writeln(fun()[0]);
> }
> ```

https://issues.dlang.org/show_bug.cgi?id=15932

Though I believe if you compile with -dip25 -dip1000 the compiler should emit an error for the above code.  If not, please file a bug against -dip1000.


T

-- 
Obviously, some things aren't very obvious.

On 5/16/21 12:32 PM, Alain De Vos wrote:
> 
> Why doesn't this program dups core ?
> Is s not recycled ?
> ```
> import std.stdio:writeln;
> void main(){
> //I point to the heap
> int[] p=[1,2,3];
>      {
>          int[3]s=[1,2,3];
>          //I point to the stack
>          p=s;
>      }
>      //Why do I still live ?
>      writeln(p[0]);
> }
> 
> ```

To answer your question, why does this not dump core, it's because you didn't access memory that was invalid. Stack memory, like most computer memory, is allocated in chunks to the program. The OS typically allocates pages at a time per request for it. Which means, even though the memory isn't technically in scope, it's not going to cause a segmentation fault (this is a hardware fault saying you accessed an address that doesn't exist in your process).

In order for a dangling pointer (which is what this is) to cause a seg fault, you have to release that memory back to the OS, and make that address invalid before accessing. D very rarely gives memory back to the OS.

The more common problem for dangling pointers is that you access a piece of memory that has since been reallocated to something else, and screw up that something (generally a pointer).

-Steve

On Sunday, 16 May 2021 at 16:58:15 UTC, H. S. Teoh wrote:
> On Sun, May 16, 2021 at 04:40:53PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
>> This works also,
>> 
>> ```
>> import std.stdio:writeln;
>> 
>> int [] fun(){
>> 	int[3]s=[1,2,3];
>> 	int[] r=s;
>> 	return r;
>> }
>> 
>> void main(){
>> 	writeln(fun()[0]);
>> }
>> ```
>
> https://issues.dlang.org/show_bug.cgi?id=15932
>
> Though I believe if you compile with -dip25 -dip1000 the compiler should emit an error for the above code.  If not, please file a bug against -dip1000.
>
>
> T

I use ldc2. No dip flags here.

On 16.05.21 19:24, Alain De Vos wrote:
> On Sunday, 16 May 2021 at 16:58:15 UTC, H. S. Teoh wrote:
[...]
>> Though I believe if you compile with -dip25 -dip1000 the compiler should emit an error for the above code.  If not, please file a bug against -dip1000.
>>
>>
>> T
> 
> I use ldc2. No dip flags here.

ldc2 understands `-dip1000`. It also understands the newer `-preview=dip1000`.

More importantly, the code needs to be @safe. @system code is not checked for this kind of error.

the flag dip1000 was not shown in the help file.
And indeed for the second program compiling with dip1000 results in,
test.d(6): Error: scope variable r may not be returned

But the first program still compiles and runs without problem, even with dip1000.

On Sun, May 16, 2021 at 05:24:40PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
> On Sunday, 16 May 2021 at 16:58:15 UTC, H. S. Teoh wrote:
> > On Sun, May 16, 2021 at 04:40:53PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
> > > This works also,
> > > 
> > > ```
> > > import std.stdio:writeln;
> > > 
> > > int [] fun(){
> > > 	int[3]s=[1,2,3];
> > > 	int[] r=s;
> > > 	return r;
> > > }
> > > 
> > > void main(){
> > > 	writeln(fun()[0]);
> > > }
> > > ```
> > 
> > https://issues.dlang.org/show_bug.cgi?id=15932
> > 
> > Though I believe if you compile with -dip25 -dip1000 the compiler should emit an error for the above code.  If not, please file a bug against -dip1000.
[...]
> I use ldc2. No dip flags here.

---------snip---------
import std.stdio:writeln;

int [] fun() @safe {		// N.B.: need @safe
	int[3]s=[1,2,3];
	int[] r=s;
	return r;
}

void main() @safe {		// N.B.: need @safe
	writeln(fun()[0]);
}
---------snip---------


LDC output:

---------snip---------
$ ldc2 -dip1000 /tmp/test.d
/tmp/test.d(6): Error: scope variable `r` may not be returned
---------snip---------


T

-- 
People say I'm indecisive, but I'm not sure about that. -- YHL, CONLANG

Is there a list of compiler flags not shown ?

On Sunday, 16 May 2021 at 18:27:40 UTC, H. S. Teoh wrote:
> On Sun, May 16, 2021 at 05:24:40PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
>> On Sunday, 16 May 2021 at 16:58:15 UTC, H. S. Teoh wrote:
>> > On Sun, May 16, 2021 at 04:40:53PM +0000, Alain De Vos via Digitalmars-d-learn wrote:
>> > > This works also,
>> > > 
>> > > ```
>> > > import std.stdio:writeln;
>> > > 
>> > > int [] fun(){
>> > > 	int[3]s=[1,2,3];
>> > > 	int[] r=s;
>> > > 	return r;
>> > > }
>> > > 
>> > > void main(){
>> > > 	writeln(fun()[0]);
>> > > }
>> > > ```
>> > 
>> > https://issues.dlang.org/show_bug.cgi?id=15932
>> > 
>> > Though I believe if you compile with -dip25 -dip1000 the compiler should emit an error for the above code.  If not, please file a bug against -dip1000.
> [...]
>> I use ldc2. No dip flags here.
>
> ---------snip---------
> import std.stdio:writeln;
>
> int [] fun() @safe {		// N.B.: need @safe
> 	int[3]s=[1,2,3];
> 	int[] r=s;
> 	return r;
> }
>
> void main() @safe {		// N.B.: need @safe
> 	writeln(fun()[0]);
> }
> ---------snip---------
>
>
> LDC output:
>
> ---------snip---------
> $ ldc2 -dip1000 /tmp/test.d
> /tmp/test.d(6): Error: scope variable `r` may not be returned
> ---------snip---------
>
>
> T

So I put everywhere @safe ?
When not ?