Auto merge of #27045 - nikomatsakis:better-object-defaults-error, r=pnkfelix

Transition to the new object lifetime defaults, replacing the old defaults completely.

r? @pnkfelix 

This is a [breaking-change] as specified by [RFC 1156][1156] (though all cases that would break should have been receiving warnings starting in Rust 1.2). Types like `&'a Box<Trait>` (or `&'a Rc<Trait>`, etc) will change from being interpreted as `&'a Box<Trait+'a>` to `&'a Box<Trait+'static>`. To restore the old behavior, write the `+'a` explicitly. For example, the function:


```rust
trait Trait { }
fn foo(x: &Box<Trait>) { ... }
```

would be rewritten as:

```rust
trait Trait { }
fn foo(x: &'a Box<Trait+'a>) { ... }
```

if one wanted to preserve the current typing.

[1156]: https://github.com/rust-lang/rfcs/blob/master/text/1156-adjust-default-object-bounds.md

Author: bors

src/librustc/metadata/tydecode.rs

@@ -887,16 +887,9 @@ 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,
-                                   region_bound_will_change: region_bound_will_change };
+                                   projection_bounds: projection_bounds };
 }
 
 fn parse_builtin_bounds<F>(st: &mut PState, mut _conv: F) -> ty::BuiltinBounds where

src/librustc/metadata/tyencode.rs

@@ -390,8 +390,6 @@ 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,

src/librustc/middle/infer/bivariate.rs

@@ -49,11 +49,6 @@ 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,

src/librustc/middle/infer/equate.rs

@@ -34,11 +34,6 @@ 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,

src/librustc/middle/infer/error_reporting.rs

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

src/librustc/middle/infer/glb.rs

@@ -35,16 +35,6 @@ 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,

src/librustc/middle/infer/lub.rs

@@ -35,11 +35,6 @@ 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,

src/librustc/middle/infer/mod.rs

@@ -191,9 +191,6 @@ 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),
@@ -1466,7 +1463,6 @@ 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,

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

@@ -1357,56 +1357,9 @@ 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();
 

src/librustc/middle/infer/sub.rs

@@ -45,14 +45,6 @@ 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,
@@ -106,12 +98,10 @@ 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);
-        let origin = match self.fields.cause {
-            Some(Cause::ExistentialRegionBound(true)) =>
-                SubregionOrigin::DefaultExistentialBound(self.fields.trace.clone()),
-            _ =>
-                SubregionOrigin::Subtype(self.fields.trace.clone()),
-        };
+        // 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());
         self.fields.infcx.region_vars.make_subregion(origin, a, b);
         Ok(a)
     }