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::FieldDef<'_>, 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 length) => {
314 let nested_ty = ty.make(offset + 1, id, scx)?;
315 let expr = id_to_string(&scx.tcx.hir(), length.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::Macro(_) => {
420 let mut text = "macro".to_owned();
421 let name = self.ident.to_string();
422 text.push_str(&name);
423 text.push_str(&"! {}");
427 hir::ItemKind::Mod(ref _mod) => {
428 let mut text = "mod ".to_owned();
429 let name = self.ident.to_string();
430 let defs = vec![SigElement {
431 id: id_from_def_id(self.def_id.to_def_id()),
432 start: offset + text.len(),
433 end: offset + text.len() + name.len(),
435 text.push_str(&name);
436 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
439 Ok(Signature { text, defs, refs: vec![] })
441 hir::ItemKind::TyAlias(ref ty, ref generics) => {
442 let text = "type ".to_owned();
444 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
446 sig.text.push_str(" = ");
447 let ty = ty.make(offset + sig.text.len(), id, scx)?;
448 sig.text.push_str(&ty.text);
451 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
453 hir::ItemKind::Enum(_, ref generics) => {
454 let text = "enum ".to_owned();
456 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
457 sig.text.push_str(" {}");
460 hir::ItemKind::Struct(_, ref generics) => {
461 let text = "struct ".to_owned();
463 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
464 sig.text.push_str(" {}");
467 hir::ItemKind::Union(_, ref generics) => {
468 let text = "union ".to_owned();
470 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
471 sig.text.push_str(" {}");
474 hir::ItemKind::Trait(is_auto, unsafety, ref generics, bounds, _) => {
475 let mut text = String::new();
477 if is_auto == hir::IsAuto::Yes {
478 text.push_str("auto ");
481 if let hir::Unsafety::Unsafe = unsafety {
482 text.push_str("unsafe ");
484 text.push_str("trait ");
486 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
488 if !bounds.is_empty() {
489 sig.text.push_str(": ");
490 sig.text.push_str(&bounds_to_string(bounds));
492 // FIXME where clause
493 sig.text.push_str(" {}");
497 hir::ItemKind::TraitAlias(ref generics, bounds) => {
498 let mut text = String::new();
499 text.push_str("trait ");
501 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
503 if !bounds.is_empty() {
504 sig.text.push_str(" = ");
505 sig.text.push_str(&bounds_to_string(bounds));
507 // FIXME where clause
512 hir::ItemKind::Impl(hir::Impl {
523 let mut text = String::new();
524 if let hir::Defaultness::Default { .. } = defaultness {
525 text.push_str("default ");
527 if let hir::Unsafety::Unsafe = unsafety {
528 text.push_str("unsafe ");
530 text.push_str("impl");
531 if let hir::Constness::Const = constness {
532 text.push_str(" const");
535 let generics_sig = generics.make(offset + text.len(), id, scx)?;
536 text.push_str(&generics_sig.text);
540 let trait_sig = if let Some(ref t) = *of_trait {
541 if let hir::ImplPolarity::Negative(_) = polarity {
544 let trait_sig = t.path.make(offset + text.len(), id, scx)?;
545 text.push_str(&trait_sig.text);
546 text.push_str(" for ");
549 text_sig(String::new())
552 let ty_sig = self_ty.make(offset + text.len(), id, scx)?;
553 text.push_str(&ty_sig.text);
555 text.push_str(" {}");
557 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
559 // FIXME where clause
561 hir::ItemKind::ForeignMod { .. } => Err("extern mod"),
562 hir::ItemKind::GlobalAsm(_) => Err("global asm"),
563 hir::ItemKind::ExternCrate(_) => Err("extern crate"),
564 hir::ItemKind::OpaqueTy(..) => Err("opaque type"),
565 // FIXME should implement this (e.g., pub use).
566 hir::ItemKind::Use(..) => Err("import"),
571 impl<'hir> Sig for hir::Path<'hir> {
572 fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
573 let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
575 let (name, start, end) = match res {
576 Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => {
577 return Ok(Signature { text: path_to_string(self), defs: vec![], refs: vec![] });
579 Res::Def(DefKind::AssocConst | DefKind::Variant | DefKind::Ctor(..), _) => {
580 let len = self.segments.len();
582 return Err("Bad path");
584 // FIXME: really we should descend into the generics here and add SigElements for
586 // FIXME: would be nice to have a def for the first path segment.
587 let seg1 = path_segment_to_string(&self.segments[len - 2]);
588 let seg2 = path_segment_to_string(&self.segments[len - 1]);
589 let start = offset + seg1.len() + 2;
590 (format!("{}::{}", seg1, seg2), start, start + seg2.len())
593 let name = path_segment_to_string(self.segments.last().ok_or("Bad path")?);
594 let end = offset + name.len();
599 let id = id_from_def_id(res.def_id());
600 Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
604 // This does not cover the where clause, which must be processed separately.
605 impl<'hir> Sig for hir::Generics<'hir> {
606 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
607 if self.params.is_empty() {
608 return Ok(text_sig(String::new()));
611 let mut text = "<".to_owned();
613 let mut defs = Vec::with_capacity(self.params.len());
614 for param in self.params {
615 let mut param_text = String::new();
616 if let hir::GenericParamKind::Const { .. } = param.kind {
617 param_text.push_str("const ");
619 param_text.push_str(param.name.ident().as_str());
620 defs.push(SigElement {
621 id: id_from_hir_id(param.hir_id, scx),
622 start: offset + text.len(),
623 end: offset + text.len() + param_text.as_str().len(),
625 if let hir::GenericParamKind::Const { ref ty, default } = param.kind {
626 param_text.push_str(": ");
627 param_text.push_str(&ty_to_string(&ty));
628 if let Some(default) = default {
629 param_text.push_str(" = ");
630 param_text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id));
633 if !param.bounds.is_empty() {
634 param_text.push_str(": ");
636 hir::GenericParamKind::Lifetime { .. } => {
640 .map(|bound| match bound {
641 hir::GenericBound::Outlives(lt) => lt.name.ident().to_string(),
646 param_text.push_str(&bounds);
647 // FIXME add lifetime bounds refs.
649 hir::GenericParamKind::Type { .. } => {
650 param_text.push_str(&bounds_to_string(param.bounds));
651 // FIXME descend properly into bounds.
653 hir::GenericParamKind::Const { .. } => {
654 // Const generics cannot contain bounds.
658 text.push_str(¶m_text);
663 Ok(Signature { text, defs, refs: vec![] })
667 impl<'hir> Sig for hir::FieldDef<'hir> {
668 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
669 let mut text = String::new();
671 text.push_str(&self.ident.to_string());
672 let defs = Some(SigElement {
673 id: id_from_hir_id(self.hir_id, scx),
675 end: offset + text.len(),
679 let mut ty_sig = self.ty.make(offset + text.len(), Some(self.hir_id), scx)?;
680 text.push_str(&ty_sig.text);
682 ty_sig.defs.extend(defs.into_iter());
687 impl<'hir> Sig for hir::Variant<'hir> {
688 fn make(&self, offset: usize, parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
689 let mut text = self.ident.to_string();
691 hir::VariantData::Struct(fields, r) => {
692 let id = parent_id.ok_or("Missing id for Variant's parent")?;
693 let name_def = SigElement {
694 id: id_from_hir_id(id, scx),
696 end: offset + text.len(),
698 text.push_str(" { ");
699 let mut defs = vec![name_def];
700 let mut refs = vec![];
702 text.push_str("/* parse error */ ");
705 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
706 text.push_str(&field_sig.text);
708 defs.extend(field_sig.defs.into_iter());
709 refs.extend(field_sig.refs.into_iter());
713 Ok(Signature { text, defs, refs })
715 hir::VariantData::Tuple(fields, id) => {
716 let name_def = SigElement {
717 id: id_from_hir_id(id, scx),
719 end: offset + text.len(),
722 let mut defs = vec![name_def];
723 let mut refs = vec![];
725 let field_sig = f.make(offset + text.len(), Some(id), scx)?;
726 text.push_str(&field_sig.text);
728 defs.extend(field_sig.defs.into_iter());
729 refs.extend(field_sig.refs.into_iter());
732 Ok(Signature { text, defs, refs })
734 hir::VariantData::Unit(id) => {
735 let name_def = SigElement {
736 id: id_from_hir_id(id, scx),
738 end: offset + text.len(),
740 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
746 impl<'hir> Sig for hir::ForeignItem<'hir> {
747 fn make(&self, offset: usize, _parent_id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result {
748 let id = Some(self.hir_id());
750 hir::ForeignItemKind::Fn(decl, _, ref generics) => {
751 let mut text = String::new();
752 text.push_str("fn ");
755 name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
758 for i in decl.inputs {
759 sig.text.push_str(": ");
760 let nested = i.make(offset + sig.text.len(), Some(i.hir_id), scx)?;
761 sig.text.push_str(&nested.text);
763 sig.defs.extend(nested.defs.into_iter());
764 sig.refs.extend(nested.refs.into_iter());
768 if let hir::FnRetTy::Return(ref t) = decl.output {
769 sig.text.push_str(" -> ");
770 let nested = t.make(offset + sig.text.len(), None, scx)?;
771 sig.text.push_str(&nested.text);
772 sig.defs.extend(nested.defs.into_iter());
773 sig.refs.extend(nested.refs.into_iter());
779 hir::ForeignItemKind::Static(ref ty, m) => {
780 let mut text = "static ".to_owned();
781 if m == Mutability::Mut {
782 text.push_str("mut ");
784 let name = self.ident.to_string();
785 let defs = vec![SigElement {
786 id: id_from_def_id(self.def_id.to_def_id()),
787 start: offset + text.len(),
788 end: offset + text.len() + name.len(),
790 text.push_str(&name);
793 let ty_sig = ty.make(offset + text.len(), id, scx)?;
796 Ok(extend_sig(ty_sig, text, defs, vec![]))
798 hir::ForeignItemKind::Type => {
799 let mut text = "type ".to_owned();
800 let name = self.ident.to_string();
801 let defs = vec![SigElement {
802 id: id_from_def_id(self.def_id.to_def_id()),
803 start: offset + text.len(),
804 end: offset + text.len() + name.len(),
806 text.push_str(&name);
809 Ok(Signature { text, defs, refs: vec![] })
815 fn name_and_generics(
818 generics: &hir::Generics<'_>,
821 scx: &SaveContext<'_>,
823 let name = name.to_string();
824 let def = SigElement {
825 id: id_from_hir_id(id, scx),
826 start: offset + text.len(),
827 end: offset + text.len() + name.len(),
829 text.push_str(&name);
830 let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?;
831 // FIXME where clause
832 let text = format!("{}{}", text, generics.text);
833 Ok(extend_sig(generics, text, vec![def], vec![]))
836 fn make_assoc_type_signature(
839 bounds: Option<hir::GenericBounds<'_>>,
840 default: Option<&hir::Ty<'_>>,
841 scx: &SaveContext<'_>,
843 let mut text = "type ".to_owned();
844 let name = ident.to_string();
845 let mut defs = vec![SigElement {
846 id: id_from_hir_id(id, scx),
848 end: text.len() + name.len(),
850 let mut refs = vec![];
851 text.push_str(&name);
852 if let Some(bounds) = bounds {
854 // FIXME should descend into bounds
855 text.push_str(&bounds_to_string(bounds));
857 if let Some(default) = default {
858 text.push_str(" = ");
859 let ty_sig = default.make(text.len(), Some(id), scx)?;
860 text.push_str(&ty_sig.text);
861 defs.extend(ty_sig.defs.into_iter());
862 refs.extend(ty_sig.refs.into_iter());
865 Ok(Signature { text, defs, refs })
868 fn make_assoc_const_signature(
872 default: Option<&hir::Expr<'_>>,
873 scx: &SaveContext<'_>,
875 let mut text = "const ".to_owned();
876 let name = ident.to_string();
877 let mut defs = vec![SigElement {
878 id: id_from_hir_id(id, scx),
880 end: text.len() + name.len(),
882 let mut refs = vec![];
883 text.push_str(&name);
886 let ty_sig = ty.make(text.len(), Some(id), scx)?;
887 text.push_str(&ty_sig.text);
888 defs.extend(ty_sig.defs.into_iter());
889 refs.extend(ty_sig.refs.into_iter());
891 if let Some(default) = default {
892 text.push_str(" = ");
893 text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id));
896 Ok(Signature { text, defs, refs })
899 fn make_method_signature(
902 generics: &hir::Generics<'_>,
904 scx: &SaveContext<'_>,
906 // FIXME code dup with function signature
907 let mut text = String::new();
908 if let hir::Constness::Const = m.header.constness {
909 text.push_str("const ");
911 if hir::IsAsync::Async == m.header.asyncness {
912 text.push_str("async ");
914 if let hir::Unsafety::Unsafe = m.header.unsafety {
915 text.push_str("unsafe ");
917 text.push_str("fn ");
919 let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
922 for i in m.decl.inputs {
923 sig.text.push_str(": ");
924 let nested = i.make(sig.text.len(), Some(i.hir_id), scx)?;
925 sig.text.push_str(&nested.text);
927 sig.defs.extend(nested.defs.into_iter());
928 sig.refs.extend(nested.refs.into_iter());
932 if let hir::FnRetTy::Return(ref t) = m.decl.output {
933 sig.text.push_str(" -> ");
934 let nested = t.make(sig.text.len(), None, scx)?;
935 sig.text.push_str(&nested.text);
936 sig.defs.extend(nested.defs.into_iter());
937 sig.refs.extend(nested.refs.into_iter());
939 sig.text.push_str(" {}");