---

yaml
---
r: 146520
b: refs/heads/try2
c: 3851f90
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 2fcc70ec9d2f73b61285283aeb4abce4a4e84901
+refs/heads/try2: 3851f908d16b55dfe69d5a423ecbef4cd224fae2
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -125,6 +125,7 @@ ifdef TRACE
   CFG_RUSTC_FLAGS += -Z trace
 endif
 ifndef DEBUG_BORROWS
+  RUSTFLAGS_STAGE0 += -Z no-debug-borrows
   RUSTFLAGS_STAGE1 += -Z no-debug-borrows
   RUSTFLAGS_STAGE2 += -Z no-debug-borrows
 endif

branches/try2/src/libextra/arc.rs

@@ -233,10 +233,10 @@ impl<T:Send> MutexArc<T> {
 
     /// As unsafe_access(), but with a condvar, as sync::mutex.lock_cond().
     #[inline]
-    pub unsafe fn unsafe_access_cond<'x, 'c, U>(&self,
-                                         blk: &fn(x: &'x mut T,
-                                                  c: &'c Condvar) -> U)
-                                         -> U {
+    pub unsafe fn unsafe_access_cond<U>(&self,
+                                        blk: &fn(x: &mut T,
+                                                 c: &Condvar) -> U)
+                                        -> U {
         let state = self.x.get();
         do (&(*state).lock).lock_cond |cond| {
             check_poison(true, (*state).failed);
@@ -290,10 +290,10 @@ impl<T:Freeze + Send> MutexArc<T> {
 
     /// As unsafe_access_cond but safe and Freeze.
     #[inline]
-    pub fn access_cond<'x, 'c, U>(&self,
-                                  blk: &fn(x: &'x mut T,
-                                           c: &'c Condvar) -> U)
-                                  -> U {
+    pub fn access_cond<U>(&self,
+                          blk: &fn(x: &mut T,
+                                   c: &Condvar) -> U)
+                          -> U {
         unsafe { self.unsafe_access_cond(blk) }
     }
 }
@@ -402,9 +402,9 @@ impl<T:Freeze + Send> RWArc<T> {
 
     /// As write(), but with a condvar, as sync::rwlock.write_cond().
     #[inline]
-    pub fn write_cond<'x, 'c, U>(&self,
-                                 blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
-                                 -> U {
+    pub fn write_cond<U>(&self,
+                         blk: &fn(x: &mut T, c: &Condvar) -> U)
+                         -> U {
         unsafe {
             let state = self.x.get();
             do (*borrow_rwlock(state)).write_cond |cond| {
@@ -554,9 +554,9 @@ impl<'self, T:Freeze + Send> RWWriteMode<'self, T> {
     }
 
     /// Access the pre-downgrade RWArc in write mode with a condvar.
-    pub fn write_cond<'x, 'c, U>(&mut self,
-                                 blk: &fn(x: &'x mut T, c: &'c Condvar) -> U)
-                                 -> U {
+    pub fn write_cond<U>(&mut self,
+                         blk: &fn(x: &mut T, c: &Condvar) -> U)
+                         -> U {
         match *self {
             RWWriteMode {
                 data: &ref mut data,

branches/try2/src/libextra/getopts.rs

@@ -185,18 +185,14 @@ impl Name {
 }
 
 impl Matches {
-    /// FIXME: #9311 This used to be private, but rustpkg somehow managed to depend on it.
-    /// No idea what this does.
-    pub fn opt_vals(&self, nm: &str) -> ~[Optval] {
+    fn opt_vals(&self, nm: &str) -> ~[Optval] {
         match find_opt(self.opts, Name::from_str(nm)) {
             Some(id) => self.vals[id].clone(),
             None => fail!("No option '{}' defined", nm)
         }
     }
 
-    /// FIXME: #9311 This used to be private, but rustpkg somehow managed to depend on it.
-    /// No idea what this does.
-    pub fn opt_val(&self, nm: &str) -> Option<Optval> {
+    fn opt_val(&self, nm: &str) -> Option<Optval> {
         let vals = self.opt_vals(nm);
         if (vals.is_empty()) {
             None

branches/try2/src/libextra/lib.rs

@@ -21,6 +21,7 @@ Rust extras are part of the standard Rust distribution.
 */
 
 #[link(name = "extra",
+       package_id = "extra",
        vers = "0.9-pre",
        uuid = "122bed0b-c19b-4b82-b0b7-7ae8aead7297",
        url = "https://github.com/mozilla/rust/tree/master/src/libextra")];

branches/try2/src/librustc/back/link.rs

@@ -635,6 +635,18 @@ pub fn build_link_meta(sess: Session,
         }
     }
 
+    fn crate_meta_pkgid(sess: Session, name: @str, opt_pkg_id: Option<@str>)
+        -> @str {
+        match opt_pkg_id {
+            Some(v) if !v.is_empty() => v,
+            _ => {
+                let pkg_id = name.clone();
+                warn_missing(sess, "package_id", pkg_id);
+                pkg_id
+            }
+        }
+    }
+
     let ProvidedMetas {
         name: opt_name,
         vers: opt_vers,
@@ -643,15 +655,16 @@ pub fn build_link_meta(sess: Session,
     } = provided_link_metas(sess, c);
     let name = crate_meta_name(sess, output, opt_name);
     let vers = crate_meta_vers(sess, opt_vers);
+    let pkg_id = crate_meta_pkgid(sess, name, opt_pkg_id);
     let dep_hashes = cstore::get_dep_hashes(sess.cstore);
     let extras_hash =
         crate_meta_extras_hash(symbol_hasher, cmh_items,
-                               dep_hashes, opt_pkg_id);
+                               dep_hashes, Some(pkg_id));
 
     LinkMeta {
         name: name,
         vers: vers,
-        package_id: opt_pkg_id,
+        package_id: Some(pkg_id),
         extras_hash: extras_hash
     }
 }

branches/try2/src/librustc/driver/driver.rs

@@ -239,20 +239,20 @@ pub fn phase_3_run_analysis_passes(sess: Session,
         time(time_passes, "resolution", (), |_|
              middle::resolve::resolve_crate(sess, lang_items, crate));
 
+    let named_region_map = time(time_passes, "lifetime resolution", (),
+                                |_| middle::resolve_lifetime::crate(sess, crate));
+
     time(time_passes, "looking for entry point", (),
          |_| middle::entry::find_entry_point(sess, crate, ast_map));
 
     let freevars = time(time_passes, "freevar finding", (), |_|
                         freevars::annotate_freevars(def_map, crate));
 
     let region_map = time(time_passes, "region resolution", (), |_|
-                          middle::region::resolve_crate(sess, def_map, crate));
-
-    let rp_set = time(time_passes, "region parameterization inference", (), |_|
-                      middle::region::determine_rp_in_crate(sess, ast_map, def_map, crate));
+                          middle::region::resolve_crate(sess, crate));
 
-    let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars,
-                            region_map, rp_set, lang_items);
+    let ty_cx = ty::mk_ctxt(sess, def_map, named_region_map, ast_map, freevars,
+                            region_map, lang_items);
 
     // passes are timed inside typeck
     let (method_map, vtable_map) = typeck::check_crate(

branches/try2/src/librustc/front/std_inject.rs

@@ -116,12 +116,12 @@ impl fold::ast_fold for StandardLibraryInjector {
             segments: ~[
                 ast::PathSegment {
                     identifier: self.sess.ident_of("std"),
-                    lifetime: None,
+                    lifetimes: opt_vec::Empty,
                     types: opt_vec::Empty,
                 },
                 ast::PathSegment {
                     identifier: self.sess.ident_of("prelude"),
-                    lifetime: None,
+                    lifetimes: opt_vec::Empty,
                     types: opt_vec::Empty,
                 },
             ],

branches/try2/src/librustc/front/test.rs

@@ -343,7 +343,7 @@ fn path_node(ids: ~[ast::Ident]) -> ast::Path {
         global: false,
         segments: ids.move_iter().map(|identifier| ast::PathSegment {
             identifier: identifier,
-            lifetime: None,
+            lifetimes: opt_vec::Empty,
             types: opt_vec::Empty,
         }).collect()
     }
@@ -355,7 +355,7 @@ fn path_node_global(ids: ~[ast::Ident]) -> ast::Path {
         global: true,
         segments: ids.move_iter().map(|identifier| ast::PathSegment {
             identifier: identifier,
-            lifetime: None,
+            lifetimes: opt_vec::Empty,
             types: opt_vec::Empty,
         }).collect()
     }

branches/try2/src/librustc/lib.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 #[link(name = "rustc",
+       package_id = "rustc",
        vers = "0.9-pre",
        uuid = "0ce89b41-2f92-459e-bbc1-8f5fe32f16cf",
        url = "https://github.com/mozilla/rust/tree/master/src/rustc")];
@@ -53,8 +54,10 @@ use syntax::diagnostic;
 pub mod middle {
     pub mod trans;
     pub mod ty;
+    pub mod ty_fold;
     pub mod subst;
     pub mod resolve;
+    pub mod resolve_lifetime;
     pub mod typeck;
     pub mod check_loop;
     pub mod check_match;

branches/try2/src/librustc/metadata/common.rs

@@ -89,7 +89,7 @@ pub static tag_path_elt_name: uint = 0x43u;
 pub static tag_item_field: uint = 0x44u;
 pub static tag_struct_mut: uint = 0x45u;
 
-pub static tag_region_param: uint = 0x46u;
+pub static tag_item_variances: uint = 0x46;
 pub static tag_mod_impl_trait: uint = 0x47u;
 /*
   trait items contain tag_item_trait_method elements,
@@ -193,6 +193,11 @@ pub static tag_path_elt_pretty_name: uint = 0x87;
 pub static tag_path_elt_pretty_name_ident: uint = 0x88;
 pub static tag_path_elt_pretty_name_extra: uint = 0x89;
 
+pub static tag_region_param_def: uint = 0x100;
+pub static tag_region_param_def_ident: uint = 0x101;
+pub static tag_region_param_def_def_id: uint = 0x102;
+
+
 pub struct LinkMeta {
     name: @str,
     vers: @str,

branches/try2/src/librustc/metadata/csearch.rs

@@ -14,7 +14,6 @@
 use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
-use metadata;
 use middle::ty;
 use middle::typeck;
 
@@ -144,6 +143,12 @@ pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore,
     decoder::get_trait_method_def_ids(cdata, def.node)
 }
 
+pub fn get_item_variances(cstore: @mut cstore::CStore,
+                          def: ast::DefId) -> ty::ItemVariances {
+    let cdata = cstore::get_crate_data(cstore, def.crate);
+    decoder::get_item_variances(cdata, def.node)
+}
+
 pub fn get_provided_trait_methods(tcx: ty::ctxt,
                                   def: ast::DefId)
                                -> ~[@ty::Method] {
@@ -199,12 +204,6 @@ pub fn get_trait_def(tcx: ty::ctxt, def: ast::DefId) -> ty::TraitDef {
     decoder::get_trait_def(cdata, def.node, tcx)
 }
 
-pub fn get_region_param(cstore: @mut metadata::cstore::CStore,
-                        def: ast::DefId) -> Option<ty::region_variance> {
-    let cdata = cstore::get_crate_data(cstore, def.crate);
-    return decoder::get_region_param(cdata, def.node);
-}
-
 pub fn get_field_type(tcx: ty::ctxt, class_id: ast::DefId,
                       def: ast::DefId) -> ty::ty_param_bounds_and_ty {
     let cstore = tcx.cstore;
@@ -224,7 +223,7 @@ pub fn get_field_type(tcx: ty::ctxt, class_id: ast::DefId,
     let ty = decoder::item_type(def, the_field, tcx, cdata);
     ty::ty_param_bounds_and_ty {
         generics: ty::Generics {type_param_defs: @~[],
-                                region_param: None},
+                                region_param_defs: @[]},
         ty: ty
     }
 }