---

yaml
---
r: 124735
b: refs/heads/try
c: 707cf47
h: refs/heads/master
i:
  124733: 07d0993
  124731: 211e210
  124727: f3d8a04
  124719: 8bbe496
  124703: 62f203e
  124671: a218b22
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: f15d6d28396e8700b6c3f2704204a2769e710403
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9fc8394d3bce22ab483f98842434c84c396212ae
-refs/heads/try: 56fafe28ee17a4aa48795083ee08be744f068067
+refs/heads/try: 707cf47ac814c7af124dcfe378f97c25eb6b4511
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcollections/dlist.rs

@@ -87,14 +87,12 @@ impl<T> Rawlink<T> {
     }
 
     /// Convert the `Rawlink` into an Option value
-    fn resolve_immut<'a>(&self) -> Option<&'a T> {
-        unsafe {
-            mem::transmute(self.p.to_option())
-        }
+    fn resolve_immut(&self) -> Option<&T> {
+        unsafe { self.p.to_option() }
     }
 
     /// Convert the `Rawlink` into an Option value
-    fn resolve<'a>(&mut self) -> Option<&'a mut T> {
+    fn resolve(&mut self) -> Option<&mut T> {
         if self.p.is_null() {
             None
         } else {

branches/try/src/libgraphviz/lib.rs

@@ -455,12 +455,12 @@ impl<'a> LabelText<'a> {
     }
 
     /// Puts `prefix` on a line above this label, with a blank line separator.
-    pub fn prefix_line(self, prefix: LabelText) -> LabelText<'static> {
+    pub fn prefix_line(self, prefix: LabelText) -> LabelText {
         prefix.suffix_line(self)
     }
 
     /// Puts `suffix` on a line below this label, with a blank line separator.
-    pub fn suffix_line(self, suffix: LabelText) -> LabelText<'static> {
+    pub fn suffix_line(self, suffix: LabelText) -> LabelText {
         let prefix = self.pre_escaped_content().into_string();
         let suffix = suffix.pre_escaped_content();
         EscStr(str::Owned(prefix.append(r"\n\n").append(suffix.as_slice())))

branches/try/src/libgraphviz/maybe_owned_vec.rs

@@ -109,7 +109,7 @@ impl<'b,T> slice::Vector<T> for MaybeOwnedVector<'b,T> {
 }
 
 impl<'a,T> FromIterator<T> for MaybeOwnedVector<'a,T> {
-    fn from_iter<I:Iterator<T>>(iterator: I) -> MaybeOwnedVector<'a,T> {
+    fn from_iter<I:Iterator<T>>(iterator: I) -> MaybeOwnedVector<T> {
         // If we are building from scratch, might as well build the
         // most flexible variant.
         Growable(FromIterator::from_iter(iterator))

branches/try/src/libgreen/sched.rs

@@ -959,13 +959,13 @@ impl CleanupJob {
 type UnsafeTaskReceiver = raw::Closure;
 trait ClosureConverter {
     fn from_fn(|&mut Scheduler, Box<GreenTask>|) -> Self;
-    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>|:'static ;
+    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>|;
 }
 impl ClosureConverter for UnsafeTaskReceiver {
     fn from_fn(f: |&mut Scheduler, Box<GreenTask>|) -> UnsafeTaskReceiver {
         unsafe { mem::transmute(f) }
     }
-    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>|:'static {
+    fn to_fn(self) -> |&mut Scheduler, Box<GreenTask>| {
         unsafe { mem::transmute(self) }
     }
 }

branches/try/src/librustc/middle/trans/basic_block.rs

@@ -31,7 +31,7 @@ impl BasicBlock {
         }
     }
 
-    pub fn pred_iter(self) -> Preds<'static> {
+    pub fn pred_iter(self) -> Preds {
         self.as_value().user_iter()
             .filter(|user| user.is_a_terminator_inst())
             .map(|user| user.get_parent().unwrap())

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

@@ -4872,55 +4872,3 @@ pub enum ExplicitSelfCategory {
     ByBoxExplicitSelfCategory,
 }
 
-/// 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(accumulator: &mut Vec<ty::Region>,
-                                    typ: t) {
-    walk_ty(typ, |typ| {
-        match get(typ).sty {
-            ty_rptr(region, _) => accumulator.push(region),
-            ty_enum(_, ref substs) |
-            ty_trait(box TyTrait {
-                substs: ref substs,
-                ..
-            }) |
-            ty_struct(_, ref substs) => {
-                match substs.regions {
-                    subst::ErasedRegions => {}
-                    subst::NonerasedRegions(ref regions) => {
-                        for region in regions.iter() {
-                            accumulator.push(*region)
-                        }
-                    }
-                }
-            }
-            ty_closure(ref closure_ty) => {
-                match closure_ty.store {
-                    RegionTraitStore(region, _) => accumulator.push(region),
-                    UniqTraitStore => {}
-                }
-            }
-            ty_nil |
-            ty_bot |
-            ty_bool |
-            ty_char |
-            ty_int(_) |
-            ty_uint(_) |
-            ty_float(_) |
-            ty_box(_) |
-            ty_uniq(_) |
-            ty_str |
-            ty_vec(_, _) |
-            ty_ptr(_) |
-            ty_bare_fn(_) |
-            ty_tup(_) |
-            ty_param(_) |
-            ty_infer(_) |
-            ty_unboxed_closure(_) |
-            ty_err => {}
-        }
-    })
-}
-

branches/try/src/librustc/middle/typeck/astconv.rs

@@ -55,7 +55,6 @@ use middle::lang_items::FnMutTraitLangItem;
 use middle::subst::{FnSpace, TypeSpace, SelfSpace, Subst, Substs};
 use middle::ty;
 use middle::ty_fold::TypeFolder;
-use middle::typeck::rscope::{ExplicitRscope, ImpliedSingleRscope};
 use middle::typeck::rscope::RegionScope;
 use middle::typeck::{TypeAndSubsts, infer, lookup_def_tcx, rscope};
 use middle::typeck;
@@ -932,45 +931,31 @@ fn ty_of_method_or_bare_fn<AC:AstConv>(
                                Option<ty::ExplicitSelfCategory>) {
     debug!("ty_of_method_or_bare_fn");
 
-    // New region names that appear inside of the arguments of the function
-    // declaration are bound to that function type.
+    // new region names that appear inside of the fn decl are bound to
+    // that function type
     let rb = rscope::BindingRscope::new(id);
 
-    // `implied_output_region` is the region that will be assumed for any
-    // region parameters in the return type. In accordance with the rules for
-    // lifetime elision, we can determine it in two ways. First (determined
-    // here), if self is by-reference, then the implied output region is the
-    // region of the self parameter.
     let mut explicit_self_category_result = None;
-    let (self_ty, mut implied_output_region) = match opt_self_info {
-        None => (None, None),
-        Some(self_info) => {
-            // Figure out and record the explicit self category.
-            let explicit_self_category =
-                determine_explicit_self_category(this, &rb, &self_info);
-            explicit_self_category_result = Some(explicit_self_category);
-            match explicit_self_category {
-                ty::StaticExplicitSelfCategory => (None, None),
-                ty::ByValueExplicitSelfCategory => {
-                    (Some(self_info.untransformed_self_ty), None)
-                }
-                ty::ByReferenceExplicitSelfCategory(region, mutability) => {
-                    (Some(ty::mk_rptr(this.tcx(),
-                                      region,
-                                      ty::mt {
-                                        ty: self_info.untransformed_self_ty,
-                                        mutbl: mutability
-                                      })),
-                     Some(region))
-                }
-                ty::ByBoxExplicitSelfCategory => {
-                    (Some(ty::mk_uniq(this.tcx(),
-                                      self_info.untransformed_self_ty)),
-                     None)
-                }
+    let self_ty = opt_self_info.and_then(|self_info| {
+        // Figure out and record the explicit self category.
+        let explicit_self_category =
+            determine_explicit_self_category(this, &rb, &self_info);
+        explicit_self_category_result = Some(explicit_self_category);
+        match explicit_self_category {
+            ty::StaticExplicitSelfCategory => None,
+            ty::ByValueExplicitSelfCategory => {
+                Some(self_info.untransformed_self_ty)
+            }
+            ty::ByReferenceExplicitSelfCategory(region, mutability) => {
+                Some(ty::mk_rptr(this.tcx(), region,
+                                 ty::mt {ty: self_info.untransformed_self_ty,
+                                         mutbl: mutability}))
+            }
+            ty::ByBoxExplicitSelfCategory => {
+                Some(ty::mk_uniq(this.tcx(), self_info.untransformed_self_ty))
             }
         }
-    };
+    });
 
     // HACK(eddyb) replace the fake self type in the AST with the actual type.
     let input_tys = if self_ty.is_some() {
@@ -979,47 +964,12 @@ fn ty_of_method_or_bare_fn<AC:AstConv>(
         decl.inputs.as_slice()
     };
     let input_tys = input_tys.iter().map(|a| ty_of_arg(this, &rb, a, None));
-    let self_and_input_tys: Vec<_> =
-        self_ty.move_iter().chain(input_tys).collect();
-
-    // Second, if there was exactly one lifetime (either a substitution or a
-    // reference) in the arguments, then any anonymous regions in the output
-    // have that lifetime.
-    if implied_output_region.is_none() {
-        let mut self_and_input_tys_iter = self_and_input_tys.iter();
-        if self_ty.is_some() {
-            // Skip the first argument if `self` is present.
-            drop(self_and_input_tys_iter.next())
-        }
 
-        let mut accumulator = Vec::new();
-        for input_type in self_and_input_tys_iter {
-            ty::accumulate_lifetimes_in_type(&mut accumulator, *input_type)
-        }
-        if accumulator.len() == 1 {
-            implied_output_region = Some(*accumulator.get(0));
-        }
-    }
+    let self_and_input_tys = self_ty.move_iter().chain(input_tys).collect();
 
     let output_ty = match decl.output.node {
         ast::TyInfer => this.ty_infer(decl.output.span),
-        _ => {
-            match implied_output_region {
-                Some(implied_output_region) => {
-                    let rb = ImpliedSingleRscope {
-                        region: implied_output_region,
-                    };
-                    ast_ty_to_ty(this, &rb, &*decl.output)
-                }
-                None => {
-                    // All regions must be explicitly specified in the output
-                    // if the lifetime elision rules do not apply. This saves
-                    // the user from potentially-confusing errors.
-                    let rb = ExplicitRscope;
-                    ast_ty_to_ty(this, &rb, &*decl.output)
-                }
-            }
-        }
+        _ => ast_ty_to_ty(this, &rb, &*decl.output)
     };
 
     (ty::BareFnTy {

branches/try/src/librustc/middle/typeck/rscope.rs

@@ -64,24 +64,10 @@ impl RegionScope for BindingRscope {
     fn anon_regions(&self,
                     _: Span,
                     count: uint)
-                    -> Result<Vec<ty::Region>, ()> {
+                    -> Result<Vec<ty::Region> , ()> {
         let idx = self.anon_bindings.get();
         self.anon_bindings.set(idx + count);
         Ok(Vec::from_fn(count, |i| ty::ReLateBound(self.binder_id,
                                                    ty::BrAnon(idx + i))))
     }
 }
-
-/// A scope in which we generate one specific region. This occurs after the
-/// `->` (i.e. in the return type) of function signatures.
-pub struct ImpliedSingleRscope {
-    pub region: ty::Region,
-}
-
-impl RegionScope for ImpliedSingleRscope {
-    fn anon_regions(&self, _: Span, count: uint)
-                    -> Result<Vec<ty::Region>,()> {
-        Ok(Vec::from_elem(count, self.region.clone()))
-    }
-}
-

branches/try/src/librustc_back/lib.rs

@@ -21,7 +21,6 @@
 //! one that doesn't; the one that doesn't might get decent parallel
 //! build speedups.
 
-#![crate_id = "rustc_back#0.11.0-pre"]
 #![crate_name = "rustc_back"]
 #![experimental]
 #![comment = "The Rust compiler minimal-dependency dumping-ground"]
@@ -33,7 +32,6 @@
       html_root_url = "http://doc.rust-lang.org/")]
 
 #![feature(globs, phase, macro_rules)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
 
 #[phase(plugin, link)]
 extern crate log;

branches/try/src/librustc_llvm/lib.rs

@@ -13,7 +13,6 @@
 #![allow(non_snake_case_functions)]
 #![allow(dead_code)]
 
-#![crate_id = "rustc_llvm#0.11.0"]
 #![crate_name = "rustc_llvm"]
 #![experimental]
 #![license = "MIT/ASL2"]
@@ -25,7 +24,6 @@
 
 #![feature(globs)]
 #![feature(link_args)]
-#![allow(unused_attribute)] // NOTE: remove after stage0
 
 extern crate libc;
 

branches/try/src/librustrt/local_data.rs

@@ -94,7 +94,7 @@ pub type Map = Vec<Option<(*const u8, TLSValue, uint)>>;
 type TLSValue = Box<LocalData + Send>;
 
 // Gets the map from the runtime. Lazily initialises if not done so already.
-unsafe fn get_local_map<'a>() -> Option<&'a mut Map> {
+unsafe fn get_local_map() -> Option<&mut Map> {
     if !Local::exists(None::<Task>) { return None }
 
     let task: *mut Task = Local::unsafe_borrow();

branches/try/src/librustrt/rtio.rs

@@ -134,7 +134,7 @@ impl<'a> Drop for LocalIo<'a> {
 impl<'a> LocalIo<'a> {
     /// Returns the local I/O: either the local scheduler's I/O services or
     /// the native I/O services.
-    pub fn borrow() -> Option<LocalIo<'a>> {
+    pub fn borrow() -> Option<LocalIo> {
         // FIXME(#11053): bad
         //
         // This is currently very unsafely implemented. We don't actually

branches/try/src/librustuv/file.rs

@@ -469,7 +469,7 @@ mod test {
     use super::super::Loop;
     use super::super::local_loop;
 
-    fn l() -> &'static mut Loop { &mut local_loop().loop_ }
+    fn l() -> &mut Loop { &mut local_loop().loop_ }
 
     #[test]
     fn file_test_full_simple_sync() {