Infer return types as sendable for mutable methods

In addition to inferring return types as sendable for immutable methods,
we now do the same for mutable methods _if and only if_ it's guaranteed
the receiver won't be able to store _any_ aliases (i.e. borrows). When
working with files and sockets (and similar types) this makes it easier
to work with mutating methods, removing the need for manually recovering
the values to owned values and then recovering them back to unique
values. For example, it's now possible to write this:

    import std.fs.file (WriteOnlyFile)

    let file = recover WriteOnlyFile.new('/tmp/test.txt'.to_path).get

    file.write_string('hello').get

Prior to this commit this wouldn't be possible as `write_string` is a
mutable method, requiring you to write something along the lines of this
instead:

    import std.fs.file (WriteOnlyFile)

    let mut file = recover {
      WriteOnlyFile.new('/tmp/test.txt'.to_path).get
    }

    file = recover {
      let file = recover file

      file.write_string('hello').get
      file
    }

This fixes #589.

Changelog: added

Author: yorickpeterse

compiler/src/type_check/expressions.rs

@@ -536,10 +536,12 @@ impl MethodCall {
             return;
         }
 
+        let immutable = self.method.is_immutable(&state.db);
+
         // It's safe to pass `ref T` as an argument if all arguments and `self`
         // are immutable, as this prevents storing of the `ref T` in `self`,
         // thus violating the uniqueness constraints.
-        let ref_safe = self.method.is_immutable(&state.db)
+        let ref_safe = immutable
             && self.check_sendable.iter().all(|(typ, _)| {
                 typ.is_sendable(&state.db) || typ.is_sendable_ref(&state.db)
             });
@@ -566,13 +568,24 @@ impl MethodCall {
             return;
         }
 
-        // If `self` and all arguments are immutable, we allow owned return
-        // values provided they don't contain any references. This is safe
-        // because `self` can't have references to it (because it's immutable),
-        // we can't "leak" a reference through the arguments (because they too
-        // are immutable), and the returned value can't refer to `self` because
-        // we don't allow references anywhere in the type or its sub types.
-        let ret_sendable = if ref_safe {
+        // In certain cases it's fine to allow non-unique owned values to be
+        // returned, provided we can guarantee (based on what we know at the
+        // call site) no uniqueness constaints are violated.
+        //
+        // For immutable methods, if all the arguments are sendable then
+        // returned owned values can't be aliased by the callee.
+        //
+        // For mutable methods, we additionally require that the receiver can't
+        // ever store aliases to the returned data. Since the receiver is likely
+        // typed as `uni T` (which itself is sendable) we perform that check
+        // against its owned counterpart.
+        let ret_sendable = if ref_safe
+            || (!immutable
+                && self
+                    .receiver
+                    .as_owned(&state.db)
+                    .is_sendable_output(&state.db))
+        {
             self.return_type.is_sendable_output(&state.db)
         } else {
             self.return_type.is_sendable(&state.db)

docs/source/getting-started/concurrency.md

@@ -124,7 +124,7 @@ any values returned must be sendable for the method to be available. Since this
 is overly strict in many instances, the compiler relaxes this rule whenever it
 determines it's safe to do so. These exceptions are listed below.
 
-### Immutable methods and arguments
+### Immutable methods
 
 If a method isn't able to mutate its receiver because it's defined as `fn`
 instead of `fn mut`, it's safe to pass immutable borrows as arguments (which
@@ -155,69 +155,69 @@ its `user` argument can't be stored in the `uni User` value stored in `alice`.
 This _isn't_ possible if the method allows mutations (= it's an `fn mut` method)
 because that would allow it to store the `ref User` in `self`.
 
-### Non-unique return values
+### Mutable methods
 
-If the return type of a method is owned and not unique (e.g. `Array[String]`
-instead of `uni Array[String]`), the method _is_ available if it either doesn't
-specify any arguments, all arguments are immutable borrows or all arguments
-are sendable, _and_ the returned value doesn't contain any borrows:
+There's an exception to the previous rule when it comes to the use of mutating
+methods on unique receivers: if the compiler can guarantee the receiver can't
+store any aliases to the returned data, it's in fact safe to use a mutating
+method:
 
 ```inko
 type User {
   let @name: String
   let @friends: Array[String]
 
-  fn friends -> Array[String] {
-    @friends.clone
+  fn mut remove_last_friend -> Option[String] {
+    @friends.pop
   }
 }
 
 type async Main {
   fn async main {
     let alice = recover User(name: 'Alice', friends: ['Bob'])
-
-    alice.friends
+    let friend = alice.remove_last_friend
   }
 }
 ```
 
-Here the call `alice.friends` is valid because:
+Here the call to `User.remove_last_friend` _is_ allowed because the `User` type
+doesn't store any borrows, nor do any sub values (e.g. the `Array` stored in the
+`friends` field).
 
