Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-11-15 09:27:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Move FunctionSignature creation to display

Browse source
This commit is contained in:
Ville Penttinen 2019-04-04 20:05:01 +03:00
parent ed65e2619a
commit f4aa15c16b
3 changed files with 54 additions and 50 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
crates/ra_ide_api/src/call_info.rs
View file

@ -8,7 +8,7 @@ use ra_syntax::{
};
use hir::Docs;
use crate::{FilePosition, CallInfo, db::RootDatabase};
use crate::{FilePosition, CallInfo, FunctionSignature, db::RootDatabase};
/// Computes parameter information for the given call expression.
pub(crate) fn call_info(db: &RootDatabase, position: FilePosition) -> Option<CallInfo> {
@ -108,11 +108,10 @@ impl<'a> FnCallNode<'a> {
impl CallInfo {
fn new(db: &RootDatabase, function: hir::Function, node: &ast::FnDef) -> Option<Self> {
let sig = crate::completion::function_signature(node)?;
let doc = function.docs(db);
let sig = sig.with_doc_opt(doc);
let signature = FunctionSignature::from(node).with_doc_opt(doc);
Some(CallInfo { signature: sig, active_parameter: None })
Some(CallInfo { signature, active_parameter: None })
}
fn parameters(&self) -> &[String] {

48
crates/ra_ide_api/src/completion.rs
View file

@ -13,7 +13,7 @@ mod complete_scope;
mod complete_postfix;
use ra_db::SourceDatabase;
use ra_syntax::{ast::{self, AstNode, NameOwner, VisibilityOwner, TypeParamsOwner}, SyntaxKind::{ATTR, COMMENT}};
use ra_syntax::{ast::{self, AstNode}, SyntaxKind::{ATTR, COMMENT}};
use crate::{
db,
@ -72,52 +72,8 @@ pub(crate) fn completions(db: &db::RootDatabase, position: FilePosition) -> Opti
Some(acc)
}
pub fn generic_parameters<N: TypeParamsOwner>(node: &N) -> Vec<String> {
let mut res = vec![];
if let Some(type_params) = node.type_param_list() {
res.extend(type_params.lifetime_params().map(|p| p.syntax().text().to_string()));
res.extend(type_params.type_params().map(|p| p.syntax().text().to_string()));
}
res
}
pub fn where_predicates<N: TypeParamsOwner>(node: &N) -> Vec<String> {
let mut res = vec![];
if let Some(clause) = node.where_clause() {
res.extend(clause.predicates().map(|p| p.syntax().text().to_string()));
}
res
}
pub fn function_signature(node: &ast::FnDef) -> Option<FunctionSignature> {
fn param_list(node: &ast::FnDef) -> Vec<String> {
let mut res = vec![];
if let Some(param_list) = node.param_list() {
if let Some(self_param) = param_list.self_param() {
res.push(self_param.syntax().text().to_string())
}
res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
}
res
}
let sig = FunctionSignature {
visibility: node.visibility().map(|n| n.syntax().text().to_string()),
name: node.name().map(|n| n.text().to_string()),
ret_type: node.ret_type().and_then(|r| r.type_ref()).map(|n| n.syntax().text().to_string()),
parameters: param_list(node),
generic_parameters: generic_parameters(node),
where_predicates: where_predicates(node),
// docs are processed separately
doc: None,
};
Some(sig)
}
pub fn function_label(node: &ast::FnDef) -> Option<String> {
function_signature(node).map(|n| n.to_string())
Some(FunctionSignature::from(node).to_string())
}
pub fn const_label(node: &ast::ConstDef) -> String {

49
crates/ra_ide_api/src/display.rs
View file

@ -3,6 +3,8 @@
use super::*;
use std::fmt::{self, Display};
use join_to_string::join;
use ra_syntax::ast::{self, AstNode, NameOwner, VisibilityOwner, TypeParamsOwner};
use std::convert::From;
/// Contains information about a function signature
#[derive(Debug)]
@ -30,6 +32,36 @@ impl FunctionSignature {
}
}
impl From<&'_ ast::FnDef> for FunctionSignature {
fn from(node: &ast::FnDef) -> FunctionSignature {
fn param_list(node: &ast::FnDef) -> Vec<String> {
let mut res = vec![];
if let Some(param_list) = node.param_list() {
if let Some(self_param) = param_list.self_param() {
res.push(self_param.syntax().text().to_string())
}
res.extend(param_list.params().map(|param| param.syntax().text().to_string()));
}
res
}
FunctionSignature {
visibility: node.visibility().map(|n| n.syntax().text().to_string()),
name: node.name().map(|n| n.text().to_string()),
ret_type: node
.ret_type()
.and_then(|r| r.type_ref())
.map(|n| n.syntax().text().to_string()),
parameters: param_list(node),
generic_parameters: generic_parameters(node),
where_predicates: where_predicates(node),
// docs are processed separately
doc: None,
}
}
}
impl Display for FunctionSignature {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
if let Some(t) = &self.visibility {
@ -61,3 +93,20 @@ impl Display for FunctionSignature {
Ok(())
}
}
pub(crate) fn generic_parameters<N: TypeParamsOwner>(node: &N) -> Vec<String> {
let mut res = vec![];
if let Some(type_params) = node.type_param_list() {
res.extend(type_params.lifetime_params().map(|p| p.syntax().text().to_string()));
res.extend(type_params.type_params().map(|p| p.syntax().text().to_string()));
}
res
}
pub(crate) fn where_predicates<N: TypeParamsOwner>(node: &N) -> Vec<String> {
let mut res = vec![];
if let Some(clause) = node.where_clause() {
res.extend(clause.predicates().map(|p| p.syntax().text().to_string()));
}
res
}