How to validate reference use?

Question

I use "reference" term here like in C++ world, not like in C# (for example). I use non-C++ syntax on purpose -- this is general question, not about this particular implementation.

Starting something like C++ afresh I would like to make rules and validation in order to prevent a case when reference outlives its source. For example this looks like a valid usage:

def foo(x ref int) ref int
    return x;
end

But this is wrong:

def bar() ref int
    x int = 5;
    return x;
end

because in bar example x is put on stack and when reference to it is returned this stack is already gone.

I didn't so far find the analysis algorithm description so that is why I am asking -- what to allow (for example defining parameters as references), and how to check when the usage is abused creating dangling references?

Answer 1

What you are looking for is called escape analysis, and like pretty much all static analysis of programs is equivalent to solving the Halting Problem.

It can only be solved in restricted circumstances, in particular, it is much easier to solve if the language is specifically designed in such a way as to restrict the kinds of programs that can be written to that subset which is amenable to static escape analysis.

Answer 2

If you are creating a low-level language, there is nothing you can do to stop dangling pointers, null pointers, circular references, and memory leaks. The best you can do is provide a memory debugger to help track down bugs.

On the other hand, if you are creating a higher-level language, then you can stop all these problems by not allowing programmers direct access to pointers. An example of this is the POSIX ln command. A user cannot use it to hard link directories; only the root user can. A user simply cannot any of the problems with pointers.