1 files changed, 126 insertions, 24 deletions

diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 9f8c6c4a5..fd7776fb7 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,8 +1,6 @@
 //! FIXME: write short doc here
 
 pub(crate) mod src;
-pub(crate) mod docs;
-pub(crate) mod attrs;
 
 use std::sync::Arc;
 
@@ -10,18 +8,20 @@ use hir_def::{
     adt::VariantData,
     body::scope::ExprScopes,
     builtin_type::BuiltinType,
-    nameres::per_ns::PerNs,
+    docs::Documentation,
+    per_ns::PerNs,
     resolver::{HasResolver, TypeNs},
     type_ref::TypeRef,
-    ContainerId, CrateModuleId, HasModule, ImplId, LocalEnumVariantId, LocalStructFieldId, Lookup,
-    ModuleId, UnionId,
+    ContainerId, HasModule, ImplId, LocalEnumVariantId, LocalImportId, LocalModuleId,
+    LocalStructFieldId, Lookup, ModuleId, UnionId,
 };
 use hir_expand::{
     diagnostics::DiagnosticSink,
     name::{self, AsName},
+    AstId,
 };
-use ra_db::{CrateId, Edition};
-use ra_syntax::ast;
+use ra_db::{CrateId, Edition, FileId, FilePosition};
+use ra_syntax::{ast, AstNode, SyntaxNode};
 
 use crate::{
     db::{DefDatabase, HirDatabase},
@@ -31,7 +31,7 @@ use crate::{
         TypeAliasId,
     },
     ty::{InferenceResult, Namespace, TraitRef},
-    Either, HasSource, ImportId, Name, Source, Ty,
+    Either, HasSource, Name, Source, Ty,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -79,6 +79,64 @@ impl Crate {
     }
 }
 
+pub enum ModuleSource {
+    SourceFile(ast::SourceFile),
+    Module(ast::Module),
+}
+
+impl ModuleSource {
+    pub fn new(
+        db: &impl DefDatabase,
+        file_id: Option<FileId>,
+        decl_id: Option<AstId<ast::Module>>,
+    ) -> ModuleSource {
+        match (file_id, decl_id) {
+            (Some(file_id), _) => {
+                let source_file = db.parse(file_id).tree();
+                ModuleSource::SourceFile(source_file)
+            }
+            (None, Some(item_id)) => {
+                let module = item_id.to_node(db);
+                assert!(module.item_list().is_some(), "expected inline module");
+                ModuleSource::Module(module)
+            }
+            (None, None) => panic!(),
+        }
+    }
+
+    // FIXME: this methods do not belong here
+    pub fn from_position(db: &impl DefDatabase, position: FilePosition) -> ModuleSource {
+        let parse = db.parse(position.file_id);
+        match &ra_syntax::algo::find_node_at_offset::<ast::Module>(
+            parse.tree().syntax(),
+            position.offset,
+        ) {
+            Some(m) if !m.has_semi() => ModuleSource::Module(m.clone()),
+            _ => {
+                let source_file = parse.tree();
+                ModuleSource::SourceFile(source_file)
+            }
+        }
+    }
+
+    pub fn from_child_node(db: &impl DefDatabase, child: Source<&SyntaxNode>) -> ModuleSource {
+        if let Some(m) =
+            child.value.ancestors().filter_map(ast::Module::cast).find(|it| !it.has_semi())
+        {
+            ModuleSource::Module(m)
+        } else {
+            let file_id = child.file_id.original_file(db);
+            let source_file = db.parse(file_id).tree();
+            ModuleSource::SourceFile(source_file)
+        }
+    }
+
+    pub fn from_file_id(db: &impl DefDatabase, file_id: FileId) -> ModuleSource {
+        let source_file = db.parse(file_id).tree();
+        ModuleSource::SourceFile(source_file)
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct Module {
     pub(crate) id: ModuleId,
@@ -110,10 +168,10 @@ impl_froms!(
     BuiltinType
 );
 
-pub use hir_def::ModuleSource;
+pub use hir_def::attr::Attrs;
 
 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 } }
     }
 
@@ -130,17 +188,6 @@ impl Module {
         })
     }
 
-    /// Returns the syntax of the last path segment corresponding to this import
-    pub fn import_source(
-        self,
-        db: &impl HirDatabase,
-        import: ImportId,
-    ) -> Either<ast::UseTree, ast::ExternCrateItem> {
-        let src = self.definition_source(db);
-        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
-        source_map.get(&src.value, import)
-    }
-
     /// Returns the crate this module is part of.
     pub fn krate(self) -> Crate {
         Crate { crate_id: self.id.krate }
@@ -190,11 +237,13 @@ impl Module {
     }
 
     /// Returns a `ModuleScope`: a set of items, visible in this module.
-    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<ImportId>)> {
+    pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<Import>)> {
         db.crate_def_map(self.id.krate)[self.id.module_id]
             .scope
             .entries()
-            .map(|(name, res)| (name.clone(), res.def.into(), res.import))
+            .map(|(name, res)| {
+                (name.clone(), res.def.into(), res.import.map(|id| Import { parent: self, id }))
+            })
             .collect()
     }
 
@@ -232,11 +281,16 @@ impl Module {
         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)
     }
 }
 
+pub struct Import {
+    pub(crate) parent: Module,
+    pub(crate) id: LocalImportId,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct StructField {
     pub(crate) parent: VariantDef,
@@ -991,3 +1045,51 @@ impl From<PerNs> for ScopeDef {
             .unwrap_or(ScopeDef::Unknown)
     }
 }
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum AttrDef {
+    Module(Module),
+    StructField(StructField),
+    Adt(Adt),
+    Function(Function),
+    EnumVariant(EnumVariant),
+    Static(Static),
+    Const(Const),
+    Trait(Trait),
+    TypeAlias(TypeAlias),
+    MacroDef(MacroDef),
+}
+
+impl_froms!(
+    AttrDef: Module,
+    StructField,
+    Adt(Struct, Enum, Union),
+    EnumVariant,
+    Static,
+    Const,
+    Function,
+    Trait,
+    TypeAlias,
+    MacroDef
+);
+
+pub trait HasAttrs {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs;
+}
+
+impl<T: Into<AttrDef>> HasAttrs for T {
+    fn attrs(self, db: &impl DefDatabase) -> Attrs {
+        let def: AttrDef = self.into();
+        db.attrs(def.into())
+    }
+}
+
+pub trait Docs {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation>;
+}
+impl<T: Into<AttrDef> + Copy> Docs for T {
+    fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
+        let def: AttrDef = (*self).into();
+        db.documentation(def.into())
+    }
+}