No Aliasing In Any Nested Call

The no-aliasing rule for pointer parameters checks for conflicting accesses in any nested function call.

This is the rule again, but with particular emphasis:

a pointer is passed as an argument to user-declared function, and
the called function, or one of the stack of functions it may call, has two views (pointer, reference, or both) into the same original variable, and
there is a potential write via one of those views.

The code sample shows valid and invalid cases where a helper function writes via a pointer parameter p1, and reads from a pointer parameter p2. It is an error for p1 to alias p2.

The analysis checks for a conflict in the directly called function, or any deeply nested call.

// f1 writes via p1, reads via p2 fn f1(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { *p1 = *p2; // Writes via p1, reads via p2 } // f2 delegates to f1. fn f2(p1 : ptr<function, i32>, p2 : ptr<function, i32>) { f1(p1, p2); } fn f3() { var a: i32; // f1(&a,&a); // Error: Cannot pass two pointer parameters // with the same root identifier. // The conflicting accesses are in the directly called // function, f1. // f2(&a,&a); // Error: This time the conflict is in f1, called by f2. // The analysis looks through the whole call stack. var b: i32; f2(&a, &b); // This is ok, since a and b don't alias. }