---

yaml
---
r: 220652
b: refs/heads/tmp
c: d0e1b06
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: c8bab9d06a179028a0d5129aa62f09d694d9cc49
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 2ea87785becef1b0d031c9fe40c7ae17717e3b76
+refs/heads/tmp: d0e1b06fc0d20d1a6a0a2213134bcc84658e96a0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 1b28ffa5216c845d1cef6b0cb3e5ac7db12025d0
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/doc/trpl/testing.md

@@ -250,11 +250,10 @@ that our tests are entirely left out of a normal build.
 
 The second change is the `use` declaration. Because we're in an inner module,
 we need to bring our test function into scope. This can be annoying if you have
-a large module, and so this is a common use of the `glob` feature. Let's change
-our `src/lib.rs` to make use of it:
+a large module, and so this is a common use of globs. Let's change our
+`src/lib.rs` to make use of it:
 
 ```rust,ignore
-
 pub fn add_two(a: i32) -> i32 {
     a + 2
 }

branches/tmp/src/libcollections/vec.rs

@@ -231,7 +231,6 @@ impl<T> Vec<T> {
     ///
     /// * `ptr` needs to have been previously allocated via `String`/`Vec<T>`
     ///   (at least, it's highly likely to be incorrect if it wasn't).
-    /// * `length` needs to be the length that less than or equal to `capacity`.
     /// * `capacity` needs to be the capacity that the pointer was allocated with.
     ///
     /// Violating these may cause problems like corrupting the allocator's

branches/tmp/src/librustc/lib.rs

@@ -99,8 +99,14 @@ pub mod diagnostics;
 
 pub mod back {
     pub use rustc_back::abi;
+    pub use rustc_back::arm;
+    pub use rustc_back::mips;
+    pub use rustc_back::mipsel;
     pub use rustc_back::rpath;
     pub use rustc_back::svh;
+    pub use rustc_back::target_strs;
+    pub use rustc_back::x86;
+    pub use rustc_back::x86_64;
 }
 
 pub mod ast_map;

branches/tmp/src/librustc/metadata/tydecode.rs

@@ -887,9 +887,16 @@ fn parse_existential_bounds_<'a,'tcx, F>(st: &mut PState<'a,'tcx>,
         }
     }
 
+    let region_bound_will_change = match next(st) {
+        'y' => true,
+        'n' => false,
+        c => panic!("parse_ty: expected y/n not '{}'", c)
+    };
+
     return ty::ExistentialBounds { region_bound: region_bound,
                                    builtin_bounds: builtin_bounds,
-                                   projection_bounds: projection_bounds };
+                                   projection_bounds: projection_bounds,
+                                   region_bound_will_change: region_bound_will_change };
 }
 
 fn parse_builtin_bounds<F>(st: &mut PState, mut _conv: F) -> ty::BuiltinBounds where

branches/tmp/src/librustc/metadata/tyencode.rs

@@ -390,6 +390,8 @@ pub fn enc_existential_bounds<'a,'tcx>(w: &mut Encoder,
     }
 
     mywrite!(w, ".");
+
+    mywrite!(w, "{}", if bs.region_bound_will_change {'y'} else {'n'});
 }
 
 pub fn enc_region_bounds<'a, 'tcx>(w: &mut Encoder,

branches/tmp/src/librustc/middle/infer/bivariate.rs

@@ -49,6 +49,11 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Bivariate<'a, 'tcx> {
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
+    fn will_change(&mut self, _: bool, _: bool) -> bool {
+        // since we are not comparing regions, we don't care
+        false
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                variance: ty::Variance,
                                                a: &T,

branches/tmp/src/librustc/middle/infer/equate.rs

@@ -34,6 +34,11 @@ impl<'a, 'tcx> TypeRelation<'a,'tcx> for Equate<'a, 'tcx> {
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
+    fn will_change(&mut self, a: bool, b: bool) -> bool {
+        // if either side changed from what it was, that could cause equality to fail
+        a || b
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                _: ty::Variance,
                                                a: &T,

branches/tmp/src/librustc/middle/infer/error_reporting.rs

@@ -593,7 +593,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
                                sub: Region,
                                sup: Region) {
         match origin {
-            infer::Subtype(trace) => {
+            infer::Subtype(trace) |
+            infer::DefaultExistentialBound(trace) => {
                 let terr = TypeError::RegionsDoesNotOutlive(sup, sub);
                 self.report_and_explain_type_error(trace, &terr);
             }
@@ -1569,7 +1570,8 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
 
     fn note_region_origin(&self, origin: &SubregionOrigin<'tcx>) {
         match *origin {
-            infer::Subtype(ref trace) => {
+            infer::Subtype(ref trace) |
+            infer::DefaultExistentialBound(ref trace) => {
                 let desc = match trace.origin {
                     infer::Misc(_) => {
                         "types are compatible"

branches/tmp/src/librustc/middle/infer/glb.rs

@@ -35,6 +35,16 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Glb<'a, 'tcx> {
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
+    fn will_change(&mut self, a: bool, b: bool) -> bool {
+        // Hmm, so the result of GLB will still be a LB if one or both
+        // sides change to 'static, but it may no longer be the GLB.
+        // I'm going to go with `a || b` here to be conservative,
+        // since the result of this operation may be affected, though
+        // I think it would mostly be more accepting than before (since the result
+        // would be a bigger region).
+        a || b
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                variance: ty::Variance,
                                                a: &T,

branches/tmp/src/librustc/middle/infer/lub.rs

@@ -35,6 +35,11 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Lub<'a, 'tcx> {
 
     fn a_is_expected(&self) -> bool { self.fields.a_is_expected }
 
+    fn will_change(&mut self, a: bool, b: bool) -> bool {
+        // result will be 'static if a || b
+        a || b
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                variance: ty::Variance,
                                                a: &T,

branches/tmp/src/librustc/middle/infer/mod.rs

@@ -191,6 +191,9 @@ pub enum SubregionOrigin<'tcx> {
     // Arose from a subtyping relation
     Subtype(TypeTrace<'tcx>),
 
+    // Arose from a subtyping relation
+    DefaultExistentialBound(TypeTrace<'tcx>),
+
     // Stack-allocated closures cannot outlive innermost loop
     // or function so as to ensure we only require finite stack
     InfStackClosure(Span),
@@ -1463,6 +1466,7 @@ impl<'tcx> SubregionOrigin<'tcx> {
     pub fn span(&self) -> Span {
         match *self {
             Subtype(ref a) => a.span(),
+            DefaultExistentialBound(ref a) => a.span(),
             InfStackClosure(a) => a,
             InvokeClosure(a) => a,
             DerefPointer(a) => a,

branches/tmp/src/librustc/middle/infer/region_inference/mod.rs

@@ -1357,9 +1357,56 @@ impl<'a, 'tcx> RegionVarBindings<'a, 'tcx> {
             }
         }
 
+        // Check for future hostile edges tied to a bad default
+        self.report_future_hostility(&graph);
+
         (0..self.num_vars() as usize).map(|idx| var_data[idx].value).collect()
     }
 
+    fn report_future_hostility(&self, graph: &RegionGraph) {
+        let constraints = self.constraints.borrow();
+        for edge in graph.all_edges() {
+            match constraints[&edge.data] {
+                SubregionOrigin::DefaultExistentialBound(_) => {
+                    // this will become 'static in the future
+                }
+                _ => { continue; }
+            }
+
+            // this constraint will become a 'static constraint in the
+            // future, so walk outward and see if we have any hard
+            // bounds that could not be inferred to 'static
+            for nid in graph.depth_traverse(edge.target()) {
+                for (_, succ) in graph.outgoing_edges(nid) {
+                    match succ.data {
+                        ConstrainVarSubReg(_, r) => {
+                            match r {
+                                ty::ReStatic | ty::ReInfer(_) => {
+                                    /* OK */
+                                }
+                                ty::ReFree(_) | ty::ReScope(_) | ty::ReEmpty => {
+                                    span_warn!(
+                                        self.tcx.sess,
+                                        constraints[&edge.data].span(),
+                                        E0398,
+                                        "this code may fail to compile in Rust 1.3 due to \
+                                         the proposed change in object lifetime bound defaults");
+                                    return; // only issue the warning once per fn
+                                }
+                                ty::ReEarlyBound(..) | ty::ReLateBound(..) => {
+                                    self.tcx.sess.span_bug(
+                                        constraints[&succ.data].span(),
+                                        "relation to bound region");
+                                }
+                            }
+                        }
+                        _ => { }
+                    }
+                }
+            }
+        }
+    }
+
     fn construct_graph(&self) -> RegionGraph {
         let num_vars = self.num_vars();
 

branches/tmp/src/librustc/middle/infer/sub.rs

@@ -45,6 +45,14 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
         r
     }
 
+    fn will_change(&mut self, a: bool, b: bool) -> bool {
+        // if we have (Foo+'a) <: (Foo+'b), this requires that 'a:'b.
+        // So if 'a becomes 'static, no additional errors can occur.
+        // OTOH, if 'a stays the same, but 'b becomes 'static, we
+        // could have a problem.
+        !a && b
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                variance: ty::Variance,
                                                a: &T,
@@ -98,10 +106,12 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Sub<'a, 'tcx> {
     fn regions(&mut self, a: ty::Region, b: ty::Region) -> RelateResult<'tcx, ty::Region> {
         debug!("{}.regions({:?}, {:?}) self.cause={:?}",
                self.tag(), a, b, self.fields.cause);
-        // FIXME -- we have more fine-grained information available
-        // from the "cause" field, we could perhaps give more tailored
-        // error messages.
-        let origin = SubregionOrigin::Subtype(self.fields.trace.clone());
+        let origin = match self.fields.cause {
+            Some(Cause::ExistentialRegionBound(true)) =>
+                SubregionOrigin::DefaultExistentialBound(self.fields.trace.clone()),
+            _ =>
+                SubregionOrigin::Subtype(self.fields.trace.clone()),
+        };
         self.fields.infcx.region_vars.make_subregion(origin, a, b);
         Ok(a)
     }

branches/tmp/src/librustc/middle/traits/select.rs

@@ -2462,6 +2462,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     region_bound: data_b.bounds.region_bound,
                     builtin_bounds: data_b.bounds.builtin_bounds,
                     projection_bounds: data_a.bounds.projection_bounds.clone(),
+                    region_bound_will_change: data_b.bounds.region_bound_will_change,
                 };
 
                 let new_trait = tcx.mk_trait(data_a.principal.clone(), bounds);

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

@@ -1989,6 +1989,11 @@ pub struct ExistentialBounds<'tcx> {
     pub region_bound: ty::Region,
     pub builtin_bounds: BuiltinBounds,
     pub projection_bounds: Vec<PolyProjectionPredicate<'tcx>>,
+
+    // If true, this TyTrait used a "default bound" in the surface
+    // syntax.  This makes no difference to the type system but is
+    // handy for error reporting.
+    pub region_bound_will_change: bool,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]

branches/tmp/src/librustc/middle/ty_fold.rs

@@ -700,6 +700,7 @@ pub fn super_fold_existential_bounds<'tcx, T: TypeFolder<'tcx>>(
         region_bound: bounds.region_bound.fold_with(this),
         builtin_bounds: bounds.builtin_bounds,
         projection_bounds: bounds.projection_bounds.fold_with(this),
+        region_bound_will_change: bounds.region_bound_will_change,
     }
 }
 

branches/tmp/src/librustc/middle/ty_match.rs

@@ -42,6 +42,11 @@ impl<'a, 'tcx> TypeRelation<'a, 'tcx> for Match<'a, 'tcx> {
     fn tcx(&self) -> &'a ty::ctxt<'tcx> { self.tcx }
     fn a_is_expected(&self) -> bool { true } // irrelevant
 
+    fn will_change(&mut self, _: bool, _: bool) -> bool {
+        // we're ignoring regions in this code
+        false
+    }
+
     fn relate_with_variance<T:Relate<'a,'tcx>>(&mut self,
                                                _: ty::Variance,
                                                a: &T,

branches/tmp/src/librustc/middle/ty_relate/mod.rs

@@ -24,7 +24,7 @@ pub type RelateResult<'tcx, T> = Result<T, ty::TypeError<'tcx>>;
 
 #[derive(Clone, Debug)]
 pub enum Cause {
-    ExistentialRegionBound, // relating an existential region bound
+    ExistentialRegionBound(bool), // if true, this is a default, else explicit
 }
 
 pub trait TypeRelation<'a,'tcx> : Sized {
@@ -43,6 +43,13 @@ pub trait TypeRelation<'a,'tcx> : Sized {
         f(self)
     }
 
+    /// Hack for deciding whether the lifetime bound defaults change
+    /// will be a breaking change or not. The bools indicate whether
+    /// `a`/`b` have a default that will change to `'static`; the
+    /// result is true if this will potentially affect the affect of
+    /// relating `a` and `b`.
+    fn will_change(&mut self, a: bool, b: bool) -> bool;
+
     /// Generic relation routine suitable for most anything.
     fn relate<T:Relate<'a,'tcx>>(&mut self, a: &T, b: &T) -> RelateResult<'tcx, T> {
         Relate::relate(self, a, b)
