build: upgrade to rust v1.86.0 (#584)

Author: gvozdvmozgu

Cargo.lock

@@ -107,7 +107,8 @@ impl<'a> TypeDefinition<'a> {
 
     /// Returns the size of the type in bytes
     pub fn size_in_bytes(&self) -> usize {
-        ((self.size_in_bits + 7) / 8)
+        self.size_in_bits
+            .div_ceil(8)
             .try_into()
             .expect("cannot covert size in bytes to platform size")
     }

crates/mun_abi/src/type_info.rs

@@ -19,7 +19,6 @@ apple-codesign = { workspace = true }
 array-init = { workspace = true }
 by_address = { workspace = true }
 bytemuck = { workspace = true }
-mun_db = { version = "0.6.0-dev", path = "../mun_db" }
 mun_hir = { version = "0.6.0-dev", path = "../mun_hir" }
 mun_hir_input = { version = "0.6.0-dev", path = "../mun_hir_input" }
 inkwell = { workspace = true, features = ["llvm14-0", "target-x86", "target-aarch64"] }

crates/mun_codegen/Cargo.toml

@@ -32,10 +32,10 @@ impl<'db, 'ink> CodeGenContext<'db, 'ink> {
         Self {
             context,
             rust_types: RefCell::new(HashMap::default()),
-            hir_types: HirTypeCache::new(context, db.upcast(), target_machine.get_target_data()),
+            hir_types: HirTypeCache::new(context, db, target_machine.get_target_data()),
             optimization_level: db.optimization_level(),
             target_machine,
-            db: db.upcast(),
+            db,
         }
     }
 

crates/mun_codegen/src/code_gen/context.rs

@@ -209,7 +209,7 @@ fn gen_struct_info<'ink>(
             .len()
             .try_into()
             .expect("could not convert num_fields to smaller bit size"),
-        memory_kind: hir_struct.data(db.upcast()).memory_kind,
+        memory_kind: hir_struct.data(db).memory_kind,
     }
 }
 

crates/mun_codegen/src/code_gen/symbols/mod.rs

@@ -14,7 +14,7 @@ use crate::{AssemblyIr, ModuleGroupId, ModulePartition, TargetAssembly};
 /// generation cache is pretty granular there is still a benefit to not having
 /// to recompile assemblies if not required.
 #[salsa::query_group(CodeGenDatabaseStorage)]
