---

yaml
---
r: 150899
b: refs/heads/try2
c: d35804e
h: refs/heads/master
i:
  150897: 9ee7b9a
  150895: 203ffb0
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: 37096730fbcbf2f14990a024fa908a5dc427730d
+refs/heads/try2: d35804ea5e69c9a3a8957626533a856f976fe4e3
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcollections/bitv.rs

@@ -97,12 +97,12 @@ impl SmallBitv {
     pub fn set_all(&mut self) { self.bits = !0; }
 
     #[inline]
-    pub fn is_true(&self, nbits: uint) -> bool {
+    pub fn all(&self, nbits: uint) -> bool {
         small_mask(nbits) & !self.bits == 0
     }
 
     #[inline]
-    pub fn is_false(&self, nbits: uint) -> bool {
+    pub fn none(&self, nbits: uint) -> bool {
         small_mask(nbits) & self.bits == 0
     }
 
@@ -412,13 +412,10 @@ impl Bitv {
 
     /// Returns `true` if all bits are 1
     #[inline]
-    pub fn is_true(&self) -> bool {
+    pub fn all(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.is_true(self.nbits),
-        _ => {
-          for i in self.iter() { if !i { return false; } }
-          true
-        }
+        Small(ref b) => b.all(self.nbits),
+        _ => self.iter().all(|x| x)
       }
     }
 
@@ -433,16 +430,19 @@ impl Bitv {
     }
 
     /// Returns `true` if all bits are 0
-    pub fn is_false(&self) -> bool {
+    pub fn none(&self) -> bool {
       match self.rep {
-        Small(ref b) => b.is_false(self.nbits),
-        Big(_) => {
-          for i in self.iter() { if i { return false; } }
-          true
-        }
+        Small(ref b) => b.none(self.nbits),
+        _ => self.iter().all(|x| !x)
       }
     }
 
+    #[inline]
+    /// Returns `true` if any bit is 1
+    pub fn any(&self) -> bool {
+        !self.none()
+    }
+
     pub fn init_to_vec(&self, i: uint) -> uint {
       return if self.get(i) { 1 } else { 0 };
     }
@@ -1551,6 +1551,51 @@ mod tests {
         assert!(b.contains(&1000));
     }
 
+    #[test]
+    fn test_small_bitv_tests() {
+        let v = from_bytes([0]);
+        assert!(!v.all());
+        assert!(!v.any());
+        assert!(v.none());
+
+        let v = from_bytes([0b00010100]);
+        assert!(!v.all());
+        assert!(v.any());
+        assert!(!v.none());
+
+        let v = from_bytes([0xFF]);
+        assert!(v.all());
+        assert!(v.any());
+        assert!(!v.none());
+    }
+
+    #[test]
+    fn test_big_bitv_tests() {
+        let v = from_bytes([ // 88 bits
+            0, 0, 0, 0,
+            0, 0, 0, 0,
+            0, 0, 0]);
+        assert!(!v.all());
+        assert!(!v.any());
+        assert!(v.none());
+
+        let v = from_bytes([ // 88 bits
+            0, 0, 0b00010100, 0,
+            0, 0, 0, 0b00110100,
+            0, 0, 0]);
+        assert!(!v.all());
+        assert!(v.any());
+        assert!(!v.none());
+
+        let v = from_bytes([ // 88 bits
+            0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF, 0xFF,
+            0xFF, 0xFF, 0xFF]);
+        assert!(v.all());
+        assert!(v.any());
+        assert!(!v.none());
+    }
+
     fn rng() -> rand::IsaacRng {
         let seed = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
         rand::SeedableRng::from_seed(seed)

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

@@ -300,10 +300,6 @@ fn resolve_crate<'a>(e: &mut Env,
                 dylib, rlib, metadata
             } = load_ctxt.load_library_crate(root);
 
-            // Claim this crate number and cache it
-            let cnum = e.next_crate_num;
-            e.next_crate_num += 1;
-
             // Stash paths for top-most crate locally if necessary.
             let crate_paths = if root.is_none() {
                 Some(CratePaths {
@@ -324,6 +320,17 @@ fn resolve_crate<'a>(e: &mut Env,
                 @RefCell::new(HashMap::new())
             };
 
+            // Claim this crate number and cache it if we're linking to the
+            // crate, otherwise it's a syntax-only crate and we don't need to
+            // reserve a number
+            let cnum = if should_link {
+                let n = e.next_crate_num;
+                e.next_crate_num += 1;
+                n
+            } else {
+                -1
+            };
+
             let cmeta = @cstore::crate_metadata {
                 name: load_ctxt.crate_id.name.to_owned(),
                 data: metadata,

branches/try2/src/librustc/middle/resolve.rs

@@ -3507,8 +3507,9 @@ impl<'a> Resolver<'a> {
                         // its scope.
 
                         self.resolve_error(span,
-                                              "attempt to use a type \
-                                              argument out of scope");
+                                              "can't use type parameters from \
+                                              outer function; try using a local \
+                                              type parameter instead");
                     }
 
                     return None;
@@ -3530,8 +3531,9 @@ impl<'a> Resolver<'a> {
                         // its scope.
 
                         self.resolve_error(span,
-                                              "attempt to use a type \
-                                              argument out of scope");
+                                              "can't use type parameters from \
+                                              outer function; try using a local \
+                                              type parameter instead");
                     }
 
                     return None;

branches/try2/src/librustc/middle/subst.rs

@@ -95,8 +95,9 @@ impl<'a> TypeFolder for SubstFolder<'a> {
                                               root.repr(self.tcx)),
                         None => ~""
                     };
-                    let m = format!("missing type param `{}`{}",
-                                    t.repr(self.tcx), root_msg);
+                    let m = format!("can't use type parameters from outer \
+                                    function{}; try using a local type \
+                                    parameter instead", root_msg);
                     match self.span {
                         Some(span) => self.tcx.sess.span_err(span, m),
                         None => self.tcx.sess.err(m)

branches/try2/src/librustc/middle/trans/monomorphize.rs

@@ -272,6 +272,7 @@ pub fn monomorphic_fn(ccx: &CrateContext,
         }
 
         // Ugh -- but this ensures any new variants won't be forgotten
+        ast_map::NodeLifetime(..) |
         ast_map::NodeExpr(..) |
         ast_map::NodeStmt(..) |
         ast_map::NodeArg(..) |

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

@@ -2416,13 +2416,13 @@ pub enum Representability {
 
 /// Check whether a type is representable. This means it cannot contain unboxed
 /// structural recursion. This check is needed for structs and enums.
-pub fn is_type_representable(cx: &ctxt, ty: t) -> Representability {
+pub fn is_type_representable(cx: &ctxt, sp: Span, ty: t) -> Representability {
 
     // Iterate until something non-representable is found
-    fn find_nonrepresentable<It: Iterator<t>>(cx: &ctxt, seen: &mut Vec<DefId>,
+    fn find_nonrepresentable<It: Iterator<t>>(cx: &ctxt, sp: Span, seen: &mut Vec<DefId>,
                                               mut iter: It) -> Representability {
         for ty in iter {
-            let r = type_structurally_recursive(cx, seen, ty);
+            let r = type_structurally_recursive(cx, sp, seen, ty);
             if r != Representable {
                  return r
             }
@@ -2432,7 +2432,7 @@ pub fn is_type_representable(cx: &ctxt, ty: t) -> Representability {
 
     // Does the type `ty` directly (without indirection through a pointer)
     // contain any types on stack `seen`?
-    fn type_structurally_recursive(cx: &ctxt, seen: &mut Vec<DefId>,
+    fn type_structurally_recursive(cx: &ctxt, sp: Span, seen: &mut Vec<DefId>,
                                    ty: t) -> Representability {
         debug!("type_structurally_recursive: {}",
                ::util::ppaux::ty_to_str(cx, ty));
@@ -2455,19 +2455,19 @@ pub fn is_type_representable(cx: &ctxt, ty: t) -> Representability {
         match get(ty).sty {
             // Tuples
             ty_tup(ref ts) => {
-                find_nonrepresentable(cx, seen, ts.iter().map(|t| *t))
+                find_nonrepresentable(cx, sp, seen, ts.iter().map(|t| *t))
             }
             // Fixed-length vectors.
             // FIXME(#11924) Behavior undecided for zero-length vectors.
             ty_vec(ty, VstoreFixed(_)) => {
-                type_structurally_recursive(cx, seen, ty)
+                type_structurally_recursive(cx, sp, seen, ty)
             }
 
             // Push struct and enum def-ids onto `seen` before recursing.
             ty_struct(did, ref substs) => {
                 seen.push(did);
                 let fields = struct_fields(cx, did, substs);
-                let r = find_nonrepresentable(cx, seen,
+                let r = find_nonrepresentable(cx, sp, seen,
                                               fields.iter().map(|f| f.mt.ty));
                 seen.pop();
                 r
@@ -2478,8 +2478,10 @@ pub fn is_type_representable(cx: &ctxt, ty: t) -> Representability {
 
                 let mut r = Representable;
                 for variant in vs.iter() {
-                    let iter = variant.args.iter().map(|aty| subst(cx, substs, *aty));
-                    r = find_nonrepresentable(cx, seen, iter);
+                    let iter = variant.args.iter().map(|aty| {
+                        aty.subst_spanned(cx, substs, Some(sp))
+                    });
+                    r = find_nonrepresentable(cx, sp, seen, iter);
 
                     if r != Representable { break }
                 }
@@ -2499,7 +2501,7 @@ pub fn is_type_representable(cx: &ctxt, ty: t) -> Representability {
     // contains a different, structurally recursive type, maintain a stack
     // of seen types and check recursion for each of them (issues #3008, #3779).
     let mut seen: Vec<DefId> = Vec::new();
-    type_structurally_recursive(cx, &mut seen, ty)
+    type_structurally_recursive(cx, sp, &mut seen, ty)
 }
 
 pub fn type_is_trait(ty: t) -> bool {

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -3356,7 +3356,7 @@ pub fn check_representable(tcx: &ty::ctxt,
     // recursive type. It is only necessary to throw an error on those that
     // contain themselves. For case 2, there must be an inner type that will be
     // caught by case 1.
-    match ty::is_type_representable(tcx, rty) {
+    match ty::is_type_representable(tcx, sp, rty) {
       ty::SelfRecursive => {
         tcx.sess.span_err(
           sp, format!("illegal recursive {} type; \

branches/try2/src/librustc/middle/typeck/collect.rs

@@ -945,7 +945,24 @@ pub fn ty_generics(ccx: &CrateCtxt,
                 let param_ty = ty::param_ty {idx: base_index + offset,
                                              def_id: local_def(param.id)};
                 let bounds = @compute_bounds(ccx, param_ty, &param.bounds);
-                let default = param.default.map(|x| ast_ty_to_ty(ccx, &ExplicitRscope, x));
+                let default = param.default.map(|path| {
+                    let ty = ast_ty_to_ty(ccx, &ExplicitRscope, path);
+                    let cur_idx = param_ty.idx;
+
+                    ty::walk_ty(ty, |t| {
+                        match ty::get(t).sty {
+                            ty::ty_param(p) => if p.idx > cur_idx {
+                                ccx.tcx.sess.span_err(path.span,
+                                                        "type parameters with a default cannot use \
+                                                        forward declared identifiers")
+                            },
+                            _ => {}
+                        }
+                    });
+
+                    ty
+                });
+
                 let def = ty::TypeParameterDef {
                     ident: param.ident,
                     def_id: local_def(param.id),