@@ -377,17 +384,21 @@ impl<'a,'tcx:'a> Relate<'a,'tcx> for ty::ExistentialBounds<'tcx> {
                  -> RelateResult<'tcx, ty::ExistentialBounds<'tcx>>
         where R: TypeRelation<'a,'tcx>
     {
+        let will_change = relation.will_change(a.region_bound_will_change,
+                                               b.region_bound_will_change);
+
         let r =
             try!(relation.with_cause(
-                Cause::ExistentialRegionBound,
+                Cause::ExistentialRegionBound(will_change),
                 |relation| relation.relate_with_variance(ty::Contravariant,
                                                          &a.region_bound,
                                                          &b.region_bound)));
         let nb = try!(relation.relate(&a.builtin_bounds, &b.builtin_bounds));
         let pb = try!(relation.relate(&a.projection_bounds, &b.projection_bounds));
         Ok(ty::ExistentialBounds { region_bound: r,
                                    builtin_bounds: nb,
-                                   projection_bounds: pb })
+                                   projection_bounds: pb,
+                                   region_bound_will_change: will_change })
     }
 }
 

branches/tmp/src/librustc/util/ppaux.rs

@@ -300,6 +300,10 @@ impl<'tcx> fmt::Display for ty::TraitTy<'tcx> {
             try!(write!(f, " + {}", bound));
         }
 
+        if bounds.region_bound_will_change && verbose() {
+            try!(write!(f, " [WILL-CHANGE]"));
+        }
+
         Ok(())
     }
 }