refactor: migrate to rust 2024 edition

Author: secona

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 members = [
 	"crates/belalang",
 	"crates/belalang_compiler",

crates/belalang/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "belalang"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 publish = false
 license = "Apache-2.0"
 

crates/belalang/src/main.rs

@@ -13,13 +13,10 @@ fn main() {
         .get_matches();
 
     match matches.subcommand() {
-        None => {
-            if let Some(filename) = matches.get_one::<String>("filename") {
-                run(filename.into()).unwrap();
-            } else {
-                repl();
-            }
-        }
+        None => match matches.get_one::<String>("filename") {
+            Some(filename) => run(filename.into()).unwrap(),
+            _ => repl(),
+        },
         _ => unreachable!(),
     }
 }

crates/belalang_compiler/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "belalang_compiler"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 publish = false
 license = "Apache-2.0"
 

crates/belalang_compiler/src/ast/parser.rs

@@ -48,7 +48,7 @@ impl From<&Token> for Precedence {
 }
 
 macro_rules! expect_peek {
-    ($self:expr, $token:pat) => {
+    ($self:expr_2021, $token:pat) => {
         if matches!($self.peek_token, $token) {
             $self.next_token()?;
             true
@@ -61,7 +61,7 @@ macro_rules! expect_peek {
 pub(super) use expect_peek;
 
 macro_rules! optional_peek {
-    ($self:expr, $token:pat) => {
+    ($self:expr_2021, $token:pat) => {
         if matches!($self.peek_token, $token) {
             $self.next_token()?;
             true

crates/belalang_compiler/tests/common/mod.rs

@@ -18,7 +18,7 @@ pub fn test_parse_to_string(input: &str, expected: &str) {
 
 #[macro_export]
 macro_rules! as_variant {
-    ($value:expr, $variant:path) => {
+    ($value:expr_2021, $variant:path) => {
         if let $variant(x) = $value {
             x
         } else {
@@ -29,28 +29,28 @@ macro_rules! as_variant {
 
 #[macro_export]
 macro_rules! ident_has_name {
-    ($value:expr, $expected:expr) => {
+    ($value:expr_2021, $expected:expr_2021) => {
         assert_eq!($value.value, $expected);
         assert_eq!($value.token.to_string(), $expected.to_string());
     };
 }
 
 #[macro_export]
 macro_rules! expr_variant {
-    ($value:expr, $variant:path = $expected:expr) => {
+    ($value:expr_2021, $variant:path = $expected:expr_2021) => {
         let v = as_variant!($value, $variant);
 
         assert_eq!(v.value, $expected);
         assert_eq!(v.token.to_string(), $expected.to_string());
     };
-    ($value:expr, Infix => ($left_variant:path = $left:expr, $op:expr, $right_variant:path = $right:expr)) => {
+    ($value:expr_2021, Infix => ($left_variant:path = $left:expr_2021, $op:expr_2021, $right_variant:path = $right:expr_2021)) => {
         let v = as_variant!($value, ast::Expression::Infix);
 
         expr_variant!(&*v.left, $left_variant = $left);
         expr_variant!(&*v.right, $right_variant = $right);
         assert_eq!(v.operator, $op);
     };
-    ($value: expr, Prefix => ($op:expr, $right_variant:path = $right:expr)) => {
+    ($value: expr_2021, Prefix => ($op:expr_2021, $right_variant:path = $right:expr_2021)) => {
         let v = as_variant!($value, ast::Expression::Prefix);
 
         expr_variant!(&*v.right, $right_variant = $right);

crates/belalang_macros/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "belalang_macros"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 publish = false
 license = "Apache-2.0"
 

crates/belalang_vm/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "belalang_vm"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 publish = false
 license = "Apache-2.0"
 

crates/belalang_vm/src/core/vm.rs

@@ -10,7 +10,7 @@ use crate::objects::integer::BelalangInteger;
 use crate::objects::string::BelalangString;
 
 macro_rules! pop_object {
-    ($self:expr) => {
+    ($self:expr_2021) => {
         if let Ok(StackObject::Object(obj)) = $self.stack.pop() {
             obj.as_ptr()
         } else {

crates/belalang_vm/src/mem/heap.rs

@@ -66,28 +66,30 @@ impl Heap {
     /// - The type T matches the type that was originally allocated
     /// - No other parts of the program retain references to this memory after deallocation
     pub unsafe fn dealloc<T>(&mut self, ptr: NonNull<T>) -> Result<(), RuntimeError> {
-        let layout = Layout::new::<T>();
-
-        let base_ptr = ptr.as_ptr() as *mut BelalangBase;
-
-        if let Some(start) = self.start {
-            if start.as_ptr() == base_ptr {
-                self.start = (*base_ptr).next;
-            } else {
-                let mut current = start;
-                while let Some(next) = (*current.as_ptr()).next {
-                    if next.as_ptr() == base_ptr {
-                        (*current.as_ptr()).next = (*base_ptr).next;
-                        break;
+        unsafe {
+            let layout = Layout::new::<T>();
+
+            let base_ptr = ptr.as_ptr() as *mut BelalangBase;
+
+            if let Some(start) = self.start {
+                if start.as_ptr() == base_ptr {
+                    self.start = (*base_ptr).next;
+                } else {
+                    let mut current = start;
+                    while let Some(next) = (*current.as_ptr()).next {
+                        if next.as_ptr() == base_ptr {
+                            (*current.as_ptr()).next = (*base_ptr).next;
+                            break;
+                        }
+                        current = next;
                     }
-                    current = next;
                 }
             }
-        }
 
-        dealloc(ptr.as_ptr() as *mut u8, layout);
+            dealloc(ptr.as_ptr() as *mut u8, layout);
 
-        Ok(())
+            Ok(())
+        }
     }
 }