Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-28 05:53:45 +00:00
Code Issues Projects Releases Packages Wiki Activity

minor

Browse source
This commit is contained in:
Aleksey Kladov 2019-09-06 14:30:24 +03:00
parent 3bdb456d17
commit f477f2516a
2 changed files with 51 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

96
crates/ra_hir/src/nameres.rs
View file

@ -1,51 +1,51 @@
/// This module implements import-resolution/macro expansion algorithm.
///
/// The result of this module is `CrateDefMap`: a data structure which contains:
///
/// * a tree of modules for the crate
/// * for each module, a set of items visible in the module (directly declared
/// or imported)
///
/// Note that `CrateDefMap` contains fully macro expanded code.
///
/// Computing `CrateDefMap` can be partitioned into several logically
/// independent "phases". The phases are mutually recursive though, there's no
/// strict ordering.
///
/// ## Collecting RawItems
///
/// This happens in the `raw` module, which parses a single source file into a
/// set of top-level items. Nested imports are desugared to flat imports in
/// this phase. Macro calls are represented as a triple of (Path, Option<Name>,
/// TokenTree).
///
/// ## Collecting Modules
///
/// This happens in the `collector` module. In this phase, we recursively walk
/// tree of modules, collect raw items from submodules, populate module scopes
/// with defined items (so, we assign item ids in this phase) and record the set
/// of unresolved imports and macros.
///
/// While we walk tree of modules, we also record macro_rules definitions and
/// expand calls to macro_rules defined macros.
///
/// ## Resolving Imports
///
/// We maintain a list of currently unresolved imports. On every iteration, we
/// try to resolve some imports from this list. If the import is resolved, we
/// record it, by adding an item to current module scope and, if necessary, by
/// recursively populating glob imports.
///
/// ## Resolving Macros
///
/// macro_rules from the same crate use a global mutable namespace. We expand
/// them immediately, when we collect modules.
///
/// Macros from other crates (including proc-macros) can be used with
/// `foo::bar!` syntax. We handle them similarly to imports. There's a list of
/// unexpanded macros. On every iteration, we try to resolve each macro call
/// path and, upon success, we run macro expansion and "collect module" phase
/// on the result
//! This module implements import-resolution/macro expansion algorithm.
//!
//! The result of this module is `CrateDefMap`: a data structure which contains:
//!
//! * a tree of modules for the crate
//! * for each module, a set of items visible in the module (directly declared
//! or imported)
//!
//! Note that `CrateDefMap` contains fully macro expanded code.
//!
//! Computing `CrateDefMap` can be partitioned into several logically
//! independent "phases". The phases are mutually recursive though, there's no
//! strict ordering.
//!
//! ## Collecting RawItems
//!
//! This happens in the `raw` module, which parses a single source file into a
//! set of top-level items. Nested imports are desugared to flat imports in
//! this phase. Macro calls are represented as a triple of (Path, Option<Name>,
//! TokenTree).
//!
//! ## Collecting Modules
//!
//! This happens in the `collector` module. In this phase, we recursively walk
//! tree of modules, collect raw items from submodules, populate module scopes
//! with defined items (so, we assign item ids in this phase) and record the set
//! of unresolved imports and macros.
//!
//! While we walk tree of modules, we also record macro_rules definitions and
//! expand calls to macro_rules defined macros.
//!
//! ## Resolving Imports
//!
//! We maintain a list of currently unresolved imports. On every iteration, we
//! try to resolve some imports from this list. If the import is resolved, we
//! record it, by adding an item to current module scope and, if necessary, by
//! recursively populating glob imports.
//!
//! ## Resolving Macros
//!
//! macro_rules from the same crate use a global mutable namespace. We expand
//! them immediately, when we collect modules.
//!
//! Macros from other crates (including proc-macros) can be used with
//! `foo::bar!` syntax. We handle them similarly to imports. There's a list of
//! unexpanded macros. On every iteration, we try to resolve each macro call
//! path and, upon success, we run macro expansion and "collect module" phase
//! on the result
mod per_ns;
mod raw;

4
crates/ra_hir/src/nameres/mod_resolution.rs
View file

@ -1,3 +1,5 @@
//! This module resolves `mod foo;` declaration to file.
use std::{borrow::Cow, sync::Arc};
use ra_db::{FileId, SourceRoot};
@ -77,7 +79,7 @@ pub(super) fn resolve_submodule(
let path = dir_path.join(file_path.as_ref()).normalize();
ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
}
_ => {
(None, None) => {
let is_dir_owner = is_root || mod_name == "mod";
if is_dir_owner {
let file_mod = dir_path.join(format!("{}.rs", name));