Merge #1395

1395: move docs under code model r=matklad a=matklad



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

16 files changed, 210 insertions, 195 deletions

diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index 38ff1d6f6..b3843b35c 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -11,7 +11,7 @@ use ra_syntax::{
 
 use crate::{
     Name, AsName, Struct, Union, Enum, EnumVariant, Crate, AstDatabase,
-    HirDatabase, HirFileId, StructField, FieldSource,
+    HirDatabase, StructField, FieldSource, Source, HasSource,
     type_ref::TypeRef, DefDatabase,
 };
 
@@ -59,8 +59,8 @@ impl StructData {
         db: &(impl DefDatabase + AstDatabase),
         struct_: Struct,
     ) -> Arc<StructData> {
-        let (_, struct_def) = struct_.source(db);
-        Arc::new(StructData::new(&*struct_def))
+        let src = struct_.source(db);
+        Arc::new(StructData::new(&*src.ast))
     }
 }
 
@@ -72,15 +72,15 @@ impl EnumVariant {
     pub(crate) fn source_impl(
         &self,
         db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::EnumVariant>) {
-        let (file_id, enum_def) = self.parent.source(db);
-        let var = variants(&*enum_def)
+    ) -> Source<TreeArc<ast::EnumVariant>> {
+        let src = self.parent.source(db);
+        let ast = variants(&*src.ast)
             .zip(db.enum_data(self.parent).variants.iter())
             .find(|(_syntax, (id, _))| *id == self.id)
             .unwrap()
             .0
             .to_owned();
-        (file_id, var)
+        Source { file_id: src.file_id, ast }
     }
     pub(crate) fn variant_data(&self, db: &impl DefDatabase) -> Arc<VariantData> {
         db.enum_data(self.parent).variants[self.id].variant_data.clone()
@@ -95,9 +95,9 @@ pub struct EnumData {
 
 impl EnumData {
     pub(crate) fn enum_data_query(db: &(impl DefDatabase + AstDatabase), e: Enum) -> Arc<EnumData> {
-        let (_file_id, enum_def) = e.source(db);
-        let name = enum_def.name().map(|n| n.as_name());
-        let variants = variants(&*enum_def)
+        let src = e.source(db);
+        let name = src.ast.name().map(|n| n.as_name());
+        let variants = variants(&*src.ast)
             .map(|var| EnumVariantData {
                 name: var.name().map(|it| it.as_name()),
                 variant_data: Arc::new(VariantData::new(var.kind())),
@@ -201,24 +201,19 @@ impl VariantDef {
 }
 
 impl StructField {
-    pub(crate) fn source_impl(
-        &self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, FieldSource) {
+    pub(crate) fn source_impl(&self, db: &(impl DefDatabase + AstDatabase)) -> Source<FieldSource> {
         let var_data = self.parent.variant_data(db);
         let fields = var_data.fields().unwrap();
         let ss;
         let es;
         let (file_id, struct_kind) = match self.parent {
             VariantDef::Struct(s) => {
-                let (file_id, source) = s.source(db);
-                ss = source;
-                (file_id, ss.kind())
+                ss = s.source(db);
+                (ss.file_id, ss.ast.kind())
             }
             VariantDef::EnumVariant(e) => {
-                let (file_id, source) = e.source(db);
-                es = source;
-                (file_id, es.kind())
+                es = e.source(db);
+                (es.file_id, es.ast.kind())
             }
         };
 
@@ -231,12 +226,12 @@ impl StructField {
             }
             ast::StructKind::Unit => Vec::new(),
         };
-        let field = field_sources
+        let ast = field_sources
             .into_iter()
             .zip(fields.iter())
             .find(|(_syntax, (id, _))| *id == self.id)
             .unwrap()
             .0;
-        (file_id, field)
+        Source { file_id, ast }
     }
 }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 27850028b..830aea1f3 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -1,10 +1,13 @@
+pub(crate) mod src;
+pub(crate) mod docs;
+
 use std::sync::Arc;
 
 use ra_db::{CrateId, SourceRootId, Edition, FileId};
 use ra_syntax::{ast::{self, NameOwner, TypeAscriptionOwner}, TreeArc};
 
 use crate::{
-    Name, AsName, AstId, Ty, HirFileId, Either, KnownName,
+    Name, AsName, AstId, Ty, Either, KnownName, HasSource,
     HirDatabase, DefDatabase, AstDatabase,
     type_ref::TypeRef,
     nameres::{ModuleScope, Namespace, ImportId, CrateModuleId},
@@ -179,40 +182,15 @@ impl Module {
         })
     }
 
-    /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
-    pub fn definition_source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, ModuleSource) {
-        let def_map = db.crate_def_map(self.krate);
-        let decl_id = def_map[self.module_id].declaration;
-        let file_id = def_map[self.module_id].definition;
-        let module_source = ModuleSource::new(db, file_id, decl_id);
-        let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id());
-        (file_id, module_source)
-    }
-
-    /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
-    /// `None` for the crate root.
-    pub fn declaration_source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> Option<(HirFileId, TreeArc<ast::Module>)> {
-        let def_map = db.crate_def_map(self.krate);
-        let decl = def_map[self.module_id].declaration?;
-        let ast = decl.to_node(db);
-        Some((decl.file_id(), ast))
-    }
-
     /// Returns the syntax of the last path segment corresponding to this import
     pub fn import_source(
         self,
         db: &impl HirDatabase,
         import: ImportId,
     ) -> Either<TreeArc<ast::UseTree>, TreeArc<ast::ExternCrateItem>> {
-        let (file_id, source) = self.definition_source(db);
-        let (_, source_map) = db.raw_items_with_source_map(file_id);
-        source_map.get(&source, import)
+        let src = self.definition_source(db);
+        let (_, source_map) = db.raw_items_with_source_map(src.file_id);
+        source_map.get(&src.ast, import)
     }
 
     /// Returns the crate this module is part of.
@@ -335,10 +313,6 @@ impl StructField {
         self.parent.variant_data(db).fields().unwrap()[self.id].name.clone()
     }
 
-    pub fn source(&self, db: &(impl DefDatabase + AstDatabase)) -> (HirFileId, FieldSource) {
-        self.source_impl(db)
-    }
-
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
         db.type_for_field(*self)
     }
@@ -354,13 +328,6 @@ pub struct Struct {
 }
 
 impl Struct {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::StructDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl HirDatabase) -> Module {
         self.id.module(db)
     }
@@ -415,13 +382,6 @@ pub struct Union {
 }
 
 impl Union {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::StructDef>) {
-        self.id.source(db)
-    }
-
     pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
         db.struct_data(Struct { id: self.id }).name.clone()
     }
@@ -448,13 +408,6 @@ pub struct Enum {
 }
 
 impl Enum {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::EnumDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl HirDatabase) -> Module {
         self.id.module(db)
     }
@@ -498,12 +451,6 @@ pub struct EnumVariant {
 }
 
 impl EnumVariant {
-    pub fn source(
-        &self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::EnumVariant>) {
-        self.source_impl(db)
-    }
     pub fn module(&self, db: &impl HirDatabase) -> Module {
         self.parent.module(db)
     }
@@ -588,11 +535,11 @@ impl FnSignature {
         db: &(impl DefDatabase + AstDatabase),
         func: Function,
     ) -> Arc<FnSignature> {
-        let (_, node) = func.source(db);
-        let name = node.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
+        let src = func.source(db);
+        let name = src.ast.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
         let mut params = Vec::new();
         let mut has_self_param = false;
-        if let Some(param_list) = node.param_list() {
+        if let Some(param_list) = src.ast.param_list() {
             if let Some(self_param) = param_list.self_param() {
                 let self_type = if let Some(type_ref) = self_param.ascribed_type() {
                     TypeRef::from_ast(type_ref)
@@ -616,7 +563,7 @@ impl FnSignature {
                 params.push(type_ref);
             }
         }
-        let ret_type = if let Some(type_ref) = node.ret_type().and_then(|rt| rt.type_ref()) {
+        let ret_type = if let Some(type_ref) = src.ast.ret_type().and_then(|rt| rt.type_ref()) {
             TypeRef::from_ast(type_ref)
         } else {
             TypeRef::unit()
@@ -645,10 +592,6 @@ impl FnSignature {
 }
 
 impl Function {
-    pub fn source(self, db: &(impl DefDatabase + AstDatabase)) -> (HirFileId, TreeArc<ast::FnDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.module(db)
     }
@@ -723,13 +666,6 @@ pub struct Const {
 }
 
 impl Const {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::ConstDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.module(db)
     }
@@ -780,7 +716,7 @@ impl ConstSignature {
         db: &(impl DefDatabase + AstDatabase),
         konst: Const,
     ) -> Arc<ConstSignature> {
-        let (_, node) = konst.source(db);
+        let node = konst.source(db).ast;
         const_signature_for(&*node)
     }
 
@@ -788,7 +724,7 @@ impl ConstSignature {
         db: &(impl DefDatabase + AstDatabase),
         konst: Static,
     ) -> Arc<ConstSignature> {
-        let (_, node) = konst.source(db);
+        let node = konst.source(db).ast;
         const_signature_for(&*node)
     }
 }
@@ -806,13 +742,6 @@ pub struct Static {
 }
 
 impl Static {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::StaticDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.module(db)
     }
@@ -838,13 +767,6 @@ pub struct Trait {
 }
 
 impl Trait {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::TraitDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.module(db)
     }
@@ -884,13 +806,6 @@ pub struct TypeAlias {
 }
 
 impl TypeAlias {
-    pub fn source(
-        self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::TypeAliasDef>) {
-        self.id.source(db)
-    }
-
     pub fn module(self, db: &impl DefDatabase) -> Module {
         self.id.module(db)
     }
@@ -939,14 +854,7 @@ pub struct MacroDef {
     pub(crate) id: MacroDefId,
 }
 
-impl MacroDef {
-    pub fn source(
-        &self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::MacroCall>) {
-        (self.id.0.file_id(), self.id.0.to_node(db))
-    }
-}
+impl MacroDef {}
 
 pub enum Container {
     Trait(Trait),
diff --git a/crates/ra_hir/src/docs.rs b/crates/ra_hir/src/code_model/docs.rs
index 1b0f84de5..da2b9b854 100644
--- a/crates/ra_hir/src/docs.rs
+++ b/crates/ra_hir/src/code_model/docs.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use ra_syntax::ast;
 
 use crate::{
-    HirDatabase, DefDatabase, AstDatabase,
+    HirDatabase, DefDatabase, AstDatabase, HasSource,
     Module, StructField, Struct, Enum, EnumVariant, Static, Const, Function, Union, Trait, TypeAlias, FieldSource, MacroDef,
 };
 
@@ -71,21 +71,21 @@ pub(crate) fn documentation_query(
     def: DocDef,
 ) -> Option<Documentation> {
     match def {
-        DocDef::Module(it) => docs_from_ast(&*it.declaration_source(db)?.1),
-        DocDef::StructField(it) => match it.source(db).1 {
+        DocDef::Module(it) => docs_from_ast(&*it.declaration_source(db)?.ast),
+        DocDef::StructField(it) => match it.source(db).ast {
             FieldSource::Named(named) => docs_from_ast(&*named),
             FieldSource::Pos(..) => return None,
         },
-        DocDef::Struct(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Enum(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::EnumVariant(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Static(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Const(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Function(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Union(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::Trait(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::TypeAlias(it) => docs_from_ast(&*it.source(db).1),
-        DocDef::MacroDef(it) => docs_from_ast(&*it.source(db).1),
+        DocDef::Struct(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Enum(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::EnumVariant(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Static(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Const(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Function(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Union(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::Trait(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::TypeAlias(it) => docs_from_ast(&*it.source(db).ast),
+        DocDef::MacroDef(it) => docs_from_ast(&*it.source(db).ast),
     }
 }
 
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
new file mode 100644
index 000000000..5785d3b26
--- /dev/null
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -0,0 +1,110 @@
+use ra_syntax::{TreeArc, ast};
+
+use crate::{
+    HirFileId, DefDatabase, AstDatabase, Module, ModuleSource,
+    StructField, Struct, Enum, Union, EnumVariant, Function, Static, Trait, Const, TypeAlias,
+    FieldSource, MacroDef, ids::AstItemDef,
+};
+
+pub struct Source<T> {
+    pub file_id: HirFileId,
+    pub ast: T,
+}
+
+pub trait HasSource {
+    type Ast;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<Self::Ast>;
+}
+
+/// NB: Module is !HasSource, because it has two source nodes at the same time:
+/// definition and declaration.
+impl Module {
+    /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
+    pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ModuleSource> {
+        let def_map = db.crate_def_map(self.krate);
+        let decl_id = def_map[self.module_id].declaration;
+        let file_id = def_map[self.module_id].definition;
+        let ast = ModuleSource::new(db, file_id, decl_id);
+        let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id());
+        Source { file_id, ast }
+    }
+
+    /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
+    /// `None` for the crate root.
+    pub fn declaration_source(
+        self,
+        db: &(impl DefDatabase + AstDatabase),
+    ) -> Option<Source<TreeArc<ast::Module>>> {
+        let def_map = db.crate_def_map(self.krate);
+        let decl = def_map[self.module_id].declaration?;
+        let ast = decl.to_node(db);
+        Some(Source { file_id: decl.file_id(), ast })
+    }
+}
+
+impl HasSource for StructField {
+    type Ast = FieldSource;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<FieldSource> {
+        self.source_impl(db)
+    }
+}
+impl HasSource for Struct {
+    type Ast = TreeArc<ast::StructDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StructDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for Union {
+    type Ast = TreeArc<ast::StructDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StructDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for Enum {
+    type Ast = TreeArc<ast::EnumDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::EnumDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for EnumVariant {
+    type Ast = TreeArc<ast::EnumVariant>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::EnumVariant>> {
+        self.source_impl(db)
+    }
+}
+impl HasSource for Function {
+    type Ast = TreeArc<ast::FnDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::FnDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for Const {
+    type Ast = TreeArc<ast::ConstDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::ConstDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for Static {
+    type Ast = TreeArc<ast::StaticDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::StaticDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for Trait {
+    type Ast = TreeArc<ast::TraitDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::TraitDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for TypeAlias {
+    type Ast = TreeArc<ast::TypeAliasDef>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::TypeAliasDef>> {
+        self.id.source(db)
+    }
+}
+impl HasSource for MacroDef {
+    type Ast = TreeArc<ast::MacroCall>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::MacroCall>> {
+        Source { file_id: self.id.0.file_id(), ast: self.id.0.to_node(db) }
+    }
+}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index d2a372f3b..d2d6f95b7 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -128,8 +128,8 @@ pub trait DefDatabase: SourceDatabase {
     #[salsa::invoke(crate::lang_item::LangItems::lang_item_query)]
     fn lang_item(&self, start_crate: Crate, item: SmolStr) -> Option<LangItemTarget>;
 
-    #[salsa::invoke(crate::docs::documentation_query)]
-    fn documentation(&self, def: crate::docs::DocDef) -> Option<crate::docs::Documentation>;
+    #[salsa::invoke(crate::code_model::docs::documentation_query)]
+    fn documentation(&self, def: crate::DocDef) -> Option<crate::Documentation>;
 }
 
 #[salsa::query_group(HirDatabaseStorage)]
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index 012f374ec..b1973d19d 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -11,6 +11,7 @@ use ra_syntax::{
 
 use crate::{
     Path, Name, HirDatabase, Resolver,DefWithBody, Either, HirFileId, MacroCallLoc, MacroFileKind,
+    HasSource,
     name::AsName,
     type_ref::{Mutability, TypeRef},
 };
@@ -1018,19 +1019,19 @@ pub(crate) fn body_with_source_map_query(
 
     match def {
         DefWithBody::Const(ref c) => {
-            let (file_id, src) = c.source(db);
-            collector = ExprCollector::new(def, file_id, def.resolver(db), db);
-            collector.collect_const_body(&src)
+            let src = c.source(db);
+            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
+            collector.collect_const_body(&src.ast)
         }
         DefWithBody::Function(ref f) => {
-            let (file_id, src) = f.source(db);
-            collector = ExprCollector::new(def, file_id, def.resolver(db), db);
-            collector.collect_fn_body(&src)
+            let src = f.source(db);
+            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
+            collector.collect_fn_body(&src.ast)
         }
         DefWithBody::Static(ref s) => {
-            let (file_id, src) = s.source(db);
-            collector = ExprCollector::new(def, file_id, def.resolver(db), db);
-            collector.collect_static_body(&src)
+            let src = s.source(db);
+            collector = ExprCollector::new(def, src.file_id, def.resolver(db), db);
+            collector.collect_static_body(&src.ast)
         }
     }
 
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs
index a1b2641da..534fd482b 100644
--- a/crates/ra_hir/src/expr/validation.rs
+++ b/crates/ra_hir/src/expr/validation.rs
@@ -5,7 +5,7 @@ use ra_syntax::ast::{AstNode, StructLit};
 
 use crate::{
     expr::AstPtr,
-    HirDatabase, Function, Name,
+    HirDatabase, Function, Name, HasSource,
     diagnostics::{DiagnosticSink, MissingFields},
     adt::AdtDef,
     Path,
@@ -71,7 +71,7 @@ impl<'a, 'b> ExprValidator<'a, 'b> {
             return;
         }
         let source_map = self.func.body_source_map(db);
-        let file_id = self.func.source(db).0;
+        let file_id = self.func.source(db).file_id;
         let source_file = db.parse(file_id.original_file(db)).tree;
         if let Some(field_list_node) = source_map
             .expr_syntax(id)
diff --git a/crates/ra_hir/src/generics.rs b/crates/ra_hir/src/generics.rs
index b6c5e18d3..462b136b7 100644
--- a/crates/ra_hir/src/generics.rs
+++ b/crates/ra_hir/src/generics.rs
@@ -8,8 +8,10 @@ use std::sync::Arc;
 use ra_syntax::ast::{self, NameOwner, TypeParamsOwner, TypeBoundsOwner, DefaultTypeParamOwner};
 
 use crate::{
+    HasSource,
+    Name, AsName, Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock, Container, AdtDef,
     db::{HirDatabase, DefDatabase, AstDatabase},
-    Name, AsName, Function, Struct, Union, Enum, Trait, TypeAlias, ImplBlock, Container, path::Path, type_ref::TypeRef, AdtDef
+    path::Path, type_ref::TypeRef,
 };
 
 /// Data about a generic parameter (to a function, struct, impl, ...).
@@ -68,10 +70,10 @@ impl GenericParams {
         generics.parent_params = parent.map(|p| db.generic_params(p));
         let start = generics.parent_params.as_ref().map(|p| p.params.len()).unwrap_or(0) as u32;
         match def {
-            GenericDef::Function(it) => generics.fill(&*it.source(db).1, start),
-            GenericDef::Struct(it) => generics.fill(&*it.source(db).1, start),
-            GenericDef::Union(it) => generics.fill(&*it.source(db).1, start),
-            GenericDef::Enum(it) => generics.fill(&*it.source(db).1, start),
+            GenericDef::Function(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Struct(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Union(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::Enum(it) => generics.fill(&*it.source(db).ast, start),
             GenericDef::Trait(it) => {
                 // traits get the Self type as an implicit first type parameter
                 generics.params.push(GenericParam {
@@ -79,10 +81,10 @@ impl GenericParams {
                     name: Name::self_type(),
                     default: None,
                 });
-                generics.fill(&*it.source(db).1, start + 1);
+                generics.fill(&*it.source(db).ast, start + 1);
             }
-            GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).1, start),
-            GenericDef::ImplBlock(it) => generics.fill(&*it.source(db).1, start),
+            GenericDef::TypeAlias(it) => generics.fill(&*it.source(db).ast, start),
+            GenericDef::ImplBlock(it) => generics.fill(&*it.source(db).ast, start),
         }
 
         Arc::new(generics)
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index a95561812..352f9ffd9 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -9,7 +9,7 @@ use ra_prof::profile;
 use mbe::MacroRules;
 
 use crate::{
-    Module, DefDatabase, AstId, FileAstId, AstDatabase,
+    Module, DefDatabase, AstId, FileAstId, AstDatabase, Source,
 };
 
 /// hir makes heavy use of ids: integer (u32) handlers to various things. You
@@ -265,10 +265,10 @@ pub(crate) trait AstItemDef<N: AstNode>: salsa::InternKey + Clone {
         let loc = ItemLoc { module: ctx.module, ast_id: ast_id.with_file_id(ctx.file_id) };
         Self::intern(ctx.db, loc)
     }
-    fn source(self, db: &(impl AstDatabase + DefDatabase)) -> (HirFileId, TreeArc<N>) {
+    fn source(self, db: &(impl AstDatabase + DefDatabase)) -> Source<TreeArc<N>> {
         let loc = self.lookup_intern(db);
         let ast = loc.ast_id.to_node(db);
-        (loc.ast_id.file_id(), ast)
+        Source { file_id: loc.ast_id.file_id(), ast }
     }
     fn module(self, db: &impl DefDatabase) -> Module {
         let loc = self.lookup_intern(db);
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index a0d3b33fe..fb9daf1bf 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -8,7 +8,7 @@ use ra_syntax::{
 };
 
 use crate::{
-    Const, TypeAlias, Function, HirFileId, AstDatabase,
+    Const, TypeAlias, Function, HirFileId, AstDatabase, HasSource, Source,
     HirDatabase, DefDatabase, TraitRef,
     type_ref::TypeRef,
     ids::LocationCtx,
@@ -44,6 +44,15 @@ pub struct ImplBlock {
     impl_id: ImplId,
 }
 
+impl HasSource for ImplBlock {
+    type Ast = TreeArc<ast::ImplBlock>;
+    fn source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<TreeArc<ast::ImplBlock>> {
+        let source_map = db.impls_in_module_with_source_map(self.module).1;
+        let src = self.module.definition_source(db);
+        Source { file_id: src.file_id, ast: source_map.get(&src.ast, self.impl_id) }
+    }
+}
+
 impl ImplBlock {
     pub(crate) fn containing(
         module_impl_blocks: Arc<ModuleImplBlocks>,
@@ -57,16 +66,6 @@ impl ImplBlock {
         ImplBlock { module, impl_id }
     }
 
-    /// Returns the syntax of the impl block
-    pub fn source(
-        &self,
-        db: &(impl DefDatabase + AstDatabase),
-    ) -> (HirFileId, TreeArc<ast::ImplBlock>) {
-        let source_map = db.impls_in_module_with_source_map(self.module).1;
-        let (file_id, source) = self.module.definition_source(db);
-        (file_id, source_map.get(&source, self.impl_id))
-    }
-
     pub fn id(&self) -> ImplId {
         self.impl_id
     }
@@ -201,8 +200,8 @@ impl ModuleImplBlocks {
             impls_by_def: FxHashMap::default(),
         };
 
-        let (file_id, module_source) = m.module.definition_source(db);
-        let node = match &module_source {
+        let src = m.module.definition_source(db);
+        let node = match &src.ast {
             ModuleSource::SourceFile(node) => node.syntax(),
             ModuleSource::Module(node) => {
                 node.item_list().expect("inline module should have item list").syntax()
@@ -210,7 +209,7 @@ impl ModuleImplBlocks {
         };
 
         for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) {
-            let impl_block = ImplData::from_ast(db, file_id, m.module, impl_block_ast);
+            let impl_block = ImplData::from_ast(db, src.file_id, m.module, impl_block_ast);
             let id = m.impls.alloc(impl_block);
             for &impl_item in &m.impls[id].items {
                 m.impls_by_def.insert(impl_item, id);
diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs
index 684fbc068..cdc9182d6 100644
--- a/crates/ra_hir/src/lang_item.rs
+++ b/crates/ra_hir/src/lang_item.rs
@@ -84,7 +84,7 @@ impl LangItems {
     ) {
         // Look for impl targets
         let (impl_blocks, source_map) = db.impls_in_module_with_source_map(module.clone());
-        let source = module.definition_source(db).1;
+        let source = module.definition_source(db).ast;
         for (impl_id, _) in impl_blocks.impls.iter() {
             let impl_block = source_map.get(&source, impl_id);
             let lang_item_name = impl_block
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 0e4aaf678..2e99bdac8 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -38,7 +38,6 @@ mod impl_block;
 mod expr;
 mod lang_item;
 mod generics;
-mod docs;
 mod resolve;
 pub mod diagnostics;
 
@@ -64,7 +63,6 @@ pub use self::{
     nameres::{PerNs, Namespace, ImportId},
     ty::{Ty, ApplicationTy, TypeCtor, TraitRef, Substs, display::HirDisplay, CallableDef},
     impl_block::{ImplBlock, ImplItem},
-    docs::{Docs, Documentation},
     adt::AdtDef,
     expr::ExprScopes,
     resolve::Resolution,
@@ -82,4 +80,6 @@ pub use self::code_model::{
     Static, Const, ConstSignature,
     Trait, TypeAlias, MacroDef, Container,
     BuiltinType,
+    src::{Source, HasSource},
+    docs::{Docs, Documentation, DocDef},
 };
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 876ebe0e3..4f9e8c5a9 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -97,13 +97,13 @@ pub fn struct_from_module(
     module: Module,
     struct_def: &ast::StructDef,
 ) -> Struct {
-    let (file_id, _) = module.definition_source(db);
+    let file_id = module.definition_source(db).file_id;
     let ctx = LocationCtx::new(db, module, file_id);
     Struct { id: ctx.to_def(struct_def) }
 }
 
 pub fn enum_from_module(db: &impl HirDatabase, module: Module, enum_def: &ast::EnumDef) -> Enum {
-    let (file_id, _) = module.definition_source(db);
+    let file_id = module.definition_source(db).file_id;
     let ctx = LocationCtx::new(db, module, file_id);
     Enum { id: ctx.to_def(enum_def) }
 }
@@ -113,7 +113,7 @@ pub fn trait_from_module(
     module: Module,
     trait_def: &ast::TraitDef,
 ) -> Trait {
-    let (file_id, _) = module.definition_source(db);
+    let file_id = module.definition_source(db).file_id;
     let ctx = LocationCtx::new(db, module, file_id);
     Trait { id: ctx.to_def(trait_def) }
 }
diff --git a/crates/ra_hir/src/traits.rs b/crates/ra_hir/src/traits.rs
index 967654e97..f2950e1b2 100644
--- a/crates/ra_hir/src/traits.rs
+++ b/crates/ra_hir/src/traits.rs
@@ -6,7 +6,7 @@ use rustc_hash::FxHashMap;
 use ra_syntax::ast::{self, NameOwner};
 
 use crate::{
-    Function, Const, TypeAlias, Name, DefDatabase, Trait, AstDatabase, Module,
+    Function, Const, TypeAlias, Name, DefDatabase, Trait, AstDatabase, Module, HasSource,
     ids::LocationCtx, name::AsName,
 };
 
@@ -22,12 +22,12 @@ impl TraitData {
         db: &(impl DefDatabase + AstDatabase),
         tr: Trait,
     ) -> Arc<TraitData> {
-        let (file_id, node) = tr.source(db);
-        let name = node.name().map(|n| n.as_name());
+        let src = tr.source(db);
+        let name = src.ast.name().map(|n| n.as_name());
         let module = tr.module(db);
-        let ctx = LocationCtx::new(db, module, file_id);
-        let auto = node.is_auto();
-        let items = if let Some(item_list) = node.item_list() {
+        let ctx = LocationCtx::new(db, module, src.file_id);
+        let auto = src.ast.is_auto();
+        let items = if let Some(item_list) = src.ast.item_list() {
             item_list
                 .impl_items()
                 .map(|item_node| match item_node.kind() {
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 6aa727ea1..fef0f1d24 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -1415,7 +1415,7 @@ mod diagnostics {
     use crate::{
         expr::ExprId,
         diagnostics::{DiagnosticSink, NoSuchField},
-        HirDatabase, Function,
+        HirDatabase, Function, HasSource,
 };
 
     #[derive(Debug, PartialEq, Eq, Clone)]
@@ -1432,7 +1432,7 @@ mod diagnostics {
         ) {
             match self {
                 InferenceDiagnostic::NoSuchField { expr, field } => {
-                    let (file, _) = owner.source(db);
+                    let file = owner.source(db).file_id;
                     let field = owner.body_source_map(db).field_syntax(*expr, *field);
                     sink.push(NoSuchField { file, field })
                 }
diff --git a/crates/ra_hir/src/type_alias.rs b/crates/ra_hir/src/type_alias.rs
index 970468e3c..87b9caa8a 100644
--- a/crates/ra_hir/src/type_alias.rs
+++ b/crates/ra_hir/src/type_alias.rs
@@ -2,12 +2,12 @@
 
 use std::sync::Arc;
 
-use crate::{TypeAlias, DefDatabase, AstDatabase, type_ref::TypeRef};
+use crate::{TypeAlias, DefDatabase, AstDatabase, HasSource, type_ref::TypeRef};
 
 pub(crate) fn type_alias_ref_query(
     db: &(impl DefDatabase + AstDatabase),
     typ: TypeAlias,
 ) -> Arc<TypeRef> {
-    let (_, node) = typ.source(db);
+    let node = typ.source(db).ast;
     Arc::new(TypeRef::from_ast_opt(node.type_ref()))
 }