Merge #1779

1779: minor r=matklad a=matklad



Co-authored-by: Aleksey Kladov <[email protected]>

2 files changed, 51 insertions, 49 deletions

diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index dc2e2172b..fe90879b6 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -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;
diff --git a/crates/ra_hir/src/nameres/mod_resolution.rs b/crates/ra_hir/src/nameres/mod_resolution.rs
index de81fd422..918c9591f 100644
--- a/crates/ra_hir/src/nameres/mod_resolution.rs
+++ b/crates/ra_hir/src/nameres/mod_resolution.rs
@@ -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));