}
}
+/// 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<ast::ConstDef>) {
+ match *self {
+ DefWithBody::Const(ref c) => c.source(db),
+ _ => unreachable!()
+ }
+ }
+
+ pub fn func_source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
+ match *self {
+ DefWithBody::Func(ref f) => f.source(db),
+ _ => unreachable!()
+ }
+ }
+
+ pub fn static_source(&self, db: &impl DefDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
+ match *self {
+ DefWithBody::Static(ref s) => s.source(db),
+ _ => unreachable!()
+ }
+ }
+
+ pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+ db.infer(*self)
+ }
+
+ pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
+ 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<FnSignature> {
+ // 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,
}
pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
- db.body_with_source_map(*self).1
+ db.body_with_source_map(DefWithBody::Func(*self)).1
}
pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
- db.body_hir(*self)
+ db.body_hir(DefWithBody::Func(*self))
}
pub fn ty(&self, db: &impl HirDatabase) -> Ty {
}
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 }
}
}
pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
- db.infer(*self)
+ db.infer(DefWithBody::Func(*self))
}
pub fn generic_params(&self, db: &impl DefDatabase) -> Arc<GenericParams> {
fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
docs_from_ast(&*self.source(db).1)
}
-}
+}
\ No newline at end of file
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},
#[salsa::query_group(HirDatabaseStorage)]
pub trait HirDatabase: DefDatabase {
#[salsa::invoke(ExprScopes::expr_scopes_query)]
- fn expr_scopes(&self, func: Function) -> Arc<ExprScopes>;
+ fn expr_scopes(&self, def: DefWithBody) -> Arc<ExprScopes>;
#[salsa::invoke(crate::ty::infer)]
- fn infer(&self, func: Function) -> Arc<InferenceResult>;
+ fn infer(&self, def:DefWithBody) -> Arc<InferenceResult>;
#[salsa::invoke(crate::ty::type_for_def)]
fn type_for_def(&self, def: TypableDef, ns: Namespace) -> Ty;
#[salsa::invoke(crate::expr::body_with_source_map_query)]
fn body_with_source_map(
&self,
- func: Function,
+ def: DefWithBody,
) -> (Arc<crate::expr::Body>, Arc<crate::expr::BodySourceMap>);
#[salsa::invoke(crate::expr::body_hir_query)]
- fn body_hir(&self, func: Function) -> Arc<crate::expr::Body>;
+ fn body_hir(&self, def: DefWithBody) -> Arc<crate::expr::Body>;
#[salsa::invoke(crate::ty::method_resolution::CrateImplBlocks::impls_in_crate_query)]
fn impls_in_crate(&self, krate: Crate) -> Arc<CrateImplBlocks>;
};
use crate::{
- Path, Name, HirDatabase, Function, Resolver,
+ Path, Name, HirDatabase, Function, Resolver,DefWithBody,
name::AsName,
type_ref::{Mutability, TypeRef},
};
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<ExprId, Expr>,
pats: Arena<PatId, Pat>,
/// The patterns for the function's parameters. While the parameter types are
self.body_expr
}
- pub fn owner(&self) -> Function {
+ pub fn owner(&self) -> DefWithBody {
self.owner
}
// Queries
struct ExprCollector {
- owner: Function,
+ owner: DefWithBody,
exprs: Arena<ExprId, Expr>,
pats: Arena<PatId, Pat>,
source_map: BodySourceMap,
}
impl ExprCollector {
- fn new(owner: Function) -> Self {
+ fn new(owner: DefWithBody) -> Self {
ExprCollector {
owner,
exprs: Arena::default(),
self.exprs.alloc(block)
}
+
+
+
fn collect_expr(&mut self, expr: &ast::Expr) -> ExprId {
let syntax_ptr = SyntaxNodePtr::new(expr.syntax());
match expr.kind() {
}
}
+
+ 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() {
pub(crate) fn body_with_source_map_query(
db: &impl HirDatabase,
- func: Function,
+ def: DefWithBody,
) -> (Arc<Body>, Arc<BodySourceMap>) {
- 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<Body> {
- db.body_with_source_map(func).0
+pub(crate) fn body_hir_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<Body> {
+ db.body_with_source_map(def).0
}
#[cfg(test)]
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,
};
impl ExprScopes {
// FIXME: This should take something more general than Function
- pub(crate) fn expr_scopes_query(db: &impl HirDatabase, function: Function) -> Arc<ExprScopes> {
- let body = db.body_hir(function);
+ pub(crate) fn expr_scopes_query(db: &impl HirDatabase, def: DefWithBody) -> Arc<ExprScopes> {
+ let body = db.body_hir(def);
let res = ExprScopes::new(body);
Arc::new(res)
}
pub use self::code_model_api::{
Crate, CrateDependency,
+ DefWithBody,
Module, ModuleDef, ModuleSource,
Struct, Enum, EnumVariant,
Function, FnSignature,
StructField, FieldSource,
Static, Const, ConstSignature,
Trait, TypeAlias,
+
};
}
+
impl ContinueExpr {}
// DynTraitType
"DocCommentsOwner",
"TypeAscriptionOwner",
],
+ options: ["body","Block"],
),
"StaticDef": (
traits: [
"DocCommentsOwner",
"TypeAscriptionOwner",
],
+ options: ["body","Block"],
),
"TypeAliasDef": (
traits: [
projects / rust.git / commitdiff