From cc86ae58f3ae0a68f6d9885098e2c2af3b5a60f3 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Sun, 27 Apr 2025 11:33:17 -0700 Subject: [PATCH 1/3] chore: bump rust 1.86.0 --- rust-toolchain | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rust-toolchain b/rust-toolchain index 6b4de0a4..b7844a6f 100644 --- a/rust-toolchain +++ b/rust-toolchain @@ -1 +1 @@ -1.83.0 +1.86.0 From 6a3bf89b0214ad10773ca8f4a9c000431ce89cb1 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Sun, 27 Apr 2025 11:50:41 -0700 Subject: [PATCH 2/3] fix: clippy lints --- crates/mun_abi/src/type_info.rs | 3 +- crates/mun_codegen/src/module_group.rs | 2 +- crates/mun_hir/src/expr.rs | 2 +- crates/mun_hir/src/mock.rs | 2 - crates/mun_hir/src/package_defs/collector.rs | 59 +++++++++---------- crates/mun_hir/src/package_defs/tests.rs | 4 +- crates/mun_hir/src/pretty.rs | 4 +- crates/mun_hir/src/resolve.rs | 4 +- .../src/completion/render.rs | 2 +- .../integration_tests/document_symbols.rs | 2 +- crates/mun_memory/tests/diff/util.rs | 2 +- crates/mun_runtime_capi/src/test_util.rs | 1 + crates/mun_syntax/src/ast/tokens.rs | 2 +- crates/mun_target/src/abi/size.rs | 2 +- 14 files changed, 44 insertions(+), 47 deletions(-) diff --git a/crates/mun_abi/src/type_info.rs b/crates/mun_abi/src/type_info.rs index 89c27c15..51a729b9 100644 --- a/crates/mun_abi/src/type_info.rs +++ b/crates/mun_abi/src/type_info.rs @@ -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") } diff --git a/crates/mun_codegen/src/module_group.rs b/crates/mun_codegen/src/module_group.rs index 507fb679..f8c4b871 100644 --- a/crates/mun_codegen/src/module_group.rs +++ b/crates/mun_codegen/src/module_group.rs @@ -102,7 +102,7 @@ impl ModuleGroup { .get(&visible_mod.into()) // If all its children are also part of the module group we can keep the // function internal, so there is no need to export it. - .map_or(true, |&includes_subtree| !includes_subtree) + .is_none_or(|&includes_subtree| !includes_subtree) } } } diff --git a/crates/mun_hir/src/expr.rs b/crates/mun_hir/src/expr.rs index 210c7386..4a42f83f 100644 --- a/crates/mun_hir/src/expr.rs +++ b/crates/mun_hir/src/expr.rs @@ -1071,7 +1071,7 @@ fn integer_lit(str: &str, suffix: Option<&str>) -> (Literal, Vec) let from_lexer = base < 10 && str .chars() - .any(|c| c.to_digit(10).map_or(false, |d| d >= base)); + .any(|c| c.to_digit(10).is_some_and(|d| d >= base)); if from_lexer { (0, Some(LiteralError::LexerError)) } else { diff --git a/crates/mun_hir/src/mock.rs b/crates/mun_hir/src/mock.rs index dc0417af..a6465e6e 100644 --- a/crates/mun_hir/src/mock.rs +++ b/crates/mun_hir/src/mock.rs @@ -1,5 +1,3 @@ -#![cfg(test)] - use mun_db::Upcast; use mun_hir_input::SourceDatabase; use mun_target::spec::Target; diff --git a/crates/mun_hir/src/package_defs/collector.rs b/crates/mun_hir/src/package_defs/collector.rs index 330d04b0..3dec5a29 100644 --- a/crates/mun_hir/src/package_defs/collector.rs +++ b/crates/mun_hir/src/package_defs/collector.rs @@ -411,38 +411,35 @@ impl DefCollector<'_> { // pub foo::Foo; // This is not allowed because Foo is only public within the package. // ``` - match name { - Some(name) => { - let add_result = scope.add_resolution_from_import( - &mut self.from_glob_import, - (import_module_id, name.clone()), - resolution.map(|(item, _)| (item, import_visibility)), - import_type, - ); + let Some(name) = name else { + // This is not yet implemented (bringing in types into scope + // without a name). This might be useful for + // traits. e.g.: ```mun + // use foo::SomeTrait as _; // Should be able to call methods added by + // SomeTrait. ``` + continue; + }; - if add_result.changed { - changed = true; - } - if add_result.duplicate { - let item_tree = self.db.item_tree(import_source.file_id); - let import_data = &item_tree[import_source.value]; - self.package_defs - .diagnostics - .push(DefDiagnostic::duplicate_import( - import_module_id, - InFile::new(import_source.file_id, import_data.ast_id), - import_data.index, - )); - } - } - None => { - // This is not yet implemented (bringing in types into scope without a name). - // This might be useful for traits. e.g.: - // ```mun - // use foo::SomeTrait as _; // Should be able to call methods added by SomeTrait. - // ``` - continue; - } + let add_result = scope.add_resolution_from_import( + &mut self.from_glob_import, + (import_module_id, name.clone()), + resolution.map(|(item, _)| (item, import_visibility)), + import_type, + ); + + if add_result.changed { + changed = true; + } + if add_result.duplicate { + let item_tree = self.db.item_tree(import_source.file_id); + let import_data = &item_tree[import_source.value]; + self.package_defs + .diagnostics + .push(DefDiagnostic::duplicate_import( + import_module_id, + InFile::new(import_source.file_id, import_data.ast_id), + import_data.index, + )); } } diff --git a/crates/mun_hir/src/package_defs/tests.rs b/crates/mun_hir/src/package_defs/tests.rs index dd40d7e8..0d16cb17 100644 --- a/crates/mun_hir/src/package_defs/tests.rs +++ b/crates/mun_hir/src/package_defs/tests.rs @@ -240,7 +240,7 @@ fn tree_for_module( "mod {}", module .name(db) - .map_or_else(|| "mod".to_owned(), |name| name.to_string()) + .map_or_else(|| "mod".to_owned(), |name| name.clone()) )); // Add module level diagnostics @@ -344,7 +344,7 @@ fn fully_qualified_module_path(db: &dyn HirDatabase, module: Module) -> String { .into_iter() .map(|m| { m.name(db) - .map_or_else(|| "package".to_owned(), |name| name.to_string()) + .map_or_else(|| "package".to_owned(), |name| name.clone()) }) .rev(), "::".to_string(), diff --git a/crates/mun_hir/src/pretty.rs b/crates/mun_hir/src/pretty.rs index a3cccba4..48a01dfa 100644 --- a/crates/mun_hir/src/pretty.rs +++ b/crates/mun_hir/src/pretty.rs @@ -39,9 +39,9 @@ pub(crate) fn print_type_ref( pub(crate) fn print_path(_db: &dyn DefDatabase, path: &Path, buf: &mut dyn Write) -> fmt::Result { // Create an iterator that yields the prefix of the path. let prefix_iter = match &path.kind { - PathKind::Super(p) if *p > 0 => Either::Left(iter::repeat("super").take(*p as usize)), + PathKind::Super(p) if *p > 0 => Either::Left(std::iter::repeat_n("super", *p as usize)), PathKind::Package => Either::Right(iter::once("package")), - _ => Either::Left(iter::repeat("").take(0)), + _ => Either::Left(std::iter::repeat_n("", 0)), } .map(Either::Left); diff --git a/crates/mun_hir/src/resolve.rs b/crates/mun_hir/src/resolve.rs index d8e22128..e0bd8fcd 100644 --- a/crates/mun_hir/src/resolve.rs +++ b/crates/mun_hir/src/resolve.rs @@ -208,7 +208,7 @@ impl Resolver { )); } } - Scope::Expr(_) => continue, + Scope::Expr(_) => (), Scope::Impl(i) => { if first_name == &name![Self] { @@ -296,7 +296,7 @@ impl Resolver { for scope in self.scopes.iter().rev() { match scope { - Scope::Expr(_) => continue, + Scope::Expr(_) => {} Scope::Impl(i) => { if first_name == &name![Self] { return Some((TypeNs::SelfType(*i), Visibility::Public, remaining_idx())); diff --git a/crates/mun_language_server/src/completion/render.rs b/crates/mun_language_server/src/completion/render.rs index bce657cf..dab603f4 100644 --- a/crates/mun_language_server/src/completion/render.rs +++ b/crates/mun_language_server/src/completion/render.rs @@ -95,7 +95,7 @@ impl<'a> Render<'a> { ScopeDef::Local(local) => set_item_relevance(local.ty(self.ctx.db())), ScopeDef::ModuleDef(ModuleDef::Struct(st)) => set_item_relevance(st.ty(self.ctx.db())), ScopeDef::ModuleDef(ModuleDef::PrimitiveType(pt)) => { - set_item_relevance(pt.ty(self.ctx.db())) + set_item_relevance(pt.ty(self.ctx.db())); } ScopeDef::ImplSelfType(imp) => set_item_relevance(imp.self_ty(self.ctx.db())), ScopeDef::Unknown diff --git a/crates/mun_language_server/tests/integration_tests/document_symbols.rs b/crates/mun_language_server/tests/integration_tests/document_symbols.rs index d219f64e..8ea28e30 100644 --- a/crates/mun_language_server/tests/integration_tests/document_symbols.rs +++ b/crates/mun_language_server/tests/integration_tests/document_symbols.rs @@ -83,7 +83,7 @@ fn format_document_symbol(symbol: &lsp_types::DocumentSymbol) -> text_trees::Str symbol .detail .as_ref() - .map_or_else(String::new, |s| format!(" ({})", s)) + .map_or_else(String::new, |s| format!(" ({s})")) ), symbol.children.iter().flatten().map(format_document_symbol), ) diff --git a/crates/mun_memory/tests/diff/util.rs b/crates/mun_memory/tests/diff/util.rs index bcbb7634..01266c34 100644 --- a/crates/mun_memory/tests/diff/util.rs +++ b/crates/mun_memory/tests/diff/util.rs @@ -83,7 +83,7 @@ fn apply_struct_mapping( match diff { FieldDiff::Insert { index, .. } => *index, FieldDiff::Move { new_index, .. } => *new_index, - _ => std::usize::MAX, + _ => usize::MAX, } } diff --git a/crates/mun_runtime_capi/src/test_util.rs b/crates/mun_runtime_capi/src/test_util.rs index 9ef58dce..4a3a4803 100644 --- a/crates/mun_runtime_capi/src/test_util.rs +++ b/crates/mun_runtime_capi/src/test_util.rs @@ -71,6 +71,7 @@ macro_rules! test_invalid_runtime { $( paste::item! { #[test] + #[allow(clippy::macro_metavars_in_unsafe)] fn []() { let runtime = Runtime(ptr::null_mut()); let handle = diff --git a/crates/mun_syntax/src/ast/tokens.rs b/crates/mun_syntax/src/ast/tokens.rs index 7be8de94..35720829 100644 --- a/crates/mun_syntax/src/ast/tokens.rs +++ b/crates/mun_syntax/src/ast/tokens.rs @@ -154,6 +154,6 @@ impl Whitespace { pub fn spans_multiple_lines(&self) -> bool { let text = self.text(); text.find('\n') - .map_or(false, |idx| text[idx + 1..].contains('\n')) + .is_some_and(|idx| text[idx + 1..].contains('\n')) } } diff --git a/crates/mun_target/src/abi/size.rs b/crates/mun_target/src/abi/size.rs index 9104bda4..6f3ec288 100644 --- a/crates/mun_target/src/abi/size.rs +++ b/crates/mun_target/src/abi/size.rs @@ -18,7 +18,7 @@ impl Size { pub fn from_bits(bits: impl TryInto) -> Size { let bits = bits.try_into().ok().unwrap(); // Avoid potential overflow from `bits + 7`. - Size::from_bytes(bits / 8 + ((bits % 8) + 7) / 8) + Size::from_bytes(bits / 8 + (bits % 8).div_ceil(8)) } #[inline] From 4c13594a62f08eeded8188781c6f8d39294bcd32 Mon Sep 17 00:00:00 2001 From: gvozdvmozgu Date: Sun, 27 Apr 2025 12:43:06 -0700 Subject: [PATCH 3/3] refactor: remove all upcasts --- Cargo.lock | 8 ----- crates/mun_codegen/Cargo.toml | 1 - crates/mun_codegen/src/code_gen/context.rs | 4 +-- .../mun_codegen/src/code_gen/symbols/mod.rs | 2 +- crates/mun_codegen/src/db.rs | 2 +- crates/mun_codegen/src/ir/body.rs | 22 ++++++------- crates/mun_codegen/src/ir/intrinsics.rs | 6 ++-- crates/mun_codegen/src/ir/ty.rs | 2 +- crates/mun_codegen/src/mock.rs | 30 ----------------- crates/mun_codegen/src/module_partition.rs | 13 +++----- crates/mun_codegen/src/test.rs | 9 +++--- crates/mun_compiler/Cargo.toml | 1 - crates/mun_compiler/src/db.rs | 32 ------------------- crates/mun_compiler/src/driver.rs | 13 ++++---- crates/mun_db/Cargo.toml | 14 -------- crates/mun_db/src/lib.rs | 6 ---- crates/mun_hir/Cargo.toml | 1 - crates/mun_hir/src/code_model.rs | 2 +- crates/mun_hir/src/code_model/function.rs | 12 +++---- crates/mun_hir/src/code_model/impl.rs | 4 +-- crates/mun_hir/src/code_model/module.rs | 2 +- crates/mun_hir/src/code_model/struct.rs | 20 ++++++------ .../src/code_model/struct/validator.rs | 4 +-- crates/mun_hir/src/code_model/type_alias.rs | 22 ++++++------- crates/mun_hir/src/db.rs | 5 ++- crates/mun_hir/src/expr/validator.rs | 28 ++++++++-------- .../expr/validator/uninitialized_access.rs | 4 +-- crates/mun_hir/src/item_tree.rs | 4 +-- crates/mun_hir/src/item_tree/tests.rs | 3 +- crates/mun_hir/src/lib.rs | 1 - crates/mun_hir/src/method_resolution.rs | 22 ++++--------- crates/mun_hir/src/mock.rs | 25 +-------------- crates/mun_hir/src/package_defs.rs | 4 +-- crates/mun_hir/src/semantics.rs | 6 ++-- crates/mun_hir/src/semantics/source_to_def.rs | 6 ++-- crates/mun_hir/src/source_analyzer.rs | 8 ++--- crates/mun_hir/src/ty.rs | 4 +-- crates/mun_hir/src/ty/infer.rs | 23 +++++++------ crates/mun_hir/src/ty/infer/place_expr.rs | 2 +- crates/mun_hir/src/ty/lower.rs | 22 ++++++------- crates/mun_language_server/Cargo.toml | 1 - .../mun_language_server/src/completion/dot.rs | 4 +-- crates/mun_language_server/src/db.rs | 25 --------------- 43 files changed, 129 insertions(+), 300 deletions(-) delete mode 100644 crates/mun_db/Cargo.toml delete mode 100644 crates/mun_db/src/lib.rs diff --git a/Cargo.lock b/Cargo.lock index 80c6c5dd..ab2a8cf8 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2422,7 +2422,6 @@ dependencies = [ "lld_rs", "mun_abi", "mun_codegen_macros", - "mun_db", "mun_hir", "mun_hir_input", "mun_libloader", @@ -2459,7 +2458,6 @@ dependencies = [ "lockfile", "log", "mun_codegen", - "mun_db", "mun_diagnostics", "mun_hir", "mun_hir_input", @@ -2486,10 +2484,6 @@ dependencies = [ "winapi 0.3.9", ] -[[package]] -name = "mun_db" -version = "0.6.0-dev" - [[package]] name = "mun_diagnostics" version = "0.6.0-dev" @@ -2509,7 +2503,6 @@ dependencies = [ "insta", "itertools 0.12.1", "la-arena", - "mun_db", "mun_hir_input", "mun_paths", "mun_syntax", @@ -2547,7 +2540,6 @@ dependencies = [ "log", "lsp-server", "lsp-types", - "mun_db", "mun_diagnostics", "mun_hir", "mun_hir_input", diff --git a/crates/mun_codegen/Cargo.toml b/crates/mun_codegen/Cargo.toml index 5047cbee..52990240 100644 --- a/crates/mun_codegen/Cargo.toml +++ b/crates/mun_codegen/Cargo.toml @@ -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"] } diff --git a/crates/mun_codegen/src/code_gen/context.rs b/crates/mun_codegen/src/code_gen/context.rs index cbb99dee..bf7ccdca 100644 --- a/crates/mun_codegen/src/code_gen/context.rs +++ b/crates/mun_codegen/src/code_gen/context.rs @@ -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, } } diff --git a/crates/mun_codegen/src/code_gen/symbols/mod.rs b/crates/mun_codegen/src/code_gen/symbols/mod.rs index cafe65f0..b337e5b5 100644 --- a/crates/mun_codegen/src/code_gen/symbols/mod.rs +++ b/crates/mun_codegen/src/code_gen/symbols/mod.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, } } diff --git a/crates/mun_codegen/src/db.rs b/crates/mun_codegen/src/db.rs index 7b9fa3f3..9269c1f9 100644 --- a/crates/mun_codegen/src/db.rs +++ b/crates/mun_codegen/src/db.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 { +pub trait CodeGenDatabase: mun_hir::HirDatabase { /// Set the optimization level used to generate assemblies #[salsa::input] fn optimization_level(&self) -> inkwell::OptimizationLevel; diff --git a/crates/mun_codegen/src/ir/body.rs b/crates/mun_codegen/src/ir/body.rs index f811af2d..1648c19a 100644 --- a/crates/mun_codegen/src/ir/body.rs +++ b/crates/mun_codegen/src/ir/body.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 { diff --git a/crates/mun_codegen/src/ir/intrinsics.rs b/crates/mun_codegen/src/ir/intrinsics.rs index 619316cf..fb6c6fea 100644 --- a/crates/mun_codegen/src/ir/intrinsics.rs +++ b/crates/mun_codegen/src/ir/intrinsics.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; diff --git a/crates/mun_codegen/src/ir/ty.rs b/crates/mun_codegen/src/ir/ty.rs index f523ae03..dac50050 100644 --- a/crates/mun_codegen/src/ir/ty.rs +++ b/crates/mun_codegen/src/ir/ty.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 {} diff --git a/crates/mun_codegen/src/mock.rs b/crates/mun_codegen/src/mock.rs index ddf4ac72..716d0b29 100644 --- a/crates/mun_codegen/src/mock.rs +++ b/crates/mun_codegen/src/mock.rs @@ -35,36 +35,6 @@ impl salsa::Database for MockDatabase { } } -impl mun_db::Upcast for MockDatabase { - fn upcast(&self) -> &(dyn mun_hir::AstDatabase + 'static) { - self - } -} - -impl mun_db::Upcast for MockDatabase { - fn upcast(&self) -> &(dyn SourceDatabase + 'static) { - self - } -} - -impl mun_db::Upcast for MockDatabase { - fn upcast(&self) -> &(dyn mun_hir::DefDatabase + 'static) { - self - } -} - -impl mun_db::Upcast for MockDatabase { - fn upcast(&self) -> &(dyn mun_hir::HirDatabase + 'static) { - self - } -} - -impl mun_db::Upcast for MockDatabase { - fn upcast(&self) -> &(dyn CodeGenDatabase + 'static) { - self - } -} - impl Default for MockDatabase { fn default() -> Self { let mut db = MockDatabase { diff --git a/crates/mun_codegen/src/module_partition.rs b/crates/mun_codegen/src/module_partition.rs index 62405236..6433babe 100644 --- a/crates/mun_codegen/src/module_partition.rs +++ b/crates/mun_codegen/src/module_partition.rs @@ -74,20 +74,17 @@ impl Index for ModulePartition { /// Builds a module partition from the contents of the database pub(crate) fn build_partition(db: &dyn CodeGenDatabase) -> Arc { let mut partition = ModulePartition::default(); - for module in mun_hir::Package::all(db.upcast()) + for module in mun_hir::Package::all(db) .into_iter() - .flat_map(|package| package.modules(db.upcast())) + .flat_map(|package| package.modules(db)) { - let name = if module.name(db.upcast()).is_some() { - module.full_name(db.upcast()) + let name = if module.name(db).is_some() { + module.full_name(db) } else { String::from("mod") }; - partition.add_group( - db.upcast(), - ModuleGroup::new(db.upcast(), name, vec![module]), - ); + partition.add_group(db, ModuleGroup::new(db, name, vec![module])); } Arc::new(partition) } diff --git a/crates/mun_codegen/src/test.rs b/crates/mun_codegen/src/test.rs index 9cc86c59..be608dce 100644 --- a/crates/mun_codegen/src/test.rs +++ b/crates/mun_codegen/src/test.rs @@ -1,7 +1,6 @@ use std::cell::RefCell; use inkwell::{context::Context, OptimizationLevel}; -use mun_db::Upcast; use mun_hir::{diagnostics::DiagnosticSink, HirDatabase}; use mun_hir_input::{SourceDatabase, WithFixture}; use mun_target::spec::Target; @@ -1100,18 +1099,18 @@ fn test_snapshot_with_optimization(name: &str, text: &str, opt: OptimizationLeve diag.message() )); }); - for module in mun_hir::Package::all(db.upcast()) + for module in mun_hir::Package::all(&db) .into_iter() - .flat_map(|package| package.modules(db.upcast())) + .flat_map(|package| package.modules(&db)) { - module.diagnostics(db.upcast(), &mut sink); + module.diagnostics(&db, &mut sink); } drop(sink); let messages = messages.into_inner(); // Setup code generation let llvm_context = Context::create(); - let code_gen = CodeGenContext::new(&llvm_context, db.upcast()); + let code_gen = CodeGenContext::new(&llvm_context, &db); let module_parition = db.module_partition(); let value = if messages.is_empty() { diff --git a/crates/mun_compiler/Cargo.toml b/crates/mun_compiler/Cargo.toml index 3b1dd20d..1c94916a 100644 --- a/crates/mun_compiler/Cargo.toml +++ b/crates/mun_compiler/Cargo.toml @@ -15,7 +15,6 @@ license.workspace = true [dependencies] mun_codegen = { version = "0.6.0-dev", path = "../mun_codegen" } mun_syntax = { version = "0.6.0-dev", path = "../mun_syntax" } -mun_db = { version = "0.6.0-dev", path = "../mun_db" } mun_hir_input = { version = "0.6.0-dev", path = "../mun_hir_input" } mun_hir = { version = "0.6.0-dev", path = "../mun_hir" } mun_paths = { version = "0.6.0-dev", path = "../mun_paths" } diff --git a/crates/mun_compiler/src/db.rs b/crates/mun_compiler/src/db.rs index 53104acb..c2f3e736 100644 --- a/crates/mun_compiler/src/db.rs +++ b/crates/mun_compiler/src/db.rs @@ -1,7 +1,5 @@ use mun_codegen::{CodeGenDatabase, CodeGenDatabaseStorage}; -use mun_db::Upcast; use mun_hir::{salsa, HirDatabase}; -use mun_hir_input::SourceDatabase; use crate::Config; @@ -18,36 +16,6 @@ pub struct CompilerDatabase { storage: salsa::Storage, } -impl Upcast for CompilerDatabase { - fn upcast(&self) -> &(dyn mun_hir::AstDatabase + 'static) { - self - } -} - -impl Upcast for CompilerDatabase { - fn upcast(&self) -> &(dyn SourceDatabase + 'static) { - self - } -} - -impl Upcast for CompilerDatabase { - fn upcast(&self) -> &(dyn mun_hir::DefDatabase + 'static) { - self - } -} - -impl Upcast for CompilerDatabase { - fn upcast(&self) -> &(dyn mun_hir::HirDatabase + 'static) { - self - } -} - -impl Upcast for CompilerDatabase { - fn upcast(&self) -> &(dyn CodeGenDatabase + 'static) { - self - } -} - impl CompilerDatabase { /// Constructs a new database pub fn new(config: &Config) -> Self { diff --git a/crates/mun_compiler/src/driver.rs b/crates/mun_compiler/src/driver.rs index ec9bb3b8..9da70b7d 100644 --- a/crates/mun_compiler/src/driver.rs +++ b/crates/mun_compiler/src/driver.rs @@ -23,7 +23,6 @@ use std::{ time::Duration, }; -use mun_db::Upcast; use mun_project::{Package, LOCKFILE_NAME}; use walkdir::WalkDir; @@ -216,9 +215,9 @@ impl Driver { let emit_colors = display_color.should_enable(); let mut has_error = false; - for package in mun_hir::Package::all(self.db.upcast()) { - for module in package.modules(self.db.upcast()) { - if let Some(file_id) = module.file_id(self.db.upcast()) { + for package in mun_hir::Package::all(&self.db) { + for module in package.modules(&self.db) { + if let Some(file_id) = module.file_id(&self.db) { let parse = self.db.parse(file_id); let source_code = self.db.file_text(file_id); let relative_file_path = self.db.file_relative_path(file_id); @@ -240,7 +239,7 @@ impl Driver { // Emit all HIR diagnostics let mut error = None; module.diagnostics( - self.db.upcast(), + &self.db, &mut DiagnosticSink::new(|d| { has_error = true; if let Err(e) = @@ -338,8 +337,8 @@ impl Driver { let _lock = self.acquire_filesystem_output_lock(); // Create a copy of all current files - for package in mun_hir::Package::all(self.db.upcast()) { - for module in package.modules(self.db.upcast()) { + for package in mun_hir::Package::all(&self.db) { + for module in package.modules(&self.db) { if self.emit_ir { self.write_assembly_ir(module)?; } else { diff --git a/crates/mun_db/Cargo.toml b/crates/mun_db/Cargo.toml deleted file mode 100644 index 3970a8d0..00000000 --- a/crates/mun_db/Cargo.toml +++ /dev/null @@ -1,14 +0,0 @@ -[package] -name = "mun_db" -description = "Salsa database utilities for everything mun related." -version.workspace = true -authors.workspace = true -edition.workspace = true -documentation.workspace = true -readme.workspace = true -homepage.workspace = true -repository.workspace = true -license.workspace = true -categories.workspace = true - -[dependencies] diff --git a/crates/mun_db/src/lib.rs b/crates/mun_db/src/lib.rs deleted file mode 100644 index 3e1038c5..00000000 --- a/crates/mun_db/src/lib.rs +++ /dev/null @@ -1,6 +0,0 @@ -//! This crate provides utilitiy functions to be used alongside salsa databases -//! used by mun. - -pub trait Upcast { - fn upcast(&self) -> &T; -} diff --git a/crates/mun_hir/Cargo.toml b/crates/mun_hir/Cargo.toml index c8e6a388..2576b886 100644 --- a/crates/mun_hir/Cargo.toml +++ b/crates/mun_hir/Cargo.toml @@ -17,7 +17,6 @@ la-arena = { workspace = true } mun_syntax = { version = "0.6.0-dev", path = "../mun_syntax" } mun_target = { version = "0.6.0-dev", path = "../mun_target" } mun_paths = { version = "0.6.0-dev", path="../mun_paths" } -mun_db = { version = "0.6.0-dev", path="../mun_db" } mun_hir_input = { version = "0.6.0-dev", path="../mun_hir_input" } drop_bomb = { workspace = true } either = { workspace = true } diff --git a/crates/mun_hir/src/code_model.rs b/crates/mun_hir/src/code_model.rs index fe41b7e0..caa631a4 100644 --- a/crates/mun_hir/src/code_model.rs +++ b/crates/mun_hir/src/code_model.rs @@ -70,7 +70,7 @@ impl DefWithStruct { pub fn data(self, db: &dyn HirDatabase) -> Arc { match self { - DefWithStruct::Struct(s) => s.data(db.upcast()), + DefWithStruct::Struct(s) => s.data(db), } } } diff --git a/crates/mun_hir/src/code_model/function.rs b/crates/mun_hir/src/code_model/function.rs index fb7d2042..9b0af405 100644 --- a/crates/mun_hir/src/code_model/function.rs +++ b/crates/mun_hir/src/code_model/function.rs @@ -122,7 +122,7 @@ impl FunctionData { impl Function { pub fn module(self, db: &dyn HirDatabase) -> Module { - self.id.module(db.upcast()).into() + self.id.module(db).into() } /// Returns the full name of the function including all module specifiers @@ -140,11 +140,11 @@ impl Function { } pub fn file_id(self, db: &dyn HirDatabase) -> FileId { - self.id.lookup(db.upcast()).id.file_id + self.id.lookup(db).id.file_id } pub fn name(self, db: &dyn HirDatabase) -> Name { - self.data(db.upcast()).name.clone() + self.data(db).name.clone() } pub fn data(self, db: &dyn DefDatabase) -> Arc { @@ -174,8 +174,8 @@ impl Function { } pub fn ret_type(self, db: &dyn HirDatabase) -> Ty { - let resolver = self.id.resolver(db.upcast()); - let data = self.data(db.upcast()); + let resolver = self.id.resolver(db); + let data = self.data(db); Ty::from_hir(db, &resolver, &data.type_ref_map, data.ret_type).0 } @@ -228,7 +228,7 @@ impl Param { /// Returns the source of the parameter. pub fn source(&self, db: &dyn HirDatabase) -> Option> { - let InFile { file_id, value } = self.func.source(db.upcast()); + let InFile { file_id, value } = self.func.source(db); let params = value.param_list()?; params .params() diff --git a/crates/mun_hir/src/code_model/impl.rs b/crates/mun_hir/src/code_model/impl.rs index 5c3b328a..5b79a8b2 100644 --- a/crates/mun_hir/src/code_model/impl.rs +++ b/crates/mun_hir/src/code_model/impl.rs @@ -28,12 +28,12 @@ impl Impl { /// defined. `impl`s can be defined in any module from where the self /// type is visibile. pub fn module(self, db: &dyn HirDatabase) -> Module { - self.id.module(db.upcast()).into() + self.id.module(db).into() } /// Returns the file in which the implementation was defined pub fn file_id(self, db: &dyn HirDatabase) -> FileId { - self.id.lookup(db.upcast()).id.file_id + self.id.lookup(db).id.file_id } /// Returns the type for which this is an implementation diff --git a/crates/mun_hir/src/code_model/module.rs b/crates/mun_hir/src/code_model/module.rs index 356b6773..6af8ccbf 100644 --- a/crates/mun_hir/src/code_model/module.rs +++ b/crates/mun_hir/src/code_model/module.rs @@ -77,7 +77,7 @@ impl Module { pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink<'_>) { // Add diagnostics from the package definitions let package_defs = db.package_defs(self.id.package); - package_defs.add_diagnostics(db.upcast(), self.id.local_id, sink); + package_defs.add_diagnostics(db, self.id.local_id, sink); // Add diagnostics from inherent impls let inherent_impls = db.inherent_impls_in_package(self.id.package); diff --git a/crates/mun_hir/src/code_model/struct.rs b/crates/mun_hir/src/code_model/struct.rs index b8e867df..e0695819 100644 --- a/crates/mun_hir/src/code_model/struct.rs +++ b/crates/mun_hir/src/code_model/struct.rs @@ -44,7 +44,7 @@ pub struct Field { impl Field { /// Returns the type of the field pub fn ty(self, db: &dyn HirDatabase) -> Ty { - let data = self.parent.data(db.upcast()); + let data = self.parent.data(db); let type_ref_id = data.fields[self.id].type_ref; let lower = self.parent.lower(db); lower[type_ref_id].clone() @@ -52,7 +52,7 @@ impl Field { /// Returns the name of the field pub fn name(self, db: &dyn HirDatabase) -> Name { - self.parent.data(db.upcast()).fields[self.id].name.clone() + self.parent.data(db).fields[self.id].name.clone() } /// Returns the index of this field in the parent @@ -68,11 +68,11 @@ impl Field { impl Struct { pub fn module(self, db: &dyn HirDatabase) -> Module { - self.id.module(db.upcast()).into() + self.id.module(db).into() } pub fn file_id(self, db: &dyn HirDatabase) -> FileId { - self.id.lookup(db.upcast()).id.file_id + self.id.lookup(db).id.file_id } pub fn data(self, db: &dyn DefDatabase) -> Arc { @@ -82,7 +82,7 @@ impl Struct { /// Returns the name of the struct non including any module specifiers (e.g: /// `Bar`). pub fn name(self, db: &dyn HirDatabase) -> Name { - self.data(db.upcast()).name.clone() + self.data(db).name.clone() } /// Returns the full name of the struct including all module specifiers @@ -100,7 +100,7 @@ impl Struct { } pub fn fields(self, db: &dyn HirDatabase) -> Vec { - self.data(db.upcast()) + self.data(db) .fields .iter() .map(|(id, _)| Field { parent: self, id }) @@ -108,7 +108,7 @@ impl Struct { } pub fn field(self, db: &dyn HirDatabase, name: &Name) -> Option { - self.data(db.upcast()) + self.data(db) .fields .iter() .find(|(_, data)| data.name == *name) @@ -124,7 +124,7 @@ impl Struct { } pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink<'_>) { - let data = self.data(db.upcast()); + let data = self.data(db); let lower = self.lower(db); lower.add_diagnostics(db, self.file_id(db), data.type_ref_source_map(), sink); let validator = validator::StructValidator::new(self, db, self.file_id(db)); @@ -255,8 +255,6 @@ impl StructData { impl HasVisibility for Struct { fn visibility(&self, db: &dyn HirDatabase) -> Visibility { - self.data(db.upcast()) - .visibility - .resolve(db.upcast(), &self.id.resolver(db.upcast())) + self.data(db).visibility.resolve(db, &self.id.resolver(db)) } } diff --git a/crates/mun_hir/src/code_model/struct/validator.rs b/crates/mun_hir/src/code_model/struct/validator.rs index 59a642eb..5913f591 100644 --- a/crates/mun_hir/src/code_model/struct/validator.rs +++ b/crates/mun_hir/src/code_model/struct/validator.rs @@ -25,8 +25,8 @@ impl<'a> StructValidator<'a> { } pub fn validate_privacy(&self, sink: &mut DiagnosticSink<'_>) { - let resolver = self.strukt.id.resolver(self.db.upcast()); - let struct_data = self.strukt.data(self.db.upcast()); + let resolver = self.strukt.id.resolver(self.db); + let struct_data = self.strukt.data(self.db); let public_fields = struct_data .fields diff --git a/crates/mun_hir/src/code_model/type_alias.rs b/crates/mun_hir/src/code_model/type_alias.rs index 6b60f3fa..57d28861 100644 --- a/crates/mun_hir/src/code_model/type_alias.rs +++ b/crates/mun_hir/src/code_model/type_alias.rs @@ -27,11 +27,11 @@ impl From for TypeAlias { impl TypeAlias { pub fn module(self, db: &dyn HirDatabase) -> Module { - self.id.module(db.upcast()).into() + self.id.module(db).into() } pub fn file_id(self, db: &dyn HirDatabase) -> FileId { - self.id.lookup(db.upcast()).id.file_id + self.id.lookup(db).id.file_id } pub fn data(self, db: &dyn DefDatabase) -> Arc { @@ -39,11 +39,11 @@ impl TypeAlias { } pub fn name(self, db: &dyn HirDatabase) -> Name { - self.data(db.upcast()).name.clone() + self.data(db).name.clone() } pub fn type_ref(self, db: &dyn HirDatabase) -> LocalTypeRefId { - self.data(db.upcast()).type_ref_id + self.data(db).type_ref_id } pub fn lower(self, db: &dyn HirDatabase) -> Arc { @@ -51,20 +51,20 @@ impl TypeAlias { } pub fn target_type(self, db: &dyn HirDatabase) -> Ty { - let data = self.data(db.upcast()); + let data = self.data(db); let mut ty = Ty::from_hir( db, - &self.id.resolver(db.upcast()), + &self.id.resolver(db), data.type_ref_map(), data.type_ref_id, ) .0; while let &TyKind::TypeAlias(alias) = ty.interned() { - let data = alias.data(db.upcast()); + let data = alias.data(db); ty = Ty::from_hir( db, - &alias.id.resolver(db.upcast()), + &alias.id.resolver(db), data.type_ref_map(), data.type_ref_id, ) @@ -75,7 +75,7 @@ impl TypeAlias { } pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink<'_>) { - let data = self.data(db.upcast()); + let data = self.data(db); let lower = self.lower(db); lower.add_diagnostics(db, self.file_id(db), data.type_ref_source_map(), sink); @@ -127,8 +127,6 @@ impl TypeAliasData { impl HasVisibility for TypeAlias { fn visibility(&self, db: &dyn HirDatabase) -> Visibility { - self.data(db.upcast()) - .visibility - .resolve(db.upcast(), &self.id.resolver(db.upcast())) + self.data(db).visibility.resolve(db, &self.id.resolver(db)) } } diff --git a/crates/mun_hir/src/db.rs b/crates/mun_hir/src/db.rs index 36309476..d6c6d927 100644 --- a/crates/mun_hir/src/db.rs +++ b/crates/mun_hir/src/db.rs @@ -3,7 +3,6 @@ use std::sync::Arc; use la_arena::ArenaMap; -use mun_db::Upcast; use mun_hir_input::{FileId, PackageId, SourceDatabase}; use mun_syntax::{ast, Parse, SourceFile}; use mun_target::{abi, spec::Target}; @@ -50,7 +49,7 @@ pub trait InternDatabase: SourceDatabase { } #[salsa::query_group(DefDatabaseStorage)] -pub trait DefDatabase: InternDatabase + AstDatabase + Upcast { +pub trait DefDatabase: InternDatabase + AstDatabase { /// Returns the `ItemTree` for a specific file. An `ItemTree` represents all /// the top level declarations within a file. #[salsa::invoke(item_tree::ItemTree::item_tree_query)] @@ -91,7 +90,7 @@ pub trait DefDatabase: InternDatabase + AstDatabase + Upcast { } #[salsa::query_group(HirDatabaseStorage)] -pub trait HirDatabase: DefDatabase + Upcast { +pub trait HirDatabase: DefDatabase { /// Returns the target for code generation. #[salsa::input] fn target(&self) -> Target; diff --git a/crates/mun_hir/src/expr/validator.rs b/crates/mun_hir/src/expr/validator.rs index e53d124b..24a689f9 100644 --- a/crates/mun_hir/src/expr/validator.rs +++ b/crates/mun_hir/src/expr/validator.rs @@ -49,8 +49,8 @@ impl<'a> ExprValidator<'a> { } pub fn validate_privacy(&self, sink: &mut DiagnosticSink<'_>) { - let resolver = self.func.id.resolver(self.db.upcast()); - let fn_data = self.func.data(self.db.upcast()); + let resolver = self.func.id.resolver(self.db); + let fn_data = self.func.data(self.db); let ret_type_ref = fn_data.ret_type(); let param_types = fn_data .params() @@ -69,7 +69,7 @@ impl<'a> ExprValidator<'a> { Visibility::Public => ty.visibility(self.db).is_externally_visible(), }; - let file_id = self.func.source(self.db.upcast()).file_id; + let file_id = self.func.source(self.db).file_id; param_types .filter(|(ty, _)| !type_is_allowed(ty)) .for_each(|(_, type_ref)| { @@ -94,13 +94,13 @@ impl<'a> ExprValidator<'a> { _ => sink.push(ExternCannotHaveBody { func: self .func - .source(self.db.upcast()) + .source(self.db) .map(|f| SyntaxNodePtr::new(f.syntax())), }), } if let Some(sig) = self.func.ty(self.db).callable_sig(self.db) { - let fn_data = self.func.data(self.db.upcast()); + let fn_data = self.func.data(self.db); for (arg_ty, ty_ref) in sig.params().iter().zip(fn_data.params()) { if arg_ty.as_struct().is_some() { let arg_ptr = fn_data @@ -109,7 +109,7 @@ impl<'a> ExprValidator<'a> { .map(|ptr| ptr.syntax_node_ptr()) .unwrap(); sink.push(ExternNonPrimitiveParam { - param: InFile::new(self.func.source(self.db.upcast()).file_id, arg_ptr), + param: InFile::new(self.func.source(self.db).file_id, arg_ptr), }); } } @@ -122,7 +122,7 @@ impl<'a> ExprValidator<'a> { .map(|ptr| ptr.syntax_node_ptr()) .unwrap(); sink.push(ExternNonPrimitiveParam { - param: InFile::new(self.func.source(self.db.upcast()).file_id, arg_ptr), + param: InFile::new(self.func.source(self.db).file_id, arg_ptr), }); } } @@ -142,7 +142,7 @@ impl<'a> TypeAliasValidator<'a> { /// Validates that the provided `TypeAlias` has a target type of alias. pub fn validate_target_type_existence(&self, sink: &mut DiagnosticSink<'_>) { - let src = self.type_alias.source(self.db.upcast()); + let src = self.type_alias.source(self.db); if src.value.type_ref().is_none() { sink.push(FreeTypeAliasWithoutTypeRef { type_alias_def: src.map(|t| SyntaxNodePtr::new(t.syntax())), @@ -154,7 +154,7 @@ impl<'a> TypeAliasValidator<'a> { /// its target type. pub fn validate_target_type_privacy(&self, sink: &mut DiagnosticSink<'_>) { let lower = self.type_alias.lower(self.db); - let data = self.type_alias.data(self.db.upcast()); + let data = self.type_alias.data(self.db); let target_ty = &lower[data.type_ref_id]; let target_visibility = target_ty.visibility(self.db); @@ -166,7 +166,7 @@ impl<'a> TypeAliasValidator<'a> { }; if leaks_privacy { - let src = self.type_alias.source(self.db.upcast()); + let src = self.type_alias.source(self.db); let (kind, name) = match target_ty.interned() { TyKind::Struct(s) => ("struct", s.name(self.db)), @@ -192,12 +192,12 @@ impl<'a> TypeAliasValidator<'a> { // Detect cyclic type if ids.contains(&alias.id) { - let src = self.type_alias.source(self.db.upcast()); + let src = self.type_alias.source(self.db); sink.push(CyclicType { file: src.file_id, type_ref: self .type_alias - .data(self.db.upcast()) + .data(self.db) .type_ref_source_map() .type_ref_syntax(type_ref) .unwrap(), @@ -209,8 +209,8 @@ impl<'a> TypeAliasValidator<'a> { let ty = Ty::from_hir( self.db, - &alias.id.resolver(self.db.upcast()), - alias.data(self.db.upcast()).type_ref_map(), + &alias.id.resolver(self.db), + alias.data(self.db).type_ref_map(), type_ref, ) .0; diff --git a/crates/mun_hir/src/expr/validator/uninitialized_access.rs b/crates/mun_hir/src/expr/validator/uninitialized_access.rs index ee014d51..134afab7 100644 --- a/crates/mun_hir/src/expr/validator/uninitialized_access.rs +++ b/crates/mun_hir/src/expr/validator/uninitialized_access.rs @@ -60,7 +60,7 @@ impl ExprValidator<'_> { } } Expr::Path(p) => { - let resolver = resolver_for_expr(self.db.upcast(), self.body.owner(), expr); + let resolver = resolver_for_expr(self.db, self.body.owner(), expr); self.validate_path_access( sink, initialized_patterns, @@ -207,7 +207,7 @@ impl ExprValidator<'_> { expr: ExprId, expr_side: ExprKind, ) { - let pat = match resolver.resolve_path_as_value_fully(self.db.upcast(), path) { + let pat = match resolver.resolve_path_as_value_fully(self.db, path) { Some((ValueNs::LocalBinding(pat), _)) => pat, _ => return, }; diff --git a/crates/mun_hir/src/item_tree.rs b/crates/mun_hir/src/item_tree.rs index 84385ce6..c1a4863e 100644 --- a/crates/mun_hir/src/item_tree.rs +++ b/crates/mun_hir/src/item_tree.rs @@ -540,8 +540,8 @@ mod diagnostics { second, } => sink.push(DuplicateDefinition { name: name.to_string(), - first_definition: ast_ptr_from_mod(db.upcast(), item_tree, *first), - definition: ast_ptr_from_mod(db.upcast(), item_tree, *second), + first_definition: ast_ptr_from_mod(db, item_tree, *first), + definition: ast_ptr_from_mod(db, item_tree, *second), }), }; } diff --git a/crates/mun_hir/src/item_tree/tests.rs b/crates/mun_hir/src/item_tree/tests.rs index 7f0357cf..efe4be4e 100644 --- a/crates/mun_hir/src/item_tree/tests.rs +++ b/crates/mun_hir/src/item_tree/tests.rs @@ -1,6 +1,5 @@ use std::fmt; -use mun_db::Upcast; use mun_hir_input::WithFixture; use crate::{mock::MockDatabase, DefDatabase, DiagnosticSink}; @@ -8,7 +7,7 @@ use crate::{mock::MockDatabase, DefDatabase, DiagnosticSink}; fn print_item_tree(text: &str) -> Result { let (db, file_id) = MockDatabase::with_single_file(text); let item_tree = db.item_tree(file_id); - let mut result_str = super::pretty::print_item_tree(db.upcast(), &item_tree)?; + let mut result_str = super::pretty::print_item_tree(&db, &item_tree)?; let mut sink = DiagnosticSink::new(|diag| { result_str.push_str(&format!( "\n{:?}: {}", diff --git a/crates/mun_hir/src/lib.rs b/crates/mun_hir/src/lib.rs index 8eb6c155..d769ffdd 100644 --- a/crates/mun_hir/src/lib.rs +++ b/crates/mun_hir/src/lib.rs @@ -6,7 +6,6 @@ #![allow(dead_code)] -pub use mun_db::Upcast; pub use mun_hir_input::ModuleId; pub use salsa; diff --git a/crates/mun_hir/src/method_resolution.rs b/crates/mun_hir/src/method_resolution.rs index 1120ea49..2499ba70 100644 --- a/crates/mun_hir/src/method_resolution.rs +++ b/crates/mun_hir/src/method_resolution.rs @@ -146,7 +146,7 @@ impl InherentImpls { ) { self.diagnostics .iter() - .filter(|it| it.module_id(db.upcast()).local_id == module_id) + .filter(|it| it.module_id(db).local_id == module_id) .for_each(|it| it.add_to(db, sink)); } @@ -175,30 +175,22 @@ impl InherentImplsDiagnostics { match self { InherentImplsDiagnostics::LowerDiagnostic(impl_id, diag) => { let impl_data = db.impl_data(*impl_id); - let file_id = impl_id.lookup(db.upcast()).id.file_id; + let file_id = impl_id.lookup(db).id.file_id; diag.add_to(db, file_id, &impl_data.type_ref_source_map, sink); } InherentImplsDiagnostics::InvalidSelfTy(impl_id) => sink.push(InvalidSelfTyImpl { - impl_: impl_id - .lookup(db.upcast()) - .source(db.upcast()) - .as_ref() - .map(AstPtr::new), + impl_: impl_id.lookup(db).source(db).as_ref().map(AstPtr::new), }), InherentImplsDiagnostics::ImplForForeignType(impl_id) => { sink.push(ImplForForeignType { - impl_: impl_id - .lookup(db.upcast()) - .source(db.upcast()) - .as_ref() - .map(AstPtr::new), + impl_: impl_id.lookup(db).source(db).as_ref().map(AstPtr::new), }); } InherentImplsDiagnostics::DuplicateDefinitions(first, second) => { sink.push(DuplicateDefinition { - definition: assoc_item_syntax_node_ptr(db.upcast(), second), - first_definition: assoc_item_syntax_node_ptr(db.upcast(), first), - name: assoc_item_name(db.upcast(), first), + definition: assoc_item_syntax_node_ptr(db, second), + first_definition: assoc_item_syntax_node_ptr(db, first), + name: assoc_item_name(db, first), }); } } diff --git a/crates/mun_hir/src/mock.rs b/crates/mun_hir/src/mock.rs index a6465e6e..f41dfb4b 100644 --- a/crates/mun_hir/src/mock.rs +++ b/crates/mun_hir/src/mock.rs @@ -1,12 +1,7 @@ -use mun_db::Upcast; -use mun_hir_input::SourceDatabase; use mun_target::spec::Target; use parking_lot::Mutex; -use crate::{ - db::{AstDatabase, HirDatabase}, - DefDatabase, -}; +use crate::db::HirDatabase; /// A mock implementation of the IR database. It can be used to set up a simple /// test case. @@ -31,24 +26,6 @@ impl salsa::Database for MockDatabase { } } -impl Upcast for MockDatabase { - fn upcast(&self) -> &(dyn AstDatabase + 'static) { - self - } -} - -impl Upcast for MockDatabase { - fn upcast(&self) -> &(dyn DefDatabase + 'static) { - self - } -} - -impl Upcast for MockDatabase { - fn upcast(&self) -> &(dyn SourceDatabase + 'static) { - self - } -} - impl Default for MockDatabase { fn default() -> Self { let mut db: MockDatabase = MockDatabase { diff --git a/crates/mun_hir/src/package_defs.rs b/crates/mun_hir/src/package_defs.rs index 5b4ab7f2..2b85757f 100644 --- a/crates/mun_hir/src/package_defs.rs +++ b/crates/mun_hir/src/package_defs.rs @@ -134,12 +134,12 @@ mod diagnostics { match &self.kind { DiagnosticKind::UnresolvedImport { ast, index } => { - if let Some(use_tree) = use_tree_ptr_from_ast(db.upcast(), ast, *index) { + if let Some(use_tree) = use_tree_ptr_from_ast(db, ast, *index) { sink.push(UnresolvedImport { use_tree }); } } DiagnosticKind::DuplicateImport { ast, index } => { - if let Some(use_tree) = use_tree_ptr_from_ast(db.upcast(), ast, *index) { + if let Some(use_tree) = use_tree_ptr_from_ast(db, ast, *index) { sink.push(ImportDuplicateDefinition { use_tree }); } } diff --git a/crates/mun_hir/src/semantics.rs b/crates/mun_hir/src/semantics.rs index 49a326e5..ccf5dc52 100644 --- a/crates/mun_hir/src/semantics.rs +++ b/crates/mun_hir/src/semantics.rs @@ -108,8 +108,8 @@ impl<'db> Semantics<'db> { SourceToDefContainer::DefWithBodyId(def) => { return SourceAnalyzer::new_for_body(self.db, def, node, offset) } - SourceToDefContainer::ModuleId(id) => id.resolver(self.db.upcast()), - SourceToDefContainer::Impl(id) => id.resolver(self.db.upcast()), + SourceToDefContainer::ModuleId(id) => id.resolver(self.db), + SourceToDefContainer::Impl(id) => id.resolver(self.db), }; SourceAnalyzer::new_for_resolver(resolver, node) @@ -248,7 +248,7 @@ impl SemanticsScope<'_> { pub fn visit_all_names(&self, visit: &mut dyn FnMut(Name, ScopeDef)) { let resolver = &self.resolver; - resolver.visit_all_names(self.db.upcast(), &mut |name, def| { + resolver.visit_all_names(self.db, &mut |name, def| { let def = match def { resolve::ScopeDef::ImplSelfType(id) => ScopeDef::ImplSelfType(Impl { id }), resolve::ScopeDef::PerNs(it) => { diff --git a/crates/mun_hir/src/semantics/source_to_def.rs b/crates/mun_hir/src/semantics/source_to_def.rs index 6255ae25..6d04efe0 100644 --- a/crates/mun_hir/src/semantics/source_to_def.rs +++ b/crates/mun_hir/src/semantics/source_to_def.rs @@ -164,10 +164,10 @@ impl SourceToDef for ItemScope { let mut result = SourceToDefMap::default(); self.declarations() - .for_each(|item| add_module_def(db.upcast(), &mut result, item)); + .for_each(|item| add_module_def(db, &mut result, item)); self.impls().for_each(|id| { - let src = id.lookup(db.upcast()).source(db.upcast()); + let src = id.lookup(db).source(db); result.impls.insert(src, id); }); @@ -182,7 +182,7 @@ impl SourceToDef for ImplId { for &assoc_item in &impl_items.items { match assoc_item { AssocItemId::FunctionId(id) => { - let src = id.lookup(db.upcast()).source(db.upcast()); + let src = id.lookup(db).source(db); result.functions.insert(src, id); } } diff --git a/crates/mun_hir/src/source_analyzer.rs b/crates/mun_hir/src/source_analyzer.rs index 4629bcd9..c5615e72 100644 --- a/crates/mun_hir/src/source_analyzer.rs +++ b/crates/mun_hir/src/source_analyzer.rs @@ -44,7 +44,7 @@ impl SourceAnalyzer { None => scope_for(&scopes, &source_map, node), Some(offset) => scope_for_offset(db, &scopes, &source_map, node.with_value(offset)), }; - let resolver = resolver_for_scope(db.upcast(), def, scope); + let resolver = resolver_for_scope(db, def, scope); SourceAnalyzer { resolver, body: Some(body), @@ -127,7 +127,7 @@ fn scope_for_offset( if source.file_id != offset.file_id { return None; } - let root = source.file_syntax(db.upcast()); + let root = source.file_syntax(db); let node = source .value .either(|ptr| ptr.syntax_node_ptr(), |ptr| ptr.syntax_node_ptr()); @@ -164,7 +164,7 @@ fn adjust( if source.file_id != offset.file_id { return None; } - let root = source.file_syntax(db.upcast()); + let root = source.file_syntax(db); let node = source .value .either(|ptr| ptr.syntax_node_ptr(), |ptr| ptr.syntax_node_ptr()); @@ -199,7 +199,7 @@ fn resolve_hir_path_qualifier( resolver: &Resolver, path: &Path, ) -> Option { - let (ty, _, remaining_idx) = resolver.resolve_path_as_type(db.upcast(), path)?; + let (ty, _, remaining_idx) = resolver.resolve_path_as_type(db, path)?; let (ty, _unresolved) = match remaining_idx { Some(remaining_idx) => { if remaining_idx + 1 == path.segments.len() { diff --git a/crates/mun_hir/src/ty.rs b/crates/mun_hir/src/ty.rs index c3263718..d882e010 100644 --- a/crates/mun_hir/src/ty.rs +++ b/crates/mun_hir/src/ty.rs @@ -196,7 +196,7 @@ impl Ty { &TyKind::Struct(s) => { let name = s.name(db).to_string(); - Some(if s.data(db.upcast()).memory_kind == StructMemoryKind::Gc { + Some(if s.data(db).memory_kind == StructMemoryKind::Gc { format!("struct {name}") } else { let fields: Vec = s @@ -356,7 +356,7 @@ impl FnSig { pub fn marshallable(&self, db: &dyn HirDatabase) -> bool { for ty in self.params_and_return.iter() { if let Some(s) = ty.as_struct() { - if s.data(db.upcast()).memory_kind == StructMemoryKind::Value { + if s.data(db).memory_kind == StructMemoryKind::Value { return false; } } diff --git a/crates/mun_hir/src/ty/infer.rs b/crates/mun_hir/src/ty/infer.rs index 435bf704..ee69da8d 100644 --- a/crates/mun_hir/src/ty/infer.rs +++ b/crates/mun_hir/src/ty/infer.rs @@ -110,7 +110,7 @@ impl InferenceResult { /// stored in the `InferenceResult`. pub fn infer_query(db: &dyn HirDatabase, def: DefWithBodyId) -> Arc { let body = db.body(def); - let resolver = def.resolver(db.upcast()); + let resolver = def.resolver(db); let mut ctx = InferenceResultBuilder::new(db, &body, resolver); match def { @@ -203,7 +203,7 @@ impl<'a> InferenceResultBuilder<'a> { /// Returns the module in which the body is defined. pub fn module(&self) -> ModuleId { match self.body.owner() { - DefWithBodyId::FunctionId(func) => func.module(self.db.upcast()), + DefWithBodyId::FunctionId(func) => func.module(self.db), } } @@ -339,7 +339,7 @@ impl InferenceResultBuilder<'_> { Expr::Missing => error_type(), Expr::Path(p) => { // FIXME this could be more efficient... - let resolver = resolver_for_expr(self.db.upcast(), self.body.owner(), tgt_expr); + let resolver = resolver_for_expr(self.db, self.body.owner(), tgt_expr); self.infer_path_expr(&resolver, p, tgt_expr, check_params) .unwrap_or_else(error_type) } @@ -356,8 +356,7 @@ impl InferenceResultBuilder<'_> { }; let lhs_ty = self.infer_expr(*lhs, &lhs_expected); if let BinaryOp::Assignment { op: _op } = op { - let resolver = - resolver_for_expr(self.db.upcast(), self.body.owner(), tgt_expr); + let resolver = resolver_for_expr(self.db, self.body.owner(), tgt_expr); if !self.check_place_expression(&resolver, *lhs) { self.diagnostics.push(InferenceDiagnostic::InvalidLhs { id: tgt_expr, @@ -732,7 +731,7 @@ impl InferenceResultBuilder<'_> { // Erroneously found either a unit struct or record struct literal. Record // struct literals can never be used as a value so that will // have already been reported. - if s.data(self.db.upcast()).kind == StructKind::Unit { + if s.data(self.db).kind == StructKind::Unit { self.diagnostics .push(InferenceDiagnostic::MismatchedStructLit { id: tgt_expr, @@ -781,7 +780,7 @@ impl InferenceResultBuilder<'_> { /// Checks whether the specified struct type is a unit struct. fn check_unit_struct_lit(&mut self, tgt_expr: ExprId, expected: Struct) { - let struct_data = expected.data(self.db.upcast()); + let struct_data = expected.data(self.db); if struct_data.kind != StructKind::Unit { self.diagnostics .push(InferenceDiagnostic::MismatchedStructLit { @@ -826,7 +825,7 @@ impl InferenceResultBuilder<'_> { expected: Struct, fields: &[RecordLitField], ) { - let struct_data = expected.data(self.db.upcast()); + let struct_data = expected.data(self.db); if struct_data.kind != StructKind::Record { self.diagnostics .push(InferenceDiagnostic::MismatchedStructLit { @@ -909,7 +908,7 @@ impl InferenceResultBuilder<'_> { path: &Path, id: ExprId, ) -> Option { - let value_or_partial = resolver.resolve_path_as_value(self.db.upcast(), path)?; + let value_or_partial = resolver.resolve_path_as_value(self.db, path)?; match value_or_partial { ResolveValueResult::ValueNs(it, vis) => { if !vis.is_visible_from(self.db, self.module()) { @@ -959,12 +958,12 @@ impl InferenceResultBuilder<'_> { } else { // If no value was found, try to resolve the path as a type. This will always // result in an error but it does provide much better diagnostics. - let ty = resolver.resolve_path_as_type_fully(self.db.upcast(), path); + let ty = resolver.resolve_path_as_type_fully(self.db, path); if let Some((TypeNs::StructId(struct_id), _)) = ty { // We can only really get here if the struct is actually a record. Both other // types can be seen as a values because they have a constructor. debug_assert_eq!( - Struct::from(struct_id).data(self.db.upcast()).kind, + Struct::from(struct_id).data(self.db).kind, StructKind::Record ); @@ -1385,7 +1384,7 @@ mod diagnostics { owner: Function, sink: &mut DiagnosticSink<'_>, ) { - let file = owner.source(db.upcast()).file_id; + let file = owner.source(db).file_id; let body = owner.body_source_map(db); match self { InferenceDiagnostic::UnresolvedValue { id } => { diff --git a/crates/mun_hir/src/ty/infer/place_expr.rs b/crates/mun_hir/src/ty/infer/place_expr.rs index d56d4983..76fadaf3 100644 --- a/crates/mun_hir/src/ty/infer/place_expr.rs +++ b/crates/mun_hir/src/ty/infer/place_expr.rs @@ -14,7 +14,7 @@ impl InferenceResultBuilder<'_> { /// Checks if the specified path references a memory location. fn check_place_path(&mut self, resolver: &Resolver, path: &Path) -> bool { - match resolver.resolve_path_as_value_fully(self.db.upcast(), path) { + match resolver.resolve_path_as_value_fully(self.db, path) { Some((ValueNs::ImplSelf(_) | ValueNs::LocalBinding(_), _)) => true, Some((ValueNs::FunctionId(_) | ValueNs::StructId(_), _)) | None => false, } diff --git a/crates/mun_hir/src/ty/lower.rs b/crates/mun_hir/src/ty/lower.rs index de524cab..fc910b77 100644 --- a/crates/mun_hir/src/ty/lower.rs +++ b/crates/mun_hir/src/ty/lower.rs @@ -123,7 +123,7 @@ impl Ty { diagnostics: &mut Vec, ) -> Option { // Find the type namespace and visibility - let (type_ns, vis) = resolver.resolve_path_as_type_fully(db.upcast(), path)?; + let (type_ns, vis) = resolver.resolve_path_as_type_fully(db, path)?; // Get the current module and see if the type is visible from here if let Some(module) = resolver.module() { @@ -160,13 +160,13 @@ pub fn lower_types( } pub fn lower_struct_query(db: &dyn HirDatabase, s: Struct) -> Arc { - let data = s.data(db.upcast()); - lower_types(db, &s.id.resolver(db.upcast()), data.type_ref_map()) + let data = s.data(db); + lower_types(db, &s.id.resolver(db), data.type_ref_map()) } pub fn lower_type_alias_query(db: &dyn HirDatabase, t: TypeAlias) -> Arc { - let data = t.data(db.upcast()); - lower_types(db, &t.id.resolver(db.upcast()), data.type_ref_map()) + let data = t.data(db); + lower_types(db, &t.id.resolver(db), data.type_ref_map()) } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] @@ -255,7 +255,7 @@ pub(crate) fn type_for_def(db: &dyn HirDatabase, def: TypableDef, ns: Namespace) pub(crate) fn type_for_impl_self(db: &dyn HirDatabase, i: ImplId) -> Ty { let impl_data = db.impl_data(i); - let resolver = i.resolver(db.upcast()); + let resolver = i.resolver(db); Ty::from_hir(db, &resolver, &impl_data.type_ref_map, impl_data.self_ty).0 } @@ -283,8 +283,8 @@ pub(crate) fn callable_item_sig(db: &dyn HirDatabase, def: CallableDef) -> FnSig } pub(crate) fn fn_sig_for_fn(db: &dyn HirDatabase, def: Function) -> FnSig { - let data = def.data(db.upcast()); - let resolver = def.id.resolver(db.upcast()); + let data = def.data(db); + let resolver = def.id.resolver(db); let params = data .params() .iter() @@ -295,8 +295,8 @@ pub(crate) fn fn_sig_for_fn(db: &dyn HirDatabase, def: Function) -> FnSig { } pub(crate) fn fn_sig_for_struct_constructor(db: &dyn HirDatabase, def: Struct) -> FnSig { - let data = def.data(db.upcast()); - let resolver = def.id.resolver(db.upcast()); + let data = def.data(db); + let resolver = def.id.resolver(db); let params = data .fields .iter() @@ -326,7 +326,7 @@ fn type_for_type_alias(_db: &dyn HirDatabase, def: TypeAlias) -> Ty { pub(crate) fn lower_impl_query(db: &dyn HirDatabase, impl_id: ImplId) -> Arc { let impl_data = db.impl_data(impl_id); - let resolver = impl_id.resolver(db.upcast()); + let resolver = impl_id.resolver(db); lower_types(db, &resolver, &impl_data.type_ref_map) } diff --git a/crates/mun_language_server/Cargo.toml b/crates/mun_language_server/Cargo.toml index 926dfc3f..0e5f5f5e 100644 --- a/crates/mun_language_server/Cargo.toml +++ b/crates/mun_language_server/Cargo.toml @@ -13,7 +13,6 @@ repository.workspace = true license.workspace = true [dependencies] -mun_db = { version = "0.6.0-dev", path="../mun_db" } mun_hir_input = { version = "0.6.0-dev", path="../mun_hir_input" } mun_hir = { version = "0.6.0-dev", path="../mun_hir" } mun_vfs = { version = "0.6.0-dev", path = "../mun_vfs" } diff --git a/crates/mun_language_server/src/completion/dot.rs b/crates/mun_language_server/src/completion/dot.rs index 7316a8a0..091ac968 100644 --- a/crates/mun_language_server/src/completion/dot.rs +++ b/crates/mun_language_server/src/completion/dot.rs @@ -1,5 +1,3 @@ -use mun_db::Upcast; - use super::{CompletionContext, Completions, DotAccess}; /// Complete dot accesses, i.e. fields. Adds `CompletionItems` to `result`. @@ -18,7 +16,7 @@ pub(super) fn complete_dot( // Get all the fields of the expression if let Some(strukt) = receiver_ty.as_struct() { - for field in strukt.fields(ctx.db.upcast()) { + for field in strukt.fields(ctx.db) { result.add_field(ctx, field); } }; diff --git a/crates/mun_language_server/src/db.rs b/crates/mun_language_server/src/db.rs index 96fac4c1..c3a0cbdf 100644 --- a/crates/mun_language_server/src/db.rs +++ b/crates/mun_language_server/src/db.rs @@ -2,7 +2,6 @@ use std::panic; -use mun_db::Upcast; use mun_hir::HirDatabase; use mun_target::spec::Target; use salsa::{Database, Durability, Snapshot}; @@ -65,30 +64,6 @@ impl salsa::Database for AnalysisDatabase { } } -impl Upcast for AnalysisDatabase { - fn upcast(&self) -> &(dyn mun_hir::AstDatabase + 'static) { - self - } -} - -impl Upcast for AnalysisDatabase { - fn upcast(&self) -> &(dyn mun_hir_input::SourceDatabase + 'static) { - self - } -} - -impl Upcast for AnalysisDatabase { - fn upcast(&self) -> &(dyn mun_hir::DefDatabase + 'static) { - self - } -} - -impl Upcast for AnalysisDatabase { - fn upcast(&self) -> &(dyn mun_hir::HirDatabase + 'static) { - self - } -} - impl AnalysisDatabase { fn check_canceled(&self) { if self.salsa_runtime().is_current_revision_canceled() {