src/librustc_mir/util/pretty.rs

   1 use rustc::hir::def_id::{DefId, LOCAL_CRATE};
   2 use rustc::mir::*;
   3 use rustc::mir::visit::Visitor;
   4 use rustc::ty::{self, TyCtxt};
   5 use rustc_data_structures::fx::FxHashMap;
   6 use rustc_data_structures::indexed_vec::Idx;
   7 use std::fmt::Display;
   8 use std::fmt::Write as _;
   9 use std::fs;
  10 use std::io::{self, Write};
  11 use std::path::{Path, PathBuf};
  12 use super::graphviz::write_mir_fn_graphviz;
  13 use crate::transform::MirSource;
  14
  15 const INDENT: &str = "    ";
  16 /// Alignment for lining up comments following MIR statements
  17 pub(crate) const ALIGN: usize = 40;
  18
  19 /// An indication of where we are in the control flow graph. Used for printing
  20 /// extra information in `dump_mir`
  21 pub enum PassWhere {
  22     /// We have not started dumping the control flow graph, but we are about to.
  23     BeforeCFG,
  24
  25     /// We just finished dumping the control flow graph. This is right before EOF
  26     AfterCFG,
  27
  28     /// We are about to start dumping the given basic block.
  29     BeforeBlock(BasicBlock),
  30
  31     /// We are just about to dump the given statement or terminator.
  32     BeforeLocation(Location),
  33
  34     /// We just dumped the given statement or terminator.
  35     AfterLocation(Location),
  36
  37     /// We just dumped the terminator for a block but not the closing `}`.
  38     AfterTerminator(BasicBlock),
  39 }
  40
  41 /// If the session is properly configured, dumps a human-readable
  42 /// representation of the mir into:
  43 ///
  44 /// ```text
  45 /// rustc.node<node_id>.<pass_num>.<pass_name>.<disambiguator>
  46 /// ```
  47 ///
  48 /// Output from this function is controlled by passing `-Z dump-mir=<filter>`,
  49 /// where `<filter>` takes the following forms:
  50 ///
  51 /// - `all` -- dump MIR for all fns, all passes, all everything
  52 /// - a filter defined by a set of substrings combined with `&` and `|`
  53 ///   (`&` has higher precedence). At least one of the `|`-separated groups
  54 ///   must match; an `|`-separated group matches if all of its `&`-separated
  55 ///   substrings are matched.
  56 ///
  57 /// Example:
  58 ///
  59 /// - `nll` == match if `nll` appears in the name
  60 /// - `foo & nll` == match if `foo` and `nll` both appear in the name
  61 /// - `foo & nll | typeck` == match if `foo` and `nll` both appear in the name
  62 ///   or `typeck` appears in the name.
  63 /// - `foo & nll | bar & typeck` == match if `foo` and `nll` both appear in the name
  64 ///   or `typeck` and `bar` both appear in the name.
  65 pub fn dump_mir<'a, 'gcx, 'tcx, F>(
  66     tcx: TyCtxt<'a, 'gcx, 'tcx>,
  67     pass_num: Option<&dyn Display>,
  68     pass_name: &str,
  69     disambiguator: &dyn Display,
  70     source: MirSource<'tcx>,
  71     mir: &Mir<'tcx>,
  72     extra_data: F,
  73 ) where
  74     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
  75 {
  76     if !dump_enabled(tcx, pass_name, source) {
  77         return;
  78     }
  79
  80     let node_path = ty::print::with_forced_impl_filename_line(|| {
  81         // see notes on #41697 below
  82         tcx.def_path_str(source.def_id())
  83     });
  84     dump_matched_mir_node(
  85         tcx,
  86         pass_num,
  87         pass_name,
  88         &node_path,
  89         disambiguator,
  90         source,
  91         mir,
  92         extra_data,
  93     );
  94 }
  95
  96 pub fn dump_enabled<'a, 'gcx, 'tcx>(
  97     tcx: TyCtxt<'a, 'gcx, 'tcx>,
  98     pass_name: &str,
  99     source: MirSource<'tcx>,
 100 ) -> bool {
 101     let filters = match tcx.sess.opts.debugging_opts.dump_mir {
 102         None => return false,
 103         Some(ref filters) => filters,
 104     };
 105     let node_path = ty::print::with_forced_impl_filename_line(|| {
 106         // see notes on #41697 below
 107         tcx.def_path_str(source.def_id())
 108     });
 109     filters.split('|').any(|or_filter| {
 110         or_filter.split('&').all(|and_filter| {
 111             and_filter == "all" || pass_name.contains(and_filter) || node_path.contains(and_filter)
 112         })
 113     })
 114 }
 115
 116 // #41697 -- we use `with_forced_impl_filename_line()` because
 117 // `def_path_str()` would otherwise trigger `type_of`, and this can
 118 // run while we are already attempting to evaluate `type_of`.
 119
 120 fn dump_matched_mir_node<'a, 'gcx, 'tcx, F>(
 121     tcx: TyCtxt<'a, 'gcx, 'tcx>,
 122     pass_num: Option<&dyn Display>,
 123     pass_name: &str,
 124     node_path: &str,
 125     disambiguator: &dyn Display,
 126     source: MirSource<'tcx>,
 127     mir: &Mir<'tcx>,
 128     mut extra_data: F,
 129 ) where
 130     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 131 {
 132     let _: io::Result<()> = try {
 133         let mut file = create_dump_file(tcx, "mir", pass_num, pass_name, disambiguator, source)?;
 134         writeln!(file, "// MIR for `{}`", node_path)?;
 135         writeln!(file, "// source = {:?}", source)?;
 136         writeln!(file, "// pass_name = {}", pass_name)?;
 137         writeln!(file, "// disambiguator = {}", disambiguator)?;
 138         if let Some(ref layout) = mir.generator_layout {
 139             writeln!(file, "// generator_layout = {:?}", layout)?;
 140         }
 141         writeln!(file, "")?;
 142         extra_data(PassWhere::BeforeCFG, &mut file)?;
 143         write_user_type_annotations(mir, &mut file)?;
 144         write_mir_fn(tcx, source, mir, &mut extra_data, &mut file)?;
 145         extra_data(PassWhere::AfterCFG, &mut file)?;
 146     };
 147
 148     if tcx.sess.opts.debugging_opts.dump_mir_graphviz {
 149         let _: io::Result<()> = try {
 150             let mut file =
 151                 create_dump_file(tcx, "dot", pass_num, pass_name, disambiguator, source)?;
 152             write_mir_fn_graphviz(tcx, source.def_id(), mir, &mut file)?;
 153         };
 154     }
 155 }
 156
 157 /// Returns the path to the filename where we should dump a given MIR.
 158 /// Also used by other bits of code (e.g., NLL inference) that dump
 159 /// graphviz data or other things.
 160 fn dump_path(
 161     tcx: TyCtxt<'_, '_, '_>,
 162     extension: &str,
 163     pass_num: Option<&dyn Display>,
 164     pass_name: &str,
 165     disambiguator: &dyn Display,
 166     source: MirSource<'tcx>,
 167 ) -> PathBuf {
 168     let promotion_id = match source.promoted {
 169         Some(id) => format!("-{:?}", id),
 170         None => String::new(),
 171     };
 172
 173     let pass_num = if tcx.sess.opts.debugging_opts.dump_mir_exclude_pass_number {
 174         String::new()
 175     } else {
 176         match pass_num {
 177             None => ".-------".to_string(),
 178             Some(pass_num) => format!(".{}", pass_num),
 179         }
 180     };
 181
 182     let mut file_path = PathBuf::new();
 183     file_path.push(Path::new(&tcx.sess.opts.debugging_opts.dump_mir_dir));
 184
 185     let item_name = tcx
 186         .def_path(source.def_id())
 187         .to_filename_friendly_no_crate();
 188     // All drop shims have the same DefId, so we have to add the type
 189     // to get unique file names.
 190     let shim_disambiguator = match source.instance {
 191         ty::InstanceDef::DropGlue(_, Some(ty)) => {
 192             // Unfortunately, pretty-printed typed are not very filename-friendly.
 193             // We dome some filtering.
 194             let mut s = ".".to_owned();
 195             s.extend(ty.to_string()
 196                 .chars()
 197                 .filter_map(|c| match c {
 198                     ' ' => None,
 199                     ':' | '<' | '>' => Some('_'),
 200                     c => Some(c)
 201                 }));
 202             s
 203         }
 204         _ => String::new(),
 205     };
 206
 207     let file_name = format!(
 208         "rustc.{}{}{}{}.{}.{}.{}",
 209         item_name,
 210         shim_disambiguator,
 211         promotion_id,
 212         pass_num,
 213         pass_name,
 214         disambiguator,
 215         extension,
 216     );
 217
 218     file_path.push(&file_name);
 219
 220     file_path
 221 }
 222
 223 /// Attempts to open a file where we should dump a given MIR or other
 224 /// bit of MIR-related data. Used by `mir-dump`, but also by other
 225 /// bits of code (e.g., NLL inference) that dump graphviz data or
 226 /// other things, and hence takes the extension as an argument.
 227 pub(crate) fn create_dump_file(
 228     tcx: TyCtxt<'_, '_, '_>,
 229     extension: &str,
 230     pass_num: Option<&dyn Display>,
 231     pass_name: &str,
 232     disambiguator: &dyn Display,
 233     source: MirSource<'tcx>,
 234 ) -> io::Result<fs::File> {
 235     let file_path = dump_path(tcx, extension, pass_num, pass_name, disambiguator, source);
 236     if let Some(parent) = file_path.parent() {
 237         fs::create_dir_all(parent)?;
 238     }
 239     fs::File::create(&file_path)
 240 }
 241
 242 /// Write out a human-readable textual representation for the given MIR.
 243 pub fn write_mir_pretty<'a, 'gcx, 'tcx>(
 244     tcx: TyCtxt<'a, 'gcx, 'tcx>,
 245     single: Option<DefId>,
 246     w: &mut dyn Write,
 247 ) -> io::Result<()> {
 248     writeln!(
 249         w,
 250         "// WARNING: This output format is intended for human consumers only"
 251     )?;
 252     writeln!(
 253         w,
 254         "// and is subject to change without notice. Knock yourself out."
 255     )?;
 256
 257     let mut first = true;
 258     for def_id in dump_mir_def_ids(tcx, single) {
 259         let mir = &tcx.optimized_mir(def_id);
 260
 261         if first {
 262             first = false;
 263         } else {
 264             // Put empty lines between all items
 265             writeln!(w, "")?;
 266         }
 267
 268         write_mir_fn(tcx, MirSource::item(def_id), mir, &mut |_, _| Ok(()), w)?;
 269
 270         for (i, mir) in mir.promoted.iter_enumerated() {
 271             writeln!(w, "")?;
 272             let src = MirSource {
 273                 instance: ty::InstanceDef::Item(def_id),
 274                 promoted: Some(i),
 275             };
 276             write_mir_fn(tcx, src, mir, &mut |_, _| Ok(()), w)?;
 277         }
 278     }
 279     Ok(())
 280 }
 281
 282 pub fn write_mir_fn<'a, 'gcx, 'tcx, F>(
 283     tcx: TyCtxt<'a, 'gcx, 'tcx>,
 284     src: MirSource<'tcx>,
 285     mir: &Mir<'tcx>,
 286     extra_data: &mut F,
 287     w: &mut dyn Write,
 288 ) -> io::Result<()>
 289 where
 290     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 291 {
 292     write_mir_intro(tcx, src, mir, w)?;
 293     for block in mir.basic_blocks().indices() {
 294         extra_data(PassWhere::BeforeBlock(block), w)?;
 295         write_basic_block(tcx, block, mir, extra_data, w)?;
 296         if block.index() + 1 != mir.basic_blocks().len() {
 297             writeln!(w, "")?;
 298         }
 299     }
 300
 301     writeln!(w, "}}")?;
 302     Ok(())
 303 }
 304
 305 /// Write out a human-readable textual representation for the given basic block.
 306 pub fn write_basic_block<'cx, 'gcx, 'tcx, F>(
 307     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
 308     block: BasicBlock,
 309     mir: &Mir<'tcx>,
 310     extra_data: &mut F,
 311     w: &mut dyn Write,
 312 ) -> io::Result<()>
 313 where
 314     F: FnMut(PassWhere, &mut dyn Write) -> io::Result<()>,
 315 {
 316     let data = &mir[block];
 317
 318     // Basic block label at the top.
 319     let cleanup_text = if data.is_cleanup { " (cleanup)" } else { "" };
 320     writeln!(w, "{}{:?}{}: {{", INDENT, block, cleanup_text)?;
 321
 322     // List of statements in the middle.
 323     let mut current_location = Location {
 324         block: block,
 325         statement_index: 0,
 326     };
 327     for statement in &data.statements {
 328         extra_data(PassWhere::BeforeLocation(current_location), w)?;
 329         let indented_mir = format!("{0}{0}{1:?};", INDENT, statement);
 330         writeln!(
 331             w,
 332             "{:A$} // {:?}: {}",
 333             indented_mir,
 334             current_location,
 335             comment(tcx, statement.source_info),
 336             A = ALIGN,
 337         )?;
 338
 339         write_extra(tcx, w, |visitor| {
 340             visitor.visit_statement(statement, current_location);
 341         })?;
 342
 343         extra_data(PassWhere::AfterLocation(current_location), w)?;
 344
 345         current_location.statement_index += 1;
 346     }
 347
 348     // Terminator at the bottom.
 349     extra_data(PassWhere::BeforeLocation(current_location), w)?;
 350     let indented_terminator = format!("{0}{0}{1:?};", INDENT, data.terminator().kind);
 351     writeln!(
 352         w,
 353         "{:A$} // {:?}: {}",
 354         indented_terminator,
 355         current_location,
 356         comment(tcx, data.terminator().source_info),
 357         A = ALIGN,
 358     )?;
 359
 360     write_extra(tcx, w, |visitor| {
 361         visitor.visit_terminator(data.terminator(), current_location);
 362     })?;
 363
 364     extra_data(PassWhere::AfterLocation(current_location), w)?;
 365     extra_data(PassWhere::AfterTerminator(block), w)?;
 366
 367     writeln!(w, "{}}}", INDENT)
 368 }
 369
 370 /// After we print the main statement, we sometimes dump extra
 371 /// information. There's often a lot of little things "nuzzled up" in
 372 /// a statement.
 373 fn write_extra<'cx, 'gcx, 'tcx, F>(
 374     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
 375     write: &mut dyn Write,
 376     mut visit_op: F,
 377 ) -> io::Result<()>
 378 where
 379     F: FnMut(&mut ExtraComments<'cx, 'gcx, 'tcx>),
 380 {
 381     let mut extra_comments = ExtraComments {
 382         _tcx: tcx,
 383         comments: vec![],
 384     };
 385     visit_op(&mut extra_comments);
 386     for comment in extra_comments.comments {
 387         writeln!(write, "{:A$} // {}", "", comment, A = ALIGN)?;
 388     }
 389     Ok(())
 390 }
 391
 392 struct ExtraComments<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
 393     _tcx: TyCtxt<'cx, 'gcx, 'tcx>, // don't need it now, but bet we will soon
 394     comments: Vec<String>,
 395 }
 396
 397 impl<'cx, 'gcx, 'tcx> ExtraComments<'cx, 'gcx, 'tcx> {
 398     fn push(&mut self, lines: &str) {
 399         for line in lines.split('\n') {
 400             self.comments.push(line.to_string());
 401         }
 402     }
 403 }
 404
 405 impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for ExtraComments<'cx, 'gcx, 'tcx> {
 406     fn visit_constant(&mut self, constant: &Constant<'tcx>, location: Location) {
 407         self.super_constant(constant, location);
 408         let Constant { span, ty, user_ty, literal } = constant;
 409         self.push("mir::Constant");
 410         self.push(&format!("+ span: {:?}", span));
 411         self.push(&format!("+ ty: {:?}", ty));
 412         if let Some(user_ty) = user_ty {
 413             self.push(&format!("+ user_ty: {:?}", user_ty));
 414         }
 415         self.push(&format!("+ literal: {:?}", literal));
 416     }
 417
 418     fn visit_const(&mut self, constant: &&'tcx ty::Const<'tcx>, _: Location) {
 419         self.super_const(constant);
 420         let ty::Const { ty, val, .. } = constant;
 421         self.push("ty::Const");
 422         self.push(&format!("+ ty: {:?}", ty));
 423         self.push(&format!("+ val: {:?}", val));
 424     }
 425
 426     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
 427         self.super_rvalue(rvalue, location);
 428         match rvalue {
 429             Rvalue::Aggregate(kind, _) => match **kind {
 430                 AggregateKind::Closure(def_id, substs) => {
 431                     self.push("closure");
 432                     self.push(&format!("+ def_id: {:?}", def_id));
 433                     self.push(&format!("+ substs: {:#?}", substs));
 434                 }
 435
 436                 AggregateKind::Generator(def_id, substs, movability) => {
 437                     self.push("generator");
 438                     self.push(&format!("+ def_id: {:?}", def_id));
 439                     self.push(&format!("+ substs: {:#?}", substs));
 440                     self.push(&format!("+ movability: {:?}", movability));
 441                 }
 442
 443                 AggregateKind::Adt(_, _, _, Some(user_ty), _) => {
 444                     self.push("adt");
 445                     self.push(&format!("+ user_ty: {:?}", user_ty));
 446                 }
 447
 448                 _ => {}
 449             },
 450
 451             _ => {}
 452         }
 453     }
 454 }
 455
 456 fn comment(tcx: TyCtxt<'_, '_, '_>, SourceInfo { span, scope }: SourceInfo) -> String {
 457     format!(
 458         "scope {} at {}",
 459         scope.index(),
 460         tcx.sess.source_map().span_to_string(span)
 461     )
 462 }
 463
 464 /// Prints local variables in a scope tree.
 465 fn write_scope_tree(
 466     tcx: TyCtxt<'_, '_, '_>,
 467     mir: &Mir<'_>,
 468     scope_tree: &FxHashMap<SourceScope, Vec<SourceScope>>,
 469     w: &mut dyn Write,
 470     parent: SourceScope,
 471     depth: usize,
 472 ) -> io::Result<()> {
 473     let indent = depth * INDENT.len();
 474
 475     // Local variable types (including the user's name in a comment).
 476     for (local, local_decl) in mir.local_decls.iter_enumerated() {
 477         if (1..mir.arg_count+1).contains(&local.index()) {
 478             // Skip over argument locals, they're printed in the signature.
 479             continue;
 480         }
 481
 482         if local_decl.source_info.scope != parent {
 483             // Not declared in this scope.
 484             continue;
 485         }
 486
 487         let mut_str = if local_decl.mutability == Mutability::Mut {
 488             "mut "
 489         } else {
 490             ""
 491         };
 492
 493         let mut indented_decl = format!(
 494             "{0:1$}let {2}{3:?}: {4:?}",
 495             INDENT,
 496             indent,
 497             mut_str,
 498             local,
 499             local_decl.ty
 500         );
 501         for user_ty in local_decl.user_ty.projections() {
 502             write!(indented_decl, " as {:?}", user_ty).unwrap();
 503         }
 504         indented_decl.push_str(";");
 505
 506         let local_name = if local == RETURN_PLACE {
 507             format!(" return place")
 508         } else if let Some(name) = local_decl.name {
 509             format!(" \"{}\"", name)
 510         } else {
 511             String::new()
 512         };
 513
 514         writeln!(
 515             w,
 516             "{0:1$} //{2} in {3}",
 517             indented_decl,
 518             ALIGN,
 519             local_name,
 520             comment(tcx, local_decl.source_info),
 521         )?;
 522     }
 523
 524     let children = match scope_tree.get(&parent) {
 525         Some(childs) => childs,
 526         None => return Ok(()),
 527     };
 528
 529     for &child in children {
 530         assert_eq!(mir.source_scopes[child].parent_scope, Some(parent));
 531         writeln!(w, "{0:1$}scope {2} {{", "", indent, child.index())?;
 532         write_scope_tree(tcx, mir, scope_tree, w, child, depth + 1)?;
 533         writeln!(w, "{0:1$}}}", "", depth * INDENT.len())?;
 534     }
 535
 536     Ok(())
 537 }
 538
 539 /// Write out a human-readable textual representation of the MIR's `fn` type and the types of its
 540 /// local variables (both user-defined bindings and compiler temporaries).
 541 pub fn write_mir_intro<'a, 'gcx, 'tcx>(
 542     tcx: TyCtxt<'a, 'gcx, 'tcx>,
 543     src: MirSource<'tcx>,
 544     mir: &Mir<'_>,
 545     w: &mut dyn Write,
 546 ) -> io::Result<()> {
 547     write_mir_sig(tcx, src, mir, w)?;
 548     writeln!(w, "{{")?;
 549
 550     // construct a scope tree and write it out
 551     let mut scope_tree: FxHashMap<SourceScope, Vec<SourceScope>> = Default::default();
 552     for (index, scope_data) in mir.source_scopes.iter().enumerate() {
 553         if let Some(parent) = scope_data.parent_scope {
 554             scope_tree
 555                 .entry(parent)
 556                 .or_default()
 557                 .push(SourceScope::new(index));
 558         } else {
 559             // Only the argument scope has no parent, because it's the root.
 560             assert_eq!(index, OUTERMOST_SOURCE_SCOPE.index());
 561         }
 562     }
 563
 564     write_scope_tree(tcx, mir, &scope_tree, w, OUTERMOST_SOURCE_SCOPE, 1)?;
 565
 566     // Add an empty line before the first block is printed.
 567     writeln!(w, "")?;
 568
 569     Ok(())
 570 }
 571
 572 fn write_mir_sig(
 573     tcx: TyCtxt<'_, '_, '_>,
 574     src: MirSource<'tcx>,
 575     mir: &Mir<'_>,
 576     w: &mut dyn Write,
 577 ) -> io::Result<()> {
 578     use rustc::hir::def::DefKind;
 579
 580     trace!("write_mir_sig: {:?}", src.instance);
 581     let kind = tcx.def_kind(src.def_id());
 582     let is_function = match kind {
 583         Some(DefKind::Fn)
 584         | Some(DefKind::Method)
 585         | Some(DefKind::Ctor(..)) => true,
 586         _ => tcx.is_closure(src.def_id()),
 587     };
 588     match (kind, src.promoted) {
 589         (_, Some(i)) => write!(w, "{:?} in ", i)?,
 590         (Some(DefKind::Const), _)
 591         | (Some(DefKind::AssociatedConst), _) => write!(w, "const ")?,
 592         (Some(DefKind::Static), _) =>
 593             write!(w, "static {}", if tcx.is_mutable_static(src.def_id()) { "mut " } else { "" })?,
 594         (_, _) if is_function => write!(w, "fn ")?,
 595         (None, _) => {}, // things like anon const, not an item
 596         _ => bug!("Unexpected def kind {:?}", kind),
 597     }
 598
 599     ty::print::with_forced_impl_filename_line(|| {
 600         // see notes on #41697 elsewhere
 601         write!(w, " {}", tcx.def_path_str(src.def_id()))
 602     })?;
 603
 604     if src.promoted.is_none() && is_function {
 605         write!(w, "(")?;
 606
 607         // fn argument types.
 608         for (i, arg) in mir.args_iter().enumerate() {
 609             if i != 0 {
 610                 write!(w, ", ")?;
 611             }
 612             write!(w, "{:?}: {}", Place::Base(PlaceBase::Local(arg)), mir.local_decls[arg].ty)?;
 613         }
 614
 615         write!(w, ") -> {}", mir.return_ty())?;
 616     } else {
 617         assert_eq!(mir.arg_count, 0);
 618         write!(w, ": {} =", mir.return_ty())?;
 619     }
 620
 621     if let Some(yield_ty) = mir.yield_ty {
 622         writeln!(w)?;
 623         writeln!(w, "yields {}", yield_ty)?;
 624     }
 625
 626     write!(w, " ")?;
 627     // Next thing that gets printed is the opening {
 628
 629     Ok(())
 630 }
 631
 632 fn write_user_type_annotations(mir: &Mir<'_>, w: &mut dyn Write) -> io::Result<()> {
 633     if !mir.user_type_annotations.is_empty() {
 634         writeln!(w, "| User Type Annotations")?;
 635     }
 636     for (index, annotation) in mir.user_type_annotations.iter_enumerated() {
 637         writeln!(w, "| {:?}: {:?} at {:?}", index.index(), annotation.user_ty, annotation.span)?;
 638     }
 639     if !mir.user_type_annotations.is_empty() {
 640         writeln!(w, "|")?;
 641     }
 642     Ok(())
 643 }
 644
 645 pub fn dump_mir_def_ids(tcx: TyCtxt<'_, '_, '_>, single: Option<DefId>) -> Vec<DefId> {
 646     if let Some(i) = single {
 647         vec![i]
 648     } else {
 649         tcx.mir_keys(LOCAL_CRATE).iter().cloned().collect()
 650     }
 651 }