Aggregation of drive-by cosmetic changes.

Author: Alexander Regueiro

src/librustc/hir/lowering.rs

@@ -37,8 +37,9 @@ use crate::hir::map::{DefKey, DefPathData, Definitions};
 use crate::hir::def_id::{DefId, DefIndex, DefIndexAddressSpace, CRATE_DEF_INDEX};
 use crate::hir::def::{Def, PathResolution, PerNS};
 use crate::hir::{GenericArg, ConstArg};
-use crate::lint::builtin::{self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES,
-                    ELIDED_LIFETIMES_IN_PATHS};
+use crate::lint::builtin::{
+    self, PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES, ELIDED_LIFETIMES_IN_PATHS
+};
 use crate::middle::cstore::CrateStore;
 use crate::session::Session;
 use crate::session::config::nightly_options;
@@ -5145,7 +5146,7 @@ impl<'a> LoweringContext<'a> {
     /// `Box<dyn Debug + '_>`. In those cases, `lower_lifetime` is invoked.
     fn elided_dyn_bound(&mut self, span: Span) -> hir::Lifetime {
         match self.anonymous_lifetime_mode {
-            // NB. We intentionally ignore the create-parameter mode here.
+            // N.B., We intentionally ignore the create-parameter mode here.
             // and instead "pass through" to resolve-lifetimes, which will apply
             // the object-lifetime-defaulting rules. Elided object lifetime defaults
             // do not act like other elided lifetimes. In other words, given this:

src/librustc/infer/opaque_types/mod.rs

@@ -13,27 +13,27 @@ use crate::util::nodemap::DefIdMap;
 
 pub type OpaqueTypeMap<'tcx> = DefIdMap<OpaqueTypeDecl<'tcx>>;
 
-/// Information about the opaque, abstract types whose values we
+/// Information about the opaque, existential types whose values we
 /// are inferring in this function (these are the `impl Trait` that
 /// appear in the return type).
 #[derive(Copy, Clone, Debug)]
 pub struct OpaqueTypeDecl<'tcx> {
-    /// The substitutions that we apply to the abstract that this
+    /// The substitutions that we apply to the existential type that this
     /// `impl Trait` desugars to. e.g., if:
     ///
     ///     fn foo<'a, 'b, T>() -> impl Trait<'a>
     ///
     /// winds up desugared to:
     ///
-    ///     abstract type Foo<'x, X>: Trait<'x>
+    ///     existential type Foo<'x, X>: Trait<'x>
     ///     fn foo<'a, 'b, T>() -> Foo<'a, T>
     ///
     /// then `substs` would be `['a, T]`.
     pub substs: SubstsRef<'tcx>,
 
-    /// The type variable that represents the value of the abstract type
+    /// The type variable that represents the value of the existential type
     /// that we require. In other words, after we compile this function,
-    /// we will be created a constraint like:
+    /// we will have created a constraint like:
     ///
     ///     Foo<'a, T> = ?C
     ///
@@ -141,12 +141,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     /// Here, we have two `impl Trait` types whose values are being
     /// inferred (the `impl Bar<'a>` and the `impl
     /// Bar<'b>`). Conceptually, this is sugar for a setup where we
-    /// define underlying abstract types (`Foo1`, `Foo2`) and then, in
+    /// define underlying existential types (`Foo1`, `Foo2`) and then, in
     /// the return type of `foo`, we *reference* those definitions:
     ///
     /// ```text
-    /// abstract type Foo1<'x>: Bar<'x>;
-    /// abstract type Foo2<'x>: Bar<'x>;
+    /// existential type Foo1<'x>: Bar<'x>;
+    /// existential type Foo2<'x>: Bar<'x>;
     /// fn foo<'a, 'b>(..) -> (Foo1<'a>, Foo2<'b>) { .. }
     ///                    //  ^^^^ ^^
     ///                    //  |    |
@@ -205,7 +205,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     ///
     /// This is actually a bit of a tricky constraint in general. We
     /// want to say that each variable (e.g., `'0`) can only take on
-    /// values that were supplied as arguments to the abstract type
+    /// values that were supplied as arguments to the existential type
     /// (e.g., `'a` for `Foo1<'a>`) or `'static`, which is always in
     /// scope. We don't have a constraint quite of this kind in the current
     /// region checker.
@@ -232,10 +232,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     /// # The `free_region_relations` parameter
     ///
     /// The `free_region_relations` argument is used to find the
-    /// "minimum" of the regions supplied to a given abstract type.
+    /// "minimum" of the regions supplied to a given existential type.
     /// It must be a relation that can answer whether `'a <= 'b`,
     /// where `'a` and `'b` are regions that appear in the "substs"
-    /// for the abstract type references (the `<'a>` in `Foo1<'a>`).
+    /// for the existential type references (the `<'a>` in `Foo1<'a>`).
     ///
     /// Note that we do not impose the constraints based on the
     /// generic regions from the `Foo1` definition (e.g., `'x`). This
@@ -251,7 +251,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     ///
     /// Here, the fact that `'b: 'a` is known only because of the
     /// implied bounds from the `&'a &'b u32` parameter, and is not
-    /// "inherent" to the abstract type definition.
+    /// "inherent" to the existential type definition.
     ///
     /// # Parameters
     ///
@@ -364,16 +364,16 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     }
 
                     Component::Param(_) => {
-                        // ignore type parameters like `T`, they are captured
-                        // implicitly by the `impl Trait`
+                        // Ignore type parameters like `T`, since they are captured
+                        // implicitly by the `impl Trait`.
                     }
 
                     Component::UnresolvedInferenceVariable(_) => {
-                        // we should get an error that more type
-                        // annotations are needed in this case
+                        // We should get an error that more type
+                        // annotations are needed in this case.
                         self.tcx
                             .sess
-                            .delay_span_bug(span, "unresolved inf var in opaque");
+                            .delay_span_bug(span, "unresolved inf var in opaque type");
                     }
 
                     Component::Projection(ty::ProjectionTy {
@@ -397,20 +397,32 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 }
             }
         }
+
+        // For soundness, we need to ensure that every region that is captured by the opaque type
+        // but does not explicitly appear in the opaque type outlives the actual (concrete) type.
+        // This allows for invariant lifetimes to be captured by opaque types as long as
+        // short-lived lifetimes are not permitted to escape and cause UB. 
+        let opaque_substs_regions = opaque_defn.substs.regions().collect();
+        let captured_regions = concrete_ty_regions.difference(&opaque_substs_regions);
+        for captured_region in captured_regions {
+            for concrete_ty_region in &concrete_ty_regions {
+                self.sub_regions(infer::CallReturn(span), *concrete_ty_region, captured_region)
+            }
+        }
     }
 
     /// Given the fully resolved, instantiated type for an opaque
     /// type, i.e., the value of an inference variable like C1 or C2
