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_hir::def::{DefKind, Res};
  33 use syntax::ast::{self, Extern, NodeId};
  34 use syntax::print::pprust;
  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 f.unsafety == ast::Unsafety::Unsafe {
 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                 text.push_str(" = ");
 338
 339                 let expr = pprust::expr_to_string(expr).replace('\n', " ");
 340                 text.push_str(&expr);
 341                 text.push(';');
 342
 343                 Ok(extend_sig(ty, text, defs, vec![]))
 344             }
 345             ast::ItemKind::Const(ref ty, ref expr) => {
 346                 let mut text = "const ".to_owned();
 347                 let name = self.ident.to_string();
 348                 let defs = vec![SigElement {
 349                     id: id_from_node_id(self.id, scx),
 350                     start: offset + text.len(),
 351                     end: offset + text.len() + name.len(),
 352                 }];
 353                 text.push_str(&name);
 354                 text.push_str(": ");
 355
 356                 let ty = ty.make(offset + text.len(), id, scx)?;
 357                 text.push_str(&ty.text);
 358                 text.push_str(" = ");
 359
 360                 let expr = pprust::expr_to_string(expr).replace('\n', " ");
 361                 text.push_str(&expr);
 362                 text.push(';');
 363
 364                 Ok(extend_sig(ty, text, defs, vec![]))
 365             }
 366             ast::ItemKind::Fn(ast::FnSig { ref decl, header }, ref generics, _) => {
 367                 let mut text = String::new();
 368                 if header.constness.node == ast::Constness::Const {
 369                     text.push_str("const ");
 370                 }
 371                 if header.asyncness.node.is_async() {
 372                     text.push_str("async ");
 373                 }
 374                 if header.unsafety == ast::Unsafety::Unsafe {
 375                     text.push_str("unsafe ");
 376                 }
 377                 push_extern(&mut text, header.ext);
 378                 text.push_str("fn ");
 379
 380                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 381
 382                 sig.text.push('(');
 383                 for i in &decl.inputs {
 384                     // FIXME should descend into patterns to add defs.
 385                     sig.text.push_str(&pprust::pat_to_string(&i.pat));
 386                     sig.text.push_str(": ");
 387                     let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
 388                     sig.text.push_str(&nested.text);
 389                     sig.text.push(',');
 390                     sig.defs.extend(nested.defs.into_iter());
 391                     sig.refs.extend(nested.refs.into_iter());
 392                 }
 393                 sig.text.push(')');
 394
 395                 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
 396                     sig.text.push_str(" -> ");
 397                     let nested = t.make(offset + sig.text.len(), None, scx)?;
 398                     sig.text.push_str(&nested.text);
 399                     sig.defs.extend(nested.defs.into_iter());
 400                     sig.refs.extend(nested.refs.into_iter());
 401                 }
 402                 sig.text.push_str(" {}");
 403
 404                 Ok(sig)
 405             }
 406             ast::ItemKind::Mod(ref _mod) => {
 407                 let mut text = "mod ".to_owned();
 408                 let name = self.ident.to_string();
 409                 let defs = vec![SigElement {
 410                     id: id_from_node_id(self.id, scx),
 411                     start: offset + text.len(),
 412                     end: offset + text.len() + name.len(),
 413                 }];
 414                 text.push_str(&name);
 415                 // Could be either `mod foo;` or `mod foo { ... }`, but we'll just pick one.
 416                 text.push(';');
 417
 418                 Ok(Signature { text, defs, refs: vec![] })
 419             }
 420             ast::ItemKind::TyAlias(ref ty, ref generics) => {
 421                 let text = "type ".to_owned();
 422                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 423
 424                 sig.text.push_str(" = ");
 425                 let ty = ty.make(offset + sig.text.len(), id, scx)?;
 426                 sig.text.push_str(&ty.text);
 427                 sig.text.push(';');
 428
 429                 Ok(merge_sigs(sig.text.clone(), vec![sig, ty]))
 430             }
 431             ast::ItemKind::Enum(_, ref generics) => {
 432                 let text = "enum ".to_owned();
 433                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 434                 sig.text.push_str(" {}");
 435                 Ok(sig)
 436             }
 437             ast::ItemKind::Struct(_, ref generics) => {
 438                 let text = "struct ".to_owned();
 439                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 440                 sig.text.push_str(" {}");
 441                 Ok(sig)
 442             }
 443             ast::ItemKind::Union(_, ref generics) => {
 444                 let text = "union ".to_owned();
 445                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 446                 sig.text.push_str(" {}");
 447                 Ok(sig)
 448             }
 449             ast::ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, _) => {
 450                 let mut text = String::new();
 451
 452                 if is_auto == ast::IsAuto::Yes {
 453                     text.push_str("auto ");
 454                 }
 455
 456                 if unsafety == ast::Unsafety::Unsafe {
 457                     text.push_str("unsafe ");
 458                 }
 459                 text.push_str("trait ");
 460                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 461
 462                 if !bounds.is_empty() {
 463                     sig.text.push_str(": ");
 464                     sig.text.push_str(&pprust::bounds_to_string(bounds));
 465                 }
 466                 // FIXME where clause
 467                 sig.text.push_str(" {}");
 468
 469                 Ok(sig)
 470             }
 471             ast::ItemKind::TraitAlias(ref generics, ref bounds) => {
 472                 let mut text = String::new();
 473                 text.push_str("trait ");
 474                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 475
 476                 if !bounds.is_empty() {
 477                     sig.text.push_str(" = ");
 478                     sig.text.push_str(&pprust::bounds_to_string(bounds));
 479                 }
 480                 // FIXME where clause
 481                 sig.text.push_str(";");
 482
 483                 Ok(sig)
 484             }
 485             ast::ItemKind::Impl {
 486                 unsafety,
 487                 polarity,
 488                 defaultness,
 489                 constness,
 490                 ref generics,
 491                 ref of_trait,
 492                 ref self_ty,
 493                 items: _,
 494             } => {
 495                 let mut text = String::new();
 496                 if let ast::Defaultness::Default = defaultness {
 497                     text.push_str("default ");
 498                 }
 499                 if unsafety == ast::Unsafety::Unsafe {
 500                     text.push_str("unsafe ");
 501                 }
 502                 text.push_str("impl");
 503                 if constness == ast::Constness::Const {
 504                     text.push_str(" const");
 505                 }
 506
 507                 let generics_sig = generics.make(offset + text.len(), id, scx)?;
 508                 text.push_str(&generics_sig.text);
 509
 510                 text.push(' ');
 511
 512                 let trait_sig = if let Some(ref t) = *of_trait {
 513                     if polarity == ast::ImplPolarity::Negative {
 514                         text.push('!');
 515                     }
 516                     let trait_sig = t.path.make(offset + text.len(), id, scx)?;
 517                     text.push_str(&trait_sig.text);
 518                     text.push_str(" for ");
 519                     trait_sig
 520                 } else {
 521                     text_sig(String::new())
 522                 };
 523
 524                 let ty_sig = self_ty.make(offset + text.len(), id, scx)?;
 525                 text.push_str(&ty_sig.text);
 526
 527                 text.push_str(" {}");
 528
 529                 Ok(merge_sigs(text, vec![generics_sig, trait_sig, ty_sig]))
 530
 531                 // FIXME where clause
 532             }
 533             ast::ItemKind::ForeignMod(_) => Err("extern mod"),
 534             ast::ItemKind::GlobalAsm(_) => Err("glboal asm"),
 535             ast::ItemKind::ExternCrate(_) => Err("extern crate"),
 536             // FIXME should implement this (e.g., pub use).
 537             ast::ItemKind::Use(_) => Err("import"),
 538             ast::ItemKind::Mac(..) | ast::ItemKind::MacroDef(_) => Err("Macro"),
 539         }
 540     }
 541 }
 542
 543 impl Sig for ast::Path {
 544     fn make(&self, offset: usize, id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 545         let res = scx.get_path_res(id.ok_or("Missing id for Path")?);
 546
 547         let (name, start, end) = match res {
 548             Res::PrimTy(..) | Res::SelfTy(..) | Res::Err => {
 549                 return Ok(Signature {
 550                     text: pprust::path_to_string(self),
 551                     defs: vec![],
 552                     refs: vec![],
 553                 });
 554             }
 555             Res::Def(DefKind::AssocConst, _)
 556             | Res::Def(DefKind::Variant, _)
 557             | Res::Def(DefKind::Ctor(..), _) => {
 558                 let len = self.segments.len();
 559                 if len < 2 {
 560                     return Err("Bad path");
 561                 }
 562                 // FIXME: really we should descend into the generics here and add SigElements for
 563                 // them.
 564                 // FIXME: would be nice to have a def for the first path segment.
 565                 let seg1 = pprust::path_segment_to_string(&self.segments[len - 2]);
 566                 let seg2 = pprust::path_segment_to_string(&self.segments[len - 1]);
 567                 let start = offset + seg1.len() + 2;
 568                 (format!("{}::{}", seg1, seg2), start, start + seg2.len())
 569             }
 570             _ => {
 571                 let name = pprust::path_segment_to_string(self.segments.last().ok_or("Bad path")?);
 572                 let end = offset + name.len();
 573                 (name, offset, end)
 574             }
 575         };
 576
 577         let id = id_from_def_id(res.def_id());
 578         Ok(Signature { text: name, defs: vec![], refs: vec![SigElement { id, start, end }] })
 579     }
 580 }
 581
 582 // This does not cover the where clause, which must be processed separately.
 583 impl Sig for ast::Generics {
 584     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 585         if self.params.is_empty() {
 586             return Ok(text_sig(String::new()));
 587         }
 588
 589         let mut text = "<".to_owned();
 590
 591         let mut defs = Vec::with_capacity(self.params.len());
 592         for param in &self.params {
 593             let mut param_text = String::new();
 594             if let ast::GenericParamKind::Const { .. } = param.kind {
 595                 param_text.push_str("const ");
 596             }
 597             param_text.push_str(&param.ident.as_str());
 598             defs.push(SigElement {
 599                 id: id_from_node_id(param.id, scx),
 600                 start: offset + text.len(),
 601                 end: offset + text.len() + param_text.as_str().len(),
 602             });
 603             if let ast::GenericParamKind::Const { ref ty } = param.kind {
 604                 param_text.push_str(": ");
 605                 param_text.push_str(&pprust::ty_to_string(&ty));
 606             }
 607             if !param.bounds.is_empty() {
 608                 param_text.push_str(": ");
 609                 match param.kind {
 610                     ast::GenericParamKind::Lifetime { .. } => {
 611                         let bounds = param
 612                             .bounds
 613                             .iter()
 614                             .map(|bound| match bound {
 615                                 ast::GenericBound::Outlives(lt) => lt.ident.to_string(),
 616                                 _ => panic!(),
 617                             })
 618                             .collect::<Vec<_>>()
 619                             .join(" + ");
 620                         param_text.push_str(&bounds);
 621                         // FIXME add lifetime bounds refs.
 622                     }
 623                     ast::GenericParamKind::Type { .. } => {
 624                         param_text.push_str(&pprust::bounds_to_string(&param.bounds));
 625                         // FIXME descend properly into bounds.
 626                     }
 627                     ast::GenericParamKind::Const { .. } => {
 628                         // Const generics cannot contain bounds.
 629                     }
 630                 }
 631             }
 632             text.push_str(&param_text);
 633             text.push(',');
 634         }
 635
 636         text.push('>');
 637         Ok(Signature { text, defs, refs: vec![] })
 638     }
 639 }
 640
 641 impl Sig for ast::StructField {
 642     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 643         let mut text = String::new();
 644         let mut defs = None;
 645         if let Some(ident) = self.ident {
 646             text.push_str(&ident.to_string());
 647             defs = Some(SigElement {
 648                 id: id_from_node_id(self.id, scx),
 649                 start: offset,
 650                 end: offset + text.len(),
 651             });
 652             text.push_str(": ");
 653         }
 654
 655         let mut ty_sig = self.ty.make(offset + text.len(), Some(self.id), scx)?;
 656         text.push_str(&ty_sig.text);
 657         ty_sig.text = text;
 658         ty_sig.defs.extend(defs.into_iter());
 659         Ok(ty_sig)
 660     }
 661 }
 662
 663 impl Sig for ast::Variant {
 664     fn make(&self, offset: usize, parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 665         let mut text = self.ident.to_string();
 666         match self.data {
 667             ast::VariantData::Struct(ref fields, r) => {
 668                 let id = parent_id.unwrap();
 669                 let name_def = SigElement {
 670                     id: id_from_node_id(id, scx),
 671                     start: offset,
 672                     end: offset + text.len(),
 673                 };
 674                 text.push_str(" { ");
 675                 let mut defs = vec![name_def];
 676                 let mut refs = vec![];
 677                 if r {
 678                     text.push_str("/* parse error */ ");
 679                 } else {
 680                     for f in fields {
 681                         let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 682                         text.push_str(&field_sig.text);
 683                         text.push_str(", ");
 684                         defs.extend(field_sig.defs.into_iter());
 685                         refs.extend(field_sig.refs.into_iter());
 686                     }
 687                 }
 688                 text.push('}');
 689                 Ok(Signature { text, defs, refs })
 690             }
 691             ast::VariantData::Tuple(ref fields, id) => {
 692                 let name_def = SigElement {
 693                     id: id_from_node_id(id, scx),
 694                     start: offset,
 695                     end: offset + text.len(),
 696                 };
 697                 text.push('(');
 698                 let mut defs = vec![name_def];
 699                 let mut refs = vec![];
 700                 for f in fields {
 701                     let field_sig = f.make(offset + text.len(), Some(id), scx)?;
 702                     text.push_str(&field_sig.text);
 703                     text.push_str(", ");
 704                     defs.extend(field_sig.defs.into_iter());
 705                     refs.extend(field_sig.refs.into_iter());
 706                 }
 707                 text.push(')');
 708                 Ok(Signature { text, defs, refs })
 709             }
 710             ast::VariantData::Unit(id) => {
 711                 let name_def = SigElement {
 712                     id: id_from_node_id(id, scx),
 713                     start: offset,
 714                     end: offset + text.len(),
 715                 };
 716                 Ok(Signature { text, defs: vec![name_def], refs: vec![] })
 717             }
 718         }
 719     }
 720 }
 721
 722 impl Sig for ast::ForeignItem {
 723     fn make(&self, offset: usize, _parent_id: Option<NodeId>, scx: &SaveContext<'_, '_>) -> Result {
 724         let id = Some(self.id);
 725         match self.kind {
 726             ast::ForeignItemKind::Fn(ref decl, ref generics) => {
 727                 let mut text = String::new();
 728                 text.push_str("fn ");
 729
 730                 let mut sig = name_and_generics(text, offset, generics, self.id, self.ident, scx)?;
 731
 732                 sig.text.push('(');
 733                 for i in &decl.inputs {
 734                     // FIXME should descend into patterns to add defs.
 735                     sig.text.push_str(&pprust::pat_to_string(&i.pat));
 736                     sig.text.push_str(": ");
 737                     let nested = i.ty.make(offset + sig.text.len(), Some(i.id), scx)?;
 738                     sig.text.push_str(&nested.text);
 739                     sig.text.push(',');
 740                     sig.defs.extend(nested.defs.into_iter());
 741                     sig.refs.extend(nested.refs.into_iter());
 742                 }
 743                 sig.text.push(')');
 744
 745                 if let ast::FunctionRetTy::Ty(ref t) = decl.output {
 746                     sig.text.push_str(" -> ");
 747                     let nested = t.make(offset + sig.text.len(), None, scx)?;
 748                     sig.text.push_str(&nested.text);
 749                     sig.defs.extend(nested.defs.into_iter());
 750                     sig.refs.extend(nested.refs.into_iter());
 751                 }
 752                 sig.text.push(';');
 753
 754                 Ok(sig)
 755             }
 756             ast::ForeignItemKind::Static(ref ty, m) => {
 757                 let mut text = "static ".to_owned();
 758                 if m == ast::Mutability::Mut {
 759                     text.push_str("mut ");
 760                 }
 761                 let name = self.ident.to_string();
 762                 let defs = vec![SigElement {
 763                     id: id_from_node_id(self.id, scx),
 764                     start: offset + text.len(),
 765                     end: offset + text.len() + name.len(),
 766                 }];
 767                 text.push_str(&name);
 768                 text.push_str(": ");
 769
 770                 let ty_sig = ty.make(offset + text.len(), id, scx)?;
 771                 text.push(';');
 772
 773                 Ok(extend_sig(ty_sig, text, defs, vec![]))
 774             }
 775             ast::ForeignItemKind::Ty => {
 776                 let mut text = "type ".to_owned();
 777                 let name = self.ident.to_string();
 778                 let defs = vec![SigElement {
 779                     id: id_from_node_id(self.id, scx),
 780                     start: offset + text.len(),
 781                     end: offset + text.len() + name.len(),
 782                 }];
 783                 text.push_str(&name);
 784                 text.push(';');
 785
 786                 Ok(Signature { text: text, defs: defs, refs: vec![] })
 787             }
 788             ast::ForeignItemKind::Macro(..) => Err("macro"),
 789         }
 790     }
 791 }
 792
 793 fn name_and_generics(
 794     mut text: String,
 795     offset: usize,
 796     generics: &ast::Generics,
 797     id: NodeId,
 798     name: ast::Ident,
 799     scx: &SaveContext<'_, '_>,
 800 ) -> Result {
 801     let name = name.to_string();
 802     let def = SigElement {
 803         id: id_from_node_id(id, scx),
 804         start: offset + text.len(),
 805         end: offset + text.len() + name.len(),
 806     };
 807     text.push_str(&name);
 808     let generics: Signature = generics.make(offset + text.len(), Some(id), scx)?;
 809     // FIXME where clause
 810     let text = format!("{}{}", text, generics.text);
 811     Ok(extend_sig(generics, text, vec![def], vec![]))
 812 }
 813
 814 fn make_assoc_type_signature(
 815     id: NodeId,
 816     ident: ast::Ident,
 817     bounds: Option<&ast::GenericBounds>,
 818     default: Option<&ast::Ty>,
 819     scx: &SaveContext<'_, '_>,
 820 ) -> Result {
 821     let mut text = "type ".to_owned();
 822     let name = ident.to_string();
 823     let mut defs = vec![SigElement {
 824         id: id_from_node_id(id, scx),
 825         start: text.len(),
 826         end: text.len() + name.len(),
 827     }];
 828     let mut refs = vec![];
 829     text.push_str(&name);
 830     if let Some(bounds) = bounds {
 831         text.push_str(": ");
 832         // FIXME should descend into bounds
 833         text.push_str(&pprust::bounds_to_string(bounds));
 834     }
 835     if let Some(default) = default {
 836         text.push_str(" = ");
 837         let ty_sig = default.make(text.len(), Some(id), scx)?;
 838         text.push_str(&ty_sig.text);
 839         defs.extend(ty_sig.defs.into_iter());
 840         refs.extend(ty_sig.refs.into_iter());
 841     }
 842     text.push(';');
 843     Ok(Signature { text, defs, refs })
 844 }
 845
 846 fn make_assoc_const_signature(
 847     id: NodeId,
 848     ident: ast::Name,
 849     ty: &ast::Ty,
 850     default: Option<&ast::Expr>,
 851     scx: &SaveContext<'_, '_>,
 852 ) -> Result {
 853     let mut text = "const ".to_owned();
 854     let name = ident.to_string();
 855     let mut defs = vec![SigElement {
 856         id: id_from_node_id(id, scx),
 857         start: text.len(),
 858         end: text.len() + name.len(),
 859     }];
 860     let mut refs = vec![];
 861     text.push_str(&name);
 862     text.push_str(": ");
 863
 864     let ty_sig = ty.make(text.len(), Some(id), scx)?;
 865     text.push_str(&ty_sig.text);
 866     defs.extend(ty_sig.defs.into_iter());
 867     refs.extend(ty_sig.refs.into_iter());
 868
 869     if let Some(default) = default {
 870         text.push_str(" = ");
 871         text.push_str(&pprust::expr_to_string(default));
 872     }
 873     text.push(';');
 874     Ok(Signature { text, defs, refs })
 875 }
 876
 877 fn make_method_signature(
 878     id: NodeId,
 879     ident: ast::Ident,
 880     generics: &ast::Generics,
 881     m: &ast::FnSig,
 882     scx: &SaveContext<'_, '_>,
 883 ) -> Result {
 884     // FIXME code dup with function signature
 885     let mut text = String::new();
 886     if m.header.constness.node == ast::Constness::Const {
 887         text.push_str("const ");
 888     }
 889     if m.header.asyncness.node.is_async() {
 890         text.push_str("async ");
 891     }
 892     if m.header.unsafety == ast::Unsafety::Unsafe {
 893         text.push_str("unsafe ");
 894     }
 895     push_extern(&mut text, m.header.ext);
 896     text.push_str("fn ");
 897
 898     let mut sig = name_and_generics(text, 0, generics, id, ident, scx)?;
 899
 900     sig.text.push('(');
 901     for i in &m.decl.inputs {
 902         // FIXME should descend into patterns to add defs.
 903         sig.text.push_str(&pprust::pat_to_string(&i.pat));
 904         sig.text.push_str(": ");
 905         let nested = i.ty.make(sig.text.len(), Some(i.id), scx)?;
 906         sig.text.push_str(&nested.text);
 907         sig.text.push(',');
 908         sig.defs.extend(nested.defs.into_iter());
 909         sig.refs.extend(nested.refs.into_iter());
 910     }
 911     sig.text.push(')');
 912
 913     if let ast::FunctionRetTy::Ty(ref t) = m.decl.output {
 914         sig.text.push_str(" -> ");
 915         let nested = t.make(sig.text.len(), None, scx)?;
 916         sig.text.push_str(&nested.text);
 917         sig.defs.extend(nested.defs.into_iter());
 918         sig.refs.extend(nested.refs.into_iter());
 919     }
 920     sig.text.push_str(" {}");
 921
 922     Ok(sig)
 923 }