---

yaml
---
r: 108388
b: refs/heads/dist-snap
c: 37bf97a
h: refs/heads/master
v: v3

Author: cmacknz

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 5736deb90e8f4c15a09c8dec5e1f3467b805fe70
+refs/heads/dist-snap: 37bf97a0f9cc764a19dfcff21d62384b2445dcbc
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/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.count_ones();
+        let exact = self.bits.population_count();
         (exact, Some(exact))
     }
 }

branches/dist-snap/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/dist-snap/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/dist-snap/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.count_ones() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
+                a if a.population_count() == 1 => Type::array(&Type::vector(&Type::i32(), a / 4),
                                                               align_units),
                 _ => fail!("unsupported enum alignment: {:?}", align)
             };

branches/dist-snap/src/librustc/middle/typeck/collect.rs

@@ -552,126 +552,110 @@ pub fn ensure_no_ty_param_bounds(ccx: &CrateCtxt,
     }
 }
 
-fn ensure_generics_abi(ccx: &CrateCtxt,
-                       span: Span,
-                       abis: AbiSet,
-                       generics: &ast::Generics) {
-    if generics.ty_params.len() > 0 &&
-       !(abis.is_rust() || abis.is_intrinsic()) {
-        ccx.tcx.sess.span_err(span,
-                              "foreign functions may not use type parameters");
-    }
-}
-
 pub fn convert(ccx: &CrateCtxt, it: &ast::Item) {
     let tcx = ccx.tcx;
     debug!("convert: item {} with id {}", token::get_ident(it.ident), it.id);
     match it.node {
-        // These don't define types.
-        ast::ItemForeignMod(_) | ast::ItemMod(_) | ast::ItemMac(_) => {}
-        ast::ItemEnum(ref enum_definition, ref generics) => {
-            ensure_no_ty_param_bounds(ccx, it.span, generics, "enumeration");
-            let tpt = ty_of_item(ccx, it);
-            write_ty_to_tcx(tcx, it.id, tpt.ty);
-            get_enum_variant_types(ccx,
-                                   tpt.ty,
-                                   enum_definition.variants,
-                                   generics);
-        },
-        ast::ItemImpl(ref generics, ref opt_trait_ref, selfty, ref ms) => {
-            let i_ty_generics = ty_generics(ccx, generics, 0);
-            let selfty = ccx.to_ty(&ExplicitRscope, selfty);
-            write_ty_to_tcx(tcx, it.id, selfty);
+      // These don't define types.
+      ast::ItemForeignMod(_) | ast::ItemMod(_) | ast::ItemMac(_) => {}
+      ast::ItemEnum(ref enum_definition, ref generics) => {
+          ensure_no_ty_param_bounds(ccx, it.span, generics, "enumeration");
+          let tpt = ty_of_item(ccx, it);
+          write_ty_to_tcx(tcx, it.id, tpt.ty);
+          get_enum_variant_types(ccx,
+                                 tpt.ty,
+                                 enum_definition.variants,
+                                 generics);
+      }
+      ast::ItemImpl(ref generics, ref opt_trait_ref, selfty, ref ms) => {
+        let i_ty_generics = ty_generics(ccx, generics, 0);
+        let selfty = ccx.to_ty(&ExplicitRscope, selfty);
+        write_ty_to_tcx(tcx, it.id, selfty);
 
-            {
-                let mut tcache = tcx.tcache.borrow_mut();
-                tcache.get().insert(local_def(it.id),
-                                    ty_param_bounds_and_ty {
-                                        generics: i_ty_generics.clone(),
-                                        ty: selfty});
-            }
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id),
+                              ty_param_bounds_and_ty {
+                                  generics: i_ty_generics.clone(),
+                                  ty: selfty});
+        }
 
-            // If there is a trait reference, treat the methods as always public.
-            // This is to work around some incorrect behavior in privacy checking:
-            // when the method belongs to a trait, it should acquire the privacy
-            // from the trait, not the impl. Forcing the visibility to be public
-            // makes things sorta work.
-            let parent_visibility = if opt_trait_ref.is_some() {
-                ast::Public
-            } else {
-                it.vis
-            };
+        // If there is a trait reference, treat the methods as always public.
+        // This is to work around some incorrect behavior in privacy checking:
+        // when the method belongs to a trait, it should acquire the privacy
+        // from the trait, not the impl. Forcing the visibility to be public
+        // makes things sorta work.
+        let parent_visibility = if opt_trait_ref.is_some() {
+            ast::Public
+        } else {
+            it.vis
+        };
 
-            convert_methods(ccx,
-                            ImplContainer(local_def(it.id)),
-                            *ms,
-                            selfty,
-                            &i_ty_generics,
-                            generics,
-                            parent_visibility);
-
-            for trait_ref in opt_trait_ref.iter() {
-                let trait_ref = instantiate_trait_ref(ccx, trait_ref, selfty);
-
-                // Prevent the builtin kind traits from being manually implemented.
-                if tcx.lang_items.to_builtin_kind(trait_ref.def_id).is_some() {
-                    tcx.sess.span_err(it.span,
-                        "cannot provide an explicit implementation \
-                         for a builtin kind");
-                }
+        convert_methods(ccx,
+                        ImplContainer(local_def(it.id)),
+                        *ms,
+                        selfty,
+                        &i_ty_generics,
+                        generics,
+                        parent_visibility);
+
+        for trait_ref in opt_trait_ref.iter() {
+            let trait_ref = instantiate_trait_ref(ccx, trait_ref, selfty);
+
+            // Prevent the builtin kind traits from being manually implemented.
+            if tcx.lang_items.to_builtin_kind(trait_ref.def_id).is_some() {
+                tcx.sess.span_err(it.span,
+                    "cannot provide an explicit implementation \
+                     for a builtin kind");
             }
-        },
-        ast::ItemTrait(ref generics, _, ref trait_methods) => {
-            let trait_def = trait_def_of_item(ccx, it);
-
-            // Run convert_methods on the provided methods.
-            let (_, provided_methods) =
-                split_trait_methods(*trait_methods);
-            let untransformed_rcvr_ty = ty::mk_self(tcx, local_def(it.id));
-            convert_methods(ccx,
-                            TraitContainer(local_def(it.id)),
-                            provided_methods,
-                            untransformed_rcvr_ty,
-                            &trait_def.generics,
-                            generics,
-                            it.vis);
-
-            // We need to do this *after* converting methods, since
-            // convert_methods produces a tcache entry that is wrong for
-            // static trait methods. This is somewhat unfortunate.
-            ensure_trait_methods(ccx, it.id);
-        },
-        ast::ItemStruct(struct_def, ref generics) => {
-            ensure_no_ty_param_bounds(ccx, it.span, generics, "structure");
-
-            // Write the class type
-            let tpt = ty_of_item(ccx, it);
-            write_ty_to_tcx(tcx, it.id, tpt.ty);
+        }
+      }
+      ast::ItemTrait(ref generics, _, ref trait_methods) => {
+          let trait_def = trait_def_of_item(ccx, it);
+
+          // Run convert_methods on the provided methods.
+          let (_, provided_methods) =
+              split_trait_methods(*trait_methods);
+          let untransformed_rcvr_ty = ty::mk_self(tcx, local_def(it.id));
+          convert_methods(ccx,
+                          TraitContainer(local_def(it.id)),
+                          provided_methods,
+                          untransformed_rcvr_ty,
+                          &trait_def.generics,
+                          generics,
+                          it.vis);
+
+          // We need to do this *after* converting methods, since
+          // convert_methods produces a tcache entry that is wrong for
+          // static trait methods. This is somewhat unfortunate.
+          ensure_trait_methods(ccx, it.id);
+      }
+      ast::ItemStruct(struct_def, ref generics) => {
+        ensure_no_ty_param_bounds(ccx, it.span, generics, "structure");
+
+        // Write the class type
+        let tpt = ty_of_item(ccx, it);
+        write_ty_to_tcx(tcx, it.id, tpt.ty);
 
-            {
-                let mut tcache = tcx.tcache.borrow_mut();
-                tcache.get().insert(local_def(it.id), tpt.clone());
-            }
+        {
+            let mut tcache = tcx.tcache.borrow_mut();
+            tcache.get().insert(local_def(it.id), tpt.clone());
+        }
 
-            convert_struct(ccx, struct_def, tpt, it.id);
-        },
-        ast::ItemTy(_, ref generics) => {
-            ensure_no_ty_param_bounds(ccx, it.span, generics, "type");
-            let tpt = ty_of_item(ccx, it);
-            write_ty_to_tcx(tcx, it.id, tpt.ty);
-        },
-        ast::ItemFn(_, _, abi, ref generics, _) => {
-            ensure_generics_abi(ccx, it.span, abi, generics);
-            let tpt = ty_of_item(ccx, it);
-            write_ty_to_tcx(tcx, it.id, tpt.ty);
-        },
-        _ => {
-            // This call populates the type cache with the converted type
-            // of the item in passing. All we have to do here is to write
-            // it into the node type table.
-            let tpt = ty_of_item(ccx, it);
-            write_ty_to_tcx(tcx, it.id, tpt.ty);
-        },
+        convert_struct(ccx, struct_def, tpt, it.id);
+      }
+      ast::ItemTy(_, ref generics) => {
+        ensure_no_ty_param_bounds(ccx, it.span, generics, "type");
+        let tpt = ty_of_item(ccx, it);
+        write_ty_to_tcx(tcx, it.id, tpt.ty);
+      }
+      _ => {
+        // This call populates the type cache with the converted type
+        // of the item in passing. All we have to do here is to write
+        // it into the node type table.
+        let tpt = ty_of_item(ccx, it);
+        write_ty_to_tcx(tcx, it.id, tpt.ty);
+      }
     }
 }
 

branches/dist-snap/src/libstd/comm/shared.rs

@@ -305,6 +305,7 @@ impl<T: Send> Packet<T> {
             // See the discussion in the stream implementation for why we we
             // might decrement steals.
             Some(data) => {
+                self.steals += 1;
                 if self.steals > MAX_STEALS {
                     match self.cnt.swap(0, atomics::SeqCst) {
                         DISCONNECTED => {
@@ -313,12 +314,11 @@ impl<T: Send> Packet<T> {
                         n => {
                             let m = cmp::min(n, self.steals);
                             self.steals -= m;
-                            self.bump(n - m);
+                            self.cnt.fetch_add(n - m, atomics::SeqCst);
                         }
                     }
                     assert!(self.steals >= 0);
                 }
-                self.steals += 1;
                 Ok(data)
             }