-1. `User.friends` is immutable
-1. `User.friends` doesn't accept any arguments
-1. Because of this the `Array[String]` value can only be created from within
-   `User.friends` and no aliases to it can exist upon returning it
+### Non-unique return values
 
-This isn't the case if `User.friends` is an `fn mut` method, because now the
-value might originate from `self`:
+If the return type of a method is owned and not unique (e.g. `Array[String]`
+instead of `uni Array[String]`), the method _is_ available if it either doesn't
+specify any arguments, all arguments are immutable borrows or all arguments
+are sendable, _and_ the returned value doesn't contain any borrows:
 
 ```inko
 type User {
   let @name: String
-  let mut @friends: Array[String]
+  let @friends: Array[String]
 
-  fn mut friends -> Array[String] {
-    @friends := []
+  fn friends -> Array[String] {
+    @friends.clone
   }
 }
 
 type async Main {
   fn async main {
     let alice = recover User(name: 'Alice', friends: ['Bob'])
-    let bob = User(name: 'Bob', friends: ['Alice'])
-    let friends = alice.friends
+
+    alice.friends
   }
 }
 ```
 
-If you try to build this, the compiler produces the following error:
+Here the call `alice.friends` is valid because:
 
-```
-test.inko:14:25 error(invalid-call): the receiver of this call requires a sendable return type, but 'Array[String]' isn't sendable
-```
+1. `User.friends` is immutable
+1. `User.friends` doesn't accept any arguments
+1. Because of this the `Array[String]` value can only be created from within
+   `User.friends` and no aliases to it can exist upon returning it
 
-Similarly, the call isn't valid if the returned value contains borrows. For
-example:
+The call isn't valid if the returned value contains borrows. For example:
 
 ```inko
 type User {
@@ -287,7 +287,7 @@ type async Main {
 Here the call to `alice.wrap` is invalid because `Wrapper` defines a field of
 type `ref User`, which isn't sendable.
 
-### Unsendable and unused return values
+### Unused return values
 
 There's an exception to the above rule: if the returned value isn't sendable but
 also isn't used by the caller, the method _can_ be used:

std/fixtures/diagnostics/uni_with_mutable_methods.inko

@@ -0,0 +1,53 @@
+type HasBorrow {
+  let @a: Array[Int]
+  let @b: ref Array[Int]
+
+  fn static new -> Self {
+    let a = [10, 20]
+    let b = ref a
+
+    Self(a: a, b: b)
+  }
+
+  fn immutable -> Result[Int, String] {
+    Result.Ok(42)
+  }
+
+  fn mut mutable -> Result[Int, String] {
+    Result.Ok(42)
+  }
+}
+
+type NoBorrow {
+  let @a: Array[Int]
+
+  fn static new -> Self {
+    Self([10, 20])
+  }
+
+  fn immutable -> Result[Int, String] {
+    Result.Ok(42)
+  }
+
+  fn mut mutable -> Result[Int, String] {
+    Result.Ok(42)
+  }
+}
+
+fn example1(value: uni HasBorrow) {
+  let _used = value.immutable
+}
+
+fn example2(value: uni HasBorrow) {
+  let _used = value.mutable
+}
+
+fn example3(value: uni NoBorrow) {
+  let _used = value.immutable
+}
+
+fn example4(value: uni NoBorrow) {
+  let _used = value.mutable
+}
+
+# uni_with_mutable_methods.inko:42:21 error(invalid-call): the receiver of this call requires a sendable return type, but 'Result[Int, String]' isn't sendable