-pub trait CodeGenDatabase: mun_hir::HirDatabase + mun_db::Upcast<dyn mun_hir::HirDatabase> {
+pub trait CodeGenDatabase: mun_hir::HirDatabase {
     /// Set the optimization level used to generate assemblies
     #[salsa::input]
     fn optimization_level(&self) -> inkwell::OptimizationLevel;

crates/mun_codegen/src/db.rs

@@ -168,7 +168,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
             .map(|(idx, ty)| {
                 let param = self.fn_value.get_nth_param(idx as u32).unwrap();
                 if let Some(s) = ty.as_struct() {
-                    if s.data(self.db.upcast()).memory_kind == abi::StructMemoryKind::Value {
+                    if s.data(self.db).memory_kind == abi::StructMemoryKind::Value {
                         deref_heap_value(&self.builder, param)
                     } else {
                         param
@@ -199,9 +199,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
                 self.builder.build_return(None);
             } else if let Some(value) = ret_value {
                 let ret_value = if let Some(hir_struct) = fn_ret_type.as_struct() {
-                    if hir_struct.data(self.db.upcast()).memory_kind
-                        == mun_hir::StructMemoryKind::Value
-                    {
+                    if hir_struct.data(self.db).memory_kind == mun_hir::StructMemoryKind::Value {
                         self.gen_struct_alloc_on_heap(hir_struct, value.into_struct_value())
                     } else {
                         value
@@ -224,8 +222,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
                 tail,
             } => self.gen_block(expr, statements, *tail),
             Expr::Path(ref p) => {
-                let resolver =
-                    mun_hir::resolver_for_expr(self.db.upcast(), self.body.owner(), expr);
+                let resolver = mun_hir::resolver_for_expr(self.db, self.body.owner(), expr);
                 Some(self.gen_path_expr(p, expr, &resolver))
             }
             Expr::Literal(lit) => Some(self.gen_literal(lit, expr)),
@@ -372,7 +369,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
         }
         let struct_lit = value.into_struct_value();
 
-        match hir_struct.data(self.db.upcast()).memory_kind {
+        match hir_struct.data(self.db).memory_kind {
             mun_hir::StructMemoryKind::Value => struct_lit.into(),
             mun_hir::StructMemoryKind::Gc => {
                 // TODO: Root memory in GC
@@ -573,7 +570,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
         resolver: &Resolver,
     ) -> inkwell::values::BasicValueEnum<'ink> {
         match resolver
-            .resolve_path_as_value_fully(self.db.upcast(), path)
+            .resolve_path_as_value_fully(self.db, path)
             .expect("unknown path")
             .0
         {
@@ -603,7 +600,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
     ) -> BasicValueEnum<'ink> {
         let ty = &self.infer[expr];
         if let Some(s) = ty.as_struct() {
-            if s.data(self.db.upcast()).memory_kind == mun_hir::StructMemoryKind::Gc {
+            if s.data(self.db).memory_kind == mun_hir::StructMemoryKind::Gc {
                 return deref_heap_value(&self.builder, value);
             }
         }
@@ -618,7 +615,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
         resolver: &Resolver,
     ) -> inkwell::values::PointerValue<'ink> {
         match resolver
-            .resolve_path_as_value_fully(self.db.upcast(), path)
+            .resolve_path_as_value_fully(self.db, path)
             .expect("unknown path")
             .0
         {
@@ -647,7 +644,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
             TyKind::Float(_) => self.gen_binary_op_float(lhs, rhs, op),
             TyKind::Int(ty) => self.gen_binary_op_int(lhs, rhs, op, ty.signedness),
             TyKind::Struct(s) => {
-                if s.data(self.db.upcast()).memory_kind == mun_hir::StructMemoryKind::Value {
+                if s.data(self.db).memory_kind == mun_hir::StructMemoryKind::Value {
                     self.gen_binary_op_value_struct(lhs, rhs, op)
                 } else {
                     self.gen_binary_op_heap_struct(lhs, rhs, op)
@@ -1064,8 +1061,7 @@ impl<'db, 'ink, 't> BodyIrGenerator<'db, 'ink, 't> {
         let body = self.body.clone();
         match &body[expr] {
             Expr::Path(ref p) => {
-                let resolver =
-                    mun_hir::resolver_for_expr(self.db.upcast(), self.body.owner(), expr);
+                let resolver = mun_hir::resolver_for_expr(self.db, self.body.owner(), expr);
                 Some(self.gen_path_place_expr(p, expr, &resolver))
             }
             Expr::Field {

crates/mun_codegen/src/ir/body.rs

@@ -59,10 +59,8 @@ fn collect_expr<'ink>(
     }
 
     if let Expr::Path(path) = expr {
-        let resolver = mun_hir::resolver_for_expr(db.upcast(), body.owner(), expr_id);
-        if let Some((ValueNs::StructId(_), _)) =
-            resolver.resolve_path_as_value_fully(db.upcast(), path)
-        {
+        let resolver = mun_hir::resolver_for_expr(db, body.owner(), expr_id);
+        if let Some((ValueNs::StructId(_), _)) = resolver.resolve_path_as_value_fully(db, path) {
             collect_intrinsic(context, target, &intrinsics::new, intrinsics);
             // self.collect_intrinsic( module, entries, &intrinsics::drop);
             *needs_alloc = true;

crates/mun_codegen/src/ir/intrinsics.rs

@@ -173,7 +173,7 @@ impl<'db, 'ink> HirTypeCache<'db, 'ink> {
     /// that should be used for variables.
     pub fn get_struct_reference_type(&self, struct_ty: mun_hir::Struct) -> BasicTypeEnum<'ink> {
         let ir_ty = self.get_struct_type(struct_ty);
-        match struct_ty.data(self.db.upcast()).memory_kind {
+        match struct_ty.data(self.db).memory_kind {
             mun_hir::StructMemoryKind::Gc => {
                 // GC values are pointers to pointers
                 // struct Foo {}

crates/mun_codegen/src/ir/ty.rs

@@ -35,36 +35,6 @@ impl salsa::Database for MockDatabase {
     }
 }
 
-impl mun_db::Upcast<dyn mun_hir::AstDatabase> for MockDatabase {
-    fn upcast(&self) -> &(dyn mun_hir::AstDatabase + 'static) {
-        self
-    }
-}
-
-impl mun_db::Upcast<dyn SourceDatabase> for MockDatabase {
-    fn upcast(&self) -> &(dyn SourceDatabase + 'static) {
-        self
-    }
-}
-
-impl mun_db::Upcast<dyn mun_hir::DefDatabase> for MockDatabase {
-    fn upcast(&self) -> &(dyn mun_hir::DefDatabase + 'static) {
-        self
-    }
-}
-
-impl mun_db::Upcast<dyn mun_hir::HirDatabase> for MockDatabase {
-    fn upcast(&self) -> &(dyn mun_hir::HirDatabase + 'static) {
-        self
-    }
-}
-
-impl mun_db::Upcast<dyn CodeGenDatabase> for MockDatabase {
-    fn upcast(&self) -> &(dyn CodeGenDatabase + 'static) {
-        self
-    }
-}
-
 impl Default for MockDatabase {
     fn default() -> Self {
         let mut db = MockDatabase {