kill code_model_impl

crates/ra_hir/src/code_model_api.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use ra_db::{CrateId, SourceRootId, Edition, FileId};
-use ra_syntax::{ast::self, TreeArc};
+use ra_syntax::{ast::{self, NameOwner, TypeAscriptionOwner}, TreeArc};
 
 use crate::{
     Name, AsName, AstId, Ty, HirFileId, Either,
@@ -9,7 +9,7 @@ use crate::{
     type_ref::TypeRef,
     nameres::{ModuleScope, Namespace, ImportId, CrateModuleId},
     expr::{Body, BodySourceMap, validation::ExprValidator},
-    ty::{ TraitRef, InferenceResult},
+    ty::{TraitRef, InferenceResult},
     adt::{EnumVariantId, StructFieldId, VariantDef},
     generics::HasGenericParams,
     docs::{Documentation, Docs, docs_from_ast},
@@ -18,6 +18,7 @@ use crate::{
     resolve::Resolver,
     diagnostics::{DiagnosticSink},
     traits::{TraitItem, TraitData},
+    type_ref::Mutability,
 };
 
 /// hir::Crate describes a single crate. It's the main interface with which
@@ -572,6 +573,44 @@ pub struct FnSignature {
 }
 
 impl FnSignature {
+    pub(crate) fn fn_signature_query(db: &impl DefDatabase, func: Function) -> Arc<FnSignature> {
+        let (_, node) = func.source(db);
+        let name = node.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(self_param) = param_list.self_param() {
+                let self_type = if let Some(type_ref) = self_param.ascribed_type() {
+                    TypeRef::from_ast(type_ref)
+                } else {
+                    let self_type = TypeRef::Path(Name::self_type().into());
+                    match self_param.kind() {
+                        ast::SelfParamKind::Owned => self_type,
+                        ast::SelfParamKind::Ref => {
+                            TypeRef::Reference(Box::new(self_type), Mutability::Shared)
+                        }
+                        ast::SelfParamKind::MutRef => {
+                            TypeRef::Reference(Box::new(self_type), Mutability::Mut)
+                        }
+                    }
+                };
+                params.push(self_type);
+                has_self_param = true;
+            }
+            for param in param_list.params() {
+                let type_ref = TypeRef::from_ast_opt(param.ascribed_type());
+                params.push(type_ref);
+            }
+        }
+        let ret_type = if let Some(type_ref) = node.ret_type().and_then(|rt| rt.type_ref()) {
+            TypeRef::from_ast(type_ref)
+        } else {
+            TypeRef::unit()
+        };
+
+        let sig = FnSignature { name, params, ret_type, has_self_param };
+        Arc::new(sig)
+    }
     pub fn name(&self) -> &Name {
         &self.name
     }
@@ -731,6 +770,29 @@ impl ConstSignature {
     pub fn type_ref(&self) -> &TypeRef {
         &self.type_ref
     }
+
+    pub(crate) fn const_signature_query(
+        db: &impl DefDatabase,
+        konst: Const,
+    ) -> Arc<ConstSignature> {
+        let (_, node) = konst.source(db);
+        const_signature_for(&*node)
+    }
+
+    pub(crate) fn static_signature_query(
+        db: &impl DefDatabase,
+        konst: Static,
+    ) -> Arc<ConstSignature> {
+        let (_, node) = konst.source(db);
+        const_signature_for(&*node)
+    }
+}
+
+fn const_signature_for<N: NameOwner + TypeAscriptionOwner>(node: &N) -> Arc<ConstSignature> {
+    let name = node.name().map(|n| n.as_name()).unwrap_or_else(Name::missing);
+    let type_ref = TypeRef::from_ast_opt(node.ascribed_type());
+    let sig = ConstSignature { name, type_ref };
+    Arc::new(sig)
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]