rustc: don't keep RegionHighlightMode in a thread-local.

Author: eddyb

src/librustc/infer/error_reporting/need_type_info.rs

@@ -3,6 +3,7 @@ use hir::intravisit::{self, Visitor, NestedVisitorMap};
 use infer::InferCtxt;
 use infer::type_variable::TypeVariableOrigin;
 use ty::{self, Ty, Infer, TyVar};
+use ty::print::Print;
 use syntax::source_map::CompilerDesugaringKind;
 use syntax_pos::Span;
 use errors::DiagnosticBuilder;
@@ -64,18 +65,28 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindLocalByTypeVisitor<'a, 'gcx, 'tcx> {
 
 
 impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
-    pub fn extract_type_name(&self, ty: &'a Ty<'tcx>) -> String {
+    pub fn extract_type_name(
+        &self,
+        ty: &'a Ty<'tcx>,
+        highlight: Option<ty::print::RegionHighlightMode>,
+    ) -> String {
         if let ty::Infer(ty::TyVar(ty_vid)) = (*ty).sty {
             let ty_vars = self.type_variables.borrow();
             if let TypeVariableOrigin::TypeParameterDefinition(_, name) =
                 *ty_vars.var_origin(ty_vid) {
-                name.to_string()
-            } else {
-                ty.to_string()
+                return name.to_string();
             }
-        } else {
-            ty.to_string()
         }
+
+        let mut s = String::new();
+        let mut printer = ty::print::FmtPrinter::new(&mut s);
+        if let Some(highlight) = highlight {
+            printer.region_highlight_mode = highlight;
+        }
+        let _ = ty::print::PrintCx::with(self.tcx, printer, |cx| {
+            ty.print(cx)
+        });
+        s
     }
 
     pub fn need_type_info_err(&self,
@@ -84,7 +95,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                             ty: Ty<'tcx>)
                             -> DiagnosticBuilder<'gcx> {
         let ty = self.resolve_type_vars_if_possible(&ty);
-        let name = self.extract_type_name(&ty);
+        let name = self.extract_type_name(&ty, None);
 
         let mut err_span = span;
         let mut labels = vec![(

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

@@ -7,8 +7,10 @@ use traits::{ObligationCause, ObligationCauseCode};
 use ty;
 use ty::error::ExpectedFound;
 use ty::subst::Substs;
+use ty::print::{Print, PrettyPrinter};
 use util::common::ErrorReported;
-use util::ppaux::RegionHighlightMode;
+
+use std::fmt::Write;
 
 impl NiceRegionError<'me, 'gcx, 'tcx> {
     /// When given a `ConcreteFailure` for a function with arguments containing a named region and
@@ -241,65 +243,63 @@ impl NiceRegionError<'me, 'gcx, 'tcx> {
             .tcx
             .any_free_region_meets(&actual_trait_ref.self_ty(), |r| Some(r) == vid);
 
-        RegionHighlightMode::maybe_highlighting_region(sub_placeholder, has_sub, || {
-            RegionHighlightMode::maybe_highlighting_region(sup_placeholder, has_sup, || {
-                match (has_sub, has_sup) {
-                    (Some(n1), Some(n2)) => {
-                        err.note(&format!(
-                            "`{}` must implement `{}` \
-                             for any two lifetimes `'{}` and `'{}`",
-                            expected_trait_ref.self_ty(),
-                            expected_trait_ref,
-                            std::cmp::min(n1, n2),
-                            std::cmp::max(n1, n2),
-                        ));
-                    }
-                    (Some(n), _) | (_, Some(n)) => {
-                        err.note(&format!(
-                            "`{}` must implement `{}` \
-                             for any lifetime `'{}`",
-                            expected_trait_ref.self_ty(),
-                            expected_trait_ref,
-                            n,
-                        ));
-                    }
-                    (None, None) => {
-                        err.note(&format!(
-                            "`{}` must implement `{}`",
-                            expected_trait_ref.self_ty(),
-                            expected_trait_ref,
-                        ));
-                    }
-                }
-            })
-        });
+        {
+            let mut note = String::new();
+            let mut printer = ty::print::FmtPrinter::new(&mut note);
+            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, "`")?;
+                cx = cx.nest(|cx| expected_trait_ref.self_ty().print(cx))?;
+                write!(cx.printer, "` must implement `")?;
+                cx = cx.nest(|cx| expected_trait_ref.print(cx))?;
+                write!(cx.printer, "`")
+            });
 
-        RegionHighlightMode::maybe_highlighting_region(vid, has_vid, || match has_vid {
-            Some(n) => {
-                if self_ty_has_vid {
-                    err.note(&format!(
-                        "but `{}` only implements `{}` for the lifetime `'{}`",
-                        actual_trait_ref.self_ty(),
-                        actual_trait_ref,
-                        n
-                    ));
-                } else {
-                    err.note(&format!(
-                        "but `{}` only implements `{}` for some lifetime `'{}`",
-                        actual_trait_ref.self_ty(),
-                        actual_trait_ref,
-                        n
-                    ));
+            match (has_sub, has_sup) {
+                (Some(n1), Some(n2)) => {
+                    let _ = write!(note,
+                        " for any two lifetimes `'{}` and `'{}`",
+                        std::cmp::min(n1, n2),
+                        std::cmp::max(n1, n2),
+                    );
                 }
+                (Some(n), _) | (_, Some(n)) => {
+                    let _ = write!(note,
+                        " for any lifetime `'{}`",
+                        n,
+                    );
+                }
+                (None, None) => {}
             }
-            None => {
-                err.note(&format!(
-                    "but `{}` only implements `{}`",
-                    actual_trait_ref.self_ty(),
-                    actual_trait_ref,
-                ));
+
+            err.note(&note);
+        }
+
+        {
+            let mut note = String::new();
+            let mut printer = ty::print::FmtPrinter::new(&mut note);
+            printer.region_highlight_mode.maybe_highlighting_region(vid, has_vid);
+
+            let _ = ty::print::PrintCx::with(self.tcx, printer, |mut cx| {
+                write!(cx.printer, "but `")?;
+                cx = cx.nest(|cx| actual_trait_ref.self_ty().print(cx))?;
+                write!(cx.printer, "` only implements `")?;
+                cx = cx.nest(|cx| actual_trait_ref.print(cx))?;
+                write!(cx.printer, "`")
+            });
+
+            if let Some(n) = has_vid {
+                let _ = write!(note,
+                    " for {} lifetime `'{}`",
+                    if self_ty_has_vid { "the" } else { "some" },
+                    n
+                );
             }
-        });
+
+            err.note(&note);
+        }
 
         err.emit();
         ErrorReported

src/librustc/ty/print.rs

@@ -48,6 +48,103 @@ pub fn with_crate_prefix<F: FnOnce() -> R, R>(f: F) -> R {
 // FIXME(eddyb) this module uses `pub(crate)` for things used only
 // from `ppaux` - when that is removed, they can be re-privatized.
 
+/// The "region highlights" are used to control region printing during
+/// specific error messages. When a "region highlight" is enabled, it
+/// gives an alternate way to print specific regions. For now, we
+/// always print those regions using a number, so something like `'0`.
+///
+/// Regions not selected by the region highlight mode are presently
+/// unaffected.
+#[derive(Copy, Clone, Default)]
+pub struct RegionHighlightMode {
+    /// If enabled, when we see the selected region, use `"'N"`
+    /// instead of the ordinary behavior.
+    highlight_regions: [Option<(ty::RegionKind, usize)>; 3],
+
+    /// If enabled, when printing a "free region" that originated from
+    /// the given `ty::BoundRegion`, print it as `'1`. Free regions that would ordinarily
+    /// have names print as normal.
+    ///
+    /// This is used when you have a signature like `fn foo(x: &u32,
+    /// y: &'a u32)` and we want to give a name to the region of the
+    /// reference `x`.
+    pub(crate) highlight_bound_region: Option<(ty::BoundRegion, usize)>,
+}
+
+impl RegionHighlightMode {
+    /// If `region` and `number` are both `Some`, invoke
+    /// `highlighting_region`.
+    pub fn maybe_highlighting_region(
+        &mut self,
+        region: Option<ty::Region<'_>>,
+        number: Option<usize>,
+    ) {
+        if let Some(k) = region {
+            if let Some(n) = number {
+                self.highlighting_region(k, n);
+            }
+        }
+    }
+
+    /// Highlight the region inference variable `vid` as `'N`.
+    pub fn highlighting_region(
+        &mut self,
+        region: ty::Region<'_>,
+        number: usize,
+    ) {
+        let num_slots = self.highlight_regions.len();
+        let first_avail_slot = self.highlight_regions.iter_mut()
+            .filter(|s| s.is_none())
+            .next()
+            .unwrap_or_else(|| {
+                bug!(
+                    "can only highlight {} placeholders at a time",
+                    num_slots,
+                )
+            });
+        *first_avail_slot = Some((*region, number));
+    }
+
+    /// Convenience wrapper for `highlighting_region`
+    pub fn highlighting_region_vid(
+        &mut self,
+        vid: ty::RegionVid,
+        number: usize,
+    ) {
+        self.highlighting_region(&ty::ReVar(vid), number)
+    }
+
+    /// Returns `Some(n)` with the number to use for the given region,
+    /// if any.
+    pub(crate) fn region_highlighted(&self, region: ty::Region<'_>) -> Option<usize> {
+        self
+            .highlight_regions
+            .iter()
+            .filter_map(|h| match h {
+                Some((r, n)) if r == region => Some(*n),
+                _ => None,
+            })
+            .next()
+    }
+
+    /// Highlight the given bound region.
+    /// We can only highlight one bound region at a time.  See
+    /// the field `highlight_bound_region` for more detailed notes.
+    pub fn highlighting_bound_region(
+        &mut self,
+        br: ty::BoundRegion,
+        number: usize,
+    ) {
+        assert!(self.highlight_bound_region.is_none());
+        self.highlight_bound_region = Some((br, number));
+    }
+
+    /// Returns `Some(N)` if the placeholder `p` is highlighted to print as `'N`.
+    pub(crate) fn placeholder_highlight(&self, p: ty::PlaceholderRegion) -> Option<usize> {
+        self.region_highlighted(&ty::RePlaceholder(p))
+    }
+}
+
 struct LateBoundRegionNameCollector(FxHashSet<InternedString>);
 impl<'tcx> ty::fold::TypeVisitor<'tcx> for LateBoundRegionNameCollector {
     fn visit_region(&mut self, r: ty::Region<'tcx>) -> bool {
@@ -238,6 +335,10 @@ pub trait PrettyPrinter: Printer<Error = fmt::Error, Path = Self> + fmt::Write {
             config: self.config,
         })
     }
+
+    fn region_highlight_mode(&self) -> RegionHighlightMode {
+        RegionHighlightMode::default()
+    }
 }
 
 macro_rules! nest {
@@ -450,13 +551,15 @@ pub fn characteristic_def_id_of_type(ty: Ty<'_>) -> Option<DefId> {
 pub struct FmtPrinter<F: fmt::Write> {
     pub(crate) fmt: F,
     empty: bool,
+    pub region_highlight_mode: RegionHighlightMode,
 }
 
 impl<F: fmt::Write> FmtPrinter<F> {
     pub fn new(fmt: F) -> Self {
         FmtPrinter {
             fmt,
             empty: true,
+            region_highlight_mode: RegionHighlightMode::default(),
         }
     }
 }
@@ -918,4 +1021,8 @@ impl<F: fmt::Write> PrettyPrinter for FmtPrinter<F> {
             config: self.config,
         })
     }
+
+    fn region_highlight_mode(&self) -> RegionHighlightMode {
+        self.region_highlight_mode
+    }
 }