Borrowing of inline types allows violating of unique value constraints

[yorickpeterse]

Please describe the bug

When an inline type contains a uni T value, it's possible to borrow the inline type and still access the uni T (through e.g. a uni ref T) even after the uni T is sent to another process. For example:

type async Unsound {
  fn async unsound(value: uni Foo) {}
}

type Foo {
  let @value: Int
}

type inline Bar {
  let @value: uni Foo
}

type async Main {
  fn async main {
    let a = Bar(recover Foo(42))
    let b = ref a

    match a {
      case { @value = v } -> Unsound().unsound(v)
    }

    # we can continue to use `uni Foo` here through `b.value`
  }
}

The issue here is that inline types being copied results in an alias to the uni T value.

A potential option is to disallow borrowing of inline types if they contain a uni T value, though this may prove too heavy handed.

Operating system

Fedora

Inko version

main

[yorickpeterse]

Not allowing borrows of inline types containing uni T values won't work, as this effectively prohibits calling methods on such inline types (as this borrows the receiver).

[yorickpeterse]

I think we can handle this by extending the type verification done when lowering to MIR: if we encounter a mut T or ref T where T contains a uni V, then we produce an error as using such a borrow isn't safe.

A variation is that we allow such borrows, but restrict access to methods that happen to borrow the field(s) in question. I'm not sure yet which approach is best.

[yorickpeterse]

If we were to introduce unique types as added in #798, we'd run into a similar issue where borrows of inline types can alias the unique types.