rustc: move ty::print::PrintConfig's fields to FmtPrinter.

Author: eddyb

src/librustc/infer/error_reporting/mod.rs

@@ -527,9 +527,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             // module we could have false positives
             if !(did1.is_local() || did2.is_local()) && did1.krate != did2.krate {
                 let abs_path = |def_id| {
-                    PrintCx::with(self.tcx, AbsolutePathPrinter, |cx| {
-                        cx.print_def_path(def_id, None, iter::empty())
-                    })
+                    PrintCx::new(self.tcx, AbsolutePathPrinter)
+                        .print_def_path(def_id, None, iter::empty())
                 };
 
                 // We compare strings because DefPath can be different

src/librustc/infer/error_reporting/need_type_info.rs

@@ -84,9 +84,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         if let Some(highlight) = highlight {
             printer.region_highlight_mode = highlight;
         }
-        let _ = ty::print::PrintCx::with(self.tcx, printer, |cx| {
-            ty.print(cx)
-        });
+        let _ = ty.print(ty::print::PrintCx::new(self.tcx, printer));
         s
     }
 

src/librustc/infer/error_reporting/nice_region_error/placeholder_error.rs

@@ -250,13 +250,14 @@ impl NiceRegionError<'me, 'gcx, 'tcx> {
             printer.region_highlight_mode.maybe_highlighting_region(sub_placeholder, has_sub);
             printer.region_highlight_mode.maybe_highlighting_region(sup_placeholder, has_sup);
 
-            let _ = ty::print::PrintCx::with(self.tcx, printer, |mut cx| {
-                write!(cx.printer, "`")?;
+            let _ = (|| {
+                let mut cx = ty::print::PrintCx::new(self.tcx, printer);
+                write!(cx, "`")?;
                 cx = cx.nest(|cx| expected_trait_ref.self_ty().print(cx))?;
-                write!(cx.printer, "` must implement `")?;
+                write!(cx, "` must implement `")?;
                 cx = cx.nest(|cx| expected_trait_ref.print(cx))?;
-                write!(cx.printer, "`")
-            });
+                write!(cx, "`")
+            })();
 
             match (has_sub, has_sup) {
                 (Some(n1), Some(n2)) => {
@@ -283,13 +284,14 @@ impl NiceRegionError<'me, 'gcx, 'tcx> {
             let mut printer = ty::print::FmtPrinter::new(&mut note, Namespace::TypeNS);
             printer.region_highlight_mode.maybe_highlighting_region(vid, has_vid);
 
-            let _ = ty::print::PrintCx::with(self.tcx, printer, |mut cx| {
-                write!(cx.printer, "but `")?;
+            let _ = (|| {
+                let mut cx = ty::print::PrintCx::new(self.tcx, printer);
+                write!(cx, "but `")?;
                 cx = cx.nest(|cx| actual_trait_ref.self_ty().print(cx))?;
-                write!(cx.printer, "` only implements `")?;
+                write!(cx, "` only implements `")?;
                 cx = cx.nest(|cx| actual_trait_ref.print(cx))?;
-                write!(cx.printer, "`")
-            });
+                write!(cx, "`")
+            })();
 
             if let Some(n) = has_vid {
                 let _ = write!(note,

src/librustc/ty/print/mod.rs

@@ -4,52 +4,50 @@ use ty::{self, DefIdTree, Ty, TyCtxt};
 use ty::subst::{Subst, Substs};
 
 use rustc_data_structures::fx::FxHashSet;
-use syntax::symbol::InternedString;
 
 use std::iter;
-use std::ops::Deref;
+use std::ops::{Deref, DerefMut};
 
 // `pretty` is a separate module only for organization.
 mod pretty;
 pub use self::pretty::*;
 
-#[derive(Default)]
-struct PrintConfig {
-    used_region_names: Option<FxHashSet<InternedString>>,
-    region_index: usize,
-    binder_depth: usize,
-}
-
 pub struct PrintCx<'a, 'gcx, 'tcx, P> {
     pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
-    pub printer: P,
-    config: &'a mut PrintConfig,
+    inner: P,
 }
 
-// HACK(eddyb) this is solely for `self: PrintCx<Self>`, e.g. to
-// implement traits on the printer and call the methods on the context.
 impl<P> Deref for PrintCx<'_, '_, '_, P> {
     type Target = P;
     fn deref(&self) -> &P {
-        &self.printer
+        &self.inner
+    }
+}
+
+impl<P> DerefMut for PrintCx<'_, '_, '_, P> {
+    fn deref_mut(&mut self) -> &mut P {
+        &mut self.inner
     }
 }
 
 impl<'a, 'gcx, 'tcx, P> PrintCx<'a, 'gcx, 'tcx, P> {
-    pub fn with<R>(
-        tcx: TyCtxt<'a, 'gcx, 'tcx>,
-        printer: P,
-        f: impl FnOnce(PrintCx<'_, 'gcx, 'tcx, P>) -> R,
-    ) -> R {
-        f(PrintCx {
+    pub fn new(tcx: TyCtxt<'a, 'gcx, 'tcx>, inner: P) -> Self {
+        PrintCx {
             tcx,
-            printer,
-            config: &mut PrintConfig::default(),
-        })
+            inner,
+        }
+    }
+
+    pub fn with_tls_tcx<R>(inner: P, f: impl FnOnce(PrintCx<'_, '_, '_, P>) -> R) -> R {
+        ty::tls::with(|tcx| f(PrintCx::new(tcx, inner)))
+    }
+
+    pub fn into_inner(self) -> P {
+        self.inner
     }
 
-    pub fn with_tls_tcx<R>(printer: P, f: impl FnOnce(PrintCx<'_, '_, '_, P>) -> R) -> R {
-        ty::tls::with(|tcx| PrintCx::with(tcx, printer, f))
+    pub fn ok<E>(self) -> Result<P, E> {
+        Ok(self.into_inner())
     }
 }