Escape Analysis on reddit

[Walter Bright]

Steven Schveighoffer wrote:
> So how does foo know what scope return means?  Consider a min function:
> 
> scope T min(T)(scope T v1, scope T v2);
> 
> Now, let's try it out:
> 
> scope int *foo(scope int *p)
> {
>    int x;
>    return min(&x, p);
> }
> 
> Shouldn't this not compile?  If you say 'well, the compiler can take the 
> most conservative approach, and assume scope means the most inner scope.'

Assume the compiler keeps track of, for every expression, a list of 
references that it is composed of. For:
     min(&x, p)
the compiler knows that min() returns some combination of v1 and v2, so 
the expression min(&x, p) is tagged with the list [&x,p]. Now it 
examines the return, and sees that [&x,p] is escaping the scope of the 
function. Although p is a scope parameter, the scope on the foo() return 
value says that's ok, so that passes. The &x, however, fails because 
it's a reference to a local going out of scope.

So, I think we've got this case covered properly.

But I don't like the syntax. For one thing, if the return value might 
refer to parameter p1 but not p2, we need to express that. So, something 
like:

int* foo(return scope int* p1, scope int* p2, return scope int* p3);

Now, the caller tags a call to foo() with [arg1,arg3] for its escape 
analysis, omitting arg2.

The fly in this is I'd like to combine it somehow with the const 
propagation issue of argument type to return type.