From fa48bc216c67ca102df1b02a19bb12488ab77461 Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Tue, 27 Aug 2024 08:19:09 +0200 Subject: [PATCH] Revert "feat: Implement `module_path` macro" --- crates/base-db/src/input.rs | 1 - crates/hir-def/src/data.rs | 3 +- crates/hir-def/src/expander.rs | 9 +-- crates/hir-def/src/lib.rs | 44 ++++++------- .../hir-def/src/macro_expansion_tests/mod.rs | 15 ++--- crates/hir-def/src/nameres.rs | 27 +------- crates/hir-def/src/nameres/collector.rs | 27 ++------ crates/hir-expand/src/builtin.rs | 2 +- crates/hir-expand/src/builtin/fn_macro.rs | 30 ++++----- crates/hir-expand/src/builtin/quote.rs | 4 +- crates/hir-expand/src/eager.rs | 45 ------------- crates/hir/src/semantics.rs | 25 ++----- crates/hir/src/source_analyzer.rs | 21 ++---- crates/ide/src/goto_type_definition.rs | 8 +-- crates/ide/src/hover/tests.rs | 65 ------------------- crates/ide/src/status.rs | 1 - crates/intern/src/symbol/symbols.rs | 1 - crates/rust-analyzer/src/cli/lsif.rs | 8 +-- crates/rust-analyzer/src/cli/scip.rs | 2 + crates/test-utils/src/minicore.rs | 11 ---- 20 files changed, 71 insertions(+), 278 deletions(-) diff --git a/crates/base-db/src/input.rs b/crates/base-db/src/input.rs index b67f4c7a0cc4..3616fa9fd868 100644 --- a/crates/base-db/src/input.rs +++ b/crates/base-db/src/input.rs @@ -272,7 +272,6 @@ impl ReleaseChannel { } } -#[non_exhaustive] #[derive(Debug, Clone, PartialEq, Eq)] pub struct CrateData { pub root_file_id: FileId, diff --git a/crates/hir-def/src/data.rs b/crates/hir-def/src/data.rs index c62f2f873383..d17ebd7ff920 100644 --- a/crates/hir-def/src/data.rs +++ b/crates/hir-def/src/data.rs @@ -748,9 +748,8 @@ impl<'a> AssocItemCollector<'a> { &AstIdWithPath::new(file_id, ast_id, Clone::clone(path)), ctxt, expand_to, - self.expander.module, + self.expander.krate(), resolver, - |module| module.def_map(self.db).path_for_module(self.db, module), ) { Ok(Some(call_id)) => { let res = diff --git a/crates/hir-def/src/expander.rs b/crates/hir-def/src/expander.rs index 57bd54ed17c5..6d8b4445f75b 100644 --- a/crates/hir-def/src/expander.rs +++ b/crates/hir-def/src/expander.rs @@ -69,12 +69,9 @@ impl Expander { let result = self.within_limit(db, |this| { let macro_call = this.in_file(¯o_call); - match macro_call.as_call_id( - db.upcast(), - this.module, - |path| resolver(path).map(|it| db.macro_def(it)), - |module| this.module.def_map(db).path_for_module(db, module), - ) { + match macro_call.as_call_id_with_errors(db.upcast(), this.module.krate(), |path| { + resolver(path).map(|it| db.macro_def(it)) + }) { Ok(call_id) => call_id, Err(resolve_err) => { unresolved_macro_err = Some(resolve_err); diff --git a/crates/hir-def/src/lib.rs b/crates/hir-def/src/lib.rs index eb235f9b9f6a..0213bd904b68 100644 --- a/crates/hir-def/src/lib.rs +++ b/crates/hir-def/src/lib.rs @@ -77,7 +77,7 @@ use base_db::{ use hir_expand::{ builtin::{BuiltinAttrExpander, BuiltinDeriveExpander, BuiltinFnLikeExpander, EagerExpander}, db::ExpandDatabase, - eager::{expand_eager_macro_input, expand_module_path_as_eager}, + eager::expand_eager_macro_input, impl_intern_lookup, name::Name, proc_macro::{CustomProcMacroExpander, ProcMacroKind}, @@ -1400,19 +1400,26 @@ pub trait AsMacroCall { fn as_call_id( &self, db: &dyn ExpandDatabase, - module: ModuleId, + krate: CrateId, + resolver: impl Fn(&path::ModPath) -> Option + Copy, + ) -> Option { + self.as_call_id_with_errors(db, krate, resolver).ok()?.value + } + + fn as_call_id_with_errors( + &self, + db: &dyn ExpandDatabase, + krate: CrateId, resolver: impl Fn(&path::ModPath) -> Option + Copy, - mod_path: impl FnOnce(ModuleId) -> String, ) -> Result>, UnresolvedMacro>; } impl AsMacroCall for InFile<&ast::MacroCall> { - fn as_call_id( + fn as_call_id_with_errors( &self, db: &dyn ExpandDatabase, - module: ModuleId, + krate: CrateId, resolver: impl Fn(&path::ModPath) -> Option + Copy, - mod_path: impl FnOnce(ModuleId) -> String, ) -> Result>, UnresolvedMacro> { let expands_to = hir_expand::ExpandTo::from_call_site(self.value); let ast_id = AstId::new(self.file_id, db.ast_id_map(self.file_id).ast_id(self.value)); @@ -1439,10 +1446,9 @@ impl AsMacroCall for InFile<&ast::MacroCall> { &path, call_site.ctx, expands_to, - module, + krate, resolver, resolver, - mod_path, ) } } @@ -1469,9 +1475,8 @@ fn macro_call_as_call_id( call: &AstIdWithPath, call_site: SyntaxContextId, expand_to: ExpandTo, - module: ModuleId, + krate: CrateId, resolver: impl Fn(&path::ModPath) -> Option + Copy, - mod_path: impl FnOnce(ModuleId) -> String, ) -> Result, UnresolvedMacro> { macro_call_as_call_id_with_eager( db, @@ -1479,10 +1484,9 @@ fn macro_call_as_call_id( &call.path, call_site, expand_to, - module, + krate, resolver, resolver, - mod_path, ) .map(|res| res.value) } @@ -1493,26 +1497,16 @@ fn macro_call_as_call_id_with_eager( path: &path::ModPath, call_site: SyntaxContextId, expand_to: ExpandTo, - module: ModuleId, + krate: CrateId, resolver: impl FnOnce(&path::ModPath) -> Option, eager_resolver: impl Fn(&path::ModPath) -> Option, - mod_path: impl FnOnce(ModuleId) -> String, ) -> Result>, UnresolvedMacro> { let def = resolver(path).ok_or_else(|| UnresolvedMacro { path: path.clone() })?; let res = match def.kind { - MacroDefKind::BuiltInEager(_, EagerExpander::ModulePath) => expand_module_path_as_eager( - db, - module.krate, - mod_path(module), - &ast_id.to_node(db), - ast_id, - def, - call_site, - ), MacroDefKind::BuiltInEager(..) => expand_eager_macro_input( db, - module.krate, + krate, &ast_id.to_node(db), ast_id, def, @@ -1522,7 +1516,7 @@ fn macro_call_as_call_id_with_eager( _ if def.is_fn_like() => ExpandResult { value: Some(def.make_call( db, - module.krate, + krate, MacroCallKind::FnLike { ast_id, expand_to, eager: None }, call_site, )), diff --git a/crates/hir-def/src/macro_expansion_tests/mod.rs b/crates/hir-def/src/macro_expansion_tests/mod.rs index 0d232deb2ced..7f761192517c 100644 --- a/crates/hir-def/src/macro_expansion_tests/mod.rs +++ b/crates/hir-def/src/macro_expansion_tests/mod.rs @@ -95,16 +95,11 @@ pub fn identity_when_valid(_attr: TokenStream, item: TokenStream) -> TokenStream for macro_call in source_file.syntax().descendants().filter_map(ast::MacroCall::cast) { let macro_call = InFile::new(source.file_id, ¯o_call); let res = macro_call - .as_call_id( - &db, - resolver.module(), - |path| { - resolver - .resolve_path_as_macro(&db, path, Some(MacroSubNs::Bang)) - .map(|(it, _)| db.macro_def(it)) - }, - |module| def_map.path_for_module(&db, module), - ) + .as_call_id_with_errors(&db, krate, |path| { + resolver + .resolve_path_as_macro(&db, path, Some(MacroSubNs::Bang)) + .map(|(it, _)| db.macro_def(it)) + }) .unwrap(); let macro_call_id = res.value.unwrap(); let macro_file = MacroFileId { macro_call_id }; diff --git a/crates/hir-def/src/nameres.rs b/crates/hir-def/src/nameres.rs index db45f6bed667..11601c683e1e 100644 --- a/crates/hir-def/src/nameres.rs +++ b/crates/hir-def/src/nameres.rs @@ -63,7 +63,7 @@ use base_db::CrateId; use hir_expand::{ name::Name, proc_macro::ProcMacroKind, ErasedAstId, HirFileId, InFile, MacroCallId, MacroDefId, }; -use intern::{sym, Symbol}; +use intern::Symbol; use itertools::Itertools; use la_arena::Arena; use rustc_hash::{FxHashMap, FxHashSet}; @@ -139,7 +139,6 @@ pub struct DefMap { /// Data that belongs to a crate which is shared between a crate's def map and all its block def maps. #[derive(Clone, Debug, PartialEq, Eq)] struct DefMapCrateData { - crate_name: Option, /// The extern prelude which contains all root modules of external crates that are in scope. extern_prelude: FxIndexMap)>, @@ -165,7 +164,6 @@ struct DefMapCrateData { impl DefMapCrateData { fn new(edition: Edition) -> Self { Self { - crate_name: None, extern_prelude: FxIndexMap::default(), exported_derives: FxHashMap::default(), fn_proc_macro_mapping: FxHashMap::default(), @@ -188,7 +186,6 @@ impl DefMapCrateData { registered_attrs, registered_tools, unstable_features, - crate_name: _, rustc_coherence_is_core: _, no_core: _, no_std: _, @@ -446,28 +443,6 @@ impl DefMap { self.modules.iter() } - pub fn path_for_module(&self, db: &dyn DefDatabase, mut module: ModuleId) -> String { - debug_assert!(module.krate == self.krate && module.block == self.block.map(|b| b.block)); - let mut parts = vec![]; - if let Some(name) = module.name(db) { - parts.push(name.symbol().clone()); - } - while let Some(parent) = module.def_map(db).containing_module(module.local_id) { - module = parent; - if let Some(name) = module.name(db) { - parts.push(name.symbol().clone()); - } - if parts.len() > 10 { - break; - } - } - parts.push(match &self.data.crate_name { - Some(name) => name.clone(), - None => sym::crate_.clone(), - }); - parts.into_iter().rev().format("::").to_string() - } - pub fn derive_helpers_in_scope( &self, id: AstId, diff --git a/crates/hir-def/src/nameres/collector.rs b/crates/hir-def/src/nameres/collector.rs index 30df6c206dfb..22eb5a174d39 100644 --- a/crates/hir-def/src/nameres/collector.rs +++ b/crates/hir-def/src/nameres/collector.rs @@ -247,23 +247,18 @@ impl DefCollector<'_> { let _p = tracing::info_span!("seed_with_top_level").entered(); let crate_graph = self.db.crate_graph(); - let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap(); - crate_data.crate_name = crate_graph[self.def_map.krate] - .display_name - .as_ref() - .map(|it| it.crate_name().symbol().clone()); - let file_id = crate_graph[self.def_map.krate].root_file_id(); let item_tree = self.db.file_item_tree(file_id.into()); let attrs = item_tree.top_level_attrs(self.db, self.def_map.krate); + let crate_data = Arc::get_mut(&mut self.def_map.data).unwrap(); - let mut crate_cged_out = false; + let mut process = true; // Process other crate-level attributes. for attr in &*attrs { if let Some(cfg) = attr.cfg() { if self.cfg_options.check(&cfg) == Some(false) { - crate_cged_out = true; + process = false; break; } } @@ -277,11 +272,6 @@ impl DefCollector<'_> { } } } - () if *attr_name == sym::crate_name.clone() => { - if let Some(name) = attr.string_value().cloned() { - crate_data.crate_name = Some(name); - } - } () if *attr_name == sym::crate_type.clone() => { if attr.string_value() == Some(&sym::proc_dash_macro) { self.is_proc_macro = true; @@ -347,7 +337,7 @@ impl DefCollector<'_> { self.inject_prelude(); - if crate_cged_out { + if !process { return; } @@ -1217,9 +1207,8 @@ impl DefCollector<'_> { ast_id, *call_site, *expand_to, - self.def_map.module_id(directive.module_id), + self.def_map.krate, resolver_def_id, - |module| self.def_map.path_for_module(self.db, module), ); if let Ok(Some(call_id)) = call_id { self.def_map.modules[directive.module_id] @@ -1497,7 +1486,7 @@ impl DefCollector<'_> { ast_id, *call_site, *expand_to, - self.def_map.module_id(directive.module_id), + self.def_map.krate, |path| { let resolved_res = self.def_map.resolve_path_fp_with_macro( self.db, @@ -1509,7 +1498,6 @@ impl DefCollector<'_> { ); resolved_res.resolved_def.take_macros().map(|it| self.db.macro_def(it)) }, - |module| self.def_map.path_for_module(self.db, module), ); if let Err(UnresolvedMacro { path }) = macro_call_as_call_id { self.def_map.diagnostics.push(DefDiagnostic::unresolved_macro_call( @@ -2363,7 +2351,7 @@ impl ModCollector<'_, '_> { &ast_id.path, ctxt, expand_to, - self.def_collector.def_map.module_id(self.module_id), + self.def_collector.def_map.krate, |path| { path.as_ident().and_then(|name| { let def_map = &self.def_collector.def_map; @@ -2393,7 +2381,6 @@ impl ModCollector<'_, '_> { ); resolved_res.resolved_def.take_macros().map(|it| db.macro_def(it)) }, - |module| self.def_collector.def_map.path_for_module(self.def_collector.db, module), ) { // FIXME: if there were errors, this might've been in the eager expansion from an // unresolved macro, so we need to push this into late macro resolution. see fixme above diff --git a/crates/hir-expand/src/builtin.rs b/crates/hir-expand/src/builtin.rs index 7b9cb4e793c9..252430e4e954 100644 --- a/crates/hir-expand/src/builtin.rs +++ b/crates/hir-expand/src/builtin.rs @@ -1,6 +1,6 @@ //! Builtin macros and attributes #[macro_use] -pub(crate) mod quote; +mod quote; mod attr_macro; mod derive_macro; diff --git a/crates/hir-expand/src/builtin/fn_macro.rs b/crates/hir-expand/src/builtin/fn_macro.rs index e4d09ddb3abc..795d9b14df96 100644 --- a/crates/hir-expand/src/builtin/fn_macro.rs +++ b/crates/hir-expand/src/builtin/fn_macro.rs @@ -116,6 +116,7 @@ register_builtin! { (column, Column) => line_expand, (file, File) => file_expand, (line, Line) => line_expand, + (module_path, ModulePath) => module_path_expand, (assert, Assert) => assert_expand, (stringify, Stringify) => stringify_expand, (llvm_asm, LlvmAsm) => asm_expand, @@ -141,10 +142,7 @@ register_builtin! { (include_bytes, IncludeBytes) => include_bytes_expand, (include_str, IncludeStr) => include_str_expand, (env, Env) => env_expand, - (option_env, OptionEnv) => option_env_expand, - // This isn't really eager, we have no inputs, but we abuse the fact how eager macros are - // handled in r-a to be able to thread the module path through. - (module_path, ModulePath) => module_path_expand + (option_env, OptionEnv) => option_env_expand } fn mk_pound(span: Span) -> tt::Subtree { @@ -159,6 +157,18 @@ fn mk_pound(span: Span) -> tt::Subtree { ) } +fn module_path_expand( + _db: &dyn ExpandDatabase, + _id: MacroCallId, + _tt: &tt::Subtree, + span: Span, +) -> ExpandResult { + // Just return a dummy result. + ExpandResult::ok(quote! {span => + "module::path" + }) +} + fn line_expand( _db: &dyn ExpandDatabase, _id: MacroCallId, @@ -894,18 +904,6 @@ fn option_env_expand( ExpandResult::ok(expanded) } -fn module_path_expand( - _db: &dyn ExpandDatabase, - _id: MacroCallId, - tt: &tt::Subtree, - span: Span, -) -> ExpandResult { - // Note: The actual implementation of this is in crates\hir-expand\src\eager.rs - ExpandResult::ok(quote! {span => - #tt - }) -} - fn quote_expand( _db: &dyn ExpandDatabase, _arg_id: MacroCallId, diff --git a/crates/hir-expand/src/builtin/quote.rs b/crates/hir-expand/src/builtin/quote.rs index 0c895056c225..5c33f817f9e4 100644 --- a/crates/hir-expand/src/builtin/quote.rs +++ b/crates/hir-expand/src/builtin/quote.rs @@ -128,7 +128,7 @@ macro_rules! quote_impl__ { } }; } -pub(crate) use quote_impl__ as __quote; +pub(super) use quote_impl__ as __quote; /// FIXME: /// It probably should implement in proc-macro @@ -137,7 +137,7 @@ macro_rules! quote_impl { $crate::builtin::quote::IntoTt::to_subtree($crate::builtin::quote::__quote!($span $($tt)*), $span) } } -pub(crate) use quote_impl as quote; +pub(super) use quote_impl as quote; pub(crate) trait IntoTt { fn to_subtree(self, span: Span) -> crate::tt::Subtree; diff --git a/crates/hir-expand/src/eager.rs b/crates/hir-expand/src/eager.rs index 534d5663860d..1dadfe2ba99b 100644 --- a/crates/hir-expand/src/eager.rs +++ b/crates/hir-expand/src/eager.rs @@ -32,51 +32,6 @@ use crate::{ MacroCallId, MacroCallKind, MacroCallLoc, MacroDefId, MacroDefKind, }; -pub fn expand_module_path_as_eager( - db: &dyn ExpandDatabase, - krate: CrateId, - mod_path: String, - macro_call: &ast::MacroCall, - ast_id: AstId, - def: MacroDefId, - call_site: SyntaxContextId, -) -> ExpandResult> { - let expand_to = ExpandTo::from_call_site(macro_call); - - // Note: - // When `lazy_expand` is called, its *parent* file must already exist. - // Here we store an eager macro id for the argument expanded subtree - // for that purpose. - let arg_id = MacroCallLoc { - def, - krate, - kind: MacroCallKind::FnLike { ast_id, expand_to: ExpandTo::Expr, eager: None }, - ctxt: call_site, - } - .intern(db); - #[allow(deprecated)] // builtin eager macros are never derives - let (_, _, span) = db.macro_arg(arg_id); - let subtree = crate::builtin::quote::quote! {span => #mod_path}; - - let loc = MacroCallLoc { - def, - krate, - kind: MacroCallKind::FnLike { - ast_id, - expand_to, - eager: Some(Arc::new(EagerCallInfo { - arg: Arc::new(subtree), - arg_id, - error: None, - span, - })), - }, - ctxt: call_site, - }; - - ExpandResult { value: Some(loc.intern(db)), err: None } -} - pub fn expand_eager_macro_input( db: &dyn ExpandDatabase, krate: CrateId, diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs index 1d7ab5f6b7f6..763f53031e4c 100644 --- a/crates/hir/src/semantics.rs +++ b/crates/hir/src/semantics.rs @@ -365,6 +365,7 @@ impl<'db> SemanticsImpl<'db> { _, BuiltinFnLikeExpander::Column | BuiltinFnLikeExpander::File + | BuiltinFnLikeExpander::ModulePath | BuiltinFnLikeExpander::Asm | BuiltinFnLikeExpander::LlvmAsm | BuiltinFnLikeExpander::GlobalAsm @@ -482,26 +483,10 @@ impl<'db> SemanticsImpl<'db> { let SourceAnalyzer { file_id, resolver, .. } = self.analyze_no_infer(actual_macro_call.syntax())?; let macro_call = InFile::new(file_id, actual_macro_call); - let macro_call_id = macro_call - .as_call_id( - self.db.upcast(), - resolver.module(), - |path| { - resolver.resolve_path_as_macro_def( - self.db.upcast(), - path, - Some(MacroSubNs::Bang), - ) - }, - |module| { - resolver - .module() - .def_map(self.db.upcast()) - .path_for_module(self.db.upcast(), module) - }, - ) - .ok()? - .value?; + let krate = resolver.krate(); + let macro_call_id = macro_call.as_call_id(self.db.upcast(), krate, |path| { + resolver.resolve_path_as_macro_def(self.db.upcast(), path, Some(MacroSubNs::Bang)) + })?; hir_expand::db::expand_speculative( self.db.upcast(), macro_call_id, diff --git a/crates/hir/src/source_analyzer.rs b/crates/hir/src/source_analyzer.rs index fe1d5b5764d3..be0116862b9c 100644 --- a/crates/hir/src/source_analyzer.rs +++ b/crates/hir/src/source_analyzer.rs @@ -839,25 +839,12 @@ impl SourceAnalyzer { db: &dyn HirDatabase, macro_call: InFile<&ast::MacroCall>, ) -> Option { + let krate = self.resolver.krate(); // FIXME: This causes us to parse, generally this is the wrong approach for resolving a // macro call to a macro call id! - let macro_call_id = macro_call - .as_call_id( - db.upcast(), - self.resolver.module(), - |path| { - self.resolver.resolve_path_as_macro_def( - db.upcast(), - path, - Some(MacroSubNs::Bang), - ) - }, - |module| { - self.resolver.module().def_map(db.upcast()).path_for_module(db.upcast(), module) - }, - ) - .ok()? - .value?; + let macro_call_id = macro_call.as_call_id(db.upcast(), krate, |path| { + self.resolver.resolve_path_as_macro_def(db.upcast(), path, Some(MacroSubNs::Bang)) + })?; // why the 64? Some(macro_call_id.as_macro_file()).filter(|it| it.expansion_level(db.upcast()) < 64) } diff --git a/crates/ide/src/goto_type_definition.rs b/crates/ide/src/goto_type_definition.rs index 9b073427d795..ca04b7bb5a9b 100644 --- a/crates/ide/src/goto_type_definition.rs +++ b/crates/ide/src/goto_type_definition.rs @@ -24,11 +24,9 @@ pub(crate) fn goto_type_definition( let file: ast::SourceFile = sema.parse_guess_edition(file_id); let token: SyntaxToken = pick_best_token(file.syntax().token_at_offset(offset), |kind| match kind { - IDENT | INT_NUMBER | T![self] => 3, - // operators - T!['('] | T!['['] | T!['{'] | T![')'] | T![']'] | T!['}'] | T![!] | T![?] => 2, - kind if !kind.is_trivia() => 1, - _ => 0, + IDENT | INT_NUMBER | T![self] => 2, + kind if kind.is_trivia() => 0, + _ => 1, })?; let mut res = Vec::new(); diff --git a/crates/ide/src/hover/tests.rs b/crates/ide/src/hover/tests.rs index 08709d3cc2eb..9585bdbe4c54 100644 --- a/crates/ide/src/hover/tests.rs +++ b/crates/ide/src/hover/tests.rs @@ -8702,68 +8702,3 @@ fn foo() { "#]], ); } - -#[test] -fn module_path_macro() { - check( - r##" -//- minicore: module_path - -const C$0: &'static str = module_path!(); -"##, - expect![[r#" - *C* - - ```rust - test - ``` - - ```rust - const C: &'static str = "test" - ``` - "#]], - ); - check( - r##" -//- minicore: module_path - -mod foo { - const C$0: &'static str = module_path!(); -} -"##, - expect![[r#" - *C* - - ```rust - test::foo - ``` - - ```rust - const C: &'static str = "test::foo" - ``` - "#]], - ); - check( - r##" -//- minicore: module_path -mod baz { - const _: () = { - mod bar { - const C$0: &'static str = module_path!(); - } - } -} -"##, - expect![[r#" - *C* - - ```rust - test::bar - ``` - - ```rust - const C: &'static str = "test::baz::bar" - ``` - "#]], - ); -} diff --git a/crates/ide/src/status.rs b/crates/ide/src/status.rs index ce21e3cad5ba..67d6932da962 100644 --- a/crates/ide/src/status.rs +++ b/crates/ide/src/status.rs @@ -69,7 +69,6 @@ pub(crate) fn status(db: &RootDatabase, file_id: Option) -> String { dependencies, origin, is_proc_macro, - .. } = &crate_graph[crate_id]; format_to!( buf, diff --git a/crates/intern/src/symbol/symbols.rs b/crates/intern/src/symbol/symbols.rs index 867d9ea902cf..7eb8e4a5e2e5 100644 --- a/crates/intern/src/symbol/symbols.rs +++ b/crates/intern/src/symbol/symbols.rs @@ -177,7 +177,6 @@ define_symbols! { coroutine_state, coroutine, count, - crate_name, crate_type, CStr, debug_assertions, diff --git a/crates/rust-analyzer/src/cli/lsif.rs b/crates/rust-analyzer/src/cli/lsif.rs index f2d21208d51f..89fe712ced02 100644 --- a/crates/rust-analyzer/src/cli/lsif.rs +++ b/crates/rust-analyzer/src/cli/lsif.rs @@ -22,7 +22,7 @@ use crate::{ }; struct LsifManager<'a> { - id_counter: i32, + count: i32, token_map: FxHashMap, range_map: FxHashMap, file_map: FxHashMap, @@ -44,7 +44,7 @@ impl From for lsp_types::NumberOrString { impl LsifManager<'_> { fn new<'a>(analysis: &'a Analysis, db: &'a RootDatabase, vfs: &'a Vfs) -> LsifManager<'a> { LsifManager { - id_counter: 0, + count: 0, token_map: FxHashMap::default(), range_map: FxHashMap::default(), file_map: FxHashMap::default(), @@ -56,9 +56,9 @@ impl LsifManager<'_> { } fn add(&mut self, data: lsif::Element) -> Id { - let id = Id(self.id_counter); + let id = Id(self.count); self.emit(&serde_json::to_string(&lsif::Entry { id: id.into(), data }).unwrap()); - self.id_counter += 1; + self.count += 1; id } diff --git a/crates/rust-analyzer/src/cli/scip.rs b/crates/rust-analyzer/src/cli/scip.rs index f8d2608a31ca..a8a02712fe29 100644 --- a/crates/rust-analyzer/src/cli/scip.rs +++ b/crates/rust-analyzer/src/cli/scip.rs @@ -48,6 +48,7 @@ impl flags::Scip { let error_sink; (config, error_sink, _) = config.apply_change(change); + // FIXME @alibektas : What happens to errors without logging? error!(?error_sink, "Config Error(s)"); } let cargo_config = config.cargo(); @@ -114,6 +115,7 @@ impl flags::Scip { tokens.into_iter().for_each(|(text_range, id)| { let token = si.tokens.get(id).unwrap(); + let range = text_range_to_scip_range(&line_index, text_range); let symbol = tokens_to_symbol .entry(id) diff --git a/crates/test-utils/src/minicore.rs b/crates/test-utils/src/minicore.rs index 754042cf883d..7dbc498ead19 100644 --- a/crates/test-utils/src/minicore.rs +++ b/crates/test-utils/src/minicore.rs @@ -41,7 +41,6 @@ //! iterator: option //! iterators: iterator, fn //! manually_drop: drop -//! module_path: //! non_null: //! non_zero: //! option: panic @@ -1437,16 +1436,6 @@ mod panicking { #[macro_use] mod macros { - // region:module_path - #[macro_export] - #[rustc_builtin_macro] - macro_rules! module_path { - ($($arg:tt)*) => { - /* compiler built-in */ - }; - } - // endregion:module_path - // region:panic #[macro_export] #[rustc_builtin_macro(core_panic)]