---

yaml
---
r: 100903
b: refs/heads/snap-stage3
c: 03c5342
h: refs/heads/master
i:
  100901: 4f720b5
  100899: 08f237f
  100895: a25c95a
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: e3b1f3c443c048913e2d573fcc5a9c2be3484a78
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: b609d57b02eaf67fcc12a708dca1460bd88bcaab
+refs/heads/snap-stage3: 03c5342419fe49d060f2ea26f77ae3e716945a90
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/enum_set.rs

@@ -129,7 +129,7 @@ impl<E:CLike> Iterator<E> for Items<E> {
     }
 
     fn size_hint(&self) -> (uint, Option<uint>) {
-        let exact = self.bits.population_count();
+        let exact = self.bits.count_ones();
         (exact, Some(exact))
     }
 }

branches/snap-stage3/src/libextra/test.rs

@@ -904,15 +904,14 @@ pub fn run_test(force_ignore: bool,
                       monitor_ch: Chan<MonitorMsg>,
                       testfn: proc()) {
         spawn(proc() {
-            let mut task = task::task();
             let (p, c) = Chan::new();
             let mut reader = PortReader::new(p);
             let stdout = ChanWriter::new(c.clone());
             let stderr = ChanWriter::new(c);
-            match desc.name {
-                DynTestName(ref name) => task.name(name.clone()),
-                StaticTestName(name) => task.name(name),
-            }
+            let mut task = task::task().named(match desc.name {
+                DynTestName(ref name) => name.clone().into_maybe_owned(),
+                StaticTestName(name) => name.into_maybe_owned(),
+            });
             task.opts.stdout = Some(~stdout as ~Writer);
             task.opts.stderr = Some(~stderr as ~Writer);
             let result_future = task.future_result();

branches/snap-stage3/src/libgreen/task.rs

@@ -175,7 +175,6 @@ impl GreenTask {
                      opts: TaskOpts,
                      f: proc()) -> ~GreenTask {
         let TaskOpts {
-            watched: _watched,
             notify_chan, name, stack_size,
             stderr, stdout, logger,
         } = opts;

branches/snap-stage3/src/libnative/task.rs

@@ -57,7 +57,6 @@ pub fn spawn(f: proc()) {
 /// inside the task.
 pub fn spawn_opts(opts: TaskOpts, f: proc()) {
     let TaskOpts {
-        watched: _watched,
         notify_chan, name, stack_size,
         logger, stderr, stdout,
     } = opts;

branches/snap-stage3/src/librustc/lib.rs

@@ -371,8 +371,7 @@ pub fn monitor(f: proc()) {
     #[cfg(not(rtopt))]
     static STACK_SIZE: uint = 20000000; // 20MB
 
-    let mut task_builder = task::task();
-    task_builder.name("rustc");
+    let mut task_builder = task::task().named("rustc");
 
     // FIXME: Hacks on hacks. If the env is trying to override the stack size
     // then *don't* set it explicitly.

branches/snap-stage3/src/librustc/metadata/creader.rs

@@ -24,7 +24,7 @@ use syntax::ast;
 use syntax::abi;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
-use syntax::codemap::{Span, DUMMY_SP};
+use syntax::codemap::{Span};
 use syntax::diagnostic::SpanHandler;
 use syntax::ext::base::{CrateLoader, MacroCrate};
 use syntax::parse::token::{IdentInterner, InternedString};
@@ -147,6 +147,7 @@ fn visit_view_item(e: &mut Env, i: &ast::ViewItem) {
     match extract_crate_info(i) {
         Some(info) => {
             let cnum = resolve_crate(e,
+                                     None,
                                      info.ident.clone(),
                                      info.name.clone(),
                                      info.version.clone(),
@@ -299,6 +300,7 @@ fn existing_match(e: &Env, name: &str, version: &str, hash: &str) -> Option<ast:
 }
 
 fn resolve_crate(e: &mut Env,
+                 root_ident: Option<~str>,
                  ident: ~str,
                  name: ~str,
                  version: ~str,
@@ -319,7 +321,7 @@ fn resolve_crate(e: &mut Env,
         };
         let loader::Library {
             dylib, rlib, metadata
-        } = load_ctxt.load_library_crate();
+        } = load_ctxt.load_library_crate(root_ident.clone());
 
         let attrs = decoder::get_crate_attributes(metadata.as_slice());
         let crateid = attr::find_crateid(attrs).unwrap();
@@ -338,8 +340,17 @@ fn resolve_crate(e: &mut Env,
         }
         e.next_crate_num += 1;
 
+        // Maintain a reference to the top most crate.
+        let root_crate = match root_ident {
+            Some(c) => c,
+            None => load_ctxt.ident.clone()
+        };
+
         // Now resolve the crates referenced by this crate
-        let cnum_map = resolve_crate_deps(e, metadata.as_slice());
+        let cnum_map = resolve_crate_deps(e,
+                                          Some(root_crate),
+                                          metadata.as_slice(),
+                                          span);
 
         let cmeta = @cstore::crate_metadata {
             name: load_ctxt.name,
@@ -364,7 +375,10 @@ fn resolve_crate(e: &mut Env,
 }
 
 // Go through the crate metadata and load any crates that it references
-fn resolve_crate_deps(e: &mut Env, cdata: &[u8]) -> cstore::cnum_map {
+fn resolve_crate_deps(e: &mut Env,
+                      root_ident: Option<~str>,
+                      cdata: &[u8], span : Span)
+                   -> cstore::cnum_map {
     debug!("resolving deps of external crate");
     // The map from crate numbers in the crate we're resolving to local crate
     // numbers
@@ -387,15 +401,13 @@ fn resolve_crate_deps(e: &mut Env, cdata: &[u8]) -> cstore::cnum_map {
           None => {
             debug!("need to load it");
             // This is a new one so we've got to load it
-            // FIXME (#2404): Need better error reporting than just a bogus
-            // span.
-            let fake_span = DUMMY_SP;
             let local_cnum = resolve_crate(e,
+                                           root_ident.clone(),
                                            cname_str.get().to_str(),
                                            cname_str.get().to_str(),
                                            dep.vers.clone(),
                                            dep.hash.clone(),
-                                           fake_span);
+                                           span);
             cnum_map.insert(extrn_cnum, local_cnum);
           }
         }
@@ -427,6 +439,7 @@ impl CrateLoader for Loader {
     fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate {
         let info = extract_crate_info(krate).unwrap();
         let cnum = resolve_crate(&mut self.env,
+                                 None,
                                  info.ident.clone(),
                                  info.name.clone(),
                                  info.version.clone(),

branches/snap-stage3/src/librustc/metadata/loader.rs

@@ -65,13 +65,17 @@ pub struct ArchiveMetadata {
 }
 
 impl Context {
-    pub fn load_library_crate(&self) -> Library {
+    pub fn load_library_crate(&self, root_ident: Option<~str>) -> Library {
         match self.find_library_crate() {
             Some(t) => t,
             None => {
-                self.sess.span_fatal(self.span,
-                                     format!("can't find crate for `{}`",
-                                             self.ident));
+                let message = match root_ident {
+                    None => format!("can't find crate for `{}`", self.ident),
+                    Some(c) => format!("can't find crate for `{}` which `{}` depends on",
+                                       self.ident,
+                                       c)
+                };
+                self.sess.span_fatal(self.span, message);
             }
         }
     }

branches/snap-stage3/src/librustc/middle/trans/adt.rs

@@ -432,7 +432,7 @@ fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool
                 4 => Type::array(&Type::i32(), align_units),
                 8 if machine::llalign_of_min(cx, Type::i64()) == 8 =>
                                  Type::array(&Type::i64(), align_units),
-                a if a.population_count() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
+                a if a.count_ones() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
                                                               align_units),
                 _ => fail!("unsupported enum alignment: {:?}", align)
             };