src/librustc_save_analysis/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 ommission (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_node_id, SaveContext};
  29
  30 use rls_data::{SigElement, Signature};
  31
  32 use rustc_ast_pretty::pprust;
  33 use rustc_hir::def::{DefKind, Res};
  34 use syntax::ast::{self, Extern, NodeId};
  35
  36 pub fn item_signature(item: &ast::Item, scx: &SaveContext<'_, '_>) -> Option<Signature> {
  37     if !scx.config.signatures {
  38         return None;
  39     }
  40     item.make(0, None, scx).ok()
  41 }
  42
  43 pub fn foreign_item_signature(
  44     item: &ast::ForeignItem,
  45     scx: &SaveContext<'_, '_>,
  46 ) -> Option<Signature> {
  47     if !scx.config.signatures {
  48         return None;
  49     }
  50     item.make(0, None, scx).ok()
  51 }
  52
  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 {
  57         return None;
  58     }
  59     field.make(0, None, scx).ok()
  60 }
  61
  62 /// Does not include a trailing comma.
  63 pub fn variant_signature(variant: &ast::Variant, scx: &SaveContext<'_, '_>) -> Option<Signature> {
  64     if !scx.config.signatures {
  65         return None;
  66     }
  67     variant.make(0, None, scx).ok()
  68 }
  69
  70 pub fn method_signature(
  71     id: NodeId,
  72     ident: ast::Ident,
  73     generics: &ast::Generics,
  74     m: &ast::FnSig,
  75     scx: &SaveContext<'_, '_>,
  76 ) -> Option<Signature> {
  77     if !scx.config.signatures {
  78         return None;
  79     }
  80     make_method_signature(id, ident, generics, m, scx).ok()
  81 }
  82
  83 pub fn assoc_const_signature(
  84     id: NodeId,
  85     ident: ast::Name,
  86     ty: &ast::Ty,
  87     default: Option<&ast::Expr>,
  88     scx: &SaveContext<'_, '_>,
  89 ) -> Option<Signature> {
  90     if !scx.config.signatures {
  91         return None;
  92     }
  93     make_assoc_const_signature(id, ident, ty, default, scx).ok()
  94 }
  95
  96 pub fn assoc_type_signature(
  97     id: NodeId,
  98     ident: ast::Ident,
  99     bounds: Option<&ast::GenericBounds>,
 100     default: Option<&ast::Ty>,
 101     scx: &SaveContext<'_, '_>,
 102 ) -> Option<Signature> {
 103     if !scx.config.signatures {
 104         return None;
 105     }
 106     make_assoc_type_signature(id, ident, bounds, default, scx).ok()
 107 }
 108
 109 type Result = std::result::Result<Signature, &'static str>;
 110
 111 trait Sig {
 112     fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result;
 113 }
 114
 115 fn extend_sig(
 116     mut sig: Signature,
 117     text: String,
 118     defs: Vec<SigElement>,
 119     refs: Vec<SigElement>,
 120 ) -> Signature {
 121     sig.text = text;
 122     sig.defs.extend(defs.into_iter());
 123     sig.refs.extend(refs.into_iter());
 124     sig
 125 }
 126
 127 fn replace_text(mut sig: Signature, text: String) -> Signature {
 128     sig.text = text;
 129     sig
 130 }
 131
 132 fn merge_sigs(text: String, sigs: Vec<Signature>) -> Signature {
 133     let mut result = Signature { text, defs: vec![], refs: vec![] };
 134
 135     let (defs, refs): (Vec<_>, Vec<_>) = sigs.into_iter().map(|s| (s.defs, s.refs)).unzip();
 136
 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()));
 139
 140     result
 141 }
 142
 143 fn text_sig(text: String) -> Signature {
 144     Signature { text, defs: vec![], refs: vec![] }
 145 }
 146
 147 fn push_extern(text: &mut String, ext: Extern) {
 148     match ext {
 149         Extern::None => {}
 150         Extern::Implicit => text.push_str("extern "),
 151         Extern::Explicit(abi) => text.push_str(&format!("extern \"{}\" ", abi.symbol)),
 152     }
 153 }
 154
 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);
 158         match self.kind {
 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))
 163             }
 164             ast::TyKind::Ptr(ref mt) => {
 165                 let prefix = match mt.mutbl {
 166                     ast::Mutability::Mut => "*mut ",
 167                     ast::Mutability::Not => "*const ",
 168                 };
 169                 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
 170                 let text = format!("{}{}", prefix, nested.text);
 171                 Ok(replace_text(nested, text))
 172             }
 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());
 177                     prefix.push(' ');
 178                 }
 179                 if let ast::Mutability::Mut = mt.mutbl {
 180                     prefix.push_str("mut ");
 181                 };
 182
 183                 let nested = mt.ty.make(offset + prefix.len(), id, scx)?;
 184                 let text = format!("{}{}", prefix, nested.text);
 185                 Ok(replace_text(nested, text))
 186             }
 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![];
 193                 for t in ts {
 194                     let nested = t.make(offset + text.len(), id, scx)?;
 195                     text.push_str(&nested.text);
 196                     text.push(',');
 197                     defs.extend(nested.defs.into_iter());
 198                     refs.extend(nested.refs.into_iter());
 199                 }
 200                 text.push(')');
 201                 Ok(Signature { text, defs, refs })
 202             }
 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))
 207             }
 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<");
 213                     text.push_str(
 214                         &f.generic_params
 215                             .iter()
 216                             .filter_map(|param| match param.kind {
 217                                 ast::GenericParamKind::Lifetime { .. } => {
 218                                     Some(param.ident.to_string())
 219                                 }
 220                                 _ => None,
 221                             })
 222                             .collect::<Vec<_>>()
 223                             .join(", "),
 224                     );
 225                     text.push('>');
 226                 }
 227
 228                 if let ast::Unsafe::Yes(_) = f.unsafety {
 229                     text.push_str("unsafe ");
 230                 }
 231                 push_extern(&mut text, f.ext);
 232                 text.push_str("fn(");
 233
 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);
 239                     text.push(',');
 240                     defs.extend(nested.defs.into_iter());
 241                     refs.extend(nested.refs.into_iter());
 242                 }
 243                 text.push(')');
 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);
 248                     text.push(',');
 249                     defs.extend(nested.defs.into_iter());
 250                     refs.extend(nested.refs.into_iter());
 251                 }
 252
 253                 Ok(Signature { text, defs, refs })
 254             }
 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)
 263                 } else {
 264                     // FIXME handle path instead of elipses.
 265                     format!("<{} as ...>::", nested_ty.text)
 266                 };
 267
 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();
 274
 275                     Ok(Signature {
 276                         text: prefix + &name,
 277                         defs: vec![],
 278                         refs: vec![SigElement { id, start, end }],
 279                     })
 280                 } else {
 281                     let start = offset + prefix.len() + 5;
 282                     let end = start + name.len();
 283                     // FIXME should put the proper path in there, not elipses.
 284                     Ok(Signature {
 285                         text: prefix + "...::" + &name,
 286                         defs: vec![],
 287                         refs: vec![SigElement { id, start, end }],
 288                     })
 289                 }
 290             }
 291             ast::TyKind::TraitObject(ref bounds, ..) => {
 292                 // FIXME recurse into bounds
 293                 let nested = pprust::bounds_to_string(bounds);
 294                 Ok(text_sig(nested))
 295             }
 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)))
 300             }
 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))
 306             }
 307             ast::TyKind::Typeof(_)
 308             | ast::TyKind::Infer
 309             | ast::TyKind::Err
 310             | ast::TyKind::ImplicitSelf
 311             | ast::TyKind::Mac(_) => Err("Ty"),
 312         }
 313     }
 314 }
 315
 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);
 319
 320         match self.kind {
 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 ");
 325                 }
 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(),
 331                 }];
 332                 text.push_str(&name);
 333                 text.push_str(": ");
 334
 335                 let ty = ty.make(offset + text.len(), id, scx)?;
 336                 text.push_str(&ty.text);
 337
 338                 if let Some(expr) = expr {
 339                     text.push_str(" = ");
 340                     let expr = pprust::expr_to_string(expr).replace('\n', " ");
 341                     text.push_str(&expr);
 342                 }
 343
 344                 text.push(';');
 345
 346                 Ok(extend_sig(ty, text, defs, vec![]))
 347             }
 348             ast::ItemKind::Const(ref ty, ref expr) => {
 349                 let mut text = "const ".to_owned();
 350                 let name = self.ident.to_string();
 351                 let defs = vec![SigElement {
 352                     id: id_from_node_id(self.id, scx),
 353                     start: offset + text.len(),
 354                     end: offset + text.len() + name.len(),
 355                 }];
 356                 text.push_str(&name);
 357                 text.push_str(": ");
 358
 359                 let ty = ty.make(offset + text.len(), id, scx)?;
 360                 text.push_str(&ty.text);
 361
 362                 if let Some(expr) = expr {
 363                     text.push_str(" = ");
 364                     let expr = pprust::expr_to_string(expr).replace('\n', " ");
 365                     text.push_str(&expr);
 366                 }
 367
 368                 text.push(';');
 369
 370                 Ok(extend_sig(ty, text, defs, vec![]))
 371             }
 372             ast::ItemKind::Fn(ast::FnSig { ref decl, header }, ref generics, _) => {
 373                 let mut text = String::new();
 374                 if let ast::Const::Yes(_) = header.constness {
 375                     text.push_str("const ");
 376                 }
 377                 if header.asyncness.is_async() {
 378                     text.push_str("async ");
 379                 }
 380                 if let ast::Unsafe::Yes(_) = header.unsafety {
 381                     text.push_str("unsafe ");
 382                 }
 383                 push_extern(&mut text, header.ext);
 384                 text.push_str("fn ");
 385
 386                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 387
 388                 sig.text.push('(');
 389                 for i in &decl.inputs {
 390                     // FIXME should descend into patterns to add defs.
 391                     sig.text.push_str(&pprust::pat_to_string(&i.pat));
 392                     sig.text.push_str(": ");
 393                     let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
 394                     sig.text.push_str(&nested.text);
 395                     sig.text.push(',');
 396                     sig.defs.extend(nested.defs.into_iter());
 397                     sig.refs.extend(nested.refs.into_iter());
 398                 }
 399                 sig.text.push(')');
 400
 401                 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
 402                     sig.text.push_str(" -> ");
 403                     let nested = t.make(offset + sig.text.len(), None, scx)?;
 404                     sig.text.push_str(&nested.text);
 405                     sig.defs.extend(nested.defs.into_iter());
 406                     sig.refs.extend(nested.refs.into_iter());
 407                 }
 408                 sig.text.push_str(" {}");
 409
 410                 Ok(sig)
 411             }
 412             ast::ItemKind::Mod(ref _mod) => {
 413                 let mut text = "mod ".to_owned();
 414                 let name = self.ident.to_string();
 415                 let defs = vec![SigElement {
 416                     id: id_from_node_id(self.id, scx),
 417                     start: offset + text.len(),
 418                     end: offset + text.len() + name.len(),
 419                 }];
 420                 text.push_str(&name);
 421                 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
 422                 text.push(';');
 423
 424                 Ok(Signature { text, defs, refs: vec![] })
 425             }
 426             ast::ItemKind::TyAlias(ref ty, ref generics) => {
 427                 let text = "type ".to_owned();
 428                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 429
 430                 sig.text.push_str(" = ");
 431                 let ty = ty.make(offset + sig.text.len(), id, scx)?;
 432                 sig.text.push_str(&ty.text);
 433                 sig.text.push(';');
 434
 435                 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
 436             }
 437             ast::ItemKind::Enum(_, ref generics) => {
 438                 let text = "enum ".to_owned();
 439                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 440                 sig.text.push_str(" {}");
 441                 Ok(sig)
 442             }
 443             ast::ItemKind::Struct(_, ref generics) => {
 444                 let text = "struct ".to_owned();
 445                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 446                 sig.text.push_str(" {}");
 447                 Ok(sig)
 448             }
 449             ast::ItemKind::Union(_, ref generics) => {
 450                 let text = "union ".to_owned();
 451                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 452                 sig.text.push_str(" {}");
 453                 Ok(sig)
 454             }
 455             ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, _) => {
 456                 let mut text = String::new();
 457
 458                 if is_auto == ast::IsAuto::Yes {
 459                     text.push_str("auto ");
 460                 }
 461
 462                 if let ast::Unsafe::Yes(_) = unsafety {
 463                     text.push_str("unsafe ");
 464                 }
 465                 text.push_str("trait ");
 466                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 467
 468                 if !bounds.is_empty() {
 469                     sig.text.push_str(": ");
 470                     sig.text.push_str(&pprust::bounds_to_string(bounds));
 471                 }
 472                 // FIXME where clause
 473                 sig.text.push_str(" {}");
 474
 475                 Ok(sig)
 476             }
 477             ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
 478                 let mut text = String::new();
 479                 text.push_str("trait ");
 480                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 481
 482                 if !bounds.is_empty() {
 483                     sig.text.push_str(" = ");
 484                     sig.text.push_str(&pprust::bounds_to_string(bounds));
 485                 }
 486                 // FIXME where clause
 487                 sig.text.push_str(";");
 488
 489                 Ok(sig)
 490             }
 491             ast::ItemKind::Impl {
 492                 unsafety,
 493                 polarity,
 494                 defaultness,
 495                 constness,
 496                 ref generics,
 497                 ref of_trait,
 498                 ref self_ty,
 499                 items: _,
 500             } => {
 501                 let mut text = String::new();
 502                 if let ast::Defaultness::Default = defaultness {
 503                     text.push_str("default ");
 504                 }
 505                 if let ast::Unsafe::Yes(_) = unsafety {
 506                     text.push_str("unsafe ");
 507                 }
 508                 text.push_str("impl");
 509                 if let ast::Const::Yes(_) = constness {
 510                     text.push_str(" const");
 511                 }
 512
 513                 let generics_sig = generics.make(offset + text.len(), id, scx)?;
 514                 text.push_str(&generics_sig.text);
 515
 516                 text.push(' ');
 517
 518                 let trait_sig = if let Some(ref t) = *of_trait {
 519                     if polarity == ast::ImplPolarity::Negative {
 520                         text.push('!');
 521                     }
 522                     let trait_sig = t.path.make(offset + text.len(), id, scx)?;
 523                     text.push_str(&trait_sig.text);
 524                     text.push_str(" for ");
 525                     trait_sig
 526                 } else {
 527                     text_sig(String::new())
 528                 };
 529
 530                 let ty_sig = self_ty.make(offset + text.len(), id, scx)?;
 531                 text.push_str(&ty_sig.text);
 532
 533                 text.push_str(" {}");
 534
 535                 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
 536
 537                 // FIXME where clause
 538             }
 539             ast::ItemKind::ForeignMod(_) => Err("extern mod"),
 540             ast::ItemKind::GlobalAsm(_) => Err("glboal asm"),
 541             ast::ItemKind::ExternCrate(_) => Err("extern crate"),
 542             // FIXME should implement this (e.g., pub use).
 543             ast::ItemKind::Use(_) => Err("import"),
 544             ast::ItemKind::Mac(..) | ast::ItemKind::MacroDef(_) => Err("Macro"),
 545         }
 546     }
 547 }
 548
 549 impl Sig for ast::Path {
 550     fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 551         let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
 552
 553         let (name, start, end) = match res {
 554             Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => {
 555                 return Ok(Signature {
 556                     text: pprust::path_to_string(self),
 557                     defs: vec![],
 558                     refs: vec![],
 559                 });
 560             }
 561             Res::Def(DefKind::AssocConst, _)
 562             | Res::Def(DefKind::Variant, _)
 563             | Res::Def(DefKind::Ctor(..), _) => {
 564                 let len = self.segments.len();
 565                 if len < 2 {
 566                     return Err("Bad path");
 567                 }
 568                 // FIXME: really we should descend into the generics here and add SigElements for
 569                 // them.
 570                 // FIXME: would be nice to have a def for the first path segment.
 571                 let seg1 = pprust::path_segment_to_string(&self.segments[len - 2]);
 572                 let seg2 = pprust::path_segment_to_string(&self.segments[len - 1]);
 573                 let start = offset + seg1.len() + 2;
 574                 (format!("{}::{}", seg1, seg2), start, start + seg2.len())
 575             }
 576             _ => {
 577                 let name = pprust::path_segment_to_string(self.segments.last().ok_or("Bad path")?);
 578                 let end = offset + name.len();
 579                 (name, offset, end)
 580             }
 581         };
 582
 583         let id = id_from_def_id(res.def_id());
 584         Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
 585     }
 586 }
 587
 588 // This does not cover the where clause, which must be processed separately.
 589 impl Sig for ast::Generics {
 590     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 591         if self.params.is_empty() {
 592             return Ok(text_sig(String::new()));
 593         }
 594
 595         let mut text = "<".to_owned();
 596
 597         let mut defs = Vec::with_capacity(self.params.len());
 598         for param in &self.params {
 599             let mut param_text = String::new();
 600             if let ast::GenericParamKind::Const { .. } = param.kind {
 601                 param_text.push_str("const ");
 602             }
 603             param_text.push_str(&param.ident.as_str());
 604             defs.push(SigElement {
 605                 id: id_from_node_id(param.id, scx),
 606                 start: offset + text.len(),
 607                 end: offset + text.len() + param_text.as_str().len(),
 608             });
 609             if let ast::GenericParamKind::Const { ref ty } = param.kind {
 610                 param_text.push_str(": ");
 611                 param_text.push_str(&pprust::ty_to_string(&ty));
 612             }
 613             if !param.bounds.is_empty() {
 614                 param_text.push_str(": ");
 615                 match param.kind {
 616                     ast::GenericParamKind::Lifetime { .. } => {
 617                         let bounds = param
 618                             .bounds
 619                             .iter()
 620                             .map(|bound| match bound {
 621                                 ast::GenericBound::Outlives(lt) => lt.ident.to_string(),
 622                                 _ => panic!(),
 623                             })
 624                             .collect::<Vec<_>>()
 625                             .join(" + ");
 626                         param_text.push_str(&bounds);
 627                         // FIXME add lifetime bounds refs.
 628                     }
 629                     ast::GenericParamKind::Type { .. } => {
 630                         param_text.push_str(&pprust::bounds_to_string(&param.bounds));
 631                         // FIXME descend properly into bounds.
 632                     }
 633                     ast::GenericParamKind::Const { .. } => {
 634                         // Const generics cannot contain bounds.
 635                     }
 636                 }
 637             }
 638             text.push_str(&param_text);
 639             text.push(',');
 640         }
 641
 642         text.push('>');
 643         Ok(Signature { text, defs, refs: vec![] })
 644     }
 645 }
 646
 647 impl Sig for ast::StructField {
 648     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 649         let mut text = String::new();
 650         let mut defs = None;
 651         if let Some(ident) = self.ident {
 652             text.push_str(&ident.to_string());
 653             defs = Some(SigElement {
 654                 id: id_from_node_id(self.id, scx),
 655                 start: offset,
 656                 end: offset + text.len(),
 657             });
 658             text.push_str(": ");
 659         }
 660
 661         let mut ty_sig = self.ty.make(offset + text.len(), Some(self.id), scx)?;
 662         text.push_str(&ty_sig.text);
 663         ty_sig.text = text;
 664         ty_sig.defs.extend(defs.into_iter());
 665         Ok(ty_sig)
 666     }
 667 }
 668
 669 impl Sig for ast::Variant {
 670     fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 671         let mut text = self.ident.to_string();
 672         match self.data {
 673             ast::VariantData::Struct(ref fields, r) => {
 674                 let id = parent_id.unwrap();
 675                 let name_def = SigElement {
 676                     id: id_from_node_id(id, scx),
 677                     start: offset,
 678                     end: offset + text.len(),
 679                 };
 680                 text.push_str(" { ");
 681                 let mut defs = vec![name_def];
 682                 let mut refs = vec![];
 683                 if r {
 684                     text.push_str("/* parse error */ ");
 685                 } else {
 686                     for f in fields {
 687                         let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 688                         text.push_str(&field_sig.text);
 689                         text.push_str(", ");
 690                         defs.extend(field_sig.defs.into_iter());
 691                         refs.extend(field_sig.refs.into_iter());
 692                     }
 693                 }
 694                 text.push('}');
 695                 Ok(Signature { text, defs, refs })
 696             }
 697             ast::VariantData::Tuple(ref fields, id) => {
 698                 let name_def = SigElement {
 699                     id: id_from_node_id(id, scx),
 700                     start: offset,
 701                     end: offset + text.len(),
 702                 };
 703                 text.push('(');
 704                 let mut defs = vec![name_def];
 705                 let mut refs = vec![];
 706                 for f in fields {
 707                     let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 708                     text.push_str(&field_sig.text);
 709                     text.push_str(", ");
 710                     defs.extend(field_sig.defs.into_iter());
 711                     refs.extend(field_sig.refs.into_iter());
 712                 }
 713                 text.push(')');
 714                 Ok(Signature { text, defs, refs })
 715             }
 716             ast::VariantData::Unit(id) => {
 717                 let name_def = SigElement {
 718                     id: id_from_node_id(id, scx),
 719                     start: offset,
 720                     end: offset + text.len(),
 721                 };
 722                 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
 723             }
 724         }
 725     }
 726 }
 727
 728 impl Sig for ast::ForeignItem {
 729     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 730         let id = Some(self.id);
 731         match self.kind {
 732             ast::ForeignItemKind::Fn(ref sig, ref generics, _) => {
 733                 let decl = &sig.decl;
 734                 let mut text = String::new();
 735                 text.push_str("fn ");
 736
 737                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 738
 739                 sig.text.push('(');
 740                 for i in &decl.inputs {
 741                     // FIXME should descend into patterns to add defs.
 742                     sig.text.push_str(&pprust::pat_to_string(&i.pat));
 743                     sig.text.push_str(": ");
 744                     let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
 745                     sig.text.push_str(&nested.text);
 746                     sig.text.push(',');
 747                     sig.defs.extend(nested.defs.into_iter());
 748                     sig.refs.extend(nested.refs.into_iter());
 749                 }
 750                 sig.text.push(')');
 751
 752                 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
 753                     sig.text.push_str(" -> ");
 754                     let nested = t.make(offset + sig.text.len(), None, scx)?;
 755                     sig.text.push_str(&nested.text);
 756                     sig.defs.extend(nested.defs.into_iter());
 757                     sig.refs.extend(nested.refs.into_iter());
 758                 }
 759                 sig.text.push(';');
 760
 761                 Ok(sig)
 762             }
 763             ast::ForeignItemKind::Static(ref ty, m, _) => {
 764                 let mut text = "static ".to_owned();
 765                 if m == ast::Mutability::Mut {
 766                     text.push_str("mut ");
 767                 }
 768                 let name = self.ident.to_string();
 769                 let defs = vec![SigElement {
 770                     id: id_from_node_id(self.id, scx),
 771                     start: offset + text.len(),
 772                     end: offset + text.len() + name.len(),
 773                 }];
 774                 text.push_str(&name);
 775                 text.push_str(": ");
 776
 777                 let ty_sig = ty.make(offset + text.len(), id, scx)?;
 778                 text.push(';');
 779
 780                 Ok(extend_sig(ty_sig, text, defs, vec![]))
 781             }
 782             ast::ForeignItemKind::TyAlias(..) => {
 783                 let mut text = "type ".to_owned();
 784                 let name = self.ident.to_string();
 785                 let defs = vec![SigElement {
 786                     id: id_from_node_id(self.id, scx),
 787                     start: offset + text.len(),
 788                     end: offset + text.len() + name.len(),
 789                 }];
 790                 text.push_str(&name);
 791                 text.push(';');
 792
 793                 Ok(Signature { text: text, defs: defs, refs: vec![] })
 794             }
 795             ast::ForeignItemKind::Const(..) => Err("foreign const"),
 796             ast::ForeignItemKind::Macro(..) => Err("macro"),
 797         }
 798     }
 799 }
 800
 801 fn name_and_generics(
 802     mut text: String,
 803     offset: usize,
 804     generics: &ast::Generics,
 805     id: NodeId,
 806     name: ast::Ident,
 807     scx: &SaveContext<'_, '_>,
 808 ) -> Result {
 809     let name = name.to_string();
 810     let def = SigElement {
 811         id: id_from_node_id(id, scx),
 812         start: offset + text.len(),
 813         end: offset + text.len() + name.len(),
 814     };
 815     text.push_str(&name);
 816     let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?;
 817     // FIXME where clause
 818     let text = format!("{}{}", text, generics.text);
 819     Ok(extend_sig(generics, text, vec![def], vec![]))
 820 }
 821
 822 fn make_assoc_type_signature(
 823     id: NodeId,
 824     ident: ast::Ident,
 825     bounds: Option<&ast::GenericBounds>,
 826     default: Option<&ast::Ty>,
 827     scx: &SaveContext<'_, '_>,
 828 ) -> Result {
 829     let mut text = "type ".to_owned();
 830     let name = ident.to_string();
 831     let mut defs = vec![SigElement {
 832         id: id_from_node_id(id, scx),
 833         start: text.len(),
 834         end: text.len() + name.len(),
 835     }];
 836     let mut refs = vec![];
 837     text.push_str(&name);
 838     if let Some(bounds) = bounds {
 839         text.push_str(": ");
 840         // FIXME should descend into bounds
 841         text.push_str(&pprust::bounds_to_string(bounds));
 842     }
 843     if let Some(default) = default {
 844         text.push_str(" = ");
 845         let ty_sig = default.make(text.len(), Some(id), scx)?;
 846         text.push_str(&ty_sig.text);
 847         defs.extend(ty_sig.defs.into_iter());
 848         refs.extend(ty_sig.refs.into_iter());
 849     }
 850     text.push(';');
 851     Ok(Signature { text, defs, refs })
 852 }
 853
 854 fn make_assoc_const_signature(
 855     id: NodeId,
 856     ident: ast::Name,
 857     ty: &ast::Ty,
 858     default: Option<&ast::Expr>,
 859     scx: &SaveContext<'_, '_>,
 860 ) -> Result {
 861     let mut text = "const ".to_owned();
 862     let name = ident.to_string();
 863     let mut defs = vec![SigElement {
 864         id: id_from_node_id(id, scx),
 865         start: text.len(),
 866         end: text.len() + name.len(),
 867     }];
 868     let mut refs = vec![];
 869     text.push_str(&name);
 870     text.push_str(": ");
 871
 872     let ty_sig = ty.make(text.len(), Some(id), scx)?;
 873     text.push_str(&ty_sig.text);
 874     defs.extend(ty_sig.defs.into_iter());
 875     refs.extend(ty_sig.refs.into_iter());
 876
 877     if let Some(default) = default {
 878         text.push_str(" = ");
 879         text.push_str(&pprust::expr_to_string(default));
 880     }
 881     text.push(';');
 882     Ok(Signature { text, defs, refs })
 883 }
 884
 885 fn make_method_signature(
 886     id: NodeId,
 887     ident: ast::Ident,
 888     generics: &ast::Generics,
 889     m: &ast::FnSig,
 890     scx: &SaveContext<'_, '_>,
 891 ) -> Result {
 892     // FIXME code dup with function signature
 893     let mut text = String::new();
 894     if let ast::Const::Yes(_) = m.header.constness {
 895         text.push_str("const ");
 896     }
 897     if m.header.asyncness.is_async() {
 898         text.push_str("async ");
 899     }
 900     if let ast::Unsafe::Yes(_) = m.header.unsafety {
 901         text.push_str("unsafe ");
 902     }
 903     push_extern(&mut text, m.header.ext);
 904     text.push_str("fn ");
 905
 906     let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
 907
 908     sig.text.push('(');
 909     for i in &m.decl.inputs {
 910         // FIXME should descend into patterns to add defs.
 911         sig.text.push_str(&pprust::pat_to_string(&i.pat));
 912         sig.text.push_str(": ");
 913         let nested = i.ty.make(sig.text.len(), Some(i.id), scx)?;
 914         sig.text.push_str(&nested.text);
 915         sig.text.push(',');
 916         sig.defs.extend(nested.defs.into_iter());
 917         sig.refs.extend(nested.refs.into_iter());
 918     }
 919     sig.text.push(')');
 920
 921     if let ast::FunctionRetTy::Ty(ref t) = m.decl.output {
 922         sig.text.push_str(" -> ");
 923         let nested = t.make(sig.text.len(), None, scx)?;
 924         sig.text.push_str(&nested.text);
 925         sig.defs.extend(nested.defs.into_iter());
 926         sig.refs.extend(nested.refs.into_iter());
 927     }
 928     sig.text.push_str(" {}");
 929
 930     Ok(sig)
 931 }