compiler/rustc_save_analysis/src/sig.rs

   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
   3 // example:
   4 //
   5 // ```
   6 // fn foo(x: String) {
   7 //     println!("{}", x);
   8 // }
   9 // ```
  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`.
  12 //
  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.
  19 //
  20 // This module generates Signatures for items by walking the AST and looking up
  21 // references.
  22 //
  23 // Signatures do not include visibility info. I'm not sure if this is a feature
  24 // or an omission (FIXME).
  25 //
  26 // FIXME where clauses need implementing, defs/refs in generics are mostly missing.
  27
  28 use crate::{id_from_def_id, id_from_hir_id, SaveContext};
  29
  30 use rls_data::{SigElement, Signature};
  31
  32 use rustc_ast::Mutability;
  33 use rustc_hir as hir;
  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};
  38
  39 pub fn item_signature(item: &hir::Item<'_>, scx: &SaveContext<'_>) -> Option<Signature> {
  40     if !scx.config.signatures {
  41         return None;
  42     }
  43     item.make(0, None, scx).ok()
  44 }
  45
  46 pub fn foreign_item_signature(
  47     item: &hir::ForeignItem<'_>,
  48     scx: &SaveContext<'_>,
  49 ) -> Option<Signature> {
  50     if !scx.config.signatures {
  51         return None;
  52     }
  53     item.make(0, None, scx).ok()
  54 }
  55
  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 {
  60         return None;
  61     }
  62     field.make(0, None, scx).ok()
  63 }
  64
  65 /// Does not include a trailing comma.
  66 pub fn variant_signature(variant: &hir::Variant<'_>, scx: &SaveContext<'_>) -> Option<Signature> {
  67     if !scx.config.signatures {
  68         return None;
  69     }
  70     variant.make(0, None, scx).ok()
  71 }
  72
  73 pub fn method_signature(
  74     id: hir::HirId,
  75     ident: Ident,
  76     generics: &hir::Generics<'_>,
  77     m: &hir::FnSig<'_>,
  78     scx: &SaveContext<'_>,
  79 ) -> Option<Signature> {
  80     if !scx.config.signatures {
  81         return None;
  82     }
  83     make_method_signature(id, ident, generics, m, scx).ok()
  84 }
  85
  86 pub fn assoc_const_signature(
  87     id: hir::HirId,
  88     ident: Symbol,
  89     ty: &hir::Ty<'_>,
  90     default: Option<&hir::Expr<'_>>,
  91     scx: &SaveContext<'_>,
  92 ) -> Option<Signature> {
  93     if !scx.config.signatures {
  94         return None;
  95     }
  96     make_assoc_const_signature(id, ident, ty, default, scx).ok()
  97 }
  98
  99 pub fn assoc_type_signature(
 100     id: hir::HirId,
 101     ident: Ident,
 102     bounds: Option<hir::GenericBounds<'_>>,
 103     default: Option<&hir::Ty<'_>>,
 104     scx: &SaveContext<'_>,
 105 ) -> Option<Signature> {
 106     if !scx.config.signatures {
 107         return None;
 108     }
 109     make_assoc_type_signature(id, ident, bounds, default, scx).ok()
 110 }
 111
 112 type Result = std::result::Result<Signature, &'static str>;
 113
 114 trait Sig {
 115     fn make(&self, offset: usize, id: Option<hir::HirId>, scx: &SaveContext<'_>) -> Result;
 116 }
 117
 118 fn extend_sig(
 119     mut sig: Signature,
 120     text: String,
 121     defs: Vec<SigElement>,
 122     refs: Vec<SigElement>,
 123 ) -> Signature {
 124     sig.text = text;
 125     sig.defs.extend(defs.into_iter());
 126     sig.refs.extend(refs.into_iter());
 127     sig
 128 }
 129
 130 fn replace_text(mut sig: Signature, text: String) -> Signature {
 131     sig.text = text;
 132     sig
 133 }
 134
 135 fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature {
 136     let mut result = Signature { text, defs: vec![], refs: vec![] };
 137
 138     let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip();
 139
 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()));
 142
 143     result
 144 }
 145
 146 fn text_sig(text: String) -> Signature {
 147     Signature { text, defs: vec![], refs: vec![] }
 148 }
 149
 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);
 153         match self.kind {
 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))
 158             }
 159             hir::TyKind::Ptr(ref mt) => {
 160                 let prefix = match mt.mutbl {
 161                     hir::Mutability::Mut => "*mut ",
 162                     hir::Mutability::Not => "*const ",
 163                 };
 164                 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
 165                 let text = format!("{}{}", prefix, nested.text);
 166                 Ok(replace_text(nested, text))
 167             }
 168             hir::TyKind::Rptr(ref lifetime, ref mt) => {
 169                 let mut prefix = "&".to_owned();
 170                 prefix.push_str(&lifetime.name.ident().to_string());
 171                 prefix.push(' ');
 172                 if let hir::Mutability::Mut = mt.mutbl {
 173                     prefix.push_str("mut ");
 174                 };
 175
 176                 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
 177                 let text = format!("{}{}", prefix, nested.text);
 178                 Ok(replace_text(nested, text))
 179             }
 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![];
 185                 for t in ts {
 186                     let nested = t.make(offset + text.len(), id, scx)?;
 187                     text.push_str(&nested.text);
 188                     text.push(',');
 189                     defs.extend(nested.defs.into_iter());
 190                     refs.extend(nested.refs.into_iter());
 191                 }
 192                 text.push(')');
 193                 Ok(Signature { text, defs, refs })
 194             }
 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<");
 200                     text.push_str(
 201                         &f.generic_params
 202                             .iter()
 203                             .filter_map(|param| match param.kind {
 204                                 hir::GenericParamKind::Lifetime { .. } => {
 205                                     Some(param.name.ident().to_string())
 206                                 }
 207                                 _ => None,
 208                             })
 209                             .collect::<Vec<_>>()
 210                             .join(", "),
 211                     );
 212                     text.push('>');
 213                 }
 214
 215                 if let hir::Unsafety::Unsafe = f.unsafety {
 216                     text.push_str("unsafe ");
 217                 }
 218                 text.push_str("fn(");
 219
 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);
 225                     text.push(',');
 226                     defs.extend(nested.defs.into_iter());
 227                     refs.extend(nested.refs.into_iter());
 228                 }
 229                 text.push(')');
 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);
 234                     text.push(',');
 235                     defs.extend(nested.defs.into_iter());
 236                     refs.extend(nested.refs.into_iter());
 237                 }
 238
 239                 Ok(Signature { text, defs, refs })
 240             }
 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!(
 245                     "<{} as {}>::",
 246                     nested_ty.text,
 247                     path_segment_to_string(&path.segments[0])
 248                 );
 249
 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();
 256
 257                     Ok(Signature {
 258                         text: prefix + &name,
 259                         defs: vec![],
 260                         refs: vec![SigElement { id, start, end }],
 261                     })
 262                 } else {
 263                     let start = offset + prefix.len() + 5;
 264                     let end = start + name.len();
 265                     // FIXME should put the proper path in there, not ellipsis.
 266                     Ok(Signature {
 267                         text: prefix + "...::" + &name,
 268                         defs: vec![],
 269                         refs: vec![SigElement { id, start, end }],
 270                     })
 271                 }
 272             }
 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);
 276
 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());
 280
 281                 let start = offset + prefix.len();
 282                 let end = start + name.len();
 283                 Ok(Signature {
 284                     text: prefix + &name,
 285                     defs: vec![],
 286                     refs: vec![SigElement { id, start, end }],
 287                 })
 288             }
 289             hir::TyKind::Path(hir::QPath::LangItem(lang_item, _, _)) => {
 290                 Ok(text_sig(format!("#[lang = \"{}\"]", lang_item.name())))
 291             }
 292             hir::TyKind::TraitObject(bounds, ..) => {
 293                 // FIXME recurse into bounds
 294                 let bounds: Vec<hir::GenericBound<'_>> = bounds
 295                     .iter()
 296                     .map(|hir::PolyTraitRef { bound_generic_params, trait_ref, span }| {
 297                         hir::GenericBound::Trait(
 298                             hir::PolyTraitRef {
 299                                 bound_generic_params,
 300                                 trait_ref: hir::TraitRef {
 301                                     path: trait_ref.path,
 302                                     hir_ref_id: trait_ref.hir_ref_id,
 303                                 },
 304                                 span: *span,
 305                             },
 306                             hir::TraitBoundModifier::None,
 307                         )
 308                     })
 309                     .collect();
 310                 let nested = bounds_to_string(&bounds);
 311                 Ok(text_sig(nested))
 312             }
 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))
 318             }
 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)
 322             }
 323             hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"),
 324         }
 325     }
 326 }
 327
 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());
 331
 332         match self.kind {
 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 ");
 337                 }
 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(),
 343                 }];
 344                 text.push_str(&name);
 345                 text.push_str(": ");
 346
 347                 let ty = ty.make(offset + text.len(), id, scx)?;
 348                 text.push_str(&ty.text);
 349
 350                 text.push_str(" = ");
 351                 let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " ");
 352                 text.push_str(&expr);
 353
 354                 text.push(';');
 355
 356                 Ok(extend_sig(ty, text, defs, vec![]))
 357             }
 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(),
 365                 }];
 366                 text.push_str(&name);
 367                 text.push_str(": ");
 368
 369                 let ty = ty.make(offset + text.len(), id, scx)?;
 370                 text.push_str(&ty.text);
 371
 372                 text.push_str(" = ");
 373                 let expr = id_to_string(&scx.tcx.hir(), body.hir_id).replace('\n', " ");
 374                 text.push_str(&expr);
 375
 376                 text.push(';');
 377
 378                 Ok(extend_sig(ty, text, defs, vec![]))
 379             }
 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 ");
 384                 }
 385                 if hir::IsAsync::Async == header.asyncness {
 386                     text.push_str("async ");
 387                 }
 388                 if let hir::Unsafety::Unsafe = header.unsafety {
 389                     text.push_str("unsafe ");
 390                 }
 391                 text.push_str("fn ");
 392
 393                 let mut sig =
 394                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 395
 396                 sig.text.push('(');
 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);
 402                     sig.text.push(',');
 403                     sig.defs.extend(nested.defs.into_iter());
 404                     sig.refs.extend(nested.refs.into_iter());
 405                 }
 406                 sig.text.push(')');
 407
 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());
 414                 }
 415                 sig.text.push_str(" {}");
 416
 417                 Ok(sig)
 418             }
 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(&"! {}");
 424
 425                 Ok(text_sig(text))
 426             }
 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(),
 434                 }];
 435                 text.push_str(&name);
 436                 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
 437                 text.push(';');
 438
 439                 Ok(Signature { text, defs, refs: vec![] })
 440             }
 441             hir::ItemKind::TyAlias(ref ty, ref generics) => {
 442                 let text = "type ".to_owned();
 443                 let mut sig =
 444                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 445
 446                 sig.text.push_str(" = ");
 447                 let ty = ty.make(offset + sig.text.len(), id, scx)?;
 448                 sig.text.push_str(&ty.text);
 449                 sig.text.push(';');
 450
 451                 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
 452             }
 453             hir::ItemKind::Enum(_, ref generics) => {
 454                 let text = "enum ".to_owned();
 455                 let mut sig =
 456                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 457                 sig.text.push_str(" {}");
 458                 Ok(sig)
 459             }
 460             hir::ItemKind::Struct(_, ref generics) => {
 461                 let text = "struct ".to_owned();
 462                 let mut sig =
 463                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 464                 sig.text.push_str(" {}");
 465                 Ok(sig)
 466             }
 467             hir::ItemKind::Union(_, ref generics) => {
 468                 let text = "union ".to_owned();
 469                 let mut sig =
 470                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 471                 sig.text.push_str(" {}");
 472                 Ok(sig)
 473             }
 474             hir::ItemKind::Trait(is_auto, unsafety, ref generics, bounds, _) => {
 475                 let mut text = String::new();
 476
 477                 if is_auto == hir::IsAuto::Yes {
 478                     text.push_str("auto ");
 479                 }
 480
 481                 if let hir::Unsafety::Unsafe = unsafety {
 482                     text.push_str("unsafe ");
 483                 }
 484                 text.push_str("trait ");
 485                 let mut sig =
 486                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 487
 488                 if !bounds.is_empty() {
 489                     sig.text.push_str(": ");
 490                     sig.text.push_str(&bounds_to_string(bounds));
 491                 }
 492                 // FIXME where clause
 493                 sig.text.push_str(" {}");
 494
 495                 Ok(sig)
 496             }
 497             hir::ItemKind::TraitAlias(ref generics, bounds) => {
 498                 let mut text = String::new();
 499                 text.push_str("trait ");
 500                 let mut sig =
 501                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 502
 503                 if !bounds.is_empty() {
 504                     sig.text.push_str(" = ");
 505                     sig.text.push_str(&bounds_to_string(bounds));
 506                 }
 507                 // FIXME where clause
 508                 sig.text.push(';');
 509
 510                 Ok(sig)
 511             }
 512             hir::ItemKind::Impl(hir::Impl {
 513                 unsafety,
 514                 polarity,
 515                 defaultness,
 516                 defaultness_span: _,
 517                 constness,
 518                 ref generics,
 519                 ref of_trait,
 520                 ref self_ty,
 521                 items: _,
 522             }) => {
 523                 let mut text = String::new();
 524                 if let hir::Defaultness::Default { .. } = defaultness {
 525                     text.push_str("default ");
 526                 }
 527                 if let hir::Unsafety::Unsafe = unsafety {
 528                     text.push_str("unsafe ");
 529                 }
 530                 text.push_str("impl");
 531                 if let hir::Constness::Const = constness {
 532                     text.push_str(" const");
 533                 }
 534
 535                 let generics_sig = generics.make(offset + text.len(), id, scx)?;
 536                 text.push_str(&generics_sig.text);
 537
 538                 text.push(' ');
 539
 540                 let trait_sig = if let Some(ref t) = *of_trait {
 541                     if let hir::ImplPolarity::Negative(_) = polarity {
 542                         text.push('!');
 543                     }
 544                     let trait_sig = t.path.make(offset + text.len(), id, scx)?;
 545                     text.push_str(&trait_sig.text);
 546                     text.push_str(" for ");
 547                     trait_sig
 548                 } else {
 549                     text_sig(String::new())
 550                 };
 551
 552                 let ty_sig = self_ty.make(offset + text.len(), id, scx)?;
 553                 text.push_str(&ty_sig.text);
 554
 555                 text.push_str(" {}");
 556
 557                 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
 558
 559                 // FIXME where clause
 560             }
 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"),
 567         }
 568     }
 569 }
 570
 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")?);
 574
 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![] });
 578             }
 579             Res::Def(DefKind::AssocConst | DefKind::Variant | DefKind::Ctor(..), _) => {
 580                 let len = self.segments.len();
 581                 if len < 2 {
 582                     return Err("Bad path");
 583                 }
 584                 // FIXME: really we should descend into the generics here and add SigElements for
 585                 // them.
 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())
 591             }
 592             _ => {
 593                 let name = path_segment_to_string(self.segments.last().ok_or("Bad path")?);
 594                 let end = offset + name.len();
 595                 (name, offset, end)
 596             }
 597         };
 598
 599         let id = id_from_def_id(res.def_id());
 600         Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
 601     }
 602 }
 603
 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()));
 609         }
 610
 611         let mut text = "<".to_owned();
 612
 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 ");
 618             }
 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(),
 624             });
 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));
 631                 }
 632             }
 633             if !param.bounds.is_empty() {
 634                 param_text.push_str(": ");
 635                 match param.kind {
 636                     hir::GenericParamKind::Lifetime { .. } => {
 637                         let bounds = param
 638                             .bounds
 639                             .iter()
 640                             .map(|bound| match bound {
 641                                 hir::GenericBound::Outlives(lt) => lt.name.ident().to_string(),
 642                                 _ => panic!(),
 643                             })
 644                             .collect::<Vec<_>>()
 645                             .join(" + ");
 646                         param_text.push_str(&bounds);
 647                         // FIXME add lifetime bounds refs.
 648                     }
 649                     hir::GenericParamKind::Type { .. } => {
 650                         param_text.push_str(&bounds_to_string(param.bounds));
 651                         // FIXME descend properly into bounds.
 652                     }
 653                     hir::GenericParamKind::Const { .. } => {
 654                         // Const generics cannot contain bounds.
 655                     }
 656                 }
 657             }
 658             text.push_str(&param_text);
 659             text.push(',');
 660         }
 661
 662         text.push('>');
 663         Ok(Signature { text, defs, refs: vec![] })
 664     }
 665 }
 666
 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();
 670
 671         text.push_str(&self.ident.to_string());
 672         let defs = Some(SigElement {
 673             id: id_from_hir_id(self.hir_id, scx),
 674             start: offset,
 675             end: offset + text.len(),
 676         });
 677         text.push_str(": ");
 678
 679         let mut ty_sig = self.ty.make(offset + text.len(), Some(self.hir_id), scx)?;
 680         text.push_str(&ty_sig.text);
 681         ty_sig.text = text;
 682         ty_sig.defs.extend(defs.into_iter());
 683         Ok(ty_sig)
 684     }
 685 }
 686
 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();
 690         match self.data {
 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),
 695                     start: offset,
 696                     end: offset + text.len(),
 697                 };
 698                 text.push_str(" { ");
 699                 let mut defs = vec![name_def];
 700                 let mut refs = vec![];
 701                 if r {
 702                     text.push_str("/* parse error */ ");
 703                 } else {
 704                     for f in fields {
 705                         let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 706                         text.push_str(&field_sig.text);
 707                         text.push_str(", ");
 708                         defs.extend(field_sig.defs.into_iter());
 709                         refs.extend(field_sig.refs.into_iter());
 710                     }
 711                 }
 712                 text.push('}');
 713                 Ok(Signature { text, defs, refs })
 714             }
 715             hir::VariantData::Tuple(fields, id) => {
 716                 let name_def = SigElement {
 717                     id: id_from_hir_id(id, scx),
 718                     start: offset,
 719                     end: offset + text.len(),
 720                 };
 721                 text.push('(');
 722                 let mut defs = vec![name_def];
 723                 let mut refs = vec![];
 724                 for f in fields {
 725                     let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 726                     text.push_str(&field_sig.text);
 727                     text.push_str(", ");
 728                     defs.extend(field_sig.defs.into_iter());
 729                     refs.extend(field_sig.refs.into_iter());
 730                 }
 731                 text.push(')');
 732                 Ok(Signature { text, defs, refs })
 733             }
 734             hir::VariantData::Unit(id) => {
 735                 let name_def = SigElement {
 736                     id: id_from_hir_id(id, scx),
 737                     start: offset,
 738                     end: offset + text.len(),
 739                 };
 740                 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
 741             }
 742         }
 743     }
 744 }
 745
 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());
 749         match self.kind {
 750             hir::ForeignItemKind::Fn(decl, _, ref generics) => {
 751                 let mut text = String::new();
 752                 text.push_str("fn ");
 753
 754                 let mut sig =
 755                     name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?;
 756
 757                 sig.text.push('(');
 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);
 762                     sig.text.push(',');
 763                     sig.defs.extend(nested.defs.into_iter());
 764                     sig.refs.extend(nested.refs.into_iter());
 765                 }
 766                 sig.text.push(')');
 767
 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());
 774                 }
 775                 sig.text.push(';');
 776
 777                 Ok(sig)
 778             }
 779             hir::ForeignItemKind::Static(ref ty, m) => {
 780                 let mut text = "static ".to_owned();
 781                 if m == Mutability::Mut {
 782                     text.push_str("mut ");
 783                 }
 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(),
 789                 }];
 790                 text.push_str(&name);
 791                 text.push_str(": ");
 792
 793                 let ty_sig = ty.make(offset + text.len(), id, scx)?;
 794                 text.push(';');
 795
 796                 Ok(extend_sig(ty_sig, text, defs, vec![]))
 797             }
 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(),
 805                 }];
 806                 text.push_str(&name);
 807                 text.push(';');
 808
 809                 Ok(Signature { text, defs, refs: vec![] })
 810             }
 811         }
 812     }
 813 }
 814
 815 fn name_and_generics(
 816     mut text: String,
 817     offset: usize,
 818     generics: &hir::Generics<'_>,
 819     id: hir::HirId,
 820     name: Ident,
 821     scx: &SaveContext<'_>,
 822 ) -> Result {
 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(),
 828     };
 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![]))
 834 }
 835
 836 fn make_assoc_type_signature(
 837     id: hir::HirId,
 838     ident: Ident,
 839     bounds: Option<hir::GenericBounds<'_>>,
 840     default: Option<&hir::Ty<'_>>,
 841     scx: &SaveContext<'_>,
 842 ) -> Result {
 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),
 847         start: text.len(),
 848         end: text.len() + name.len(),
 849     }];
 850     let mut refs = vec![];
 851     text.push_str(&name);
 852     if let Some(bounds) = bounds {
 853         text.push_str(": ");
 854         // FIXME should descend into bounds
 855         text.push_str(&bounds_to_string(bounds));
 856     }
 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());
 863     }
 864     text.push(';');
 865     Ok(Signature { text, defs, refs })
 866 }
 867
 868 fn make_assoc_const_signature(
 869     id: hir::HirId,
 870     ident: Symbol,
 871     ty: &hir::Ty<'_>,
 872     default: Option<&hir::Expr<'_>>,
 873     scx: &SaveContext<'_>,
 874 ) -> Result {
 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),
 879         start: text.len(),
 880         end: text.len() + name.len(),
 881     }];
 882     let mut refs = vec![];
 883     text.push_str(&name);
 884     text.push_str(": ");
 885
 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());
 890
 891     if let Some(default) = default {
 892         text.push_str(" = ");
 893         text.push_str(&id_to_string(&scx.tcx.hir(), default.hir_id));
 894     }
 895     text.push(';');
 896     Ok(Signature { text, defs, refs })
 897 }
 898
 899 fn make_method_signature(
 900     id: hir::HirId,
 901     ident: Ident,
 902     generics: &hir::Generics<'_>,
 903     m: &hir::FnSig<'_>,
 904     scx: &SaveContext<'_>,
 905 ) -> Result {
 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 ");
 910     }
 911     if hir::IsAsync::Async == m.header.asyncness {
 912         text.push_str("async ");
 913     }
 914     if let hir::Unsafety::Unsafe = m.header.unsafety {
 915         text.push_str("unsafe ");
 916     }
 917     text.push_str("fn ");
 918
 919     let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
 920
 921     sig.text.push('(');
 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);
 926         sig.text.push(',');
 927         sig.defs.extend(nested.defs.into_iter());
 928         sig.refs.extend(nested.refs.into_iter());
 929     }
 930     sig.text.push(')');
 931
 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());
 938     }
 939     sig.text.push_str(" {}");
 940
 941     Ok(sig)
 942 }