Update to Rust 2024 edition

Author: dinfuehr

Cargo.lock

@@ -6,7 +6,7 @@ description = "The Dora programming language"
 homepage = "https://github.com/dinfuehr/dora"
 repository = "https://github.com/dinfuehr/dora"
 license = "MIT"
-edition = "2021"
+edition = "2024"
 
 [features]
 default = ["capstone"]
@@ -31,7 +31,7 @@ num_enum = "*"
 tempfile = "*"
 
 [target.'cfg(windows)'.dependencies.windows-sys]
-version = "0.52"
+version = "0.60.2"
 features = [
     "Win32_Foundation",
     "Win32_System_Console",

dora-runtime/Cargo.toml

@@ -6,7 +6,7 @@ use crate::boots::data::InstructionSet;
 use crate::compiler::codegen::get_bytecode;
 use crate::compiler::{CompilationData, CompilationMode};
 use crate::gc::Address;
-use crate::mirror::{byte_array_from_buffer, Object, Ref, UInt8Array};
+use crate::mirror::{Object, Ref, UInt8Array, byte_array_from_buffer};
 use crate::{Shape, SpecializeSelf, VM};
 use dora_bytecode::{
     BytecodeFunction, BytecodeTypeArray, ConstPoolEntry, ConstPoolOpcode, EnumData, FunctionData,
@@ -94,7 +94,7 @@ pub fn encode_optional_specialize_self(
     specialize_self: &Option<SpecializeSelf>,
     buffer: &mut ByteBuffer,
 ) {
-    if let Some(ref specialize_self) = specialize_self {
+    if let Some(specialize_self) = specialize_self {
         buffer.emit_bool(true);
         encode_specialize_self(vm, specialize_self, buffer);
     } else {
@@ -268,22 +268,22 @@ pub fn encode_bytecode_type(vm: &VM, ty: &BytecodeType, buffer: &mut ByteBuffer)
             buffer.emit_u8(BytecodeTypeKind::TypeParam as u8);
             buffer.emit_id(*type_param_id as usize);
         }
-        BytecodeType::Enum(enum_id, ref source_type_array) => {
+        BytecodeType::Enum(enum_id, source_type_array) => {
             buffer.emit_u8(BytecodeTypeKind::Enum as u8);
             buffer.emit_id(enum_id.0 as usize);
             encode_bytecode_type_array(vm, source_type_array, buffer);
         }
-        BytecodeType::Struct(struct_id, ref source_type_array) => {
+        BytecodeType::Struct(struct_id, source_type_array) => {
             buffer.emit_u8(BytecodeTypeKind::Struct as u8);
             buffer.emit_id(struct_id.0 as usize);
             encode_bytecode_type_array(vm, source_type_array, buffer);
         }
-        BytecodeType::Class(class_id, ref source_type_array) => {
+        BytecodeType::Class(class_id, source_type_array) => {
             buffer.emit_u8(BytecodeTypeKind::Class as u8);
             buffer.emit_id(class_id.0 as usize);
             encode_bytecode_type_array(vm, source_type_array, buffer);
         }
-        BytecodeType::TraitObject(trait_id, ref source_type_array, assoc_types) => {
+        BytecodeType::TraitObject(trait_id, source_type_array, assoc_types) => {
             buffer.emit_u8(BytecodeTypeKind::TraitObject as u8);
             buffer.emit_id(trait_id.0 as usize);
             encode_bytecode_type_array(vm, source_type_array, buffer);
@@ -336,7 +336,7 @@ fn encode_constpool_array(vm: &VM, fct: &BytecodeFunction, buffer: &mut ByteBuff
 
 fn encode_constpool_entry(vm: &VM, const_entry: &ConstPoolEntry, buffer: &mut ByteBuffer) {
     match const_entry {
-        ConstPoolEntry::String(ref value) => {
+        ConstPoolEntry::String(value) => {
             buffer.emit_u8(ConstPoolOpcode::String.into());
             buffer.emit_u32(value.len() as u32);
 

dora-runtime/src/boots/serializer.rs

@@ -1,31 +1,31 @@
 use std::collections::HashMap;
 
+use crate::SpecializeSelf;
 use crate::cannon::asm::BaselineAssembler;
+use crate::compiler::CompilationMode;
 use crate::compiler::codegen::{
-    ensure_runtime_entry_trampoline, AllocationSize, AnyReg, CompilationData,
+    AllocationSize, AnyReg, CompilationData, ensure_runtime_entry_trampoline,
 };
 use crate::compiler::runtime_entry_trampoline::{NativeFct, NativeFctKind};
-use crate::compiler::CompilationMode;
 use crate::cpu::{
-    has_lzcnt, has_popcnt, has_tzcnt, Reg, CALLEE_SAVED_REGS, FREG_PARAMS, FREG_RESULT, FREG_TMP1,
-    REG_PARAMS, REG_RESULT, REG_SP, REG_TMP1, REG_TMP2, STACK_FRAME_ALIGNMENT,
+    CALLEE_SAVED_REGS, FREG_PARAMS, FREG_RESULT, FREG_TMP1, REG_PARAMS, REG_RESULT, REG_SP,
+    REG_TMP1, REG_TMP2, Reg, STACK_FRAME_ALIGNMENT, has_lzcnt, has_popcnt, has_tzcnt,
 };
 use crate::gc::Address;
 use crate::masm::{CondCode, Label, Mem};
 use crate::mem::{self, align_i32};
 use crate::mirror::Header;
 use crate::mode::MachineMode;
 use crate::vm::{
+    CodeDescriptor, EnumLayout, GcPoint, INITIALIZED, Intrinsic, LazyCompilationSite, Trap, VM,
     compute_vtable_index, create_enum_instance, create_struct_instance, find_trait_impl,
     find_trait_ty_impl, get_concrete_tuple_bty, get_concrete_tuple_bty_array, specialize_ty,
-    specialize_ty_array, CodeDescriptor, EnumLayout, GcPoint, Intrinsic, LazyCompilationSite, Trap,
-    INITIALIZED, VM,
+    specialize_ty_array,
 };
-use crate::SpecializeSelf;
 use dora_bytecode::{
-    display_fct, display_ty, read, BytecodeFunction, BytecodeOffset, BytecodeTraitType,
-    BytecodeType, BytecodeTypeArray, BytecodeVisitor, ConstPoolEntry, ConstPoolIdx, FunctionId,
-    FunctionKind, GlobalId, Location, Register,
+    BytecodeFunction, BytecodeOffset, BytecodeTraitType, BytecodeType, BytecodeTypeArray,
+    BytecodeVisitor, ConstPoolEntry, ConstPoolIdx, FunctionId, FunctionKind, GlobalId, Location,
+    Register, display_fct, display_ty, read,
 };
 
 macro_rules! comment {
@@ -1946,7 +1946,7 @@ impl<'a> CannonCodeGen<'a> {
 
     fn emit_new_tuple(&mut self, dest: Register, idx: ConstPoolIdx) {
         let source_type_array = match self.bytecode.const_pool(idx) {
-            ConstPoolEntry::Tuple(ref source_type_array) => source_type_array,
+            ConstPoolEntry::Tuple(source_type_array) => source_type_array,
             _ => unreachable!(),
         };
         let subtypes = self.specialize_ty_array(source_type_array);
@@ -4606,7 +4606,7 @@ impl<'a> BytecodeVisitor for CannonCodeGen<'a> {
     fn visit_new_tuple(&mut self, dest: Register, idx: ConstPoolIdx) {
         comment!(self, {
             let subtypes = match self.bytecode.const_pool(idx) {
-                ConstPoolEntry::Tuple(ref subtypes) => subtypes,
+                ConstPoolEntry::Tuple(subtypes) => subtypes,
                 _ => unreachable!(),
             };
             let tuple_name = display_ty(&self.vm.program, &BytecodeType::Tuple(subtypes.clone()));