1 use crate::hir::def_id::DefId;
2 use crate::hir::map::definitions::DefPathData;
3 use crate::middle::region;
4 use crate::ty::subst::{self, Subst, SubstsRef};
5 use crate::ty::{BrAnon, BrEnv, BrFresh, BrNamed};
6 use crate::ty::{Bool, Char, Adt};
7 use crate::ty::{Error, Str, Array, Slice, Float, FnDef, FnPtr};
8 use crate::ty::{Param, Bound, RawPtr, Ref, Never, Tuple};
9 use crate::ty::{Closure, Generator, GeneratorWitness, Foreign, Projection, Opaque};
10 use crate::ty::{Placeholder, UnnormalizedProjection, Dynamic, Int, Uint, Infer};
11 use crate::ty::{self, Ty, TyCtxt, TypeFoldable, GenericParamCount, GenericParamDefKind};
12 use crate::util::nodemap::FxHashSet;
18 use rustc_target::spec::abi::Abi;
19 use syntax::ast::CRATE_NODE_ID;
20 use syntax::symbol::{Symbol, InternedString};
23 /// The "region highlights" are used to control region printing during
24 /// specific error messages. When a "region highlight" is enabled, it
25 /// gives an alternate way to print specific regions. For now, we
26 /// always print those regions using a number, so something like "`'0`".
28 /// Regions not selected by the region highlight mode are presently
30 #[derive(Copy, Clone, Default)]
31 pub struct RegionHighlightMode {
32 /// If enabled, when we see the selected region, use "`'N`"
33 /// instead of the ordinary behavior.
34 highlight_regions: [Option<(ty::RegionKind, usize)>; 3],
36 /// If enabled, when printing a "free region" that originated from
37 /// the given `ty::BoundRegion`, print it as "`'1`". Free regions that would ordinarily
38 /// have names print as normal.
40 /// This is used when you have a signature like `fn foo(x: &u32,
41 /// y: &'a u32)` and we want to give a name to the region of the
43 highlight_bound_region: Option<(ty::BoundRegion, usize)>,
47 /// Mechanism for highlighting of specific regions for display in NLL region inference errors.
48 /// Contains region to highlight and counter for number to use when highlighting.
49 static REGION_HIGHLIGHT_MODE: Cell<RegionHighlightMode> =
50 Cell::new(RegionHighlightMode::default())
53 impl RegionHighlightMode {
54 /// Reads and returns the current region highlight settings (accesses thread-local state).
55 pub fn get() -> Self {
56 REGION_HIGHLIGHT_MODE.with(|c| c.get())
59 // Internal helper to update current settings during the execution of `op`.
63 op: impl FnOnce() -> R,
65 REGION_HIGHLIGHT_MODE.with(|c| {
73 /// If `region` and `number` are both `Some`, invokes
74 /// `highlighting_region`; otherwise, just invokes `op` directly.
75 pub fn maybe_highlighting_region<R>(
76 region: Option<ty::Region<'_>>,
77 number: Option<usize>,
78 op: impl FnOnce() -> R,
80 if let Some(k) = region {
81 if let Some(n) = number {
82 return Self::highlighting_region(k, n, op);
89 /// During the execution of `op`, highlights the region inference
90 /// variable `vid` as `'N`. We can only highlight one region `vid`
92 pub fn highlighting_region<R>(
93 region: ty::Region<'_>,
95 op: impl FnOnce() -> R,
97 let old_mode = Self::get();
98 let mut new_mode = old_mode;
99 let first_avail_slot = new_mode.highlight_regions.iter_mut()
100 .filter(|s| s.is_none())
104 "can only highlight {} placeholders at a time",
105 old_mode.highlight_regions.len(),
108 *first_avail_slot = Some((*region, number));
109 Self::set(old_mode, new_mode, op)
112 /// Convenience wrapper for `highlighting_region`.
113 pub fn highlighting_region_vid<R>(
116 op: impl FnOnce() -> R,
118 Self::highlighting_region(&ty::ReVar(vid), number, op)
121 /// Returns `true` if any placeholders are highlighted, and `false` otherwise.
122 fn any_region_vids_highlighted(&self) -> bool {
127 Some((ty::ReVar(_), _)) => true,
132 /// Returns `Some(n)` with the number to use for the given region, if any.
133 fn region_highlighted(&self, region: ty::Region<'_>) -> Option<usize> {
137 .filter_map(|h| match h {
138 Some((r, n)) if r == region => Some(*n),
144 /// During the execution of `op`, highlight the given bound
145 /// region. We can only highlight one bound region at a time. See
146 /// the field `highlight_bound_region` for more detailed notes.
147 pub fn highlighting_bound_region<R>(
150 op: impl FnOnce() -> R,
152 let old_mode = Self::get();
153 assert!(old_mode.highlight_bound_region.is_none());
157 highlight_bound_region: Some((br, number)),
164 /// Returns `true` if any placeholders are highlighted, and `false` otherwise.
165 pub fn any_placeholders_highlighted(&self) -> bool {
170 Some((ty::RePlaceholder(_), _)) => true,
175 /// Returns `Some(N)` if the placeholder `p` is highlighted to print as "`'N`".
176 pub fn placeholder_highlight(&self, p: ty::PlaceholderRegion) -> Option<usize> {
177 self.region_highlighted(&ty::RePlaceholder(p))
181 macro_rules! gen_display_debug_body {
183 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
184 let mut cx = PrintContext::new();
185 $with(self, f, &mut cx)
189 macro_rules! gen_display_debug {
190 ( ($($x:tt)+) $target:ty, display yes ) => {
191 impl<$($x)+> fmt::Display for $target {
192 gen_display_debug_body! { Print::print_display }
195 ( () $target:ty, display yes ) => {
196 impl fmt::Display for $target {
197 gen_display_debug_body! { Print::print_display }
200 ( ($($x:tt)+) $target:ty, debug yes ) => {
201 impl<$($x)+> fmt::Debug for $target {
202 gen_display_debug_body! { Print::print_debug }
205 ( () $target:ty, debug yes ) => {
206 impl fmt::Debug for $target {
207 gen_display_debug_body! { Print::print_debug }
210 ( $generic:tt $target:ty, $t:ident no ) => {};
212 macro_rules! gen_print_impl {
213 ( ($($x:tt)+) $target:ty, ($self:ident, $f:ident, $cx:ident) $disp:block $dbg:block ) => {
214 impl<$($x)+> Print for $target {
215 fn print<F: fmt::Write>(&$self, $f: &mut F, $cx: &mut PrintContext) -> fmt::Result {
221 ( () $target:ty, ($self:ident, $f:ident, $cx:ident) $disp:block $dbg:block ) => {
222 impl Print for $target {
223 fn print<F: fmt::Write>(&$self, $f: &mut F, $cx: &mut PrintContext) -> fmt::Result {
229 ( $generic:tt $target:ty,
230 $vars:tt $gendisp:ident $disp:block $gendbg:ident $dbg:block ) => {
231 gen_print_impl! { $generic $target, $vars $disp $dbg }
232 gen_display_debug! { $generic $target, display $gendisp }
233 gen_display_debug! { $generic $target, debug $gendbg }
236 macro_rules! define_print {
237 ( $generic:tt $target:ty,
238 $vars:tt { display $disp:block debug $dbg:block } ) => {
239 gen_print_impl! { $generic $target, $vars yes $disp yes $dbg }
241 ( $generic:tt $target:ty,
242 $vars:tt { debug $dbg:block display $disp:block } ) => {
243 gen_print_impl! { $generic $target, $vars yes $disp yes $dbg }
245 ( $generic:tt $target:ty,
246 $vars:tt { debug $dbg:block } ) => {
247 gen_print_impl! { $generic $target, $vars no {
248 bug!(concat!("display not implemented for ", stringify!($target)));
251 ( $generic:tt $target:ty,
252 ($self:ident, $f:ident, $cx:ident) { display $disp:block } ) => {
253 gen_print_impl! { $generic $target, ($self, $f, $cx) yes $disp no {
254 write!($f, "{:?}", $self)
258 macro_rules! define_print_multi {
259 ( [ $($generic:tt $target:ty),* ] $vars:tt $def:tt ) => {
260 $(define_print! { $generic $target, $vars $def })*
263 macro_rules! print_inner {
264 ( $f:expr, $cx:expr, write ($($data:expr),+) ) => {
265 write!($f, $($data),+)
267 ( $f:expr, $cx:expr, $kind:ident ($data:expr) ) => {
272 ( $f:expr, $cx:expr $(, $kind:ident $data:tt)+ ) => {
273 Ok(())$(.and_then(|_| print_inner!($f, $cx, $kind $data)))+
278 struct LateBoundRegionNameCollector(FxHashSet<InternedString>);
279 impl<'tcx> ty::fold::TypeVisitor<'tcx> for LateBoundRegionNameCollector {
280 fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
282 ty::ReLateBound(_, ty::BrNamed(_, name)) => {
287 r.super_visit_with(self)
292 pub struct PrintContext {
295 identify_regions: bool,
296 used_region_names: Option<FxHashSet<InternedString>>,
302 ty::tls::with_opt(|tcx| {
303 let (is_verbose, identify_regions) = tcx.map(
304 |tcx| (tcx.sess.verbose(), tcx.sess.opts.debugging_opts.identify_regions)
305 ).unwrap_or((false, false));
308 is_verbose: is_verbose,
309 identify_regions: identify_regions,
310 used_region_names: None,
316 fn prepare_late_bound_region_info<'tcx, T>(&mut self, value: &ty::Binder<T>)
317 where T: TypeFoldable<'tcx>
319 let mut collector = LateBoundRegionNameCollector(Default::default());
320 value.visit_with(&mut collector);
321 self.used_region_names = Some(collector.0);
322 self.region_index = 0;
327 fn print<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintContext) -> fmt::Result;
328 fn print_to_string(&self, cx: &mut PrintContext) -> String {
329 let mut result = String::new();
330 let _ = self.print(&mut result, cx);
333 fn print_display<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintContext) -> fmt::Result {
334 let old_debug = cx.is_debug;
336 let result = self.print(f, cx);
337 cx.is_debug = old_debug;
340 fn print_display_to_string(&self, cx: &mut PrintContext) -> String {
341 let mut result = String::new();
342 let _ = self.print_display(&mut result, cx);
345 fn print_debug<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintContext) -> fmt::Result {
346 let old_debug = cx.is_debug;
348 let result = self.print(f, cx);
349 cx.is_debug = old_debug;
352 fn print_debug_to_string(&self, cx: &mut PrintContext) -> String {
353 let mut result = String::new();
354 let _ = self.print_debug(&mut result, cx);
360 fn fn_sig<F: fmt::Write>(&mut self,
367 let mut inputs = inputs.iter();
368 if let Some(&ty) = inputs.next() {
369 print!(f, self, print_display(ty))?;
371 print!(f, self, write(", "), print_display(ty))?;
378 if !output.is_unit() {
379 print!(f, self, write(" -> "), print_display(output))?;
385 fn parameterized<F: fmt::Write>(&mut self,
387 substs: SubstsRef<'_>,
389 projections: &[ty::ProjectionPredicate<'_>])
391 let key = ty::tls::with(|tcx| tcx.def_key(did));
393 let verbose = self.is_verbose;
394 let mut num_supplied_defaults = 0;
395 let mut has_self = false;
396 let mut own_counts: GenericParamCount = Default::default();
397 let mut is_value_path = false;
398 let mut item_name = Some(key.disambiguated_data.data.as_interned_str());
399 let fn_trait_kind = ty::tls::with(|tcx| {
400 // Unfortunately, some kinds of items (e.g., closures) don't have
401 // generics. So walk back up the find the closest parent that DOES
403 let mut item_def_id = did;
405 let key = tcx.def_key(item_def_id);
406 match key.disambiguated_data.data {
407 DefPathData::AssocTypeInTrait(_) |
408 DefPathData::AssocTypeInImpl(_) |
409 DefPathData::AssocExistentialInImpl(_) |
410 DefPathData::Trait(_) |
411 DefPathData::TraitAlias(_) |
413 DefPathData::TypeNs(_) => {
416 DefPathData::ValueNs(_) |
417 DefPathData::EnumVariant(_) => {
418 is_value_path = true;
421 DefPathData::CrateRoot |
423 DefPathData::Module(_) |
424 DefPathData::MacroDef(_) |
425 DefPathData::ClosureExpr |
426 DefPathData::TypeParam(_) |
427 DefPathData::LifetimeParam(_) |
428 DefPathData::ConstParam(_) |
429 DefPathData::Field(_) |
430 DefPathData::StructCtor |
431 DefPathData::AnonConst |
432 DefPathData::ImplTrait |
433 DefPathData::GlobalMetaData(_) => {
434 // if we're making a symbol for something, there ought
435 // to be a value or type-def or something in there
437 item_def_id.index = key.parent.unwrap_or_else(|| {
438 bug!("finding type for {:?}, encountered def-id {:?} with no \
439 parent", did, item_def_id);
444 let mut generics = tcx.generics_of(item_def_id);
445 let child_own_counts = generics.own_counts();
446 let mut path_def_id = did;
447 has_self = generics.has_self;
449 let mut child_types = 0;
450 if let Some(def_id) = generics.parent {
452 assert!(is_value_path);
453 child_types = child_own_counts.types;
454 generics = tcx.generics_of(def_id);
455 own_counts = generics.own_counts();
458 print!(f, self, write("<"), print_display(substs.type_at(0)), write(" as "))?;
461 path_def_id = def_id;
467 assert_eq!(has_self, false);
470 own_counts = child_own_counts;
475 let mut type_params =
476 generics.params.iter().rev().filter_map(|param| match param.kind {
477 GenericParamDefKind::Lifetime => None,
478 GenericParamDefKind::Type { has_default, .. } => {
479 Some((param.def_id, has_default))
483 let has_default = type_params.peek().map(|(_, has_default)| has_default);
484 *has_default.unwrap_or(&false)
487 if let Some(substs) = tcx.lift(&substs) {
488 let types = substs.types().rev().skip(child_types);
489 for ((def_id, has_default), actual) in type_params.zip(types) {
493 if tcx.type_of(def_id).subst(tcx, substs) != actual {
496 num_supplied_defaults += 1;
502 print!(f, self, write("{}", tcx.item_path_str(path_def_id)))?;
503 Ok(tcx.lang_items().fn_trait_kind(path_def_id))
506 if !verbose && fn_trait_kind.is_some() && projections.len() == 1 {
507 let projection_ty = projections[0].ty;
508 if let Tuple(ref args) = substs.type_at(1).sty {
509 return self.fn_sig(f, args, false, projection_ty);
513 let empty = Cell::new(true);
514 let start_or_continue = |f: &mut F, start: &str, cont: &str| {
517 write!(f, "{}", start)
519 write!(f, "{}", cont)
523 let print_regions = |f: &mut F, start: &str, skip, count| {
524 // Don't print any regions if they're all erased.
525 let regions = || substs.regions().skip(skip).take(count);
526 if regions().all(|r: ty::Region<'_>| *r == ty::ReErased) {
530 for region in regions() {
531 let region: ty::Region<'_> = region;
532 start_or_continue(f, start, ", ")?;
534 write!(f, "{:?}", region)?;
536 let s = region.to_string();
538 // This happens when the value of the region
539 // parameter is not easily serialized. This may be
540 // because the user omitted it in the first place,
541 // or because it refers to some block in the code,
542 // etc. I'm not sure how best to serialize this.
553 print_regions(f, "<", 0, own_counts.lifetimes)?;
555 let tps = substs.types()
556 .take(own_counts.types - num_supplied_defaults)
557 .skip(has_self as usize);
560 start_or_continue(f, "<", ", ")?;
561 ty.print_display(f, self)?;
564 for projection in projections {
565 start_or_continue(f, "<", ", ")?;
569 tcx.associated_item(projection.projection_ty.item_def_id).ident),
570 print_display(projection.ty))
574 start_or_continue(f, "", ">")?;
576 // For values, also print their name and type parameters.
584 if let Some(item_name) = item_name {
585 write!(f, "::{}", item_name)?;
588 print_regions(f, "::<", own_counts.lifetimes, usize::MAX)?;
590 // FIXME: consider being smart with defaults here too
591 for ty in substs.types().skip(own_counts.types) {
592 start_or_continue(f, "::<", ", ")?;
593 ty.print_display(f, self)?;
596 start_or_continue(f, "", ">")?;
602 fn in_binder<'a, 'gcx, 'tcx, T, U, F>(&mut self,
604 tcx: TyCtxt<'a, 'gcx, 'tcx>,
605 original: &ty::Binder<T>,
606 lifted: Option<ty::Binder<U>>) -> fmt::Result
607 where T: Print, U: Print + TypeFoldable<'tcx>, F: fmt::Write
609 fn name_by_region_index(index: usize) -> InternedString {
611 0 => Symbol::intern("'r"),
612 1 => Symbol::intern("'s"),
613 i => Symbol::intern(&format!("'t{}", i-2)),
617 // Replace any anonymous late-bound regions with named
618 // variants, using gensym'd identifiers, so that we can
619 // clearly differentiate between named and unnamed regions in
620 // the output. We'll probably want to tweak this over time to
621 // decide just how much information to give.
622 let value = if let Some(v) = lifted {
625 return original.skip_binder().print_display(f, self);
628 if self.binder_depth == 0 {
629 self.prepare_late_bound_region_info(&value);
632 let mut empty = true;
633 let mut start_or_continue = |f: &mut F, start: &str, cont: &str| {
636 write!(f, "{}", start)
638 write!(f, "{}", cont)
642 let old_region_index = self.region_index;
643 let mut region_index = old_region_index;
644 let new_value = tcx.replace_late_bound_regions(&value, |br| {
645 let _ = start_or_continue(f, "for<", ", ");
647 ty::BrNamed(_, name) => {
648 let _ = write!(f, "{}", name);
655 let name = name_by_region_index(region_index);
657 if !self.is_name_used(&name) {
661 let _ = write!(f, "{}", name);
662 ty::BrNamed(tcx.hir().local_def_id(CRATE_NODE_ID), name)
665 tcx.mk_region(ty::ReLateBound(ty::INNERMOST, br))
667 start_or_continue(f, "", "> ")?;
669 // Push current state to gcx, and restore after writing new_value.
670 self.binder_depth += 1;
671 self.region_index = region_index;
672 let result = new_value.print_display(f, self);
673 self.region_index = old_region_index;
674 self.binder_depth -= 1;
678 fn is_name_used(&self, name: &InternedString) -> bool {
679 match self.used_region_names {
680 Some(ref names) => names.contains(name),
686 pub fn verbose() -> bool {
687 ty::tls::with(|tcx| tcx.sess.verbose())
690 pub fn identify_regions() -> bool {
691 ty::tls::with(|tcx| tcx.sess.opts.debugging_opts.identify_regions)
694 pub fn parameterized<F: fmt::Write>(f: &mut F,
695 substs: SubstsRef<'_>,
697 projections: &[ty::ProjectionPredicate<'_>])
699 PrintContext::new().parameterized(f, substs, did, projections)
702 impl<'a, T: Print> Print for &'a T {
703 fn print<F: fmt::Write>(&self, f: &mut F, cx: &mut PrintContext) -> fmt::Result {
709 ('tcx) &'tcx ty::List<ty::ExistentialPredicate<'tcx>>, (self, f, cx) {
711 // Generate the main trait ref, including associated types.
712 ty::tls::with(|tcx| {
713 // Use a type that can't appear in defaults of type parameters.
714 let dummy_self = tcx.mk_infer(ty::FreshTy(0));
715 let mut first = true;
717 if let Some(principal) = self.principal() {
720 .expect("could not lift TraitRef for printing")
721 .with_self_ty(tcx, dummy_self);
722 let projections = self.projection_bounds().map(|p| {
724 .expect("could not lift projection for printing")
725 .with_self_ty(tcx, dummy_self)
726 }).collect::<Vec<_>>();
727 cx.parameterized(f, principal.substs, principal.def_id, &projections)?;
732 let mut auto_traits: Vec<_> = self.auto_traits().map(|did| {
733 tcx.item_path_str(did)
736 // The auto traits come ordered by `DefPathHash`. While
737 // `DefPathHash` is *stable* in the sense that it depends on
738 // neither the host nor the phase of the moon, it depends
739 // "pseudorandomly" on the compiler version and the target.
741 // To avoid that causing instabilities in compiletest
742 // output, sort the auto-traits alphabetically.
745 for auto_trait in auto_traits {
751 write!(f, "{}", auto_trait)?;
762 impl fmt::Debug for ty::GenericParamDef {
763 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
764 let type_name = match self.kind {
765 ty::GenericParamDefKind::Lifetime => "Lifetime",
766 ty::GenericParamDefKind::Type {..} => "Type",
768 write!(f, "{}({}, {:?}, {})",
776 impl fmt::Debug for ty::TraitDef {
777 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
778 ty::tls::with(|tcx| {
779 write!(f, "{}", tcx.item_path_str(self.def_id))
784 impl fmt::Debug for ty::AdtDef {
785 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
786 ty::tls::with(|tcx| {
787 write!(f, "{}", tcx.item_path_str(self.did))
792 impl<'tcx> fmt::Debug for ty::ClosureUpvar<'tcx> {
793 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
794 write!(f, "ClosureUpvar({:?},{:?})",
800 impl fmt::Debug for ty::UpvarId {
801 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
802 write!(f, "UpvarId({:?};`{}`;{:?})",
803 self.var_path.hir_id,
804 ty::tls::with(|tcx| tcx.hir().name_by_hir_id(self.var_path.hir_id)),
805 self.closure_expr_id)
809 impl<'tcx> fmt::Debug for ty::UpvarBorrow<'tcx> {
810 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
811 write!(f, "UpvarBorrow({:?}, {:?})",
812 self.kind, self.region)
817 ('tcx) &'tcx ty::List<Ty<'tcx>>, (self, f, cx) {
820 let mut tys = self.iter();
821 if let Some(&ty) = tys.next() {
822 print!(f, cx, print(ty))?;
824 print!(f, cx, write(", "), print(ty))?;
833 ('tcx) ty::TypeAndMut<'tcx>, (self, f, cx) {
836 write("{}", if self.mutbl == hir::MutMutable { "mut " } else { "" }),
843 ('tcx) ty::ExistentialTraitRef<'tcx>, (self, f, cx) {
845 cx.parameterized(f, self.substs, self.def_id, &[])
848 ty::tls::with(|tcx| {
849 let dummy_self = tcx.mk_infer(ty::FreshTy(0));
851 let trait_ref = *tcx.lift(&ty::Binder::bind(*self))
852 .expect("could not lift TraitRef for printing")
853 .with_self_ty(tcx, dummy_self).skip_binder();
854 cx.parameterized(f, trait_ref.substs, trait_ref.def_id, &[])
861 ('tcx) ty::adjustment::Adjustment<'tcx>, (self, f, cx) {
863 print!(f, cx, write("{:?} -> ", self.kind), print(self.target))
869 () ty::BoundRegion, (self, f, cx) {
872 return self.print_debug(f, cx);
875 if let Some((region, counter)) = RegionHighlightMode::get().highlight_bound_region {
878 BrNamed(_, name) => write!(f, "{}", name),
879 BrAnon(_) | BrFresh(_) | BrEnv => write!(f, "'{}", counter)
885 BrNamed(_, name) => write!(f, "{}", name),
886 BrAnon(_) | BrFresh(_) | BrEnv => Ok(())
891 BrAnon(n) => write!(f, "BrAnon({:?})", n),
892 BrFresh(n) => write!(f, "BrFresh({:?})", n),
893 BrNamed(did, name) => {
894 write!(f, "BrNamed({:?}:{:?}, {})",
895 did.krate, did.index, name)
897 BrEnv => write!(f, "BrEnv"),
904 () ty::PlaceholderRegion, (self, f, cx) {
907 return self.print_debug(f, cx);
910 let highlight = RegionHighlightMode::get();
911 if let Some(counter) = highlight.placeholder_highlight(*self) {
912 write!(f, "'{}", counter)
913 } else if highlight.any_placeholders_highlighted() {
916 write!(f, "{}", self.name)
923 () ty::RegionKind, (self, f, cx) {
926 return self.print_debug(f, cx);
929 // Watch out for region highlights.
930 if let Some(n) = RegionHighlightMode::get().region_highlighted(self) {
931 return write!(f, "'{:?}", n);
934 // These printouts are concise. They do not contain all the information
935 // the user might want to diagnose an error, but there is basically no way
936 // to fit that into a short string. Hence the recommendation to use
937 // `explain_region()` or `note_and_explain_region()`.
939 ty::ReEarlyBound(ref data) => {
940 write!(f, "{}", data.name)
942 ty::ReLateBound(_, br) |
943 ty::ReFree(ty::FreeRegion { bound_region: br, .. }) => {
946 ty::RePlaceholder(p) => {
949 ty::ReScope(scope) if cx.identify_regions => {
951 region::ScopeData::Node =>
952 write!(f, "'{}s", scope.item_local_id().as_usize()),
953 region::ScopeData::CallSite =>
954 write!(f, "'{}cs", scope.item_local_id().as_usize()),
955 region::ScopeData::Arguments =>
956 write!(f, "'{}as", scope.item_local_id().as_usize()),
957 region::ScopeData::Destruction =>
958 write!(f, "'{}ds", scope.item_local_id().as_usize()),
959 region::ScopeData::Remainder(first_statement_index) => write!(
962 scope.item_local_id().as_usize(),
963 first_statement_index.index()
967 ty::ReVar(region_vid) => {
968 if RegionHighlightMode::get().any_region_vids_highlighted() {
969 write!(f, "{:?}", region_vid)
970 } else if cx.identify_regions {
971 write!(f, "'{}rv", region_vid.index())
977 ty::ReErased => Ok(()),
978 ty::ReStatic => write!(f, "'static"),
979 ty::ReEmpty => write!(f, "'<empty>"),
981 // The user should never encounter these in unsubstituted form.
982 ty::ReClosureBound(vid) => write!(f, "{:?}", vid),
987 ty::ReEarlyBound(ref data) => {
988 write!(f, "ReEarlyBound({}, {})",
993 ty::ReClosureBound(ref vid) => {
994 write!(f, "ReClosureBound({:?})",
998 ty::ReLateBound(binder_id, ref bound_region) => {
999 write!(f, "ReLateBound({:?}, {:?})",
1004 ty::ReFree(ref fr) => write!(f, "{:?}", fr),
1006 ty::ReScope(id) => {
1007 write!(f, "ReScope({:?})", id)
1010 ty::ReStatic => write!(f, "ReStatic"),
1012 ty::ReVar(ref vid) => {
1013 write!(f, "{:?}", vid)
1016 ty::RePlaceholder(placeholder) => {
1017 write!(f, "RePlaceholder({:?})", placeholder)
1020 ty::ReEmpty => write!(f, "ReEmpty"),
1022 ty::ReErased => write!(f, "ReErased")
1029 () ty::FreeRegion, (self, f, cx) {
1031 write!(f, "ReFree({:?}, {:?})", self.scope, self.bound_region)
1037 () ty::Variance, (self, f, cx) {
1039 f.write_str(match *self {
1040 ty::Covariant => "+",
1041 ty::Contravariant => "-",
1042 ty::Invariant => "o",
1043 ty::Bivariant => "*",
1050 ('tcx) ty::GenericPredicates<'tcx>, (self, f, cx) {
1052 write!(f, "GenericPredicates({:?})", self.predicates)
1058 ('tcx) ty::InstantiatedPredicates<'tcx>, (self, f, cx) {
1060 write!(f, "InstantiatedPredicates({:?})", self.predicates)
1066 ('tcx) ty::FnSig<'tcx>, (self, f, cx) {
1068 if self.unsafety == hir::Unsafety::Unsafe {
1069 write!(f, "unsafe ")?;
1072 if self.abi != Abi::Rust {
1073 write!(f, "extern {} ", self.abi)?;
1077 cx.fn_sig(f, self.inputs(), self.c_variadic, self.output())
1080 write!(f, "({:?}; c_variadic: {})->{:?}", self.inputs(), self.c_variadic, self.output())
1085 impl fmt::Debug for ty::TyVid {
1086 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1087 write!(f, "_#{}t", self.index)
1091 impl fmt::Debug for ty::IntVid {
1092 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1093 write!(f, "_#{}i", self.index)
1097 impl fmt::Debug for ty::FloatVid {
1098 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1099 write!(f, "_#{}f", self.index)
1103 impl fmt::Debug for ty::RegionVid {
1104 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1105 if let Some(counter) = RegionHighlightMode::get().region_highlighted(&ty::ReVar(*self)) {
1106 return write!(f, "'{:?}", counter);
1107 } else if RegionHighlightMode::get().any_region_vids_highlighted() {
1108 return write!(f, "'_");
1111 write!(f, "'_#{}r", self.index())
1116 () ty::InferTy, (self, f, cx) {
1119 print!(f, cx, print_debug(self))
1122 ty::TyVar(_) => write!(f, "_"),
1123 ty::IntVar(_) => write!(f, "{}", "{integer}"),
1124 ty::FloatVar(_) => write!(f, "{}", "{float}"),
1125 ty::FreshTy(v) => write!(f, "FreshTy({})", v),
1126 ty::FreshIntTy(v) => write!(f, "FreshIntTy({})", v),
1127 ty::FreshFloatTy(v) => write!(f, "FreshFloatTy({})", v)
1133 ty::TyVar(ref v) => write!(f, "{:?}", v),
1134 ty::IntVar(ref v) => write!(f, "{:?}", v),
1135 ty::FloatVar(ref v) => write!(f, "{:?}", v),
1136 ty::FreshTy(v) => write!(f, "FreshTy({:?})", v),
1137 ty::FreshIntTy(v) => write!(f, "FreshIntTy({:?})", v),
1138 ty::FreshFloatTy(v) => write!(f, "FreshFloatTy({:?})", v)
1144 impl fmt::Debug for ty::IntVarValue {
1145 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1147 ty::IntType(ref v) => v.fmt(f),
1148 ty::UintType(ref v) => v.fmt(f),
1153 impl fmt::Debug for ty::FloatVarValue {
1154 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1159 // The generic impl doesn't work yet because projections are not
1160 // normalized under HRTB.
1161 /*impl<T> fmt::Display for ty::Binder<T>
1162 where T: fmt::Display + for<'a> ty::Lift<'a>,
1163 for<'a> <T as ty::Lift<'a>>::Lifted: fmt::Display + TypeFoldable<'a>
1165 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1166 ty::tls::with(|tcx| in_binder(f, tcx, self, tcx.lift(self)))
1170 define_print_multi! {
1172 ('tcx) ty::Binder<&'tcx ty::List<ty::ExistentialPredicate<'tcx>>>,
1173 ('tcx) ty::Binder<ty::TraitRef<'tcx>>,
1174 ('tcx) ty::Binder<ty::FnSig<'tcx>>,
1175 ('tcx) ty::Binder<ty::TraitPredicate<'tcx>>,
1176 ('tcx) ty::Binder<ty::SubtypePredicate<'tcx>>,
1177 ('tcx) ty::Binder<ty::ProjectionPredicate<'tcx>>,
1178 ('tcx) ty::Binder<ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>>,
1179 ('tcx) ty::Binder<ty::OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>>>
1183 ty::tls::with(|tcx| cx.in_binder(f, tcx, self, tcx.lift(self)))
1189 ('tcx) ty::TraitRef<'tcx>, (self, f, cx) {
1191 cx.parameterized(f, self.substs, self.def_id, &[])
1194 // when printing out the debug representation, we don't need
1195 // to enumerate the `for<...>` etc because the debruijn index
1196 // tells you everything you need to know.
1199 print(self.self_ty()),
1201 cx.parameterized(f, self.substs, self.def_id, &[])?;
1208 ('tcx) ty::TyKind<'tcx>, (self, f, cx) {
1211 Bool => write!(f, "bool"),
1212 Char => write!(f, "char"),
1213 Int(t) => write!(f, "{}", t.ty_to_string()),
1214 Uint(t) => write!(f, "{}", t.ty_to_string()),
1215 Float(t) => write!(f, "{}", t.ty_to_string()),
1217 write!(f, "*{} ", match tm.mutbl {
1218 hir::MutMutable => "mut",
1219 hir::MutImmutable => "const",
1223 Ref(r, ty, mutbl) => {
1225 let s = r.print_to_string(cx);
1227 write!(f, "{}", s)?;
1232 ty::TypeAndMut { ty, mutbl }.print(f, cx)
1234 Never => write!(f, "!"),
1237 let mut tys = tys.iter();
1238 if let Some(&ty) = tys.next() {
1239 print!(f, cx, print(ty), write(","))?;
1240 if let Some(&ty) = tys.next() {
1241 print!(f, cx, write(" "), print(ty))?;
1243 print!(f, cx, write(", "), print(ty))?;
1249 FnDef(def_id, substs) => {
1250 ty::tls::with(|tcx| {
1251 let mut sig = tcx.fn_sig(def_id);
1252 if let Some(substs) = tcx.lift(&substs) {
1253 sig = sig.subst(tcx, substs);
1255 print!(f, cx, print(sig), write(" {{"))
1257 cx.parameterized(f, substs, def_id, &[])?;
1260 FnPtr(ref bare_fn) => {
1261 bare_fn.print(f, cx)
1263 Infer(infer_ty) => write!(f, "{}", infer_ty),
1264 Error => write!(f, "[type error]"),
1265 Param(ref param_ty) => write!(f, "{}", param_ty),
1266 Bound(debruijn, bound_ty) => {
1267 match bound_ty.kind {
1268 ty::BoundTyKind::Anon => {
1269 if debruijn == ty::INNERMOST {
1270 write!(f, "^{}", bound_ty.var.index())
1272 write!(f, "^{}_{}", debruijn.index(), bound_ty.var.index())
1276 ty::BoundTyKind::Param(p) => write!(f, "{}", p),
1279 Adt(def, substs) => cx.parameterized(f, substs, def.did, &[]),
1280 Dynamic(data, r) => {
1281 let r = r.print_to_string(cx);
1288 write!(f, " + {})", r)
1293 Foreign(def_id) => parameterized(f, subst::InternalSubsts::empty(), def_id, &[]),
1294 Projection(ref data) => data.print(f, cx),
1295 UnnormalizedProjection(ref data) => {
1296 write!(f, "Unnormalized(")?;
1300 Placeholder(placeholder) => {
1301 write!(f, "Placeholder({:?})", placeholder)
1303 Opaque(def_id, substs) => {
1305 return write!(f, "Opaque({:?}, {:?})", def_id, substs);
1308 ty::tls::with(|tcx| {
1309 let def_key = tcx.def_key(def_id);
1310 if let Some(name) = def_key.disambiguated_data.data.get_opt_name() {
1311 write!(f, "{}", name)?;
1312 let mut substs = substs.iter();
1313 if let Some(first) = substs.next() {
1315 write!(f, "{}", first)?;
1316 for subst in substs {
1317 write!(f, ", {}", subst)?;
1323 // Grab the "TraitA + TraitB" from `impl TraitA + TraitB`,
1324 // by looking up the projections associated with the def_id.
1325 let predicates_of = tcx.predicates_of(def_id);
1326 let substs = tcx.lift(&substs).unwrap_or_else(|| {
1327 tcx.intern_substs(&[])
1329 let bounds = predicates_of.instantiate(tcx, substs);
1331 let mut first = true;
1332 let mut is_sized = false;
1334 for predicate in bounds.predicates {
1335 if let Some(trait_ref) = predicate.to_opt_poly_trait_ref() {
1336 // Don't print +Sized, but rather +?Sized if absent.
1337 if Some(trait_ref.def_id()) == tcx.lang_items().sized_trait() {
1343 write("{}", if first { " " } else { "+" }),
1349 write!(f, "{}?Sized", if first { " " } else { "+" })?;
1351 write!(f, " Sized")?;
1356 Str => write!(f, "str"),
1357 Generator(did, substs, movability) => ty::tls::with(|tcx| {
1358 let upvar_tys = substs.upvar_tys(did, tcx);
1359 let witness = substs.witness(did, tcx);
1360 if movability == hir::GeneratorMovability::Movable {
1361 write!(f, "[generator")?;
1363 write!(f, "[static generator")?;
1366 if let Some(node_id) = tcx.hir().as_local_node_id(did) {
1367 write!(f, "@{:?}", tcx.hir().span(node_id))?;
1369 tcx.with_freevars(node_id, |freevars| {
1370 for (freevar, upvar_ty) in freevars.iter().zip(upvar_tys) {
1374 tcx.hir().name(freevar.var_id())),
1381 // cross-crate closure types should only be
1382 // visible in codegen bug reports, I imagine.
1383 write!(f, "@{:?}", did)?;
1385 for (index, upvar_ty) in upvar_tys.enumerate() {
1387 write("{}{}:", sep, index),
1393 print!(f, cx, write(" "), print(witness), write("]"))
1395 GeneratorWitness(types) => {
1396 ty::tls::with(|tcx| cx.in_binder(f, tcx, &types, tcx.lift(&types)))
1398 Closure(did, substs) => ty::tls::with(|tcx| {
1399 let upvar_tys = substs.upvar_tys(did, tcx);
1400 write!(f, "[closure")?;
1402 if let Some(node_id) = tcx.hir().as_local_node_id(did) {
1403 if tcx.sess.opts.debugging_opts.span_free_formats {
1404 write!(f, "@{:?}", node_id)?;
1406 write!(f, "@{:?}", tcx.hir().span(node_id))?;
1409 tcx.with_freevars(node_id, |freevars| {
1410 for (freevar, upvar_ty) in freevars.iter().zip(upvar_tys) {
1414 tcx.hir().name(freevar.var_id())),
1421 // cross-crate closure types should only be
1422 // visible in codegen bug reports, I imagine.
1423 write!(f, "@{:?}", did)?;
1425 for (index, upvar_ty) in upvar_tys.enumerate() {
1427 write("{}{}:", sep, index),
1436 " closure_kind_ty={:?} closure_sig_ty={:?}",
1437 substs.closure_kind_ty(did, tcx),
1438 substs.closure_sig_ty(did, tcx),
1445 print!(f, cx, write("["), print(ty), write("; "))?;
1447 ty::LazyConst::Unevaluated(_def_id, _substs) => {
1450 ty::LazyConst::Evaluated(c) => ty::tls::with(|tcx| {
1451 write!(f, "{}", c.unwrap_usize(tcx))
1457 print!(f, cx, write("["), print(ty), write("]"))
1465 ('tcx) ty::TyS<'tcx>, (self, f, cx) {
1467 self.sty.print(f, cx)
1470 self.sty.print_display(f, cx)
1476 () ty::ParamTy, (self, f, cx) {
1478 write!(f, "{}", self.name)
1481 write!(f, "{}/#{}", self.name, self.idx)
1487 ('tcx, T: Print + fmt::Debug, U: Print + fmt::Debug) ty::OutlivesPredicate<T, U>,
1490 print!(f, cx, print(self.0), write(" : "), print(self.1))
1496 ('tcx) ty::SubtypePredicate<'tcx>, (self, f, cx) {
1498 print!(f, cx, print(self.a), write(" <: "), print(self.b))
1504 ('tcx) ty::TraitPredicate<'tcx>, (self, f, cx) {
1506 write!(f, "TraitPredicate({:?})",
1510 print!(f, cx, print(self.trait_ref.self_ty()), write(": "), print(self.trait_ref))
1516 ('tcx) ty::ProjectionPredicate<'tcx>, (self, f, cx) {
1519 write("ProjectionPredicate("),
1520 print(self.projection_ty),
1526 print!(f, cx, print(self.projection_ty), write(" == "), print(self.ty))
1532 ('tcx) ty::ProjectionTy<'tcx>, (self, f, cx) {
1534 // FIXME(tschottdorf): use something like
1535 // parameterized(f, self.substs, self.item_def_id, &[])
1536 // (which currently ICEs).
1537 let (trait_ref, item_name) = ty::tls::with(|tcx|
1538 (self.trait_ref(tcx), tcx.associated_item(self.item_def_id).ident)
1540 print!(f, cx, print_debug(trait_ref), write("::{}", item_name))
1546 () ty::ClosureKind, (self, f, cx) {
1549 ty::ClosureKind::Fn => write!(f, "Fn"),
1550 ty::ClosureKind::FnMut => write!(f, "FnMut"),
1551 ty::ClosureKind::FnOnce => write!(f, "FnOnce"),
1558 ('tcx) ty::Predicate<'tcx>, (self, f, cx) {
1561 ty::Predicate::Trait(ref data) => data.print(f, cx),
1562 ty::Predicate::Subtype(ref predicate) => predicate.print(f, cx),
1563 ty::Predicate::RegionOutlives(ref predicate) => predicate.print(f, cx),
1564 ty::Predicate::TypeOutlives(ref predicate) => predicate.print(f, cx),
1565 ty::Predicate::Projection(ref predicate) => predicate.print(f, cx),
1566 ty::Predicate::WellFormed(ty) => print!(f, cx, print(ty), write(" well-formed")),
1567 ty::Predicate::ObjectSafe(trait_def_id) =>
1568 ty::tls::with(|tcx| {
1569 write!(f, "the trait `{}` is object-safe", tcx.item_path_str(trait_def_id))
1571 ty::Predicate::ClosureKind(closure_def_id, _closure_substs, kind) =>
1572 ty::tls::with(|tcx| {
1573 write!(f, "the closure `{}` implements the trait `{}`",
1574 tcx.item_path_str(closure_def_id), kind)
1576 ty::Predicate::ConstEvaluatable(def_id, substs) => {
1577 write!(f, "the constant `")?;
1578 cx.parameterized(f, substs, def_id, &[])?;
1579 write!(f, "` can be evaluated")
1585 ty::Predicate::Trait(ref a) => a.print(f, cx),
1586 ty::Predicate::Subtype(ref pair) => pair.print(f, cx),
1587 ty::Predicate::RegionOutlives(ref pair) => pair.print(f, cx),
1588 ty::Predicate::TypeOutlives(ref pair) => pair.print(f, cx),
1589 ty::Predicate::Projection(ref pair) => pair.print(f, cx),
1590 ty::Predicate::WellFormed(ty) => ty.print(f, cx),
1591 ty::Predicate::ObjectSafe(trait_def_id) => {
1592 write!(f, "ObjectSafe({:?})", trait_def_id)
1594 ty::Predicate::ClosureKind(closure_def_id, closure_substs, kind) => {
1595 write!(f, "ClosureKind({:?}, {:?}, {:?})", closure_def_id, closure_substs, kind)
1597 ty::Predicate::ConstEvaluatable(def_id, substs) => {
1598 write!(f, "ConstEvaluatable({:?}, {:?})", def_id, substs)