-    /// (*), computes the "definition type" for an abstract type
+    /// (*), computes the "definition type" for an existential type
     /// definition -- that is, the inferred value of `Foo1<'x>` or
     /// `Foo2<'x>` that we would conceptually use in its definition:
     ///
-    ///     abstract type Foo1<'x>: Bar<'x> = AAA; <-- this type AAA
-    ///     abstract type Foo2<'x>: Bar<'x> = BBB; <-- or this type BBB
+    ///     existential type Foo1<'x>: Bar<'x> = AAA; <-- this type AAA
+    ///     existential type Foo2<'x>: Bar<'x> = BBB; <-- or this type BBB
     ///     fn foo<'a, 'b>(..) -> (Foo1<'a>, Foo2<'b>) { .. }
     ///
-    /// Note that these values are defined in terms of a distinct set of
-    /// generic parameters (`'x` instead of `'a`) from C1 or C2. The main
+    /// Note that these values are defined in terms of a set of generic
+    /// parameters (`'x` instead of `'a`) distinct from C1 and C2. The main
     /// purpose of this function is to do that translation.
     ///
     /// (*) C1 and C2 were introduced in the comments on
@@ -450,23 +462,20 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             .collect();
 
         // Convert the type from the function into a type valid outside
-        // the function, by replacing invalid regions with 'static,
+        // the function, by replacing invalid regions with `'static`,
         // after producing an error for each of them.
         let definition_ty =
-            instantiated_ty.fold_with(&mut ReverseMapper::new(
-                self.tcx,
-                self.is_tainted_by_errors(),
-                def_id,
+            instantiated_ty.fold_with(&mut ReverseMapper {
+                tcx: self.tcx,
                 map,
-                instantiated_ty,
-            ));
+            });
         debug!(
             "infer_opaque_definition_from_instantiation: definition_ty={:?}",
             definition_ty
         );
 
         // We can unwrap here because our reverse mapper always
-        // produces things with 'gcx lifetime, though the type folder
+        // produces things with `'gcx` lifetime, though the type folder
         // obscures that.
         let definition_ty = gcx.lift(&definition_ty).unwrap();
 
@@ -656,20 +665,20 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
                     // value we are inferring.  At present, this is
                     // always true during the first phase of
                     // type-check, but not always true later on during
-                    // NLL. Once we support named abstract types more fully,
+                    // NLL. Once we support named existential types more fully,
                     // this same scenario will be able to arise during all phases.
                     //
