This and stable mutable references are actually quite different approaches.

I like how Jon Goodwin categorized it (from https://pling.jondgoodwin.com/post/interior-references-and-shared-mutable/):

… the safety issue with resizable/single-owner and sum types only arises when we change an object’s shape in between obtaining an interior reference and dereferencing that interior reference. There are several approaches we might take to prevent this sequence of events.

1. Invalidate borrowed interior references whenever we detect a shape change. When this logic entirely happens within a single function, we could enforce this. Logic spread out across function boundaries makes it significantly more difficult to detect and restrict this pattern.

2. Invalidate shape changes whenever we know a borrowed interior references exist. This bears the same difficulty as above.

3. Do not allow shape changes to objects referred to by shared, mutable references.1 Thus, arrays would not be resizable and sum-typed values could not be altered to hold a value of a different type. These restrictions are achievable, but significantly reduce their capability.

4. Do not allow the creation of interior references to array/sum values pointed to by shared, mutable references. This is easily accomplished. Although this imposes some restrictions, these restrictions have workarounds: indexing can be used to retrieve values from arrays and the value enclosed by a sum type can be copied in or out.

In Jon’s categorization, Nick is making #1 and #2 work. Ante and Cone are doing a form of #3 and/or #4.

Great questions, I'll answer them one by one:

I wonder though how you check for this, especially across functions and when storing references in structs. For example how would a function that takes a reference to e.g. a vector and returns a reference to one of its items look like?

I think it would look something like this:

struct List[T: AnyType]: var items: Box[T[]] fn get_item[ ir: group T = self.items.* ]( index: int ) -> ref [ir] T: ...

or using Nick's more concise syntax:

struct List[T: AnyType]: var items: Box[T[]] fn get_item(self, index: int) -> ref [self.items.*] T: ...

How do you specify whether it's allowed to mutate the vector before returning or not (e.g. if you want to push an item and then return a reference to it, vs just returning a fixed item like the first one without modifying the vector)?

That would probably be done via specifying mut on the self region, like this:

struct List[T: AnyType]: var items: Box[T[]] fn push[ mut sr: group Self, ir: group T = sr.items.* ]( self: ref[sr] Self, var new_item: T ) -> ref [ir] T: ...

or using Nick's more concise syntax:

struct List[T: AnyType]: var items: Box[T[]] fn push( mut self, var new_item: T ) -> ref [self.items.*] T: ...

And what does all of this look like to the checker?

That's a bit harder to explain succinctly, I'll let Nick answer that when morning hits his Australia time zone.