6 files changed, 157 insertions, 61 deletions

diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs
index 06b732215..7da2dcdff 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir/src/nameres/collector.rs
@@ -483,7 +483,7 @@ struct ModCollector<'a, D> {
     module_id: CrateModuleId,
     file_id: HirFileId,
     raw_items: &'a raw::RawItems,
-    parent_module: Option<&'a Name>,
+    parent_module: Option<ParentModule<'a>>,
 }
 
 impl<DB> ModCollector<'_, &'_ mut DefCollector<&'_ DB>>
@@ -508,15 +508,16 @@ where
     fn collect_module(&mut self, module: &raw::ModuleData) {
         match module {
             // inline module, just recurse
-            raw::ModuleData::Definition { name, items, ast_id } => {
+            raw::ModuleData::Definition { name, items, ast_id, attr_path } => {
                 let module_id =
                     self.push_child_module(name.clone(), ast_id.with_file_id(self.file_id), None);
+                let parent_module = ParentModule { name, attr_path: attr_path.as_ref() };
                 ModCollector {
                     def_collector: &mut *self.def_collector,
                     module_id,
                     file_id: self.file_id,
                     raw_items: self.raw_items,
-                    parent_module: Some(name),
+                    parent_module: Some(parent_module),
                 }
                 .collect(&*items);
             }
@@ -530,7 +531,7 @@ where
                     name,
                     is_root,
                     attr_path.as_ref(),
-                    self.parent_module,
+                    self.parent_module.as_ref(),
                 ) {
                     Ok(file_id) => {
                         let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id));
@@ -647,7 +648,7 @@ fn resolve_submodule(
     name: &Name,
     is_root: bool,
     attr_path: Option<&SmolStr>,
-    parent_module: Option<&Name>,
+    parent_module: Option<&ParentModule>,
 ) -> Result<FileId, RelativePathBuf> {
     let file_id = file_id.original_file(db);
     let source_root_id = db.file_source_root(file_id);
@@ -657,20 +658,49 @@ fn resolve_submodule(
     let mod_name = path.file_stem().unwrap_or("unknown");
 
     let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
-        (Some(file_path), Some(parent_name)) => {
+        (Some(file_path), Some(parent_module)) => {
             let file_path = normalize_attribute_path(file_path);
-            let path = dir_path.join(format!("{}/{}", parent_name, file_path)).normalize();
-            ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(path))
+            match parent_module.attribute_path() {
+                Some(parent_module_attr_path) => {
+                    let path = dir_path
+                        .join(format!(
+                            "{}/{}",
+                            normalize_attribute_path(parent_module_attr_path),
+                            file_path
+                        ))
+                        .normalize();
+                    ResolutionMode::InlineModuleWithAttributePath(
+                        InsideInlineModuleMode::WithAttributePath(path),
+                    )
+                }
+                None => {
+                    let path =
+                        dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
+                    ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
+                        path,
+                    ))
+                }
+            }
         }
+        (None, Some(parent_module)) => match parent_module.attribute_path() {
+            Some(parent_module_attr_path) => {
+                let path = dir_path.join(format!(
+                    "{}/{}.rs",
+                    normalize_attribute_path(parent_module_attr_path),
+                    name
+                ));
+                ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
+            }
+            None => {
+                let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
+                ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
+            }
+        },
         (Some(file_path), None) => {
             let file_path = normalize_attribute_path(file_path);
             let path = dir_path.join(file_path.as_ref()).normalize();
             ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
         }
-        (None, Some(parent_name)) => {
-            let path = dir_path.join(format!("{}/{}.rs", parent_name, name));
-            ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
-        }
         _ => {
             let is_dir_owner = is_root || mod_name == "mod";
             if is_dir_owner {
@@ -743,6 +773,7 @@ impl InsideInlineModuleMode {
 enum ResolutionMode {
     OutOfLine(OutOfLineMode),
     InsideInlineModule(InsideInlineModuleMode),
+    InlineModuleWithAttributePath(InsideInlineModuleMode),
 }
 
 impl ResolutionMode {
@@ -752,6 +783,7 @@ impl ResolutionMode {
         match self {
             OutOfLine(mode) => mode.resolve(source_root),
             InsideInlineModule(mode) => mode.resolve(source_root),
+            InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
         }
     }
 }
@@ -773,6 +805,17 @@ fn resolve_find_result(
     }
 }
 
+struct ParentModule<'a> {
+    name: &'a Name,
+    attr_path: Option<&'a SmolStr>,
+}
+
+impl<'a> ParentModule<'a> {
+    pub fn attribute_path(&self) -> Option<&SmolStr> {
+        self.attr_path.filter(|p| !p.is_empty())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use ra_db::SourceDatabase;
diff --git a/crates/ra_hir/src/nameres/raw.rs b/crates/ra_hir/src/nameres/raw.rs
index 8517f3c43..584e15e29 100644
--- a/crates/ra_hir/src/nameres/raw.rs
+++ b/crates/ra_hir/src/nameres/raw.rs
@@ -130,8 +130,17 @@ impl_arena_id!(Module);
 
 #[derive(Debug, PartialEq, Eq)]
 pub(super) enum ModuleData {
-    Declaration { name: Name, ast_id: FileAstId<ast::Module>, attr_path: Option<SmolStr> },
-    Definition { name: Name, ast_id: FileAstId<ast::Module>, items: Vec<RawItem> },
+    Declaration {
+        name: Name,
+        ast_id: FileAstId<ast::Module>,
+        attr_path: Option<SmolStr>,
+    },
+    Definition {
+        name: Name,
+        ast_id: FileAstId<ast::Module>,
+        items: Vec<RawItem>,
+        attr_path: Option<SmolStr>,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -256,9 +265,9 @@ impl RawItemsCollector {
             None => return,
         };
 
-        let attr_path = extract_mod_path_attribute(&module);
         let ast_id = self.source_ast_id_map.ast_id(&module);
         if module.has_semi() {
+            let attr_path = extract_mod_path_attribute(&module);
             let item =
                 self.raw_items.modules.alloc(ModuleData::Declaration { name, ast_id, attr_path });
             self.push_item(current_module, RawItem::Module(item));
@@ -266,10 +275,12 @@ impl RawItemsCollector {
         }
 
         if let Some(item_list) = module.item_list() {
+            let attr_path = extract_mod_path_attribute(&module);
             let item = self.raw_items.modules.alloc(ModuleData::Definition {
                 name,
                 ast_id,
                 items: Vec::new(),
+                attr_path,
             });
             self.process_module(Some(item), item_list);
             self.push_item(current_module, RawItem::Module(item));
diff --git a/crates/ra_hir/src/nameres/tests/mods.rs b/crates/ra_hir/src/nameres/tests/mods.rs
index 382728149..6dd18df1a 100644
--- a/crates/ra_hir/src/nameres/tests/mods.rs
+++ b/crates/ra_hir/src/nameres/tests/mods.rs
@@ -336,9 +336,7 @@ fn module_resolution_explicit_path_mod_rs_with_win_separator() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_with_path_attribute() {
     let map = def_map_with_crate_graph(
         r###"
@@ -397,9 +395,7 @@ fn module_resolution_decl_inside_inline_module() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
     let map = def_map_with_crate_graph(
         r###"
@@ -429,9 +425,7 @@ fn module_resolution_decl_inside_inline_module_2_with_path_attribute() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_3() {
     let map = def_map_with_crate_graph(
         r###"
@@ -462,9 +456,7 @@ fn module_resolution_decl_inside_inline_module_3() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_empty_path() {
     let map = def_map_with_crate_graph(
         r###"
@@ -475,7 +467,7 @@ fn module_resolution_decl_inside_inline_module_empty_path() {
             mod bar;
         }
 
-        //- /users.rs
+        //- /foo/users.rs
         pub struct Baz;
         "###,
         crate_graph! {
@@ -520,9 +512,7 @@ fn module_resolution_decl_empty_path() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_relative_path() {
     let map = def_map_with_crate_graph(
         r###"
@@ -660,9 +650,7 @@ fn module_resolution_decl_inside_inline_module_in_non_crate_root() {
     "###);
 }
 
-// FIXME: issue #1529. not support out-of-line modules inside inline.
 #[test]
-#[ignore]
 fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() {
     let map = def_map_with_crate_graph(
         r###"
diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs
index 6603ff34d..9d6d0133f 100644
--- a/crates/ra_mbe/src/subtree_source.rs
+++ b/crates/ra_mbe/src/subtree_source.rs
@@ -1,6 +1,6 @@
 use ra_parser::{Token, TokenSource};
 use ra_syntax::{classify_literal, SmolStr, SyntaxKind, SyntaxKind::*, T};
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell, Ref, RefCell};
 use tt::buffer::{Cursor, TokenBuffer};
 
 #[derive(Debug, Clone, Eq, PartialEq)]
@@ -20,8 +20,8 @@ impl<'a> SubtreeTokenSource<'a> {
     // Helper function used in test
     #[cfg(test)]
     pub fn text(&self) -> SmolStr {
-        match self.get(self.curr.1) {
-            Some(tt) => tt.text,
+        match *self.get(self.curr.1) {
+            Some(ref tt) => tt.text.clone(),
             _ => SmolStr::new(""),
         }
     }
@@ -41,44 +41,46 @@ impl<'a> SubtreeTokenSource<'a> {
     }
 
     fn mk_token(&self, pos: usize) -> Token {
-        match self.get(pos) {
-            Some(tt) => Token { kind: tt.kind, is_jointed_to_next: tt.is_joint_to_next },
+        match *self.get(pos) {
+            Some(ref tt) => Token { kind: tt.kind, is_jointed_to_next: tt.is_joint_to_next },
             None => Token { kind: EOF, is_jointed_to_next: false },
         }
     }
 
-    fn get(&self, pos: usize) -> Option<TtToken> {
-        let mut cached = self.cached.borrow_mut();
-        if pos < cached.len() {
-            return cached[pos].clone();
+    fn get(&self, pos: usize) -> Ref<Option<TtToken>> {
+        if pos < self.cached.borrow().len() {
+            return Ref::map(self.cached.borrow(), |c| &c[pos]);
         }
 
-        while pos >= cached.len() {
-            let cursor = self.cached_cursor.get();
-            if cursor.eof() {
-                cached.push(None);
-                continue;
-            }
-
-            match cursor.token_tree() {
-                Some(tt::TokenTree::Leaf(leaf)) => {
-                    cached.push(Some(convert_leaf(&leaf)));
-                    self.cached_cursor.set(cursor.bump());
-                }
-                Some(tt::TokenTree::Subtree(subtree)) => {
-                    self.cached_cursor.set(cursor.subtree().unwrap());
-                    cached.push(Some(convert_delim(subtree.delimiter, false)));
+        {
+            let mut cached = self.cached.borrow_mut();
+            while pos >= cached.len() {
+                let cursor = self.cached_cursor.get();
+                if cursor.eof() {
+                    cached.push(None);
+                    continue;
                 }
-                None => {
-                    if let Some(subtree) = cursor.end() {
-                        cached.push(Some(convert_delim(subtree.delimiter, true)));
+
+                match cursor.token_tree() {
+                    Some(tt::TokenTree::Leaf(leaf)) => {
+                        cached.push(Some(convert_leaf(&leaf)));
                         self.cached_cursor.set(cursor.bump());
                     }
+                    Some(tt::TokenTree::Subtree(subtree)) => {
+                        self.cached_cursor.set(cursor.subtree().unwrap());
+                        cached.push(Some(convert_delim(subtree.delimiter, false)));
+                    }
+                    None => {
+                        if let Some(subtree) = cursor.end() {
+                            cached.push(Some(convert_delim(subtree.delimiter, true)));
+                            self.cached_cursor.set(cursor.bump());
+                        }
+                    }
                 }
             }
         }
 
-        cached[pos].clone()
+        Ref::map(self.cached.borrow(), |c| &c[pos])
     }
 }
 
@@ -103,8 +105,8 @@ impl<'a> TokenSource for SubtreeTokenSource<'a> {
 
     /// Is the current token a specified keyword?
     fn is_keyword(&self, kw: &str) -> bool {
-        match self.get(self.curr.1) {
-            Some(t) => t.text == *kw,
+        match *self.get(self.curr.1) {
+            Some(ref t) => t.text == *kw,
             _ => false,
         }
     }
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index c5746d98d..6f0489617 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -139,6 +139,52 @@ fn test_doc_comment_preserves_newlines() {
 }
 
 #[test]
+fn test_doc_comment_single_line_block_strips_suffix() {
+    let file = SourceFile::parse(
+        r#"
+        /** this is mod foo*/
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("this is mod foo", module.doc_comment_text().unwrap());
+}
+
+#[test]
+fn test_doc_comment_single_line_block_strips_suffix_whitespace() {
+    let file = SourceFile::parse(
+        r#"
+        /** this is mod foo */
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("this is mod foo", module.doc_comment_text().unwrap());
+}
+
+#[test]
+fn test_doc_comment_multi_line_block_strips_suffix() {
+    let file = SourceFile::parse(
+        r#"
+        /**
+        this
+        is
+        mod foo
+        */
+        mod foo {}
+        "#,
+    )
+    .ok()
+    .unwrap();
+    let module = file.syntax().descendants().find_map(Module::cast).unwrap();
+    assert_eq!("        this\n        is\n        mod foo", module.doc_comment_text().unwrap());
+}
+
+#[test]
 fn test_where_predicates() {
     fn assert_bound(text: &str, bound: Option<TypeBound>) {
         assert_eq!(text, bound.unwrap().syntax().text().to_string());
diff --git a/crates/ra_syntax/src/ast/traits.rs b/crates/ra_syntax/src/ast/traits.rs
index 6ed1b5213..1b9a2b20c 100644
--- a/crates/ra_syntax/src/ast/traits.rs
+++ b/crates/ra_syntax/src/ast/traits.rs
@@ -115,8 +115,8 @@ pub trait DocCommentsOwner: AstNode {
     }
 
     /// Returns the textual content of a doc comment block as a single string.
-    /// That is, strips leading `///` (+ optional 1 character of whitespace)
-    /// and joins lines.
+    /// That is, strips leading `///` (+ optional 1 character of whitespace),
+    /// trailing `*/`, trailing whitespace and then joins the lines.
     fn doc_comment_text(&self) -> Option<String> {
         let mut has_comments = false;
         let docs = self
@@ -136,7 +136,13 @@ pub trait DocCommentsOwner: AstNode {
                         prefix_len
                     };
 
-                line[pos..].to_owned()
+                let end = if comment.kind().shape.is_block() && line.ends_with("*/") {
+                    line.len() - 2
+                } else {
+                    line.len()
+                };
+
+                line[pos..end].trim_end().to_owned()
             })
             .join("\n");