Support StorageLive and StorageDead

Author: tiif

crates/formality-check/src/mini_rust_check.rs

@@ -94,6 +94,7 @@ impl Check<'_> {
             declared_input_tys,
             callee_input_tys: Map::new(),
             crate_id: crate_id.clone(),
+            fn_args: body.args.clone(),
         };
 
         // (4) Check statements in body are valid
@@ -150,6 +151,24 @@ impl Check<'_> {
                 self.check_place(typeck_env, place_expression)?;
                 // FIXME: check that access the place is allowed per borrowck rules
             }
+            minirust::Statement::StorageLive(local_id) => {
+                // FIXME: We need more checks here after loan is introduced.
+                if self.find_local_id(&typeck_env, local_id).is_none() {
+                    bail!("Statement::StorageLive: invalid local variable")
+                }
+            }
+            minirust::Statement::StorageDead(local_id) => {
+                // FIXME: We need more checks here after loan is introduced.
+                let Some((local_id, _)) = self.find_local_id(&typeck_env, local_id) else {
+                    bail!("Statement::StorageDead: invalid local variable")
+                };
+                // Make sure function arguments and return place are not marked as dead.
+                if local_id == typeck_env.ret_id
+                    || typeck_env.fn_args.iter().any(|fn_arg| local_id == *fn_arg)
+                {
+                    bail!("Statement::StorageDead: trying to mark function arguments or return local as dead")
+                }
+            }
         }
         Ok(())
     }
@@ -249,11 +268,7 @@ impl Check<'_> {
         match place {
             Local(local_id) => {
                 // Check if place id is a valid local id.
-                let Some((_, ty)) = env
-                    .local_variables
-                    .iter()
-                    .find(|(declared_local_id, _)| *declared_local_id == local_id)
-                else {
+                let Some((_, ty)) = self.find_local_id(env, local_id) else {
                     bail!(
                         "PlaceExpression::Local: unknown local name `{:?}`",
                         local_id
@@ -265,6 +280,17 @@ impl Check<'_> {
         Ok(place_ty.clone())
     }
 
+    fn find_local_id(&self, env: &TypeckEnv, local_id: &LocalId) -> Option<(LocalId, Ty)> {
+        if let Some((local_id, ty)) = env
+            .local_variables
+            .iter()
+            .find(|(declared_local_id, _)| *declared_local_id == local_id)
+        {
+            return Some((local_id.clone(), ty.clone()));
+        }
+        return None;
+    }
+
     // Check if the value expression is well-formed, and return the type of the value expression.
     fn check_value(&self, typeck_env: &mut TypeckEnv, value: &ValueExpression) -> Fallible<Ty> {
         let value_ty;
@@ -373,4 +399,7 @@ struct TypeckEnv {
     /// We need this to access information about other functions
     /// declared in the current crate.
     crate_id: CrateId,
+
+    /// LocalId of function argument.
+    fn_args: Vec<LocalId>,
 }

crates/formality-rust/src/grammar/minirust.rs

@@ -71,8 +71,10 @@ pub enum Statement {
     // SetDiscriminant
     // Validate
     // Deinit
-    // StorageLive
-    // StorageDead
+    #[grammar(StorageLive($v0);)]
+    StorageLive(LocalId),
+    #[grammar(StorageDead($v0);)]
+    StorageDead(LocalId),
 }
 
 /// Based on [MiniRust terminators](https://github.com/minirust/minirust/blob/9ae11cc202d040f08bc13ec5254d3d41d5f3cc25/spec/lang/syntax.md#statements-terminators).

src/test/mir_fn_bodies.rs

@@ -227,6 +227,33 @@ fn test_place_mention_statement() {
     )
 }
 
+/// Test valid StorageLive and StorageDead statements.
+#[test]
+fn test_storage_live_dead() {
+    crate::assert_ok!(
+        [
+            crate Foo {
+                fn foo (u32) -> u32 = minirust(v1) -> v0 {
+                    let v0: u32;
+                    let v1: u32;
+                    let v2: u32;
+
+                    bb0: {
+                        statements {
+                            local(v0) = load(local(v1));
+                            StorageLive(v2);
+                            StorageDead(v2);
+                        }
+                        return;
+                    }
+
+                };
+            }
+        ]
+        expect_test::expect![["()"]]
+    )
+}
+
 // Test what will happen if the next block does not exist for Terminator::Call.
 #[test]
 fn test_no_next_bb_for_call_terminator() {
@@ -660,3 +687,53 @@ fn test_invalid_value_in_switch_terminator() {
         expect_test::expect!["The value used for switch must be an int."]
     )
 }
+
+/// Test the behaviour of having return place in StorageDead.
+#[test]
+fn test_ret_place_storage_dead() {
+    crate::assert_err!(
+        [
+            crate Foo {
+                fn foo (u32) -> u32 = minirust(v1) -> v0 {
+                    let v0: u32;
+                    let v1: u32;
+
+                    bb0: {
+                        statements {
+                            StorageDead(v1);
+                        }
+                        return;
+                    }
+
+                };
+            }
+        ]
+        []
+        expect_test::expect!["Statement::StorageDead: trying to mark function arguments or return local as dead"]
+    )
+}
+
+/// Test the behaviour of having function argument in StorageDead.
+#[test]
+fn test_fn_arg_storage_dead() {
+    crate::assert_err!(
+        [
+            crate Foo {
+                fn foo (u32) -> u32 = minirust(v1) -> v0 {
+                    let v0: u32;
+                    let v1: u32;
+
+                    bb0: {
+                        statements {
+                            StorageDead(v0);
+                        }
+                        return;
+                    }
+
+                };
+            }
+        ]
+        []
+        expect_test::expect!["Statement::StorageDead: trying to mark function arguments or return local as dead"]
+    )
+}