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 ommission (FIXME).
26 // FIXME where clauses need implementing, defs/refs in generics are mostly missing.
28 use crate::{id_from_def_id, id_from_node_id, SaveContext};
30 use rls_data::{SigElement, Signature};
32 use rustc::hir::def::{DefKind, Res};
33 use syntax::ast::{self, Extern, NodeId};
34 use syntax::print::pprust;
36 pub fn item_signature(item: &ast::Item, scx: &SaveContext<'_, '_>) -> Option<Signature> {
37 if !scx.config.signatures {
40 item.make(0, None, scx).ok()
43 pub fn foreign_item_signature(
44 item: &ast::ForeignItem,
45 scx: &SaveContext<'_, '_>,
46 ) -> Option<Signature> {
47 if !scx.config.signatures {
50 item.make(0, None, scx).ok()
53 /// Signature for a struct or tuple field declaration.
54 /// Does not include a trailing comma.
55 pub fn field_signature(field: &ast::StructField, scx: &SaveContext<'_, '_>) -> Option<Signature> {
56 if !scx.config.signatures {
59 field.make(0, None, scx).ok()
62 /// Does not include a trailing comma.
63 pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext<'_, '_>) -> Option<Signature> {
64 if !scx.config.signatures {
67 variant.make(0, None, scx).ok()
70 pub fn method_signature(
73 generics: &ast::Generics,
75 scx: &SaveContext<'_, '_>,
76 ) -> Option<Signature> {
77 if !scx.config.signatures {
80 make_method_signature(id, ident, generics, m, scx).ok()
83 pub fn assoc_const_signature(
87 default: Option<&ast::Expr>,
88 scx: &SaveContext<'_, '_>,
89 ) -> Option<Signature> {
90 if !scx.config.signatures {
93 make_assoc_const_signature(id, ident, ty, default, scx).ok()
96 pub fn assoc_type_signature(
99 bounds: Option<&ast::GenericBounds>,
100 default: Option<&ast::Ty>,
101 scx: &SaveContext<'_, '_>,
102 ) -> Option<Signature> {
103 if !scx.config.signatures {
106 make_assoc_type_signature(id, ident, bounds, default, scx).ok()
109 type Result = std::result::Result<Signature, &'static str>;
112 fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result;
118 defs: Vec<SigElement>,
119 refs: Vec<SigElement>,
122 sig.defs.extend(defs.into_iter());
123 sig.refs.extend(refs.into_iter());
127 fn replace_text(mut sig: Signature, text: String) -> Signature {
132 fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature {
133 let mut result = Signature { text, defs: vec![], refs: vec![] };
135 let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip();
137 result.defs.extend(defs.into_iter().flat_map(|ds| ds.into_iter()));
138 result.refs.extend(refs.into_iter().flat_map(|rs| rs.into_iter()));
143 fn text_sig(text: String) -> Signature {
144 Signature { text, defs: vec![], refs: vec![] }
147 fn push_extern(text: &mut String, ext: Extern) {
150 Extern::Implicit => text.push_str("extern "),
151 Extern::Explicit(abi) => text.push_str(&format!("extern \"{}\" ", abi.symbol)),
155 impl Sig for ast::Ty {
156 fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
157 let id = Some(self.id);
159 ast::TyKind::Slice(ref ty) => {
160 let nested = ty.make(offset + 1, id, scx)?;
161 let text = format!("[{}]", nested.text);
162 Ok(replace_text(nested, text))
164 ast::TyKind::Ptr(ref mt) => {
165 let prefix = match mt.mutbl {
166 ast::Mutability::Mut => "*mut ",
167 ast::Mutability::Not => "*const ",
169 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
170 let text = format!("{}{}", prefix, nested.text);
171 Ok(replace_text(nested, text))
173 ast::TyKind::Rptr(ref lifetime, ref mt) => {
174 let mut prefix = "&".to_owned();
175 if let &Some(ref l) = lifetime {
176 prefix.push_str(&l.ident.to_string());
179 if let ast::Mutability::Mut = mt.mutbl {
180 prefix.push_str("mut ");
183 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
184 let text = format!("{}{}", prefix, nested.text);
185 Ok(replace_text(nested, text))
187 ast::TyKind::Never => Ok(text_sig("!".to_owned())),
188 ast::TyKind::CVarArgs => Ok(text_sig("...".to_owned())),
189 ast::TyKind::Tup(ref ts) => {
190 let mut text = "(".to_owned();
191 let mut defs = vec![];
192 let mut refs = vec![];
194 let nested = t.make(offset + text.len(), id, scx)?;
195 text.push_str(&nested.text);
197 defs.extend(nested.defs.into_iter());
198 refs.extend(nested.refs.into_iter());
201 Ok(Signature { text, defs, refs })
203 ast::TyKind::Paren(ref ty) => {
204 let nested = ty.make(offset + 1, id, scx)?;
205 let text = format!("({})", nested.text);
206 Ok(replace_text(nested, text))
208 ast::TyKind::BareFn(ref f) => {
209 let mut text = String::new();
210 if !f.generic_params.is_empty() {
211 // FIXME defs, bounds on lifetimes
212 text.push_str("for<");
216 .filter_map(|param| match param.kind {
217 ast::GenericParamKind::Lifetime { .. } => {
218 Some(param.ident.to_string())
228 if f.unsafety == ast::Unsafety::Unsafe {
229 text.push_str("unsafe ");
231 push_extern(&mut text, f.ext);
232 text.push_str("fn(");
234 let mut defs = vec![];
235 let mut refs = vec![];
236 for i in &f.decl.inputs {
237 let nested = i.ty.make(offset + text.len(), Some(i.id), scx)?;
238 text.push_str(&nested.text);
240 defs.extend(nested.defs.into_iter());
241 refs.extend(nested.refs.into_iter());
244 if let ast::FunctionRetTy::Ty(ref t) = f.decl.output {
245 text.push_str(" -> ");
246 let nested = t.make(offset + text.len(), None, scx)?;
247 text.push_str(&nested.text);
249 defs.extend(nested.defs.into_iter());
250 refs.extend(nested.refs.into_iter());
253 Ok(Signature { text, defs, refs })
255 ast::TyKind::Path(None, ref path) => path.make(offset, id, scx),
256 ast::TyKind::Path(Some(ref qself), ref path) => {
257 let nested_ty = qself.ty.make(offset + 1, id, scx)?;
258 let prefix = if qself.position == 0 {
259 format!("<{}>::", nested_ty.text)
260 } else if qself.position == 1 {
261 let first = pprust::path_segment_to_string(&path.segments[0]);
262 format!("<{} as {}>::", nested_ty.text, first)
264 // FIXME handle path instead of elipses.
265 format!("<{} as ...>::", nested_ty.text)
268 let name = pprust::path_segment_to_string(path.segments.last().ok_or("Bad path")?);
269 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
270 let id = id_from_def_id(res.def_id());
271 if path.segments.len() - qself.position == 1 {
272 let start = offset + prefix.len();
273 let end = start + name.len();
276 text: prefix + &name,
278 refs: vec![SigElement { id, start, end }],
281 let start = offset + prefix.len() + 5;
282 let end = start + name.len();
283 // FIXME should put the proper path in there, not elipses.
285 text: prefix + "...::" + &name,
287 refs: vec![SigElement { id, start, end }],
291 ast::TyKind::TraitObject(ref bounds, ..) => {
292 // FIXME recurse into bounds
293 let nested = pprust::bounds_to_string(bounds);
296 ast::TyKind::ImplTrait(_, ref bounds) => {
297 // FIXME recurse into bounds
298 let nested = pprust::bounds_to_string(bounds);
299 Ok(text_sig(format!("impl {}", nested)))
301 ast::TyKind::Array(ref ty, ref v) => {
302 let nested_ty = ty.make(offset + 1, id, scx)?;
303 let expr = pprust::expr_to_string(&v.value).replace('\n', " ");
304 let text = format!("[{}; {}]", nested_ty.text, expr);
305 Ok(replace_text(nested_ty, text))
307 ast::TyKind::Typeof(_)
310 | ast::TyKind::ImplicitSelf
311 | ast::TyKind::Mac(_) => Err("Ty"),
316 impl Sig for ast::Item {
317 fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
318 let id = Some(self.id);
321 ast::ItemKind::Static(ref ty, m, ref expr) => {
322 let mut text = "static ".to_owned();
323 if m == ast::Mutability::Mut {
324 text.push_str("mut ");
326 let name = self.ident.to_string();
327 let defs = vec![SigElement {
328 id: id_from_node_id(self.id, scx),
329 start: offset + text.len(),
330 end: offset + text.len() + name.len(),
332 text.push_str(&name);
335 let ty = ty.make(offset + text.len(), id, scx)?;
336 text.push_str(&ty.text);
337 text.push_str(" = ");
339 let expr = pprust::expr_to_string(expr).replace('\n', " ");
340 text.push_str(&expr);
343 Ok(extend_sig(ty, text, defs, vec![]))
345 ast::ItemKind::Const(ref ty, ref expr) => {
346 let mut text = "const ".to_owned();
347 let name = self.ident.to_string();
348 let defs = vec![SigElement {
349 id: id_from_node_id(self.id, scx),
350 start: offset + text.len(),
351 end: offset + text.len() + name.len(),
353 text.push_str(&name);
356 let ty = ty.make(offset + text.len(), id, scx)?;
357 text.push_str(&ty.text);
358 text.push_str(" = ");
360 let expr = pprust::expr_to_string(expr).replace('\n', " ");
361 text.push_str(&expr);
364 Ok(extend_sig(ty, text, defs, vec![]))
366 ast::ItemKind::Fn(ast::FnSig { ref decl, header }, ref generics, _) => {
367 let mut text = String::new();
368 if header.constness.node == ast::Constness::Const {
369 text.push_str("const ");
371 if header.asyncness.node.is_async() {
372 text.push_str("async ");
374 if header.unsafety == ast::Unsafety::Unsafe {
375 text.push_str("unsafe ");
377 push_extern(&mut text, header.ext);
378 text.push_str("fn ");
380 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
383 for i in &decl.inputs {
384 // FIXME should descend into patterns to add defs.
385 sig.text.push_str(&pprust::pat_to_string(&i.pat));
386 sig.text.push_str(": ");
387 let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
388 sig.text.push_str(&nested.text);
390 sig.defs.extend(nested.defs.into_iter());
391 sig.refs.extend(nested.refs.into_iter());
395 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
396 sig.text.push_str(" -> ");
397 let nested = t.make(offset + sig.text.len(), None, scx)?;
398 sig.text.push_str(&nested.text);
399 sig.defs.extend(nested.defs.into_iter());
400 sig.refs.extend(nested.refs.into_iter());
402 sig.text.push_str(" {}");
406 ast::ItemKind::Mod(ref _mod) => {
407 let mut text = "mod ".to_owned();
408 let name = self.ident.to_string();
409 let defs = vec![SigElement {
410 id: id_from_node_id(self.id, scx),
411 start: offset + text.len(),
412 end: offset + text.len() + name.len(),
414 text.push_str(&name);
415 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
418 Ok(Signature { text, defs, refs: vec![] })
420 ast::ItemKind::TyAlias(ref ty, ref generics) => {
421 let text = "type ".to_owned();
422 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
424 sig.text.push_str(" = ");
425 let ty = ty.make(offset + sig.text.len(), id, scx)?;
426 sig.text.push_str(&ty.text);
429 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
431 ast::ItemKind::Enum(_, ref generics) => {
432 let text = "enum ".to_owned();
433 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
434 sig.text.push_str(" {}");
437 ast::ItemKind::Struct(_, ref generics) => {
438 let text = "struct ".to_owned();
439 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
440 sig.text.push_str(" {}");
443 ast::ItemKind::Union(_, ref generics) => {
444 let text = "union ".to_owned();
445 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
446 sig.text.push_str(" {}");
449 ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, _) => {
450 let mut text = String::new();
452 if is_auto == ast::IsAuto::Yes {
453 text.push_str("auto ");
456 if unsafety == ast::Unsafety::Unsafe {
457 text.push_str("unsafe ");
459 text.push_str("trait ");
460 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
462 if !bounds.is_empty() {
463 sig.text.push_str(": ");
464 sig.text.push_str(&pprust::bounds_to_string(bounds));
466 // FIXME where clause
467 sig.text.push_str(" {}");
471 ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
472 let mut text = String::new();
473 text.push_str("trait ");
474 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
476 if !bounds.is_empty() {
477 sig.text.push_str(" = ");
478 sig.text.push_str(&pprust::bounds_to_string(bounds));
480 // FIXME where clause
481 sig.text.push_str(";");
494 let mut text = String::new();
495 if let ast::Defaultness::Default = defaultness {
496 text.push_str("default ");
498 if unsafety == ast::Unsafety::Unsafe {
499 text.push_str("unsafe ");
501 text.push_str("impl");
503 let generics_sig = generics.make(offset + text.len(), id, scx)?;
504 text.push_str(&generics_sig.text);
508 let trait_sig = if let Some(ref t) = *opt_trait {
509 if polarity == ast::ImplPolarity::Negative {
512 let trait_sig = t.path.make(offset + text.len(), id, scx)?;
513 text.push_str(&trait_sig.text);
514 text.push_str(" for ");
517 text_sig(String::new())
520 let ty_sig = ty.make(offset + text.len(), id, scx)?;
521 text.push_str(&ty_sig.text);
523 text.push_str(" {}");
525 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
527 // FIXME where clause
529 ast::ItemKind::ForeignMod(_) => Err("extern mod"),
530 ast::ItemKind::GlobalAsm(_) => Err("glboal asm"),
531 ast::ItemKind::ExternCrate(_) => Err("extern crate"),
532 // FIXME should implement this (e.g., pub use).
533 ast::ItemKind::Use(_) => Err("import"),
534 ast::ItemKind::Mac(..) | ast::ItemKind::MacroDef(_) => Err("Macro"),
539 impl Sig for ast::Path {
540 fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
541 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
543 let (name, start, end) = match res {
544 Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => {
545 return Ok(Signature {
546 text: pprust::path_to_string(self),
551 Res::Def(DefKind::AssocConst, _)
552 | Res::Def(DefKind::Variant, _)
553 | Res::Def(DefKind::Ctor(..), _) => {
554 let len = self.segments.len();
556 return Err("Bad path");
558 // FIXME: really we should descend into the generics here and add SigElements for
560 // FIXME: would be nice to have a def for the first path segment.
561 let seg1 = pprust::path_segment_to_string(&self.segments[len - 2]);
562 let seg2 = pprust::path_segment_to_string(&self.segments[len - 1]);
563 let start = offset + seg1.len() + 2;
564 (format!("{}::{}", seg1, seg2), start, start + seg2.len())
567 let name = pprust::path_segment_to_string(self.segments.last().ok_or("Bad path")?);
568 let end = offset + name.len();
573 let id = id_from_def_id(res.def_id());
574 Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
578 // This does not cover the where clause, which must be processed separately.
579 impl Sig for ast::Generics {
580 fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
581 if self.params.is_empty() {
582 return Ok(text_sig(String::new()));
585 let mut text = "<".to_owned();
587 let mut defs = Vec::with_capacity(self.params.len());
588 for param in &self.params {
589 let mut param_text = String::new();
590 if let ast::GenericParamKind::Const { .. } = param.kind {
591 param_text.push_str("const ");
593 param_text.push_str(¶m.ident.as_str());
594 defs.push(SigElement {
595 id: id_from_node_id(param.id, scx),
596 start: offset + text.len(),
597 end: offset + text.len() + param_text.as_str().len(),
599 if let ast::GenericParamKind::Const { ref ty } = param.kind {
600 param_text.push_str(": ");
601 param_text.push_str(&pprust::ty_to_string(&ty));
603 if !param.bounds.is_empty() {
604 param_text.push_str(": ");
606 ast::GenericParamKind::Lifetime { .. } => {
610 .map(|bound| match bound {
611 ast::GenericBound::Outlives(lt) => lt.ident.to_string(),
616 param_text.push_str(&bounds);
617 // FIXME add lifetime bounds refs.
619 ast::GenericParamKind::Type { .. } => {
620 param_text.push_str(&pprust::bounds_to_string(¶m.bounds));
621 // FIXME descend properly into bounds.
623 ast::GenericParamKind::Const { .. } => {
624 // Const generics cannot contain bounds.
628 text.push_str(¶m_text);
633 Ok(Signature { text, defs, refs: vec![] })
637 impl Sig for ast::StructField {
638 fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
639 let mut text = String::new();
641 if let Some(ident) = self.ident {
642 text.push_str(&ident.to_string());
643 defs = Some(SigElement {
644 id: id_from_node_id(self.id, scx),
646 end: offset + text.len(),
651 let mut ty_sig = self.ty.make(offset + text.len(), Some(self.id), scx)?;
652 text.push_str(&ty_sig.text);
654 ty_sig.defs.extend(defs.into_iter());
659 impl Sig for ast::Variant {
660 fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
661 let mut text = self.ident.to_string();
663 ast::VariantData::Struct(ref fields, r) => {
664 let id = parent_id.unwrap();
665 let name_def = SigElement {
666 id: id_from_node_id(id, scx),
668 end: offset + text.len(),
670 text.push_str(" { ");
671 let mut defs = vec![name_def];
672 let mut refs = vec![];
674 text.push_str("/* parse error */ ");
677 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
678 text.push_str(&field_sig.text);
680 defs.extend(field_sig.defs.into_iter());
681 refs.extend(field_sig.refs.into_iter());
685 Ok(Signature { text, defs, refs })
687 ast::VariantData::Tuple(ref fields, id) => {
688 let name_def = SigElement {
689 id: id_from_node_id(id, scx),
691 end: offset + text.len(),
694 let mut defs = vec![name_def];
695 let mut refs = vec![];
697 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
698 text.push_str(&field_sig.text);
700 defs.extend(field_sig.defs.into_iter());
701 refs.extend(field_sig.refs.into_iter());
704 Ok(Signature { text, defs, refs })
706 ast::VariantData::Unit(id) => {
707 let name_def = SigElement {
708 id: id_from_node_id(id, scx),
710 end: offset + text.len(),
712 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
718 impl Sig for ast::ForeignItem {
719 fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
720 let id = Some(self.id);
722 ast::ForeignItemKind::Fn(ref decl, ref generics) => {
723 let mut text = String::new();
724 text.push_str("fn ");
726 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
729 for i in &decl.inputs {
730 // FIXME should descend into patterns to add defs.
731 sig.text.push_str(&pprust::pat_to_string(&i.pat));
732 sig.text.push_str(": ");
733 let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
734 sig.text.push_str(&nested.text);
736 sig.defs.extend(nested.defs.into_iter());
737 sig.refs.extend(nested.refs.into_iter());
741 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
742 sig.text.push_str(" -> ");
743 let nested = t.make(offset + sig.text.len(), None, scx)?;
744 sig.text.push_str(&nested.text);
745 sig.defs.extend(nested.defs.into_iter());
746 sig.refs.extend(nested.refs.into_iter());
752 ast::ForeignItemKind::Static(ref ty, m) => {
753 let mut text = "static ".to_owned();
754 if m == ast::Mutability::Mut {
755 text.push_str("mut ");
757 let name = self.ident.to_string();
758 let defs = vec![SigElement {
759 id: id_from_node_id(self.id, scx),
760 start: offset + text.len(),
761 end: offset + text.len() + name.len(),
763 text.push_str(&name);
766 let ty_sig = ty.make(offset + text.len(), id, scx)?;
769 Ok(extend_sig(ty_sig, text, defs, vec![]))
771 ast::ForeignItemKind::Ty => {
772 let mut text = "type ".to_owned();
773 let name = self.ident.to_string();
774 let defs = vec![SigElement {
775 id: id_from_node_id(self.id, scx),
776 start: offset + text.len(),
777 end: offset + text.len() + name.len(),
779 text.push_str(&name);
782 Ok(Signature { text: text, defs: defs, refs: vec![] })
784 ast::ForeignItemKind::Macro(..) => Err("macro"),
789 fn name_and_generics(
792 generics: &ast::Generics,
795 scx: &SaveContext<'_, '_>,
797 let name = name.to_string();
798 let def = SigElement {
799 id: id_from_node_id(id, scx),
800 start: offset + text.len(),
801 end: offset + text.len() + name.len(),
803 text.push_str(&name);
804 let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?;
805 // FIXME where clause
806 let text = format!("{}{}", text, generics.text);
807 Ok(extend_sig(generics, text, vec![def], vec![]))
810 fn make_assoc_type_signature(
813 bounds: Option<&ast::GenericBounds>,
814 default: Option<&ast::Ty>,
815 scx: &SaveContext<'_, '_>,
817 let mut text = "type ".to_owned();
818 let name = ident.to_string();
819 let mut defs = vec![SigElement {
820 id: id_from_node_id(id, scx),
822 end: text.len() + name.len(),
824 let mut refs = vec![];
825 text.push_str(&name);
826 if let Some(bounds) = bounds {
828 // FIXME should descend into bounds
829 text.push_str(&pprust::bounds_to_string(bounds));
831 if let Some(default) = default {
832 text.push_str(" = ");
833 let ty_sig = default.make(text.len(), Some(id), scx)?;
834 text.push_str(&ty_sig.text);
835 defs.extend(ty_sig.defs.into_iter());
836 refs.extend(ty_sig.refs.into_iter());
839 Ok(Signature { text, defs, refs })
842 fn make_assoc_const_signature(
846 default: Option<&ast::Expr>,
847 scx: &SaveContext<'_, '_>,
849 let mut text = "const ".to_owned();
850 let name = ident.to_string();
851 let mut defs = vec![SigElement {
852 id: id_from_node_id(id, scx),
854 end: text.len() + name.len(),
856 let mut refs = vec![];
857 text.push_str(&name);
860 let ty_sig = ty.make(text.len(), Some(id), scx)?;
861 text.push_str(&ty_sig.text);
862 defs.extend(ty_sig.defs.into_iter());
863 refs.extend(ty_sig.refs.into_iter());
865 if let Some(default) = default {
866 text.push_str(" = ");
867 text.push_str(&pprust::expr_to_string(default));
870 Ok(Signature { text, defs, refs })
873 fn make_method_signature(
876 generics: &ast::Generics,
878 scx: &SaveContext<'_, '_>,
880 // FIXME code dup with function signature
881 let mut text = String::new();
882 if m.header.constness.node == ast::Constness::Const {
883 text.push_str("const ");
885 if m.header.asyncness.node.is_async() {
886 text.push_str("async ");
888 if m.header.unsafety == ast::Unsafety::Unsafe {
889 text.push_str("unsafe ");
891 push_extern(&mut text, m.header.ext);
892 text.push_str("fn ");
894 let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
897 for i in &m.decl.inputs {
898 // FIXME should descend into patterns to add defs.
899 sig.text.push_str(&pprust::pat_to_string(&i.pat));
900 sig.text.push_str(": ");
901 let nested = i.ty.make(sig.text.len(), Some(i.id), scx)?;
902 sig.text.push_str(&nested.text);
904 sig.defs.extend(nested.defs.into_iter());
905 sig.refs.extend(nested.refs.into_iter());
909 if let ast::FunctionRetTy::Ty(ref t) = m.decl.output {
910 sig.text.push_str(" -> ");
911 let nested = t.make(sig.text.len(), None, scx)?;
912 sig.text.push_str(&nested.text);
913 sig.defs.extend(nested.defs.into_iter());
914 sig.refs.extend(nested.refs.into_iter());
916 sig.text.push_str(" {}");