language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-03 07:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Revert "feat: Implement module_path macro"

Browse source
This commit is contained in:
Lukas Wirth 2024-08-27 08:19:09 +02:00 • committed by GitHub
parent 095926ea6f
commit fa48bc216c
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
20 changed files with 71 additions and 278 deletions
Download patch file Download diff file Expand all files Collapse all files

3
crates/hir-def/src/data.rs
View file

@ -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 =

9
crates/hir-def/src/expander.rs
View file

@ -69,12 +69,9 @@ impl Expander {
let result = self.within_limit(db, |this| {
let macro_call = this.in_file(&macro_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);

44
crates/hir-def/src/lib.rs
View file

@ -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<MacroDefId> + Copy,
) -> Option<MacroCallId> {
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<MacroDefId> + Copy,
mod_path: impl FnOnce(ModuleId) -> String,
) -> Result<ExpandResult<Option<MacroCallId>>, 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<MacroDefId> + Copy,
mod_path: impl FnOnce(ModuleId) -> String,
) -> Result<ExpandResult<Option<MacroCallId>>, 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<ast::MacroCall>,
call_site: SyntaxContextId,
expand_to: ExpandTo,
module: ModuleId,
krate: CrateId,
resolver: impl Fn(&path::ModPath) -> Option<MacroDefId> + Copy,
mod_path: impl FnOnce(ModuleId) -> String,
) -> Result<Option<MacroCallId>, 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<MacroDefId>,
eager_resolver: impl Fn(&path::ModPath) -> Option<MacroDefId>,
mod_path: impl FnOnce(ModuleId) -> String,
) -> Result<ExpandResult<Option<MacroCallId>>, 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,
)),

15
crates/hir-def/src/macro_expansion_tests/mod.rs
View file

@ -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, &macro_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 };

27
crates/hir-def/src/nameres.rs
View file

@ -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<Symbol>,
/// The extern prelude which contains all root modules of external crates that are in scope.
extern_prelude: FxIndexMap<Name, (CrateRootModuleId, Option<ExternCrateId>)>,
@ -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<ast::Adt>,

27
crates/hir-def/src/nameres/collector.rs
View file

@ -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