1 // A signature is a string representation of an item's type signature, excluding
2 // any body. It also includes ids for any defs or refs in the signature. For
10 // The signature string is something like "fn foo(x: String) {}" and the signature
11 // will have defs for `foo` and `x` and a ref for `String`.
13 // All signature text should parse in the correct context (i.e., in a module or
14 // impl, etc.). Clients may want to trim trailing `{}` or `;`. The text of a
15 // signature is not guaranteed to be stable (it may improve or change as the
16 // syntax changes, or whitespace or punctuation may change). It is also likely
17 // not to be pretty - no attempt is made to prettify the text. It is recommended
18 // that clients run the text through Rustfmt.
20 // This module generates Signatures for items by walking the AST and looking up
23 // Signatures do not include visibility info. I'm not sure if this is a feature
24 // or an omission (FIXME).
26 // FIXME where clauses need implementing, defs/refs in generics are mostly missing.
28 use crate::{id_from_def_id, id_from_hir_id, SaveContext};
30 use rls_data::{SigElement, Signature};
32 use rustc_ast::Mutability;
34 use rustc_hir::def::{DefKind, Res};
35 use rustc_hir_pretty::id_to_string;
36 use rustc_hir_pretty::{bounds_to_string, path_segment_to_string, path_to_string, ty_to_string};
37 use rustc_span::symbol::{Ident, Symbol};
39 pub fn item_signature(item: &hir::Item<'_>, scx: &SaveContext<'_>) -> Option<Signature> {
40 if !scx.config.signatures {
43 item.make(0, None, scx).ok()
46 pub fn foreign_item_signature(
47 item: &hir::ForeignItem<'_>,
48 scx: &SaveContext<'_>,
49 ) -> Option<Signature> {
50 if !scx.config.signatures {
53 item.make(0, None, scx).ok()
56 /// Signature for a struct or tuple field declaration.
57 /// Does not include a trailing comma.
58 pub fn field_signature(field: &hir::StructField<'_>, scx: &SaveContext<'_>) -> Option<Signature> {
59 if !scx.config.signatures {
62 field.make(0, None, scx).ok()
65 /// Does not include a trailing comma.
66 pub fn variant_signature(variant: &hir::Variant<'_>, scx: &SaveContext<'_>) -> Option<Signature> {
67 if !scx.config.signatures {
70 variant.make(0, None, scx).ok()
73 pub fn method_signature(
76 generics: &hir::Generics<'_>,
78 scx: &SaveContext<'_>,
79 ) -> Option<Signature> {
80 if !scx.config.signatures {
83 make_method_signature(id, ident, generics, m, scx).ok()
86 pub fn assoc_const_signature(
90 default: Option<&hir::Expr<'_>>,
91 scx: &SaveContext<'_>,
92 ) -> Option<Signature> {
93 if !scx.config.signatures {
96 make_assoc_const_signature(id, ident, ty, default, scx).ok()
99 pub fn assoc_type_signature(
102 bounds: Option<hir::GenericBounds<'_>>,
103 default: Option<&hir::Ty<'_>>,
104 scx: &SaveContext<'_>,
105 ) -> Option<Signature> {
106 if !scx.config.signatures {
109 make_assoc_type_signature(id, ident, bounds, default, scx).ok()
112 type Result = std::result::Result<Signature, &'static str>;
115 fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result;
121 defs: Vec<SigElement>,
122 refs: Vec<SigElement>,
125 sig.defs.extend(defs.into_iter());
126 sig.refs.extend(refs.into_iter());
130 fn replace_text(mut sig: Signature, text: String) -> Signature {
135 fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature {
136 let mut result = Signature { text, defs: vec![], refs: vec![] };
138 let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip();
140 result.defs.extend(defs.into_iter().flat_map(|ds| ds.into_iter()));
141 result.refs.extend(refs.into_iter().flat_map(|rs| rs.into_iter()));
146 fn text_sig(text: String) -> Signature {
147 Signature { text, defs: vec![], refs: vec![] }
150 impl<'hir> Sig for hir::Ty<'hir> {
151 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
152 let id = Some(self.hir_id);
154 hir::TyKind::Slice(ref ty) => {
155 let nested = ty.make(offset + 1, id, scx)?;
156 let text = format!("[{}]", nested.text);
157 Ok(replace_text(nested, text))
159 hir::TyKind::Ptr(ref mt) => {
160 let prefix = match mt.mutbl {
161 hir::Mutability::Mut => "*mut ",
162 hir::Mutability::Not => "*const ",
164 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
165 let text = format!("{}{}", prefix, nested.text);
166 Ok(replace_text(nested, text))
168 hir::TyKind::Rptr(ref lifetime, ref mt) => {
169 let mut prefix = "&".to_owned();
170 prefix.push_str(&lifetime.name.ident().to_string());
172 if let hir::Mutability::Mut = mt.mutbl {
173 prefix.push_str("mut ");
176 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
177 let text = format!("{}{}", prefix, nested.text);
178 Ok(replace_text(nested, text))
180 hir::TyKind::Never => Ok(text_sig("!".to_owned())),
181 hir::TyKind::Tup(ts) => {
182 let mut text = "(".to_owned();
183 let mut defs = vec![];
184 let mut refs = vec![];
186 let nested = t.make(offset + text.len(), id, scx)?;
187 text.push_str(&nested.text);
189 defs.extend(nested.defs.into_iter());
190 refs.extend(nested.refs.into_iter());
193 Ok(Signature { text, defs, refs })
195 hir::TyKind::BareFn(ref f) => {
196 let mut text = String::new();
197 if !f.generic_params.is_empty() {
198 // FIXME defs, bounds on lifetimes
199 text.push_str("for<");
203 .filter_map(|param| match param.kind {
204 hir::GenericParamKind::Lifetime { .. } => {
205 Some(param.name.ident().to_string())
215 if let hir::Unsafety::Unsafe = f.unsafety {
216 text.push_str("unsafe ");
218 text.push_str("fn(");
220 let mut defs = vec![];
221 let mut refs = vec![];
222 for i in f.decl.inputs {
223 let nested = i.make(offset + text.len(), Some(i.hir_id), scx)?;
224 text.push_str(&nested.text);
226 defs.extend(nested.defs.into_iter());
227 refs.extend(nested.refs.into_iter());
230 if let hir::FnRetTy::Return(ref t) = f.decl.output {
231 text.push_str(" -> ");
232 let nested = t.make(offset + text.len(), None, scx)?;
233 text.push_str(&nested.text);
235 defs.extend(nested.defs.into_iter());
236 refs.extend(nested.refs.into_iter());
239 Ok(Signature { text, defs, refs })
241 hir::TyKind::Path(hir::QPath::Resolved(None, ref path)) => path.make(offset, id, scx),
242 hir::TyKind::Path(hir::QPath::Resolved(Some(ref qself), ref path)) => {
243 let nested_ty = qself.make(offset + 1, id, scx)?;
244 let prefix = format!(
247 path_segment_to_string(&path.segments[0])
250 let name = path_segment_to_string(path.segments.last().ok_or("Bad path")?);
251 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
252 let id = id_from_def_id(res.def_id());
253 if path.segments.len() == 2 {
254 let start = offset + prefix.len();
255 let end = start + name.len();
258 text: prefix + &name,
260 refs: vec![SigElement { id, start, end }],
263 let start = offset + prefix.len() + 5;
264 let end = start + name.len();
265 // FIXME should put the proper path in there, not ellipsis.
267 text: prefix + "...::" + &name,
269 refs: vec![SigElement { id, start, end }],
273 hir::TyKind::Path(hir::QPath::TypeRelative(ty, segment)) => {
274 let nested_ty = ty.make(offset + 1, id, scx)?;
275 let prefix = format!("<{}>::", nested_ty.text);
277 let name = path_segment_to_string(segment);
278 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
279 let id = id_from_def_id(res.def_id());
281 let start = offset + prefix.len();
282 let end = start + name.len();
284 text: prefix + &name,
286 refs: vec![SigElement { id, start, end }],
289 hir::TyKind::Path(hir::QPath::LangItem(lang_item, _)) => {
290 Ok(text_sig(format!("#[lang = \"{}\"]", lang_item.name())))
292 hir::TyKind::TraitObject(bounds, ..) => {
293 // FIXME recurse into bounds
294 let bounds: Vec<hir::GenericBound<'_>> = bounds
296 .map(|hir::PolyTraitRef { bound_generic_params, trait_ref, span }| {
297 hir::GenericBound::Trait(
299 bound_generic_params,
300 trait_ref: hir::TraitRef {
301 path: trait_ref.path,
302 hir_ref_id: trait_ref.hir_ref_id,
306 hir::TraitBoundModifier::None,
310 let nested = bounds_to_string(&bounds);
313 hir::TyKind::Array(ref ty, ref anon_const) => {
314 let nested_ty = ty.make(offset + 1, id, scx)?;
315 let expr = id_to_string(&scx.tcx.hir(), anon_const.body.hir_id).replace('\n', " ");
316 let text = format!("[{}; {}]", nested_ty.text, expr);
317 Ok(replace_text(nested_ty, text))
319 hir::TyKind::OpaqueDef(item_id, _) => {
320 let item = scx.tcx.hir().item(item_id);
321 item.make(offset, Some(item_id.hir_id()), scx)
323 hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"),
328 impl<'hir> Sig for hir::Item<'hir> {
329 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
330 let id = Some(self.hir_id());
333 hir::ItemKind::Static(ref ty, m, ref body) => {
334 let mut text = "static ".to_owned();
335 if m == hir::Mutability::Mut {
336 text.push_str("mut ");
338 let name = self.ident.to_string();
339 let defs = vec![SigElement {
340 id: id_from_def_id(self.def_id.to_def_id()),
341 start: offset + text.len(),
342 end: offset + text.len() + name.len(),
344 text.push_str(&name);
347 let ty = ty.make(offset + text.len(), id, scx)?;
348 text.push_str(&ty.text);
350 text.push_str(" = ");
351 let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " ");
352 text.push_str(&expr);
356 Ok(extend_sig(ty, text, defs, vec![]))
358 hir::ItemKind::Const(ref ty, ref body) => {
359 let mut text = "const ".to_owned();
360 let name = self.ident.to_string();
361 let defs = vec![SigElement {
362 id: id_from_def_id(self.def_id.to_def_id()),
363 start: offset + text.len(),
364 end: offset + text.len() + name.len(),
366 text.push_str(&name);
369 let ty = ty.make(offset + text.len(), id, scx)?;
370 text.push_str(&ty.text);
372 text.push_str(" = ");
373 let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " ");
374 text.push_str(&expr);
378 Ok(extend_sig(ty, text, defs, vec![]))
380 hir::ItemKind::Fn(hir::FnSig { ref decl, header, span: _ }, ref generics, _) => {
381 let mut text = String::new();
382 if let hir::Constness::Const = header.constness {
383 text.push_str("const ");
385 if hir::IsAsync::Async == header.asyncness {
386 text.push_str("async ");
388 if let hir::Unsafety::Unsafe = header.unsafety {
389 text.push_str("unsafe ");
391 text.push_str("fn ");
394 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
397 for i in decl.inputs {
398 // FIXME should descend into patterns to add defs.
399 sig.text.push_str(": ");
400 let nested = i.make(offset + sig.text.len(), Some(i.hir_id), scx)?;
401 sig.text.push_str(&nested.text);
403 sig.defs.extend(nested.defs.into_iter());
404 sig.refs.extend(nested.refs.into_iter());
408 if let hir::FnRetTy::Return(ref t) = decl.output {
409 sig.text.push_str(" -> ");
410 let nested = t.make(offset + sig.text.len(), None, scx)?;
411 sig.text.push_str(&nested.text);
412 sig.defs.extend(nested.defs.into_iter());
413 sig.refs.extend(nested.refs.into_iter());
415 sig.text.push_str(" {}");
419 hir::ItemKind::Mod(ref _mod) => {
420 let mut text = "mod ".to_owned();
421 let name = self.ident.to_string();
422 let defs = vec![SigElement {
423 id: id_from_def_id(self.def_id.to_def_id()),
424 start: offset + text.len(),
425 end: offset + text.len() + name.len(),
427 text.push_str(&name);
428 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
431 Ok(Signature { text, defs, refs: vec![] })
433 hir::ItemKind::TyAlias(ref ty, ref generics) => {
434 let text = "type ".to_owned();
436 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
438 sig.text.push_str(" = ");
439 let ty = ty.make(offset + sig.text.len(), id, scx)?;
440 sig.text.push_str(&ty.text);
443 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
445 hir::ItemKind::Enum(_, ref generics) => {
446 let text = "enum ".to_owned();
448 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
449 sig.text.push_str(" {}");
452 hir::ItemKind::Struct(_, ref generics) => {
453 let text = "struct ".to_owned();
455 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
456 sig.text.push_str(" {}");
459 hir::ItemKind::Union(_, ref generics) => {
460 let text = "union ".to_owned();
462 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
463 sig.text.push_str(" {}");
466 hir::ItemKind::Trait(is_auto, unsafety, ref generics, bounds, _) => {
467 let mut text = String::new();
469 if is_auto == hir::IsAuto::Yes {
470 text.push_str("auto ");
473 if let hir::Unsafety::Unsafe = unsafety {
474 text.push_str("unsafe ");
476 text.push_str("trait ");
478 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
480 if !bounds.is_empty() {
481 sig.text.push_str(": ");
482 sig.text.push_str(&bounds_to_string(bounds));
484 // FIXME where clause
485 sig.text.push_str(" {}");
489 hir::ItemKind::TraitAlias(ref generics, bounds) => {
490 let mut text = String::new();
491 text.push_str("trait ");
493 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
495 if !bounds.is_empty() {
496 sig.text.push_str(" = ");
497 sig.text.push_str(&bounds_to_string(bounds));
499 // FIXME where clause
504 hir::ItemKind::Impl(hir::Impl {
515 let mut text = String::new();
516 if let hir::Defaultness::Default { .. } = defaultness {
517 text.push_str("default ");
519 if let hir::Unsafety::Unsafe = unsafety {
520 text.push_str("unsafe ");
522 text.push_str("impl");
523 if let hir::Constness::Const = constness {
524 text.push_str(" const");
527 let generics_sig = generics.make(offset + text.len(), id, scx)?;
528 text.push_str(&generics_sig.text);
532 let trait_sig = if let Some(ref t) = *of_trait {
533 if let hir::ImplPolarity::Negative(_) = polarity {
536 let trait_sig = t.path.make(offset + text.len(), id, scx)?;
537 text.push_str(&trait_sig.text);
538 text.push_str(" for ");
541 text_sig(String::new())
544 let ty_sig = self_ty.make(offset + text.len(), id, scx)?;
545 text.push_str(&ty_sig.text);
547 text.push_str(" {}");
549 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
551 // FIXME where clause
553 hir::ItemKind::ForeignMod { .. } => Err("extern mod"),
554 hir::ItemKind::GlobalAsm(_) => Err("global asm"),
555 hir::ItemKind::ExternCrate(_) => Err("extern crate"),
556 hir::ItemKind::OpaqueTy(..) => Err("opaque type"),
557 // FIXME should implement this (e.g., pub use).
558 hir::ItemKind::Use(..) => Err("import"),
563 impl<'hir> Sig for hir::Path<'hir> {
564 fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
565 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
567 let (name, start, end) = match res {
568 Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => {
569 return Ok(Signature { text: path_to_string(self), defs: vec![], refs: vec![] });
571 Res::Def(DefKind::AssocConst | DefKind::Variant | DefKind::Ctor(..), _) => {
572 let len = self.segments.len();
574 return Err("Bad path");
576 // FIXME: really we should descend into the generics here and add SigElements for
578 // FIXME: would be nice to have a def for the first path segment.
579 let seg1 = path_segment_to_string(&self.segments[len - 2]);
580 let seg2 = path_segment_to_string(&self.segments[len - 1]);
581 let start = offset + seg1.len() + 2;
582 (format!("{}::{}", seg1, seg2), start, start + seg2.len())
585 let name = path_segment_to_string(self.segments.last().ok_or("Bad path")?);
586 let end = offset + name.len();
591 let id = id_from_def_id(res.def_id());
592 Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
596 // This does not cover the where clause, which must be processed separately.
597 impl<'hir> Sig for hir::Generics<'hir> {
598 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
599 if self.params.is_empty() {
600 return Ok(text_sig(String::new()));
603 let mut text = "<".to_owned();
605 let mut defs = Vec::with_capacity(self.params.len());
606 for param in self.params {
607 let mut param_text = String::new();
608 if let hir::GenericParamKind::Const { .. } = param.kind {
609 param_text.push_str("const ");
611 param_text.push_str(¶m.name.ident().as_str());
612 defs.push(SigElement {
613 id: id_from_hir_id(param.hir_id, scx),
614 start: offset + text.len(),
615 end: offset + text.len() + param_text.as_str().len(),
617 if let hir::GenericParamKind::Const { ref ty, ref default } = param.kind {
618 param_text.push_str(": ");
619 param_text.push_str(&ty_to_string(&ty));
620 if let Some(ref _default) = default {
621 // FIXME(const_generics_defaults): push the `default` value here
624 if !param.bounds.is_empty() {
625 param_text.push_str(": ");
627 hir::GenericParamKind::Lifetime { .. } => {
631 .map(|bound| match bound {
632 hir::GenericBound::Outlives(lt) => lt.name.ident().to_string(),
637 param_text.push_str(&bounds);
638 // FIXME add lifetime bounds refs.
640 hir::GenericParamKind::Type { .. } => {
641 param_text.push_str(&bounds_to_string(param.bounds));
642 // FIXME descend properly into bounds.
644 hir::GenericParamKind::Const { .. } => {
645 // Const generics cannot contain bounds.
649 text.push_str(¶m_text);
654 Ok(Signature { text, defs, refs: vec![] })
658 impl<'hir> Sig for hir::StructField<'hir> {
659 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
660 let mut text = String::new();
662 text.push_str(&self.ident.to_string());
663 let defs = Some(SigElement {
664 id: id_from_hir_id(self.hir_id, scx),
666 end: offset + text.len(),
670 let mut ty_sig = self.ty.make(offset + text.len(), Some(self.hir_id), scx)?;
671 text.push_str(&ty_sig.text);
673 ty_sig.defs.extend(defs.into_iter());
678 impl<'hir> Sig for hir::Variant<'hir> {
679 fn make(&self, offset: usize, parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
680 let mut text = self.ident.to_string();
682 hir::VariantData::Struct(fields, r) => {
683 let id = parent_id.ok_or("Missing id for Variant's parent")?;
684 let name_def = SigElement {
685 id: id_from_hir_id(id, scx),
687 end: offset + text.len(),
689 text.push_str(" { ");
690 let mut defs = vec![name_def];
691 let mut refs = vec![];
693 text.push_str("/* parse error */ ");
696 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
697 text.push_str(&field_sig.text);
699 defs.extend(field_sig.defs.into_iter());
700 refs.extend(field_sig.refs.into_iter());
704 Ok(Signature { text, defs, refs })
706 hir::VariantData::Tuple(fields, id) => {
707 let name_def = SigElement {
708 id: id_from_hir_id(id, scx),
710 end: offset + text.len(),
713 let mut defs = vec![name_def];
714 let mut refs = vec![];
716 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
717 text.push_str(&field_sig.text);
719 defs.extend(field_sig.defs.into_iter());
720 refs.extend(field_sig.refs.into_iter());
723 Ok(Signature { text, defs, refs })
725 hir::VariantData::Unit(id) => {
726 let name_def = SigElement {
727 id: id_from_hir_id(id, scx),
729 end: offset + text.len(),
731 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
737 impl<'hir> Sig for hir::ForeignItem<'hir> {
738 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
739 let id = Some(self.hir_id());
741 hir::ForeignItemKind::Fn(decl, _, ref generics) => {
742 let mut text = String::new();
743 text.push_str("fn ");
746 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
749 for i in decl.inputs {
750 sig.text.push_str(": ");
751 let nested = i.make(offset + sig.text.len(), Some(i.hir_id), scx)?;
752 sig.text.push_str(&nested.text);
754 sig.defs.extend(nested.defs.into_iter());
755 sig.refs.extend(nested.refs.into_iter());
759 if let hir::FnRetTy::Return(ref t) = decl.output {
760 sig.text.push_str(" -> ");
761 let nested = t.make(offset + sig.text.len(), None, scx)?;
762 sig.text.push_str(&nested.text);
763 sig.defs.extend(nested.defs.into_iter());
764 sig.refs.extend(nested.refs.into_iter());
770 hir::ForeignItemKind::Static(ref ty, m) => {
771 let mut text = "static ".to_owned();
772 if m == Mutability::Mut {
773 text.push_str("mut ");
775 let name = self.ident.to_string();
776 let defs = vec![SigElement {
777 id: id_from_def_id(self.def_id.to_def_id()),
778 start: offset + text.len(),
779 end: offset + text.len() + name.len(),
781 text.push_str(&name);
784 let ty_sig = ty.make(offset + text.len(), id, scx)?;
787 Ok(extend_sig(ty_sig, text, defs, vec![]))
789 hir::ForeignItemKind::Type => {
790 let mut text = "type ".to_owned();
791 let name = self.ident.to_string();
792 let defs = vec![SigElement {
793 id: id_from_def_id(self.def_id.to_def_id()),
794 start: offset + text.len(),
795 end: offset + text.len() + name.len(),
797 text.push_str(&name);
800 Ok(Signature { text, defs, refs: vec![] })
806 fn name_and_generics(
809 generics: &hir::Generics<'_>,
812 scx: &SaveContext<'_>,
814 let name = name.to_string();
815 let def = SigElement {
816 id: id_from_hir_id(id, scx),
817 start: offset + text.len(),
818 end: offset + text.len() + name.len(),
820 text.push_str(&name);
821 let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?;
822 // FIXME where clause
823 let text = format!("{}{}", text, generics.text);
824 Ok(extend_sig(generics, text, vec![def], vec![]))
827 fn make_assoc_type_signature(
830 bounds: Option<hir::GenericBounds<'_>>,
831 default: Option<&hir::Ty<'_>>,
832 scx: &SaveContext<'_>,
834 let mut text = "type ".to_owned();
835 let name = ident.to_string();
836 let mut defs = vec![SigElement {
837 id: id_from_hir_id(id, scx),
839 end: text.len() + name.len(),
841 let mut refs = vec![];
842 text.push_str(&name);
843 if let Some(bounds) = bounds {
845 // FIXME should descend into bounds
846 text.push_str(&bounds_to_string(bounds));
848 if let Some(default) = default {
849 text.push_str(" = ");
850 let ty_sig = default.make(text.len(), Some(id), scx)?;
851 text.push_str(&ty_sig.text);
852 defs.extend(ty_sig.defs.into_iter());
853 refs.extend(ty_sig.refs.into_iter());
856 Ok(Signature { text, defs, refs })
859 fn make_assoc_const_signature(
863 default: Option<&hir::Expr<'_>>,
864 scx: &SaveContext<'_>,
866 let mut text = "const ".to_owned();
867 let name = ident.to_string();
868 let mut defs = vec![SigElement {
869 id: id_from_hir_id(id, scx),
871 end: text.len() + name.len(),
873 let mut refs = vec![];
874 text.push_str(&name);
877 let ty_sig = ty.make(text.len(), Some(id), scx)?;
878 text.push_str(&ty_sig.text);
879 defs.extend(ty_sig.defs.into_iter());
880 refs.extend(ty_sig.refs.into_iter());
882 if let Some(default) = default {
883 text.push_str(" = ");
884 text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id));
887 Ok(Signature { text, defs, refs })
890 fn make_method_signature(
893 generics: &hir::Generics<'_>,
895 scx: &SaveContext<'_>,
897 // FIXME code dup with function signature
898 let mut text = String::new();
899 if let hir::Constness::Const = m.header.constness {
900 text.push_str("const ");
902 if hir::IsAsync::Async == m.header.asyncness {
903 text.push_str("async ");
905 if let hir::Unsafety::Unsafe = m.header.unsafety {
906 text.push_str("unsafe ");
908 text.push_str("fn ");
910 let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
913 for i in m.decl.inputs {
914 sig.text.push_str(": ");
915 let nested = i.make(sig.text.len(), Some(i.hir_id), scx)?;
916 sig.text.push_str(&nested.text);
918 sig.defs.extend(nested.defs.into_iter());
919 sig.refs.extend(nested.refs.into_iter());
923 if let hir::FnRetTy::Return(ref t) = m.decl.output {
924 sig.text.push_str(" -> ");
925 let nested = t.make(sig.text.len(), None, scx)?;
926 sig.text.push_str(&nested.text);
927 sig.defs.extend(nested.defs.into_iter());
928 sig.refs.extend(nested.refs.into_iter());
930 sig.text.push_str(" {}");