Added const bodies and static body to the ast

Lapz · Lapz · commit 88e22e9d70ac · 2019-04-02T19:21:36.000+01:00
and added inference the inference test

reduce code duplication
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
@@ -436,73 +436,40 @@ impl Docs for EnumVariant {
 /// The defs which have a body.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum DefWithBody {
-    Func(Function),
+    Function(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!()
-       }
-    }
+impl_froms!(DefWithBody: Function, Const, Static);
 
+impl DefWithBody {
     pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
         db.infer(*self)
     }
 
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map(*self).1
+    }
+
     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!()
+        match *self {
+            DefWithBody::Const(ref c) => c.resolver(db),
+            DefWithBody::Function(ref f) => f.resolver(db),
+            DefWithBody::Static(ref s) => s.resolver(db),
+        }
     }
 
     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)]
@@ -555,20 +522,20 @@ impl Function {
     }
 
     pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
-        db.body_with_source_map(DefWithBody::Func(*self)).1
+        db.body_with_source_map((*self).into()).1
     }
 
     pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
-        db.body_hir(DefWithBody::Func(*self))
+        db.body_hir((*self).into())
     }
 
     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
         db.type_for_def((*self).into(), Namespace::Values)
     }
 
     pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSourceMap {
-        let scopes = db.expr_scopes( DefWithBody::Func(*self));
-        let source_map = db.body_with_source_map(DefWithBody::Func(*self)).1;
+        let scopes = db.expr_scopes((*self).into());
+        let source_map = db.body_with_source_map((*self).into()).1;
         ScopesWithSourceMap { scopes, source_map }
     }
 
@@ -577,7 +544,7 @@ impl Function {
     }
 
     pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
-        db.infer(DefWithBody::Func(*self))
+        db.infer((*self).into())
     }
 
     pub fn generic_params(&self, db: &impl DefDatabase) -> Arc<GenericParams> {
@@ -633,6 +600,14 @@ impl Const {
         db.const_signature(*self)
     }
 
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer((*self).into())
+    }
+
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map((*self).into()).1
+    }
+
     /// The containing impl block, if this is a method.
     pub fn impl_block(&self, db: &impl DefDatabase) -> Option<ImplBlock> {
         let module_impls = db.impls_in_module(self.module(db));
@@ -697,6 +672,14 @@ impl Static {
         // take the outer scope...
         self.module(db).resolver(db)
     }
+
+    pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
+        db.infer((*self).into())
+    }
+
+    pub fn body_source_map(&self, db: &impl HirDatabase) -> Arc<BodySourceMap> {
+        db.body_with_source_map((*self).into()).1
+    }
 }
 
 impl Docs for Static {
@@ -788,4 +771,4 @@ impl Docs for TypeAlias {
     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
         docs_from_ast(&*self.source(db).1)
     }
-}
+}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
@@ -87,7 +87,7 @@ pub trait HirDatabase: DefDatabase {
     fn expr_scopes(&self, def: DefWithBody) -> Arc<ExprScopes>;
 
     #[salsa::invoke(crate::ty::infer)]
-    fn infer(&self, def:DefWithBody) -> 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;
diff --git 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,DefWithBody,
+    Path, Name, HirDatabase, Resolver,DefWithBody,
     name::AsName,
     type_ref::{Mutability, TypeRef},
 };
