Allow passing uni ref T to ref T in certain cases

This allows passing values of type `uni ref T` to arguments of type `ref
T`, provided no aliases to the unique reference/borrow can be created.
This makes it possible to recover values into `uni T` when using methods
that take immutable references to do so, something that was previously
not possible.

This fixes #570.

Changelog: added

compiler/src/type_check/expressions.rs

@@ -441,7 +441,7 @@ impl MethodCall {
     ) {
         let given = argument.cast_according_to(expected, &state.db);
 
-        if self.require_sendable {
+        if self.require_sendable || given.is_uni_ref(&state.db) {
             self.check_sendable.push((given, location.clone()));
         }
 
@@ -463,7 +463,7 @@ impl MethodCall {
     }
 
     fn check_sendable(&mut self, state: &mut State, location: &SourceLocation) {
-        if !self.require_sendable {
+        if self.check_sendable.is_empty() {
             return;
         }
 
@@ -472,12 +472,12 @@ impl MethodCall {
         // thus violating the uniqueness constraints.
         let ref_safe = self.method.is_immutable(&state.db)
             && self.check_sendable.iter().all(|(typ, _)| {
-                typ.is_sendable(&state.db) || typ.is_ref(&state.db)
+                typ.is_sendable(&state.db) || typ.is_sendable_ref(&state.db)
             });
 
         for (given, loc) in &self.check_sendable {
             if given.is_sendable(&state.db)
-                || (given.is_ref(&state.db) && ref_safe)
+                || (given.is_sendable_ref(&state.db) && ref_safe)
             {
                 continue;
             }
@@ -1471,13 +1471,18 @@ impl<'a> CheckMethodBody<'a> {
 
         // Since other types aren't compatible with Any, we only need to check
         // the first value's type.
-        if !types.is_empty() && types[0].is_any(self.db()) {
-            self.state.diagnostics.error(
-                DiagnosticId::InvalidType,
-                "Arrays can't store values of type 'Any'",
-                self.file(),
-                node.location.clone(),
-            );
+        if let Some(&first) = types.get(0) {
+            if !first.allow_in_array(self.db()) {
+                self.state.diagnostics.error(
+                    DiagnosticId::InvalidType,
+                    format!(
+                        "Values of type '{}' can't be stored in an Array",
+                        format_type(self.db(), first)
+                    ),
+                    self.file(),
+                    node.location.clone(),
+                );
+            }
         }
 
         let ins =

types/src/check.rs

@@ -473,7 +473,7 @@ impl<'a> TypeChecker<'a> {
                 _ => false,
             },
             TypeRef::UniRef(left_id) => match right {
-                TypeRef::UniRef(right_id) => {
+                TypeRef::UniRef(right_id) | TypeRef::Ref(right_id) => {
                     self.check_type_id(left_id, right_id, env, rules)
                 }
                 TypeRef::Error => true,
@@ -1526,6 +1526,11 @@ mod tests {
             TypeRef::UniRef(instance(thing)),
             TypeRef::UniRef(instance(thing)),
         );
+        check_ok(
+            &db,
+            TypeRef::UniRef(instance(thing)),
+            TypeRef::Ref(instance(thing)),
+        );
         check_ok(&db, TypeRef::UniRef(instance(thing)), TypeRef::Error);
 
         check_err(
@@ -1555,6 +1560,11 @@ mod tests {
             TypeRef::UniMut(instance(thing)),
             TypeRef::UniRef(instance(thing)),
         );
+        check_err(
+            &db,
+            TypeRef::UniMut(instance(thing)),
+            TypeRef::Mut(instance(thing)),
+        );
         check_err(&db, TypeRef::UniMut(instance(thing)), placeholder(var));
         check_err(&db, TypeRef::UniMut(instance(thing)), TypeRef::Any);
     }

types/src/lib.rs

@@ -3458,6 +3458,19 @@ impl TypeRef {
         }
     }
 
+    pub fn allow_in_array(self, db: &Database) -> bool {
+        match self {
+            TypeRef::Any
+            | TypeRef::RefAny
+            | TypeRef::UniRef(_)
+            | TypeRef::UniMut(_) => false,
+            TypeRef::Placeholder(id) => {
+                id.value(db).map_or(true, |v| v.allow_in_array(db))
+            }
+            _ => true,
+        }
+    }
+
     pub fn is_any(self, db: &Database) -> bool {
         match self {
             TypeRef::Any | TypeRef::RefAny => true,
@@ -3620,6 +3633,16 @@ impl TypeRef {
         }
     }
 
+    pub fn is_sendable_ref(self, db: &Database) -> bool {
+        match self {
+            TypeRef::Ref(_) | TypeRef::UniRef(_) => true,
+            TypeRef::Placeholder(id) => {
+                id.value(db).map_or(false, |v| v.is_sendable_ref(db))
+            }
+            _ => false,
+        }
+    }
+
     pub fn is_ref(self, db: &Database) -> bool {
         match self {
             TypeRef::Ref(_) => true,
@@ -3815,7 +3838,10 @@ impl TypeRef {
     pub fn allow_as_ref(self, db: &Database) -> bool {
         match self {
             TypeRef::Any => true,
-            TypeRef::Owned(_) | TypeRef::Mut(_) | TypeRef::Ref(_) => true,
+            TypeRef::Owned(_)
+            | TypeRef::Mut(_)
+            | TypeRef::Ref(_)
+            | TypeRef::Uni(_) => true,
             TypeRef::Placeholder(id) => {
                 id.value(db).map_or(false, |v| v.allow_as_ref(db))
             }
@@ -3827,7 +3853,7 @@ impl TypeRef {
         match self {
             TypeRef::Any => true,
             TypeRef::Owned(TypeId::RigidTypeParameter(id)) => id.is_mutable(db),
-            TypeRef::Owned(_) | TypeRef::Mut(_) => true,
+            TypeRef::Owned(_) | TypeRef::Mut(_) | TypeRef::Uni(_) => true,
             TypeRef::Placeholder(id) => {
                 id.value(db).map_or(false, |v| v.allow_as_mut(db))
             }
@@ -4969,7 +4995,7 @@ mod tests {
         assert!(placeholder(var).allow_as_ref(&db));
         assert!(owned(rigid(param)).allow_as_ref(&db));
         assert!(TypeRef::Any.allow_as_ref(&db));
-        assert!(!uni(instance(int)).allow_as_ref(&db));
+        assert!(uni(instance(int)).allow_as_ref(&db));
     }
 
     #[test]
@@ -4990,7 +5016,7 @@ mod tests {
         assert!(owned(rigid(param2)).allow_as_mut(&db));
         assert!(!immutable(instance(int)).allow_as_mut(&db));
         assert!(!owned(rigid(param1)).allow_as_mut(&db));
-        assert!(!uni(instance(int)).allow_as_mut(&db));
+        assert!(uni(instance(int)).allow_as_mut(&db));
     }
 
     #[test]