From 7f3bf7cc738d02fde80d4fde9f32cbbe72896b87 Mon Sep 17 00:00:00 2001 From: Lenard Pratt Date: Sat, 30 Mar 2019 10:50:00 +0000 Subject: Added defWithBody --- crates/ra_hir/src/code_model_api.rs | 84 ++++++++++++++++++++++++++++++++--- crates/ra_hir/src/db.rs | 9 ++-- crates/ra_hir/src/expr.rs | 40 ++++++++++++----- crates/ra_hir/src/expr/scope.rs | 6 +-- crates/ra_hir/src/lib.rs | 2 + crates/ra_syntax/src/ast/generated.rs | 1 + crates/ra_syntax/src/grammar.ron | 2 + 7 files changed, 120 insertions(+), 24 deletions(-) (limited to 'crates') diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 624c25c4d..db6e67d7f 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -433,6 +433,78 @@ impl Docs for EnumVariant { } } +/// The defs which have a body. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub enum DefWithBody { + Func(Function), + Const(Const), + Static(Static), +} + +impl DefWithBody { + pub fn get_funct(&self) -> &Function { + match *self { + DefWithBody::Func(ref f) => f, + _ => unreachable!() + } + } + + pub fn const_source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc) { + match *self { + DefWithBody::Const(ref c) => c.source(db), + _ => unreachable!() + } + } + + pub fn func_source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc) { + match *self { + DefWithBody::Func(ref f) => f.source(db), + _ => unreachable!() + } + } + + pub fn static_source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc) { + match *self { + DefWithBody::Static(ref s) => s.source(db), + _ => unreachable!() + } + } + + pub fn infer(&self, db: &impl HirDatabase) -> Arc { + db.infer(*self) + } + + pub fn body(&self, db: &impl HirDatabase) -> Arc { + db.body_hir(*self) + } + + /// Builds a resolver for code inside this item. + pub fn resolver(&self, db: &impl HirDatabase) -> Resolver { + // // take the outer scope... + // let r = self + // .impl_block(db) + // .map(|ib| ib.resolver(db)) + // .unwrap_or_else(|| self.module(db).resolver(db)); + // // ...and add generic params, if present + // let p = self.generic_params(db); + // let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r }; + // r + unimplemented!() + } + + pub fn signature(&self, db: &impl HirDatabase) -> Arc { + // db.fn_signature(*self) + unimplemented!() + } + + pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap { + let scopes = db.expr_scopes(*self); + let source_map = db.body_with_source_map(*self).1; + ScopesWithSourceMap { scopes, source_map } + } + +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct Function { pub(crate) id: FunctionId, @@ -483,11 +555,11 @@ impl Function { } pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc { - db.body_with_source_map(*self).1 + db.body_with_source_map(DefWithBody::Func(*self)).1 } pub fn body(&self, db: &impl HirDatabase) -> Arc { - db.body_hir(*self) + db.body_hir(DefWithBody::Func(*self)) } pub fn ty(&self, db: &impl HirDatabase) -> Ty { @@ -495,8 +567,8 @@ impl Function { } pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap { - let scopes = db.expr_scopes(*self); - let source_map = db.body_with_source_map(*self).1; + let scopes = db.expr_scopes( DefWithBody::Func(*self)); + let source_map = db.body_with_source_map(DefWithBody::Func(*self)).1; ScopesWithSourceMap { scopes, source_map } } @@ -505,7 +577,7 @@ impl Function { } pub fn infer(&self, db: &impl HirDatabase) -> Arc { - db.infer(*self) + db.infer(DefWithBody::Func(*self)) } pub fn generic_params(&self, db: &impl DefDatabase) -> Arc { @@ -716,4 +788,4 @@ impl Docs for TypeAlias { fn docs(&self, db: &impl HirDatabase) -> Option { docs_from_ast(&*self.source(db).1) } -} +} \ No newline at end of file diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 147005848..a2aff241c 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -8,6 +8,7 @@ use crate::{ Function, FnSignature, ExprScopes, TypeAlias, Struct, Enum, StructField, Const, ConstSignature, Static, + DefWithBody, nameres::{Namespace, ImportSourceMap, RawItems, CrateDefMap}, ty::{InferenceResult, Ty, method_resolution::CrateImplBlocks, TypableDef, CallableDef, FnSig}, adt::{StructData, EnumData}, @@ -83,10 +84,10 @@ pub trait DefDatabase: SourceDatabase + AsRef { #[salsa::query_group(HirDatabaseStorage)] pub trait HirDatabase: DefDatabase { #[salsa::invoke(ExprScopes::expr_scopes_query)] - fn expr_scopes(&self, func: Function) -> Arc; + fn expr_scopes(&self, def: DefWithBody) -> Arc; #[salsa::invoke(crate::ty::infer)] - fn infer(&self, func: Function) -> Arc; + fn infer(&self, def:DefWithBody) -> Arc; #[salsa::invoke(crate::ty::type_for_def)] fn type_for_def(&self, def: TypableDef, ns: Namespace) -> Ty; @@ -100,11 +101,11 @@ pub trait HirDatabase: DefDatabase { #[salsa::invoke(crate::expr::body_with_source_map_query)] fn body_with_source_map( &self, - func: Function, + def: DefWithBody, ) -> (Arc, Arc); #[salsa::invoke(crate::expr::body_hir_query)] - fn body_hir(&self, func: Function) -> Arc; + fn body_hir(&self, def: DefWithBody) -> Arc; #[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)] fn impls_in_crate(&self, krate: Crate) -> Arc; diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs index a85422955..280746761 100644 --- a/crates/ra_hir/src/expr.rs +++ b/crates/ra_hir/src/expr.rs @@ -10,7 +10,7 @@ use ra_syntax::{ }; use crate::{ - Path, Name, HirDatabase, Function, Resolver, + Path, Name, HirDatabase, Function, Resolver,DefWithBody, name::AsName, type_ref::{Mutability, TypeRef}, }; @@ -29,7 +29,7 @@ impl_arena_id!(ExprId); pub struct Body { // FIXME: this should be more general, consts & statics also have bodies /// The Function of the item this body belongs to - owner: Function, + owner: DefWithBody, exprs: Arena, pats: Arena, /// The patterns for the function's parameters. While the parameter types are @@ -66,7 +66,7 @@ impl Body { self.body_expr } - pub fn owner(&self) -> Function { + pub fn owner(&self) -> DefWithBody { self.owner } @@ -464,7 +464,7 @@ impl Pat { // Queries struct ExprCollector { - owner: Function, + owner: DefWithBody, exprs: Arena, pats: Arena, source_map: BodySourceMap, @@ -473,7 +473,7 @@ struct ExprCollector { } impl ExprCollector { - fn new(owner: Function) -> Self { + fn new(owner: DefWithBody) -> Self { ExprCollector { owner, exprs: Arena::default(), @@ -503,6 +503,9 @@ impl ExprCollector { self.exprs.alloc(block) } + + + fn collect_expr(&mut self, expr: &ast::Expr) -> ExprId { let syntax_ptr = SyntaxNodePtr::new(expr.syntax()); match expr.kind() { @@ -871,6 +874,15 @@ impl ExprCollector { } } + + fn collect_const_body(&mut self,node:&ast::ConstDef) { + + } + + fn collect_static_body(&mut self,node:&ast::StaticDef) { + + } + fn collect_fn_body(&mut self, node: &ast::FnDef) { if let Some(param_list) = node.param_list() { if let Some(self_param) = param_list.self_param() { @@ -917,19 +929,25 @@ impl ExprCollector { pub(crate) fn body_with_source_map_query( db: &impl HirDatabase, - func: Function, + def: DefWithBody, ) -> (Arc, Arc) { - let mut collector = ExprCollector::new(func); - // FIXME: consts, etc. - collector.collect_fn_body(&func.source(db).1); + let mut collector = ExprCollector::new(def); + // FIXME: do can this be turned into a method + + match def { + DefWithBody::Const(ref c) => collector.collect_const_body(&def.const_source(db).1), + DefWithBody::Func(ref f) => collector.collect_fn_body(&def.func_source(db).1), + DefWithBody::Static(ref s) => collector.collect_static_body(&def.static_source(db).1) + } + let (body, source_map) = collector.finish(); (Arc::new(body), Arc::new(source_map)) } -pub(crate) fn body_hir_query(db: &impl HirDatabase, func: Function) -> Arc { - db.body_with_source_map(func).0 +pub(crate) fn body_hir_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { + db.body_with_source_map(def).0 } #[cfg(test)] diff --git a/crates/ra_hir/src/expr/scope.rs b/crates/ra_hir/src/expr/scope.rs index ed005c9f7..539da06c3 100644 --- a/crates/ra_hir/src/expr/scope.rs +++ b/crates/ra_hir/src/expr/scope.rs @@ -10,7 +10,7 @@ use ra_syntax::{ use ra_arena::{Arena, RawId, impl_arena_id}; use crate::{ - Name, AsName, Function, + Name, AsName, Function,DefWithBody, expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySourceMap}, HirDatabase, }; @@ -40,8 +40,8 @@ pub struct ScopeData { impl ExprScopes { // FIXME: This should take something more general than Function - pub(crate) fn expr_scopes_query(db: &impl HirDatabase, function: Function) -> Arc { - let body = db.body_hir(function); + pub(crate) fn expr_scopes_query(db: &impl HirDatabase, def: DefWithBody) -> Arc { + let body = db.body_hir(def); let res = ExprScopes::new(body); Arc::new(res) } diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 7c603bbd3..62cec72d9 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -67,10 +67,12 @@ pub use self::{ pub use self::code_model_api::{ Crate, CrateDependency, + DefWithBody, Module, ModuleDef, ModuleSource, Struct, Enum, EnumVariant, Function, FnSignature, StructField, FieldSource, Static, Const, ConstSignature, Trait, TypeAlias, + }; diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index 47a37e4d1..31b4e73fb 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -657,6 +657,7 @@ impl ToOwned for ContinueExpr { } + impl ContinueExpr {} // DynTraitType diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron index ad6d74162..19e50c9b8 100644 --- a/crates/ra_syntax/src/grammar.ron +++ b/crates/ra_syntax/src/grammar.ron @@ -313,6 +313,7 @@ Grammar( "DocCommentsOwner", "TypeAscriptionOwner", ], + options: ["body","Block"], ), "StaticDef": ( traits: [ @@ -323,6 +324,7 @@ Grammar( "DocCommentsOwner", "TypeAscriptionOwner", ], + options: ["body","Block"], ), "TypeAliasDef": ( traits: [ -- cgit v1.2.3