@@ -27,8 +27,7 @@ impl_arena_id!(ExprId);
 /// The body of an item (function, const etc.).
 #[derive(Debug, Eq, PartialEq)]
 pub struct Body {
-    // FIXME: this should be more general, consts & statics also have bodies
-    /// The Function of the item this body belongs to
+    /// The def of the item this body belongs to
     owner: DefWithBody,
     exprs: Arena<ExprId, Expr>,
     pats: Arena<PatId, Pat>,
@@ -503,9 +502,6 @@ 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() {
@@ -874,13 +870,14 @@ impl ExprCollector {
         }
     }
 
-
-    fn collect_const_body(&mut self,node:&ast::ConstDef)  {
-        
+    fn collect_const_body(&mut self, node: &ast::ConstDef) {
+        let body = self.collect_expr_opt(node.body());
+        self.body_expr = Some(body);
     }
 
-    fn collect_static_body(&mut self,node:&ast::StaticDef) {
-
+    fn collect_static_body(&mut self, node: &ast::StaticDef) {
+        let body = self.collect_expr_opt(node.body());
+        self.body_expr = Some(body);
     }
 
     fn collect_fn_body(&mut self, node: &ast::FnDef) {
@@ -931,28 +928,27 @@ pub(crate) fn body_with_source_map_query(
     db: &impl HirDatabase,
     def: DefWithBody,
 ) -> (Arc<Body>, Arc<BodySourceMap>) {
-
     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)
+        DefWithBody::Const(ref c) => collector.collect_const_body(&c.source(db).1),
+        DefWithBody::Function(ref f) => collector.collect_fn_body(&f.source(db).1),
+        DefWithBody::Static(ref s) => collector.collect_static_body(&s.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, def: DefWithBody) -> Arc<Body> {
-    db.body_with_source_map(def).0   
+    db.body_with_source_map(def).0
 }
 
+#[cfg(test)]
+use crate::{Function};
 #[cfg(test)]
 fn collect_fn_body_syntax(function: Function, node: &ast::FnDef) -> (Body, BodySourceMap) {
-    let mut collector = ExprCollector::new(function);
+    let mut collector = ExprCollector::new(DefWithBody::Function(function));
     collector.collect_fn_body(node);
     collector.finish()
 }
diff --git 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,DefWithBody,
+    Name, AsName,DefWithBody,
     expr::{PatId, ExprId, Pat, Expr, Body, Statement, BodySourceMap},
     HirDatabase,
 };
@@ -297,6 +297,7 @@ mod tests {
     use ra_syntax::{SourceFile, algo::find_node_at_offset};
     use test_utils::{extract_offset, assert_eq_text};
     use ra_arena::ArenaId;
+    use crate::{Function};
 
     use crate::expr;
 
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
@@ -74,5 +74,4 @@ pub use self::code_model_api::{
     StructField, FieldSource,
     Static, Const, ConstSignature,
     Trait, TypeAlias,
-    
 };
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
@@ -13,7 +13,7 @@ use ra_syntax::{
 };
 
 use crate::{
-    HirDatabase, Function, Struct, Enum,
+    HirDatabase, Function, Struct, Enum,Const,Static,
     AsName, Module, HirFileId, Crate, Trait, Resolver,
     ids::LocationCtx,
     expr, AstId
@@ -87,6 +87,27 @@ fn module_from_source(
     )
 }
 
+pub fn const_from_source(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    const_def: &ast::ConstDef,
+) -> Option<Const> {
+    let module = module_from_child_node(db, file_id, const_def.syntax())?;
+    let res = const_from_module(db, module, const_def);
+    Some(res)
+}
+
+pub fn const_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    const_def: &ast::ConstDef,
+) -> Const {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Const { id: ctx.to_def(const_def) }
+}
+
 pub fn function_from_position(db: &impl HirDatabase, position: FilePosition) -> Option<Function> {
     let file = db.parse(position.file_id);
     let fn_def = find_node_at_offset::<ast::FnDef>(file.syntax(), position.offset)?;
@@ -134,6 +155,27 @@ pub fn struct_from_module(
     Struct { id: ctx.to_def(struct_def) }
 }
 
+pub fn static_from_source(
+    db: &impl HirDatabase,
+    file_id: FileId,
+    static_def: &ast::StaticDef,
+) -> Option<Static> {
+    let module = module_from_child_node(db, file_id, static_def.syntax())?;
+    let res = static_from_module(db, module, static_def);
+    Some(res)
+}
+
+pub fn static_from_module(
+    db: &impl HirDatabase,
+    module: Module,
+    static_def: &ast::StaticDef,
+) -> Static {
+    let (file_id, _) = module.definition_source(db);
+    let file_id = file_id.into();
+    let ctx = LocationCtx::new(db, module, file_id);
+    Static { id: ctx.to_def(static_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 = file_id.into();
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
@@ -27,8 +27,9 @@ use test_utils::tested_by;
 
 use crate::{
     Function, StructField, Path, Name,
-    FnSignature, AdtDef,
+    FnSignature, AdtDef,ConstSignature,
     HirDatabase,
+    DefWithBody,
     ImplItem,
     type_ref::{TypeRef, Mutability},
     expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self},
@@ -43,14 +44,17 @@ use crate::{
 use super::{Ty, TypableDef, Substs, primitive, op, FnSig, ApplicationTy, TypeCtor};
 
 /// The entry point of type inference.
-pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
+pub fn infer(db: &impl HirDatabase, def: DefWithBody) -> Arc<InferenceResult> {
     db.check_canceled();
-    let body = func.body(db);
-    let resolver = func.resolver(db);
+    let body = def.body(db);
+    let resolver = def.resolver(db);
     let mut ctx = InferenceContext::new(db, body, resolver);
 
-    let signature = func.signature(db);
-    ctx.collect_fn_signature(&signature);
+    match def {
+        DefWithBody::Const(ref c) => ctx.collect_const_signature(&c.signature(db)),
+        DefWithBody::Function(ref f) => ctx.collect_fn_signature(&f.signature(db)),
+        DefWithBody::Static(ref s) => ctx.collect_const_signature(&s.signature(db)),
+    }
 
     ctx.infer_body();
 
@@ -1142,6 +1146,10 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
         ty
     }
 
+    fn collect_const_signature(&mut self, signature: &ConstSignature) {
+        self.return_ty = self.make_ty(signature.type_ref());
+    }
+
     fn collect_fn_signature(&mut self, signature: &FnSignature) {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         for (type_ref, pat) in signature.params().iter().zip(body.params()) {
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
