use rls_data::{SigElement, Signature};
-use rustc::hir::def::{Res, DefKind};
+use rustc_hir::def::{DefKind, Res};
use syntax::ast::{self, Extern, NodeId};
use syntax::print::pprust;
pub fn foreign_item_signature(
item: &ast::ForeignItem,
- scx: &SaveContext<'_, '_>
+ scx: &SaveContext<'_, '_>,
) -> Option<Signature> {
if !scx.config.signatures {
return None;
}
fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature {
- let mut result = Signature {
- text,
- defs: vec![],
- refs: vec![],
- };
+ let mut result = Signature { text, defs: vec![], refs: vec![] };
let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip();
- result
- .defs
- .extend(defs.into_iter().flat_map(|ds| ds.into_iter()));
- result
- .refs
- .extend(refs.into_iter().flat_map(|rs| rs.into_iter()));
+ result.defs.extend(defs.into_iter().flat_map(|ds| ds.into_iter()));
+ result.refs.extend(refs.into_iter().flat_map(|rs| rs.into_iter()));
result
}
fn text_sig(text: String) -> Signature {
- Signature {
- text,
- defs: vec![],
- refs: vec![],
- }
+ Signature { text, defs: vec![], refs: vec![] }
}
fn push_extern(text: &mut String, ext: Extern) {
}
ast::TyKind::Ptr(ref mt) => {
let prefix = match mt.mutbl {
- ast::Mutability::Mutable => "*mut ",
- ast::Mutability::Immutable => "*const ",
+ ast::Mutability::Mut => "*mut ",
+ ast::Mutability::Not => "*const ",
};
let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
let text = format!("{}{}", prefix, nested.text);
prefix.push_str(&l.ident.to_string());
prefix.push(' ');
}
- if let ast::Mutability::Mutable = mt.mutbl {
+ if let ast::Mutability::Mut = mt.mutbl {
prefix.push_str("mut ");
};
if !f.generic_params.is_empty() {
// FIXME defs, bounds on lifetimes
text.push_str("for<");
- text.push_str(&f.generic_params
- .iter()
- .filter_map(|param| match param.kind {
- ast::GenericParamKind::Lifetime { .. } => {
- Some(param.ident.to_string())
- }
- _ => None,
- })
- .collect::<Vec<_>>()
- .join(", "));
+ text.push_str(
+ &f.generic_params
+ .iter()
+ .filter_map(|param| match param.kind {
+ ast::GenericParamKind::Lifetime { .. } => {
+ Some(param.ident.to_string())
+ }
+ _ => None,
+ })
+ .collect::<Vec<_>>()
+ .join(", "),
+ );
text.push('>');
}
let text = format!("[{}; {}]", nested_ty.text, expr);
Ok(replace_text(nested_ty, text))
}
- ast::TyKind::Typeof(_) |
- ast::TyKind::Infer |
- ast::TyKind::Err |
- ast::TyKind::ImplicitSelf |
- ast::TyKind::Mac(_) => Err("Ty"),
+ ast::TyKind::Typeof(_)
+ | ast::TyKind::Infer
+ | ast::TyKind::Err
+ | ast::TyKind::ImplicitSelf
+ | ast::TyKind::Mac(_) => Err("Ty"),
}
}
}
match self.kind {
ast::ItemKind::Static(ref ty, m, ref expr) => {
let mut text = "static ".to_owned();
- if m == ast::Mutability::Mutable {
+ if m == ast::Mutability::Mut {
text.push_str("mut ");
}
let name = self.ident.to_string();
- let defs = vec![
- SigElement {
- id: id_from_node_id(self.id, scx),
- start: offset + text.len(),
- end: offset + text.len() + name.len(),
- },
- ];
+ let defs = vec![SigElement {
+ id: id_from_node_id(self.id, scx),
+ start: offset + text.len(),
+ end: offset + text.len() + name.len(),
+ }];
text.push_str(&name);
text.push_str(": ");
ast::ItemKind::Const(ref ty, ref expr) => {
let mut text = "const ".to_owned();
let name = self.ident.to_string();
- let defs = vec![
- SigElement {
- id: id_from_node_id(self.id, scx),
- start: offset + text.len(),
- end: offset + text.len() + name.len(),
- },
- ];
+ let defs = vec![SigElement {
+ id: id_from_node_id(self.id, scx),
+ start: offset + text.len(),
+ end: offset + text.len() + name.len(),
+ }];
text.push_str(&name);
text.push_str(": ");
ast::ItemKind::Mod(ref _mod) => {
let mut text = "mod ".to_owned();
let name = self.ident.to_string();
- let defs = vec![
- SigElement {
- id: id_from_node_id(self.id, scx),
- start: offset + text.len(),
- end: offset + text.len() + name.len(),
- },
- ];
+ let defs = vec![SigElement {
+ id: id_from_node_id(self.id, scx),
+ start: offset + text.len(),
+ end: offset + text.len() + name.len(),
+ }];
text.push_str(&name);
// Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
text.push(';');
- Ok(Signature {
- text,
- defs,
- refs: vec![],
- })
+ Ok(Signature { text, defs, refs: vec![] })
}
ast::ItemKind::TyAlias(ref ty, ref generics) => {
let text = "type ".to_owned();
ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
let mut text = String::new();
text.push_str("trait ");
- let mut sig = name_and_generics(text,
- offset,
- generics,
- self.id,
- self.ident,
- scx)?;
+ let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
if !bounds.is_empty() {
sig.text.push_str(" = ");
text: pprust::path_to_string(self),
defs: vec![],
refs: vec![],
- })
+ });
}
Res::Def(DefKind::AssocConst, _)
| Res::Def(DefKind::Variant, _)
};
let id = id_from_def_id(res.def_id());
- Ok(Signature {
- text: name,
- defs: vec![],
- refs: vec![SigElement { id, start, end }],
- })
+ Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
}
}
param_text.push_str(": ");
match param.kind {
ast::GenericParamKind::Lifetime { .. } => {
- let bounds = param.bounds.iter()
+ let bounds = param
+ .bounds
+ .iter()
.map(|bound| match bound {
ast::GenericBound::Outlives(lt) => lt.ident.to_string(),
_ => panic!(),
}
text.push('>');
- Ok(Signature {
- text,
- defs,
- refs: vec![],
- })
+ Ok(Signature { text, defs, refs: vec![] })
}
}
}
}
-
impl Sig for ast::Variant {
fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
let mut text = self.ident.to_string();
start: offset,
end: offset + text.len(),
};
- Ok(Signature {
- text,
- defs: vec![name_def],
- refs: vec![],
- })
+ Ok(Signature { text, defs: vec![name_def], refs: vec![] })
}
}
}
}
ast::ForeignItemKind::Static(ref ty, m) => {
let mut text = "static ".to_owned();
- if m == ast::Mutability::Mutable {
+ if m == ast::Mutability::Mut {
text.push_str("mut ");
}
let name = self.ident.to_string();
- let defs = vec![
- SigElement {
- id: id_from_node_id(self.id, scx),
- start: offset + text.len(),
- end: offset + text.len() + name.len(),
- },
- ];
+ let defs = vec![SigElement {
+ id: id_from_node_id(self.id, scx),
+ start: offset + text.len(),
+ end: offset + text.len() + name.len(),
+ }];
text.push_str(&name);
text.push_str(": ");
ast::ForeignItemKind::Ty => {
let mut text = "type ".to_owned();
let name = self.ident.to_string();
- let defs = vec![
- SigElement {
- id: id_from_node_id(self.id, scx),
- start: offset + text.len(),
- end: offset + text.len() + name.len(),
- },
- ];
+ let defs = vec![SigElement {
+ id: id_from_node_id(self.id, scx),
+ start: offset + text.len(),
+ end: offset + text.len() + name.len(),
+ }];
text.push_str(&name);
text.push(';');
- Ok(Signature {
- text: text,
- defs: defs,
- refs: vec![],
- })
+ Ok(Signature { text: text, defs: defs, refs: vec![] })
}
ast::ForeignItemKind::Macro(..) => Err("macro"),
}
Ok(extend_sig(generics, text, vec![def], vec![]))
}
-
fn make_assoc_type_signature(
id: NodeId,
ident: ast::Ident,
) -> Result {
let mut text = "type ".to_owned();
let name = ident.to_string();
- let mut defs = vec![
- SigElement {
- id: id_from_node_id(id, scx),
- start: text.len(),
- end: text.len() + name.len(),
- },
- ];
+ let mut defs = vec![SigElement {
+ id: id_from_node_id(id, scx),
+ start: text.len(),
+ end: text.len() + name.len(),
+ }];
let mut refs = vec![];
text.push_str(&name);
if let Some(bounds) = bounds {
) -> Result {
let mut text = "const ".to_owned();
let name = ident.to_string();
- let mut defs = vec![
- SigElement {
- id: id_from_node_id(id, scx),
- start: text.len(),
- end: text.len() + name.len(),
- },
- ];
+ let mut defs = vec![SigElement {
+ id: id_from_node_id(id, scx),
+ start: text.len(),
+ end: text.len() + name.len(),
+ }];
let mut refs = vec![];
text.push_str(&name);
text.push_str(": ");