Re: dip1000: why can't the addressee come into existence later?

[Stanislav Blinov via Digitalmars-d-learn]

On Saturday, 10 November 2018 at 06:56:29 UTC, Neia Neutuladh 
wrote:
The following code doesn't work with @safe -dip1000:

    int* p;
    int i;
    p = &i;
i has a shorter lifetime than p, the compiler complains.

But this code does:

    int i;
    int* p;
    p = &i;

The compiler does this even in the absence of scope guards and 
destructors because simple, obvious rules will be easier to 
understand and implement than nuanced ones, even if it makes 
you reorder declarations sometimes.

Is this right?

Yep, you just over-simplified the first case. Consider:

int* p;
{
    int i;
    p = &i;
}
*p = 42;

or even:

module thing;

int* global;

void foo() {
    int i;
    global = &i;
}

...much simpler to just go by the lifetime, instead of attempting 
to do a complex analysis. Because for the latter, it would then 
*need* to be deep to be of any use at all. Especially in a 
language that has static ifs:

// parameter is not scope, function is not pure, etc.
void nasty(int* p) { /* ... */ }

void main() {
    int *p;
    int i;
    p = &i;
    static if (someCondition) nasty(p);
}