address nits by mattewjasper

Author: nikomatsakis

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -197,26 +197,8 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
         }
     }
 
-    /// Enforce constraints of the form:
-    ///
-    /// ```
-    /// 'r0 in ['o1...'oN]
-    /// ```
-    ///
-    /// such a constraint simply means that `'r0` must be equal to one
-    /// of the regions `'o1...'oN`. This is an annoying constraint to
-    /// integrate into our inference, which generally works by
-    /// iteratively growing regions until we find a match -- that's
-    /// not an option here.
-    ///
-    /// What we currently do:
-    ///
-    /// - Search forward in the graph from `'r0` to find each region `'b`
-    ///   where `'r0 <= 'b` must hold.
-    ///   - Try to rule out some of the `'o1..'oN` options:
-    ///     - if `'o[i] <= 'b` is false, then `'o[i]` is not an option
-    ///
-    /// Hopefully this narrows it down to just one option.
+    /// Enforce all pick constraints and return true if anything
+    /// changed. See `enforce_pick_constraint` for more details.
     fn enforce_pick_constraints(
         &self,
         graph: &RegionGraph<'tcx>,
@@ -237,15 +219,17 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
     /// pick 'r from ['o...]
     /// ```
     ///
-    /// We look to see if there is a unique option `'o` from the list of options
-    /// that:
+    /// We look for all option regions from the list `'o...` that:
     ///
-    /// (a) is greater than the current value of `'r` (which is a lower bound)
+    /// (a) are greater than the current value of `'r` (which is a lower bound)
     ///
     /// and
     ///
-    /// (b) is compatible with the upper bounds of `'r` that we can
+    /// (b) are compatible with the upper bounds of `'r` that we can
     /// find by traversing the graph.
+    ///
+    /// From that list, we look for a *minimal* option `'o_min`. If we
+    /// find one, then we can enforce that `'r: 'o_min`.
     fn enforce_pick_constraint(
         &self,
         graph: &RegionGraph<'tcx>,

src/librustc/infer/mod.rs

@@ -915,7 +915,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
         region: ty::Region<'tcx>,
         in_regions: &Rc<Vec<ty::Region<'tcx>>>,
     ) {
-        debug!("sub_regions({:?} <: {:?})", region, in_regions);
+        debug!("pick_constraint({:?} <: {:?})", region, in_regions);
         self.borrow_region_constraints()
             .pick_constraint(opaque_type_def_id, definition_span, hidden_ty, region, in_regions);
     }

src/librustc/infer/opaque_types/mod.rs

@@ -271,8 +271,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
     /// is an inference variable). If we generated a constraint that
     /// `Tc: 'a`, then this would incorrectly require that `T: 'a` --
     /// but this is not necessary, because the existential type we
-    /// create will be allowed to reference `T`. So instead we just
-    /// generate a constraint that `'0: 'a`.
+    /// create will be allowed to reference `T`. So we only generate a
+    /// constraint that `'0: 'a`.
     ///
     /// # The `free_region_relations` parameter
     ///
@@ -563,8 +563,7 @@ pub fn unexpected_hidden_region_diagnostic(
         // ```
         //
         // Here the captured lifetime is the intersection of `'a` and
-        // `'b`, which we can't quite express. This prticulararticular
-        // is kind of an unfortunate error anyway.
+        // `'b`, which we can't quite express.
 
         if let Some(region_scope_tree) = region_scope_tree {
             // If the `region_scope_tree` is available, this is being

src/librustc_data_structures/graph/vec_graph/mod.rs

@@ -1,6 +1,7 @@
 use crate::indexed_vec::{Idx, IndexVec};
 use crate::graph::{DirectedGraph, WithNumNodes, WithNumEdges, WithSuccessors, GraphSuccessors};
 
+#[cfg(test)]
 mod test;
 
 pub struct VecGraph<N: Idx> {

src/librustc_data_structures/graph/vec_graph/test.rs

@@ -1,5 +1,3 @@
-#![cfg(test)]
-
 use super::*;
 
 fn create_graph() -> VecGraph<usize> {