-                    // Here is an example using `abstract type` that indicates
+                    // Here is an example using `existential type` that indicates
                     // the distinction we are checking for:
                     //
                     // ```rust
                     // mod a {
-                    //   pub abstract type Foo: Iterator;
-                    //   pub fn make_foo() -> Foo { .. }
+                    //     pub existential type Foo: Iterator;
+                    //     pub fn make_foo() -> Foo { .. }
                     // }
                     //
                     // mod b {
-                    //   fn foo() -> a::Foo { a::make_foo() }
+                    //     fn foo() -> a::Foo { a::make_foo() }
                     // }
                     // ```
                     //
@@ -777,7 +786,7 @@ impl<'a, 'gcx, 'tcx> Instantiator<'a, 'gcx, 'tcx> {
             required_region_bounds
         );
 
-        // make sure that we are in fact defining the *entire* type
+        // Make sure that we are in fact defining the *entire* type
         // e.g., `existential type Foo<T: Bound>: Bar;` needs to be
         // defined by a function like `fn foo<T: Bound>() -> Foo<T>`.
         debug!(

src/librustc/infer/outlives/env.rs

@@ -197,8 +197,8 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a> OutlivesEnvironment<'tcx> {
     ) where
         I: IntoIterator<Item = OutlivesBound<'tcx>>,
     {
-        // Record relationships such as `T:'x` that don't go into the
-        // free-region-map but which we use here.
+        // Record relationships such as `T: 'x`, which don't go into the
+        // free-region-map, but which we use here.
         for outlives_bound in outlives_bounds {
             debug!("add_outlives_bounds: outlives_bound={:?}", outlives_bound);
             match outlives_bound {

src/librustc/infer/outlives/free_region_map.rs

@@ -15,7 +15,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
         self.relation.is_empty()
     }
 
-    // Record that `'sup:'sub`. Or, put another way, `'sub <= 'sup`.
+    // Record that `'sup: 'sub`. Or, put another way, `'sub <= 'sup`.
     // (with the exception that `'static: 'x` is not notable)
     pub fn relate_regions(&mut self, sub: Region<'tcx>, sup: Region<'tcx>) {
         debug!("relate_regions(sub={:?}, sup={:?})", sub, sup);
@@ -24,7 +24,7 @@ impl<'tcx> FreeRegionMap<'tcx> {
         }
     }
 
-    /// Computes the least-upper-bound of two free regions. In some
+    /// Computes the least upper bound of two free regions. In some
     /// cases, this is more conservative than necessary, in order to
     /// avoid making arbitrary choices. See
     /// `TransitiveRelation::postdom_upper_bound` for more details.
@@ -90,6 +90,7 @@ impl_stable_hash_for!(struct FreeRegionMap<'tcx> {
 
 impl<'a, 'tcx> Lift<'tcx> for FreeRegionMap<'a> {
     type Lifted = FreeRegionMap<'tcx>;
+
     fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<FreeRegionMap<'tcx>> {
         self.relation.maybe_map(|&fr| tcx.lift(&fr))
                      .map(|relation| FreeRegionMap { relation })

src/librustc/traits/auto_trait.rs

@@ -141,9 +141,9 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
             // selection and projection:
             //
             // * We can always cache the result of a particular trait selection for the lifetime of
-            // an InfCtxt
+            // an `InferCtxt`.
             // * Given a projection bound such as '<T as SomeTrait>::SomeItem = K', if 'T:
-            // SomeTrait' doesn't hold, then we don't need to care about the 'SomeItem = K'
+            // SomeTrait' doesn't hold, then we don't need to care about the 'SomeItem = K'.
             //
             // We fix the first assumption by manually clearing out all of the InferCtxt's caches
             // in between calls to SelectionContext.select. This allows us to keep all of the

src/librustc/traits/query/outlives_bounds.rs

@@ -72,7 +72,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
     /// argument types are well-formed. This may imply certain relationships
     /// between generic parameters. For example:
     ///
-    ///     fn foo<'a,T>(x: &'a T)
+    ///     fn foo<'a, T>(x: &'a T)
     ///
     /// can only be called with a `'a` and `T` such that `&'a T` is WF.
     /// For `&'a T` to be WF, `T: 'a` must hold. So we can assume `T: 'a`.
@@ -102,7 +102,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
             Err(NoSolution) => {
                 self.tcx.sess.delay_span_bug(
                     span,
-                    "implied_outlives_bounds failed to solve all obligations"
+                    "implied_outlives_bounds: failed to solve all obligations",
                 );
                 return vec![];
             }
@@ -117,7 +117,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
             Err(_) => {
                 self.tcx.sess.delay_span_bug(
                     span,
-                    "implied_outlives_bounds failed to instantiate"
+                    "implied_outlives_bounds: failed to instantiate",
                 );
                 return vec![];
             }
@@ -130,7 +130,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
         if fulfill_cx.select_all_or_error(self).is_err() {
             self.tcx.sess.delay_span_bug(
                 span,
-                "implied_outlives_bounds failed to solve obligations from instantiation"
+                "implied_outlives_bounds: failed to solve obligations from instantiation",
             );
         }
 

src/librustc/ty/mod.rs

@@ -1643,7 +1643,7 @@ pub struct ParamEnv<'tcx> {
     pub reveal: traits::Reveal,
 
     /// If this `ParamEnv` comes from a call to `tcx.param_env(def_id)`,
-    /// register that `def_id` (useful for transitioning to the chalk trait
+    /// register that `def_id` (useful for transitioning to the Chalk trait
     /// solver).
     pub def_id: Option<DefId>,
 }

src/librustc/ty/outlives.rs

@@ -1,4 +1,4 @@
-// The outlines relation `T: 'a` or `'a: 'b`. This code frequently
+// The outlives relation; `T: 'a` or `'a: 'b`. This code frequently
 // refers to rules defined in RFC 1214 (`OutlivesFooBar`), so see that
 // RFC for reference.
 

src/librustc/ty/query/mod.rs

@@ -158,7 +158,7 @@ rustc_query_append! { [define_queries!][ <'tcx>
         [] fn is_const_fn_raw: IsConstFn(DefId) -> bool,
 
 
-        /// Returns true if calls to the function may be promoted
+        /// Returns `true` if calls to the function may be promoted.
         ///
         /// This is either because the function is e.g., a tuple-struct or tuple-variant
         /// constructor, or because it has the `#[rustc_promotable]` attribute. The attribute should
@@ -174,22 +174,22 @@ rustc_query_append! { [define_queries!][ <'tcx>
         /// instead.
         [] fn crate_variances: crate_variances(CrateNum) -> Lrc<ty::CrateVariancesMap>,
 
-        /// Maps from def-id of a type or region parameter to its
+        /// Maps from def-ID of a type or region parameter to its
         /// (inferred) variance.
         [] fn variances_of: ItemVariances(DefId) -> Lrc<Vec<ty::Variance>>,
     },
 
     TypeChecking {
-        /// Maps from def-id of a type to its (inferred) outlives.
+        /// Maps from def-ID of a type to its (inferred) outlives.
         [] fn inferred_outlives_crate: InferredOutlivesCrate(CrateNum)
             -> Lrc<ty::CratePredicatesMap<'tcx>>,
     },
 
     Other {
-        /// Maps from an impl/trait def-id to a list of the def-ids of its items
+        /// Maps from an impl/trait def-ID to a list of the def-IDs of its items.
         [] fn associated_item_def_ids: AssociatedItemDefIds(DefId) -> Lrc<Vec<DefId>>,
 
-        /// Maps from a trait item to the trait item "descriptor"
+        /// Maps from a trait item to the trait item "descriptor".
         [] fn associated_item: AssociatedItems(DefId) -> ty::AssociatedItem,
 
         [] fn impl_trait_ref: ImplTraitRef(DefId) -> Option<ty::TraitRef<'tcx>>,

src/librustc_data_structures/transitive_relation.rs

@@ -7,10 +7,9 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::mem;
 
-
 #[derive(Clone, Debug)]
 pub struct TransitiveRelation<T: Clone + Debug + Eq + Hash> {
-    // List of elements. This is used to map from a T to a usize.
+    // List of elements. This is used to map from a `T` to a `usize`.
     elements: Vec<T>,
 
     // Maps each element to an index.
@@ -22,7 +21,7 @@ pub struct TransitiveRelation<T: Clone + Debug + Eq + Hash> {
 
     // This is a cached transitive closure derived from the edges.
     // Currently, we build it lazilly and just throw out any existing
-    // copy whenever a new edge is added. (The Lock is to permit
+    // copy whenever a new edge is added. (The `Lock` is to permit
     // the lazy computation.) This is kind of silly, except for the
     // fact its size is tied to `self.elements.len()`, so I wanted to
     // wait before building it up to avoid reallocating as new edges
@@ -209,10 +208,10 @@ impl<T: Clone + Debug + Eq + Hash> TransitiveRelation<T> {
             }
         };
 
-        // in some cases, there are some arbitrary choices to be made;
+        // In some cases, there are some arbitrary choices to be made;
         // it doesn't really matter what we pick, as long as we pick
         // the same thing consistently when queried, so ensure that
-        // (a, b) are in a consistent relative order
+        // (a, b) are in a consistent relative order.
         if a > b {
             mem::swap(&mut a, &mut b);
         }