---

yaml
---
r: 235003
b: refs/heads/stable
c: e834c03
h: refs/heads/master
i:
  235001: 767f189
  234999: 2c8a418
v: v3

Author: frewsxcv

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 0b703787ab23f004fe9f635971933c6e9a9c6683
+refs/heads/stable: e834c0348fe094da4f32594278fee6b0446cb41c
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/guide-pointers.md

@@ -1,7 +1,4 @@
-% The Rust Pointer Guide
+% The (old) Rust Pointer Guide
 
-This content has been removed, with no direct replacement. Rust only
-has two built-in pointer types now,
-[references](book/references-and-borrowing.html) and [raw
-pointers](book/raw-pointers.html). Older Rusts had many more pointer
-types, they’re gone now.
+This content has moved into
+[the Rust Programming Language book](book/pointers.html).

branches/stable/src/doc/trpl/academic-research.md

@@ -12,7 +12,7 @@ Recommended for inspiration and a better understanding of Rust's background.
 * [Macros that work together](https://www.cs.utah.edu/plt/publications/jfp12-draft-fcdf.pdf)
 * [Traits: composable units of behavior](http://scg.unibe.ch/archive/papers/Scha03aTraits.pdf)
 * [Alias burying](http://www.cs.uwm.edu/faculty/boyland/papers/unique-preprint.ps) - We tried something similar and abandoned it.
-* [External uniqueness is unique enough](http://www.cs.uu.nl/research/techreps/UU-CS-2002-048.html)
+* [External uniqueness is unique enough](http://www.computingscience.nl/research/techreps/repo/CS-2002/2002-048.pdf)
 * [Uniqueness and Reference Immutability for Safe Parallelism](https://research.microsoft.com/pubs/170528/msr-tr-2012-79.pdf)
 * [Region Based Memory Management](http://www.cs.ucla.edu/~palsberg/tba/papers/tofte-talpin-iandc97.pdf)
 
@@ -26,10 +26,10 @@ Recommended for inspiration and a better understanding of Rust's background.
 * [Dynamic circular work stealing deque](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.170.1097&rep=rep1&type=pdf) - The Chase/Lev deque
 * [Work-first and help-first scheduling policies for async-finish task parallelism](http://www.cs.rice.edu/%7Eyguo/pubs/PID824943.pdf) - More general than fully-strict work stealing
 * [A Java fork/join calamity](http://www.coopsoft.com/ar/CalamityArticle.html) - critique of Java's fork/join library, particularly its application of work stealing to non-strict computation
-* [Scheduling techniques for concurrent systems](http://www.stanford.edu/~ouster/cgi-bin/papers/coscheduling.pdf)
+* [Scheduling techniques for concurrent systems](http://www.ece.rutgers.edu/%7Eparashar/Classes/ece572-papers/05/ps-ousterhout.pdf)
 * [Contention aware scheduling](http://www.blagodurov.net/files/a8-blagodurov.pdf)
 * [Balanced work stealing for time-sharing multicores](http://www.cse.ohio-state.edu/hpcs/WWW/HTML/publications/papers/TR-12-1.pdf)
-* [Three layer cake for shared-memory programming](http://dl.acm.org/citation.cfm?id=1953616&dl=ACM&coll=DL&CFID=524387192&CFTOKEN=44362705)
+* [Three layer cake](http://www.upcrc.illinois.edu/workshops/paraplop10/papers/paraplop10_submission_8.pdf)
 * [Non-blocking steal-half work queues](http://www.cs.bgu.ac.il/%7Ehendlerd/papers/p280-hendler.pdf)
 * [Reagents: expressing and composing fine-grained concurrency](http://www.mpi-sws.org/~turon/reagents.pdf)
 * [Algorithms for scalable synchronization of shared-memory multiprocessors](https://www.cs.rochester.edu/u/scott/papers/1991_TOCS_synch.pdf)

branches/stable/src/libcore/mem.rs

@@ -365,48 +365,11 @@ pub fn replace<T>(dest: &mut T, mut src: T) -> T {
 
 /// Disposes of a value.
 ///
-/// While this does call the argument's implementation of `Drop`, it will not
-/// release any borrows, as borrows are based on lexical scope.
+/// This function can be used to destroy any value by allowing `drop` to take ownership of its
+/// argument.
 ///
 /// # Examples
 ///
-/// Basic usage:
-///
-/// ```
-/// let v = vec![1, 2, 3];
-///
-/// drop(v); // explicitly drop the vector
-/// ```
-///
-/// Borrows are based on lexical scope, so this produces an error:
-///
-/// ```ignore
-/// let mut v = vec![1, 2, 3];
-/// let x = &v[0];
-///
-/// drop(x); // explicitly drop the reference, but the borrow still exists
-///
-/// v.push(4); // error: cannot borrow `v` as mutable because it is also
-///            // borrowed as immutable
-/// ```
-///
-/// An inner scope is needed to fix this:
-///
-/// ```
-/// let mut v = vec![1, 2, 3];
-///
-/// {
-///     let x = &v[0];
-///
-///     drop(x); // this is now redundant, as `x` is going out of scope anyway
-/// }
-///
-/// v.push(4); // no problems
-/// ```
-///
-/// Since `RefCell` enforces the borrow rules at runtime, `drop()` can
-/// seemingly release a borrow of one:
-///
 /// ```
 /// use std::cell::RefCell;
 ///

branches/stable/src/librustc/diagnostics.rs

@@ -357,7 +357,7 @@ Ensure that the expressions given can be evaluated as the desired integer type.
 See the FFI section of the Reference for more information about using a custom
 integer type:
 
-http://doc.rust-lang.org/reference.html#ffi-attributes
+https://doc.rust-lang.org/reference.html#ffi-attributes
 "##,
 
 E0109: r##"
@@ -408,7 +408,7 @@ fn main() {
 }
 ```
 
-See also http://doc.rust-lang.org/book/unsafe.html
+See also https://doc.rust-lang.org/book/unsafe.html
 "##,
 
 E0137: r##"

branches/stable/src/librustc/middle/infer/higher_ranked/mod.rs

@@ -359,7 +359,7 @@ fn fold_regions_in<'tcx, T, F>(tcx: &ty::ctxt<'tcx>,
     where T: TypeFoldable<'tcx>,
           F: FnMut(ty::Region, ty::DebruijnIndex) -> ty::Region,
 {
-    ty_fold::fold_regions(tcx, unbound_value, &mut false, |region, current_depth| {
+    unbound_value.fold_with(&mut ty_fold::RegionFolder::new(tcx, &mut |region, current_depth| {
         // we should only be encountering "escaping" late-bound regions here,
         // because the ones at the current level should have been replaced
         // with fresh variables
@@ -369,7 +369,7 @@ fn fold_regions_in<'tcx, T, F>(tcx: &ty::ctxt<'tcx>,
         });
 
         fldr(region, ty::DebruijnIndex::new(current_depth))
-    })
+    }))
 }
 
 impl<'a,'tcx> InferCtxtExt for InferCtxt<'a,'tcx> {
@@ -437,10 +437,11 @@ impl<'a,'tcx> InferCtxtExt for InferCtxt<'a,'tcx> {
         let escaping_types =
             self.type_variables.borrow().types_escaping_snapshot(&snapshot.type_snapshot);
 
-        let mut escaping_region_vars = FnvHashSet();
-        for ty in &escaping_types {
-            ty_fold::collect_regions(self.tcx, ty, &mut escaping_region_vars);
-        }
+        let escaping_region_vars: FnvHashSet<_> =
+            escaping_types
+            .iter()
+            .flat_map(|&t| ty_fold::collect_regions(self.tcx, &t))
+            .collect();
 
         region_vars.retain(|&region_vid| {
             let r = ty::ReInfer(ty::ReVar(region_vid));
@@ -648,7 +649,7 @@ pub fn plug_leaks<'a,'tcx,T>(infcx: &InferCtxt<'a,'tcx>,
     // binder is that we encountered in `value`. The caller is
     // responsible for ensuring that (a) `value` contains at least one
     // binder and (b) that binder is the one we want to use.
-    let result = ty_fold::fold_regions(infcx.tcx, &value, &mut false, |r, current_depth| {
+    let result = ty_fold::fold_regions(infcx.tcx, &value, |r, current_depth| {
         match inv_skol_map.get(&r) {
             None => r,
             Some(br) => {

branches/stable/src/librustc/middle/traits/fulfill.rs

@@ -421,18 +421,16 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
             // regions.  If there are, we will call this obligation an
             // error. Eventually we should be able to support some
             // cases here, I imagine (e.g., `for<'a> int : 'a`).
-            match selcx.tcx().no_late_bound_regions(binder) {
-                None => {
-                    errors.push(
-                        FulfillmentError::new(
-                            obligation.clone(),
-                            CodeSelectionError(Unimplemented)))
-                }
-                Some(ty::OutlivesPredicate(t_a, r_b)) => {
-                    register_region_obligation(t_a, r_b,
-                                               obligation.cause.clone(),
-                                               region_obligations);
-                }
+            if selcx.tcx().count_late_bound_regions(binder) != 0 {
+                errors.push(
+                    FulfillmentError::new(
+                        obligation.clone(),
+                        CodeSelectionError(Unimplemented)));
+            } else {
+                let ty::OutlivesPredicate(t_a, r_b) = binder.0;
+                register_region_obligation(t_a, r_b,
+                                           obligation.cause.clone(),
+                                           region_obligations);
             }
             true
         }
@@ -503,3 +501,5 @@ impl<'tcx> FulfilledPredicates<'tcx> {
         !self.set.insert(p.clone())
     }
 }
+
+

branches/stable/src/librustc/middle/ty.rs

@@ -1713,16 +1713,6 @@ impl Region {
             _ => false,
         }
     }
-
-    /// Returns the depth of `self` from the (1-based) binding level `depth`
-    pub fn from_depth(&self, depth: u32) -> Region {
-        match *self {
-            ty::ReLateBound(debruijn, r) => ty::ReLateBound(DebruijnIndex {
-                depth: debruijn.depth - (depth - 1)
-            }, r),
-            r => r
-        }
-    }
 }
 
 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash,
@@ -6793,6 +6783,60 @@ pub enum ExplicitSelfCategory {
     ByBoxExplicitSelfCategory,
 }
 
+impl<'tcx> TyS<'tcx> {
+    /// Pushes all the lifetimes in the given type onto the given list. A
+    /// "lifetime in a type" is a lifetime specified by a reference or a lifetime
+    /// in a list of type substitutions. This does *not* traverse into nominal
+    /// types, nor does it resolve fictitious types.
+    pub fn accumulate_lifetimes_in_type(&self, accumulator: &mut Vec<ty::Region>) {
+        for ty in self.walk() {
+            match ty.sty {
+                TyRef(region, _) => {
+                    accumulator.push(*region)
+                }
+                TyTrait(ref t) => {
+                    accumulator.push_all(t.principal.0.substs.regions().as_slice());
+                }
+                TyEnum(_, substs) |
+                TyStruct(_, substs) => {
+                    accum_substs(accumulator, substs);
+                }
+                TyClosure(_, substs) => {
+                    accum_substs(accumulator, substs);
+                }
+                TyBool |
+                TyChar |
+                TyInt(_) |
+                TyUint(_) |
+                TyFloat(_) |
+                TyBox(_) |
+                TyStr |
+                TyArray(_, _) |
+                TySlice(_) |
+                TyRawPtr(_) |
+                TyBareFn(..) |
+                TyTuple(_) |
+                TyProjection(_) |
+                TyParam(_) |
+                TyInfer(_) |
+                TyError => {
+                }
+            }
+        }
+
+        fn accum_substs(accumulator: &mut Vec<Region>, substs: &Substs) {
+            match substs.regions {
+                subst::ErasedRegions => {}
+                subst::NonerasedRegions(ref regions) => {
+                    for region in regions {
+                        accumulator.push(*region)
+                    }
+                }
+            }
+        }
+    }
+}
+
 /// A free variable referred to in a function.
 #[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
 pub struct Freevar {
@@ -6853,15 +6897,27 @@ impl<'tcx> ctxt<'tcx> {
             |br| ty::ReFree(ty::FreeRegion{scope: all_outlive_scope, bound_region: br})).0
     }
 
+    pub fn count_late_bound_regions<T>(&self, value: &Binder<T>) -> usize
+        where T : TypeFoldable<'tcx>
+    {
+        let (_, skol_map) = ty_fold::replace_late_bound_regions(self, value, |_| ty::ReStatic);
+        skol_map.len()
+    }
+
+    pub fn binds_late_bound_regions<T>(&self, value: &Binder<T>) -> bool
+        where T : TypeFoldable<'tcx>
+    {
+        self.count_late_bound_regions(value) > 0
+    }
+
     /// Flattens two binding levels into one. So `for<'a> for<'b> Foo`
     /// becomes `for<'a,'b> Foo`.
     pub fn flatten_late_bound_regions<T>(&self, bound2_value: &Binder<Binder<T>>)
                                          -> Binder<T>
         where T: TypeFoldable<'tcx>
     {
         let bound0_value = bound2_value.skip_binder().skip_binder();
-        let value = ty_fold::fold_regions(self, bound0_value, &mut false,
-                                          |region, current_depth| {
+        let value = ty_fold::fold_regions(self, bound0_value, |region, current_depth| {
             match region {
                 ty::ReLateBound(debruijn, br) if debruijn.depth >= current_depth => {
                     // should be true if no escaping regions from bound2_value
@@ -6877,9 +6933,9 @@ impl<'tcx> ctxt<'tcx> {
     }
 
     pub fn no_late_bound_regions<T>(&self, value: &Binder<T>) -> Option<T>
-        where T : TypeFoldable<'tcx> + RegionEscape
+        where T : TypeFoldable<'tcx>
     {
-        if value.0.has_escaping_regions() {
+        if self.binds_late_bound_regions(value) {
             None
         } else {
             Some(value.0.clone())
@@ -7039,19 +7095,6 @@ impl<'tcx> RegionEscape for Substs<'tcx> {
     }
 }
 
-impl<T:RegionEscape> RegionEscape for Vec<T> {
-    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
-        self.iter().any(|t| t.has_regions_escaping_depth(depth))
-    }
-}
-
-impl<'tcx> RegionEscape for FnSig<'tcx> {
-    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
-        self.inputs.has_regions_escaping_depth(depth) ||
-            self.output.has_regions_escaping_depth(depth)
-    }
-}
-
 impl<'tcx,T:RegionEscape> RegionEscape for VecPerParamSpace<T> {
     fn has_regions_escaping_depth(&self, depth: u32) -> bool {
         self.iter_enumerated().any(|(space, _, t)| {
@@ -7124,15 +7167,6 @@ impl<'tcx,T:RegionEscape> RegionEscape for Binder<T> {
     }
 }
 
-impl<'tcx> RegionEscape for FnOutput<'tcx> {
-    fn has_regions_escaping_depth(&self, depth: u32) -> bool {
-        match *self {
-            FnConverging(t) => t.has_regions_escaping_depth(depth),
-            FnDiverging => false
-        }
-    }
-}
-
 impl<'tcx> RegionEscape for EquatePredicate<'tcx> {
     fn has_regions_escaping_depth(&self, depth: u32) -> bool {
         self.0.has_regions_escaping_depth(depth) || self.1.has_regions_escaping_depth(depth)