nameres::per_ns::PerNs,
resolver::{HasResolver, TypeNs},
type_ref::TypeRef,
- ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalImportId,
+ ContainerId, HasModule, ImplId, LocalEnumVariantId, LocalImportId, LocalModuleId,
LocalStructFieldId, Lookup, ModuleId, UnionId,
};
use hir_expand::{
pub use hir_def::{attr::Attrs, ModuleSource};
impl Module {
- pub(crate) fn new(krate: Crate, crate_module_id: CrateModuleId) -> Module {
+ pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
Module { id: ModuleId { krate: krate.crate_id, module_id: crate_module_id } }
}
def_map[self.id.module_id].impls.iter().copied().map(ImplBlock::from).collect()
}
- fn with_module_id(self, module_id: CrateModuleId) -> Module {
+ fn with_module_id(self, module_id: LocalModuleId) -> Module {
Module::new(self.krate(), module_id)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct ModuleId {
pub krate: CrateId,
- pub module_id: CrateModuleId,
+ pub module_id: LocalModuleId,
}
/// An ID of a module, **local** to a specific crate
// FIXME: rename to `LocalModuleId`.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct CrateModuleId(RawId);
-impl_arena_id!(CrateModuleId);
+pub struct LocalModuleId(RawId);
+impl_arena_id!(LocalModuleId);
macro_rules! impl_intern_key {
($name:ident) => {
db::DefDatabase,
nameres::{diagnostics::DefDiagnostic, path_resolution::ResolveMode, per_ns::PerNs},
path::Path,
- AstId, CrateModuleId, FunctionId, ImplId, LocalImportId, ModuleDefId, ModuleId, TraitId,
+ AstId, FunctionId, ImplId, LocalImportId, LocalModuleId, ModuleDefId, ModuleId, TraitId,
};
/// Contains all top-level defs from a macro-expanded crate
/// a dependency (`std` or `core`).
prelude: Option<ModuleId>,
extern_prelude: FxHashMap<Name, ModuleDefId>,
- root: CrateModuleId,
- modules: Arena<CrateModuleId, ModuleData>,
+ root: LocalModuleId,
+ modules: Arena<LocalModuleId, ModuleData>,
/// Some macros are not well-behavior, which leads to infinite loop
/// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
diagnostics: Vec<DefDiagnostic>,
}
-impl std::ops::Index<CrateModuleId> for CrateDefMap {
+impl std::ops::Index<LocalModuleId> for CrateDefMap {
type Output = ModuleData;
- fn index(&self, id: CrateModuleId) -> &ModuleData {
+ fn index(&self, id: LocalModuleId) -> &ModuleData {
&self.modules[id]
}
}
#[derive(Default, Debug, PartialEq, Eq)]
pub struct ModuleData {
- pub parent: Option<CrateModuleId>,
- pub children: FxHashMap<Name, CrateModuleId>,
+ pub parent: Option<LocalModuleId>,
+ pub children: FxHashMap<Name, LocalModuleId>,
pub scope: ModuleScope,
// FIXME: these can't be both null, we need a three-state enum here.
let def_map = {
let crate_graph = db.crate_graph();
let edition = crate_graph.edition(krate);
- let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+ let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
let root = modules.alloc(ModuleData::default());
CrateDefMap {
krate,
self.krate
}
- pub fn root(&self) -> CrateModuleId {
+ pub fn root(&self) -> LocalModuleId {
self.root
}
pub fn add_diagnostics(
&self,
db: &impl DefDatabase,
- module: CrateModuleId,
+ module: LocalModuleId,
sink: &mut DiagnosticSink,
) {
self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
pub fn resolve_path(
&self,
db: &impl DefDatabase,
- original_module: CrateModuleId,
+ original_module: LocalModuleId,
path: &Path,
) -> (PerNs, Option<usize>) {
let res = self.resolve_path_fp_with_macro(db, ResolveMode::Other, original_module, path);
(res.resolved_def, res.segment_index)
}
- pub fn modules(&self) -> impl Iterator<Item = CrateModuleId> + '_ {
+ pub fn modules(&self) -> impl Iterator<Item = LocalModuleId> + '_ {
self.modules.iter().map(|(id, _data)| id)
}
- pub fn modules_for_file(&self, file_id: FileId) -> impl Iterator<Item = CrateModuleId> + '_ {
+ pub fn modules_for_file(&self, file_id: FileId) -> impl Iterator<Item = LocalModuleId> + '_ {
self.modules
.iter()
.filter(move |(_id, data)| data.definition == Some(file_id))
use ra_db::RelativePathBuf;
use ra_syntax::{ast, AstPtr};
- use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::CrateModuleId, AstId};
+ use crate::{db::DefDatabase, diagnostics::UnresolvedModule, nameres::LocalModuleId, AstId};
#[derive(Debug, PartialEq, Eq)]
pub(super) enum DefDiagnostic {
UnresolvedModule {
- module: CrateModuleId,
+ module: LocalModuleId,
declaration: AstId<ast::Module>,
candidate: RelativePathBuf,
},
pub(super) fn add_to(
&self,
db: &impl DefDatabase,
- target_module: CrateModuleId,
+ target_module: LocalModuleId,
sink: &mut DiagnosticSink,
) {
match self {
per_ns::PerNs, raw, CrateDefMap, ModuleData, Resolution, ResolveMode,
},
path::{Path, PathKind},
- AdtId, AstId, AstItemDef, ConstLoc, ContainerId, CrateModuleId, EnumId, EnumVariantId,
- FunctionLoc, ImplId, Intern, LocalImportId, LocationCtx, ModuleDefId, ModuleId, StaticId,
- StructId, StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
+ AdtId, AstId, AstItemDef, ConstLoc, ContainerId, EnumId, EnumVariantId, FunctionLoc, ImplId,
+ Intern, LocalImportId, LocalModuleId, LocationCtx, ModuleDefId, ModuleId, StaticId, StructId,
+ StructOrUnionId, TraitId, TypeAliasLoc, UnionId,
};
pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap {
struct DefCollector<'a, DB> {
db: &'a DB,
def_map: CrateDefMap,
- glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, LocalImportId)>>,
- unresolved_imports: Vec<(CrateModuleId, LocalImportId, raw::ImportData)>,
- unexpanded_macros: Vec<(
CrateModuleId, AstId<ast::MacroCall>, Path)>,
- mod_dirs: FxHashMap<CrateModuleId, ModDir>,
+ glob_imports: FxHashMap<LocalModuleId, Vec<(LocalModuleId, LocalImportId)>>,
+ unresolved_imports: Vec<(LocalModuleId, LocalImportId, raw::ImportData)>,
+ unexpanded_macros: Vec<(
LocalModuleId, AstId<ast::MacroCall>, Path)>,
+ mod_dirs: FxHashMap<LocalModuleId, ModDir>,
/// Some macro use `$tt:tt which mean we have to handle the macro perfectly
/// To prevent stack overflow, we add a deep counter here for prevent that.
/// ```
fn define_macro(
&mut self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
name: Name,
macro_: MacroDefId,
export: bool,
/// the definition of current module.
/// And also, `macro_use` on a module will import all legacy macros visable inside to
/// current legacy scope, with possible shadowing.
- fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDefId) {
+ fn define_legacy_macro(&mut self, module_id: LocalModuleId, name: Name, macro_: MacroDefId) {
// Always shadowing
self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_);
}
/// Import macros from `#[macro_use] extern crate`.
fn import_macros_from_extern_crate(
&mut self,
- current_module_id: CrateModuleId,
+ current_module_id: LocalModuleId,
import: &raw::ImportData,
) {
log::debug!(
/// Exported macros are just all macros in the root module scope.
/// Note that it contains not only all `#[macro_export]` macros, but also all aliases
/// created by `use` in the root module, ignoring the visibility of `use`.
- fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: CrateId) {
+ fn import_all_macros_exported(&mut self, current_module_id: LocalModuleId, krate: CrateId) {
let def_map = self.db.crate_def_map(krate);
for (name, def) in def_map[def_map.root].scope.macros() {
// `macro_use` only bring things into legacy scope.
fn resolve_import(
&self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
import: &raw::ImportData,
) -> (PerNs, ReachedFixedPoint) {
log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition);
fn record_resolved_import(
&mut self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
def: PerNs,
import_id: LocalImportId,
import: &raw::ImportData,
fn update(
&mut self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
import: Option<LocalImportId>,
resolutions: &[(Name, Resolution)],
) {
fn update_recursive(
&mut self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
import: Option<LocalImportId>,
resolutions: &[(Name, Resolution)],
depth: usize,
fn collect_macro_expansion(
&mut self,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
macro_call_id: MacroCallId,
macro_def_id: MacroDefId,
) {
/// Walks a single module, populating defs, imports and macros
struct ModCollector<'a, D> {
def_collector: D,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
file_id: HirFileId,
raw_items: &'a raw::RawItems,
mod_dir: ModDir,
name: Name,
declaration: AstId<ast::Module>,
definition: Option<FileId>,
- ) -> CrateModuleId {
+ ) -> LocalModuleId {
let modules = &mut self.def_collector.def_map.modules;
let res = modules.alloc(ModuleData::default());
modules[res].parent = Some(self.module_id);
self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path));
}
- fn import_all_legacy_macros(&mut self, module_id: CrateModuleId) {
+ fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
let macros = self.def_collector.def_map[module_id].scope.legacy_macros.clone();
for (name, macro_) in macros {
self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_);
let def_map = {
let edition = db.crate_graph().edition(krate);
- let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
+ let mut modules: Arena<LocalModuleId, ModuleData> = Arena::default();
let root = modules.alloc(ModuleData::default());
CrateDefMap {
krate,
db::DefDatabase,
nameres::{per_ns::PerNs, CrateDefMap},
path::{Path, PathKind},
- AdtId, CrateModuleId, EnumVariantId, ModuleDefId, ModuleId,
+ AdtId, EnumVariantId, LocalModuleId, ModuleDefId, ModuleId,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
&self,
db: &impl DefDatabase,
mode: ResolveMode,
- original_module: CrateModuleId,
+ original_module: LocalModuleId,
path: &Path,
) -> ResolvePathResult {
let mut segments = path.segments.iter().enumerate();
fn resolve_name_in_module(
&self,
db: &impl DefDatabase,
- module: CrateModuleId,
+ module: LocalModuleId,
name: &Name,
) -> PerNs {
// Resolve in:
use ra_db::{fixture::WithFixture, SourceDatabase};
use test_utils::covers;
-use crate::{db::DefDatabase, nameres::*, test_db::TestDB, CrateModuleId};
+use crate::{db::DefDatabase, nameres::*, test_db::TestDB, LocalModuleId};
fn def_map(fixtute: &str) -> String {
let dm = compute_crate_def_map(fixtute);
go(&mut buf, map, "\ncrate", map.root());
return buf.trim().to_string();
- fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
+ fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: LocalModuleId) {
*buf += path;
*buf += "\n";
@r###"
[
UnresolvedModule {
- module: CrateModuleId(
+ module: LocalModuleId(
0,
),
declaration: AstId {
generics::GenericParams,
nameres::{per_ns::PerNs, CrateDefMap},
path::{Path, PathKind},
- AdtId, AstItemDef, ConstId, ContainerId, CrateModuleId, DefWithBodyId, EnumId, EnumVariantId,
- FunctionId, GenericDefId, ImplId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId,
- TypeAliasId,
+ AdtId, AstItemDef, ConstId, ContainerId, DefWithBodyId, EnumId, EnumVariantId, FunctionId,
+ GenericDefId, ImplId, LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId,
+ TraitId, TypeAliasId,
};
#[derive(Debug, Clone, Default)]
#[derive(Debug, Clone)]
pub(crate) struct ModuleItemMap {
crate_def_map: Arc<CrateDefMap>,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
}
#[derive(Debug, Clone)]
traits
}
- fn module(&self) -> Option<(&CrateDefMap, CrateModuleId)> {
+ fn module(&self) -> Option<(&CrateDefMap, LocalModuleId)> {
self.scopes.iter().rev().find_map(|scope| match scope {
Scope::ModuleScope(m) => Some((&*m.crate_def_map, m.module_id)),
fn push_module_scope(
self,
crate_def_map: Arc<CrateDefMap>,
- module_id: CrateModuleId,
+ module_id: LocalModuleId,
) -> Resolver {
self.push_scope(Scope::ModuleScope(ModuleItemMap { crate_def_map, module_id }))
}
projects / rust.git / commitdiff