---

yaml
---
r: 158991
b: refs/heads/auto
c: a79d4be
h: refs/heads/master
i:
  158989: 9582c88
  158987: 3c2aaec
  158983: f8e4968
  158975: ed5a989
v: v3

Author: jbcrail

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: fa2983a1b7fc77dad37d49dcebeda3c25aac1e3f
+refs/heads/auto: a79d4be39cf99ed4dba1c757400a3ea708956653
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/docs.mk

@@ -28,13 +28,13 @@
 DOCS := index intro tutorial guide guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-plugin guide-crates complement-bugreport \
-	complement-lang-faq complement-design-faq complement-project-faq \
+	complement-lang-faq complement-design-faq complement-project-faq rust \
     rustdoc guide-unsafe guide-strings reference
 
 PDF_DOCS := guide reference
 
-RUSTDOC_DEPS_reference := doc/full-toc.inc
-RUSTDOC_FLAGS_reference := --html-in-header=doc/full-toc.inc
+RUSTDOC_DEPS_rust := doc/full-toc.inc
+RUSTDOC_FLAGS_rust := --html-in-header=doc/full-toc.inc
 
 L10N_LANGS := ja
 

branches/auto/src/libcollections/enum_set.rs

@@ -18,7 +18,6 @@ use core::fmt;
 
 // FIXME(conventions): implement BitXor
 // FIXME(contentions): implement union family of methods? (general design may be wrong here)
-// FIXME(conventions): implement len
 
 #[deriving(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 /// A specialized `Set` implementation to use enum types.
@@ -92,6 +91,12 @@ impl<E:CLike> EnumSet<E> {
         EnumSet {bits: 0}
     }
 
+    /// Returns the number of elements in the given `EnumSet`.
+    #[unstable = "matches collection reform specification, waiting for dust to settle"]
+    pub fn len(&self) -> uint {
+        self.bits.count_ones()
+    }
+
     /// Returns true if the `EnumSet` is empty.
     #[unstable = "matches collection reform specification, waiting for dust to settle"]
     pub fn is_empty(&self) -> bool {
@@ -269,6 +274,20 @@ mod test {
         assert_eq!("{A, C}", e.to_string().as_slice());
     }
 
+    #[test]
+    fn test_len() {
+        let mut e = EnumSet::new();
+        assert_eq!(e.len(), 0);
+        e.insert(A);
+        e.insert(B);
+        e.insert(C);
+        assert_eq!(e.len(), 3);
+        e.remove(&A);
+        assert_eq!(e.len(), 2);
+        e.clear();
+        assert_eq!(e.len(), 0);
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // intersect
 

branches/auto/src/libcollections/vec.rs

@@ -801,13 +801,14 @@ impl<T> Vec<T> {
     ///
     /// # Example
     /// ```
-    /// let mut v = vec!["foo", "bar", "baz", "qux"];
+    /// let mut v = vec!["foo".to_string(), "bar".to_string(),
+    ///                  "baz".to_string(), "qux".to_string()];
     ///
-    /// assert_eq!(v.swap_remove(1), Some("bar"));
-    /// assert_eq!(v, vec!["foo", "qux", "baz"]);
+    /// assert_eq!(v.swap_remove(1), Some("bar".to_string()));
+    /// assert_eq!(v, vec!["foo".to_string(), "qux".to_string(), "baz".to_string()]);
     ///
-    /// assert_eq!(v.swap_remove(0), Some("foo"));
-    /// assert_eq!(v, vec!["baz", "qux"]);
+    /// assert_eq!(v.swap_remove(0), Some("foo".to_string()));
+    /// assert_eq!(v, vec!["baz".to_string(), "qux".to_string()]);
     ///
     /// assert_eq!(v.swap_remove(2), None);
     /// ```

branches/auto/src/libcore/atomic.rs

@@ -717,15 +717,15 @@ unsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {
 /// A fence 'A' which has `Release` ordering semantics, synchronizes with a
 /// fence 'B' with (at least) `Acquire` semantics, if and only if there exists
 /// atomic operations X and Y, both operating on some atomic object 'M' such
-/// that A is sequenced before X, Y is synchronized before B and Y observes
+/// that A is sequenced before X, Y is synchronized before B and Y observers
 /// the change to M. This provides a happens-before dependence between A and B.
 ///
 /// Atomic operations with `Release` or `Acquire` semantics can also synchronize
 /// with a fence.
 ///
-/// A fence which has `SeqCst` ordering, in addition to having both `Acquire`
-/// and `Release` semantics, participates in the global program order of the
-/// other `SeqCst` operations and/or fences.
+/// A fence with has `SeqCst` ordering, in addition to having both `Acquire` and
+/// `Release` semantics, participates in the global program order of the other
+/// `SeqCst` operations and/or fences.
 ///
 /// Accepts `Acquire`, `Release`, `AcqRel` and `SeqCst` orderings.
 ///

branches/auto/src/libcore/intrinsics.rs

@@ -536,7 +536,7 @@ extern "rust-intrinsic" {
 /// `TypeId` represents a globally unique identifier for a type
 #[lang="type_id"] // This needs to be kept in lockstep with the code in trans/intrinsic.rs and
                   // middle/lang_items.rs
-#[deriving(Clone, PartialEq, Eq, Show)]
+#[deriving(PartialEq, Eq, Show)]
 pub struct TypeId {
     t: u64,
 }

branches/auto/src/librustc/driver/driver.rs

@@ -212,6 +212,11 @@ pub fn phase_2_configure_and_expand(sess: &Session,
         *ty == config::CrateTypeExecutable
     });
 
+    krate = time(time_passes, "crate injection", krate, |krate|
+                 syntax::std_inject::maybe_inject_crates_ref(krate,
+                                                             sess.opts.alt_std_name.clone(),
+                                                             any_exe));
+
     // strip before expansion to allow macros to depend on
     // configuration variables e.g/ in
     //
@@ -223,11 +228,6 @@ pub fn phase_2_configure_and_expand(sess: &Session,
     krate = time(time_passes, "configuration 1", krate, |krate|
                  syntax::config::strip_unconfigured_items(sess.diagnostic(), krate));
 
-    krate = time(time_passes, "crate injection", krate, |krate|
-                 syntax::std_inject::maybe_inject_crates_ref(krate,
-                                                             sess.opts.alt_std_name.clone(),
-                                                             any_exe));
-
     let mut addl_plugins = Some(addl_plugins);
     let Plugins { macros, registrars }
         = time(time_passes, "plugin loading", (), |_|

branches/auto/src/librustc/middle/traits/mod.rs

@@ -176,7 +176,7 @@ pub enum Vtable<N> {
     /// ID is the ID of the closure expression. This is a `VtableImpl`
     /// in spirit, but the impl is generated by the compiler and does
     /// not appear in the source.
-    VtableUnboxedClosure(ast::DefId, subst::Substs),
+    VtableUnboxedClosure(ast::DefId),
 
     /// Successful resolution to an obligation provided by the caller
     /// for some type parameter.
@@ -338,7 +338,7 @@ impl<N> Vtable<N> {
     pub fn iter_nested(&self) -> Items<N> {
         match *self {
             VtableImpl(ref i) => i.iter_nested(),
-            VtableUnboxedClosure(..) => (&[]).iter(),
+            VtableUnboxedClosure(_) => (&[]).iter(),
             VtableParam(_) => (&[]).iter(),
             VtableBuiltin(ref i) => i.iter_nested(),
         }
@@ -347,7 +347,7 @@ impl<N> Vtable<N> {
     pub fn map_nested<M>(&self, op: |&N| -> M) -> Vtable<M> {
         match *self {
             VtableImpl(ref i) => VtableImpl(i.map_nested(op)),
-            VtableUnboxedClosure(d, ref s) => VtableUnboxedClosure(d, s.clone()),
+            VtableUnboxedClosure(d) => VtableUnboxedClosure(d),
             VtableParam(ref p) => VtableParam((*p).clone()),
             VtableBuiltin(ref i) => VtableBuiltin(i.map_nested(op)),
         }
@@ -356,7 +356,7 @@ impl<N> Vtable<N> {
     pub fn map_move_nested<M>(self, op: |N| -> M) -> Vtable<M> {
         match self {
             VtableImpl(i) => VtableImpl(i.map_move_nested(op)),
-            VtableUnboxedClosure(d, s) => VtableUnboxedClosure(d, s),
+            VtableUnboxedClosure(d) => VtableUnboxedClosure(d),
             VtableParam(p) => VtableParam(p),
             VtableBuiltin(i) => VtableBuiltin(i.map_move_nested(op)),
         }

branches/auto/src/librustc/middle/traits/select.rs

@@ -1582,9 +1582,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 Ok(VtableImpl(vtable_impl))
             }
 
-            UnboxedClosureCandidate(closure_def_id, substs) => {
-                try!(self.confirm_unboxed_closure_candidate(obligation, closure_def_id, &substs));
-                Ok(VtableUnboxedClosure(closure_def_id, substs))
+            UnboxedClosureCandidate(closure_def_id, ref substs) => {
+                try!(self.confirm_unboxed_closure_candidate(obligation, closure_def_id, substs));
+                Ok(VtableUnboxedClosure(closure_def_id))
             }
         }
     }

branches/auto/src/librustc/middle/traits/util.rs

@@ -311,10 +311,9 @@ impl<N:Repr> Repr for super::Vtable<N> {
             super::VtableImpl(ref v) =>
                 v.repr(tcx),
 
-            super::VtableUnboxedClosure(ref d, ref s) =>
-                format!("VtableUnboxedClosure({},{})",
-                        d.repr(tcx),
-                        s.repr(tcx)),
+            super::VtableUnboxedClosure(ref d) =>
+                format!("VtableUnboxedClosure({})",
+                        d.repr(tcx)),
 
             super::VtableParam(ref v) =>
                 format!("VtableParam({})", v.repr(tcx)),

branches/auto/src/librustc/middle/trans/callee.rs

@@ -490,9 +490,7 @@ pub fn trans_fn_ref_with_substs(
     };
 
     // If this is an unboxed closure, redirect to it.
-    match closure::get_or_create_declaration_if_unboxed_closure(bcx,
-                                                                def_id,
-                                                                &substs) {
+    match closure::get_or_create_declaration_if_unboxed_closure(bcx, def_id) {
         None => {}
         Some(llfn) => return llfn,
     }

branches/auto/src/librustc/middle/trans/closure.rs

@@ -27,7 +27,6 @@ use middle::trans::monomorphize::MonoId;
 use middle::trans::type_of::*;
 use middle::trans::type_::Type;
 use middle::ty;
-use middle::subst::{Subst, Substs};
 use util::ppaux::Repr;
 use util::ppaux::ty_to_string;
 
@@ -421,21 +420,15 @@ pub fn trans_expr_fn<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 /// Returns the LLVM function declaration for an unboxed closure, creating it
 /// if necessary. If the ID does not correspond to a closure ID, returns None.
 pub fn get_or_create_declaration_if_unboxed_closure<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
-                                                                closure_id: ast::DefId,
-                                                                substs: &Substs)
+                                                                closure_id: ast::DefId)
                                                                 -> Option<ValueRef> {
     let ccx = bcx.ccx();
     if !ccx.tcx().unboxed_closures.borrow().contains_key(&closure_id) {
         // Not an unboxed closure.
         return None
     }
 
-    let function_type = ty::node_id_to_type(bcx.tcx(), closure_id.node);
-    let function_type = function_type.subst(bcx.tcx(), substs);
-
-    // Normalize type so differences in regions and typedefs don't cause
-    // duplicate declarations
-    let function_type = ty::normalize_ty(bcx.tcx(), function_type);
+    let function_type = node_id_type(bcx, closure_id.node);
     let params = match ty::get(function_type).sty {
         ty::ty_unboxed_closure(_, _, ref substs) => substs.types.clone(),
         _ => unreachable!()
@@ -454,6 +447,7 @@ pub fn get_or_create_declaration_if_unboxed_closure<'blk, 'tcx>(bcx: Block<'blk,
         None => {}
     }
 
+    let function_type = node_id_type(bcx, closure_id.node);
     let symbol = ccx.tcx().map.with_path(closure_id.node, |path| {
         mangle_internal_name_by_path_and_seq(path, "unboxed_closure")
     });
@@ -486,12 +480,12 @@ pub fn trans_unboxed_closure<'blk, 'tcx>(
     let closure_id = ast_util::local_def(id);
     let llfn = get_or_create_declaration_if_unboxed_closure(
         bcx,
-        closure_id,
-        &bcx.fcx.param_substs.substs).unwrap();
+        closure_id).unwrap();
 
-    let function_type = (*bcx.tcx().unboxed_closures.borrow())[closure_id]
-                                                              .closure_type
-                                                              .clone();
+    let unboxed_closures = bcx.tcx().unboxed_closures.borrow();
+    let function_type = (*unboxed_closures)[closure_id]
+                                        .closure_type
+                                        .clone();
     let function_type = ty::mk_closure(bcx.tcx(), function_type);
 
     let freevars: Vec<ty::Freevar> =

branches/auto/src/librustc/middle/trans/meth.rs

@@ -355,13 +355,16 @@ fn trans_monomorphized_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 
             Callee { bcx: bcx, data: Fn(llfn) }
         }
-        traits::VtableUnboxedClosure(closure_def_id, substs) => {
-            // The substitutions should have no type parameters remaining
-            // after passing through fulfill_obligation
+        traits::VtableUnboxedClosure(closure_def_id) => {
+            let self_ty = node_id_type(bcx, closure_def_id.node);
+            let callee_substs = get_callee_substitutions_for_unboxed_closure(
+                bcx,
+                self_ty);
+
             let llfn = trans_fn_ref_with_substs(bcx,
                                                 closure_def_id,
                                                 MethodCall(method_call),
-                                                substs);
+                                                callee_substs);
 
             Callee {
                 bcx: bcx,
@@ -515,6 +518,24 @@ pub fn trans_trait_callee_from_llval<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
     };
 }
 
+/// Looks up the substitutions for an unboxed closure and adds the
+/// self type
+fn get_callee_substitutions_for_unboxed_closure(bcx: Block,
+                                                self_ty: ty::t)
+                                                -> subst::Substs {
+    match ty::get(self_ty).sty {
+        ty::ty_unboxed_closure(_, _, ref substs) => {
+            substs.with_self_ty(ty::mk_rptr(bcx.tcx(),
+                                            ty::ReStatic,
+                                            ty::mt {
+                                                ty: self_ty,
+                                                mutbl: ast::MutMutable,
+                                            }))
+        },
+        _ => unreachable!()
+    }
+}
+
 /// Creates a returns a dynamic vtable for the given type and vtable origin.
 /// This is used only for objects.
 ///
@@ -559,19 +580,19 @@ pub fn get_vtable(bcx: Block,
                     nested: _ }) => {
                 emit_vtable_methods(bcx, id, substs).into_iter()
             }
-            traits::VtableUnboxedClosure(closure_def_id, substs) => {
-                // Look up closure type
-                let self_ty = ty::node_id_to_type(bcx.tcx(), closure_def_id.node);
-                // Apply substitutions from closure param environment.
-                // The substitutions should have no type parameters
-                // remaining after passing through fulfill_obligation
-                let self_ty = self_ty.subst(bcx.tcx(), &substs);
+            traits::VtableUnboxedClosure(closure_def_id) => {
+                let self_ty = node_id_type(bcx, closure_def_id.node);
+
+                let callee_substs =
+                    get_callee_substitutions_for_unboxed_closure(
+                        bcx,
+                        self_ty.clone());
 
                 let mut llfn = trans_fn_ref_with_substs(
                     bcx,
                     closure_def_id,
                     ExprId(0),
-                    substs.clone());
+                    callee_substs.clone());
 
                 {
                     let unboxed_closures = bcx.tcx()
@@ -624,7 +645,7 @@ pub fn get_vtable(bcx: Block,
                                                    llfn,
                                                    &closure_type,
                                                    closure_def_id,
-                                                   substs);
+                                                   callee_substs);
                     }
                 }
 

branches/auto/src/librustc/middle/ty_fold.rs

@@ -414,9 +414,7 @@ impl<N:TypeFoldable> TypeFoldable for traits::Vtable<N> {
     fn fold_with<'tcx, F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::Vtable<N> {
         match *self {
             traits::VtableImpl(ref v) => traits::VtableImpl(v.fold_with(folder)),
-            traits::VtableUnboxedClosure(d, ref s) => {
-                traits::VtableUnboxedClosure(d, s.fold_with(folder))
-            }
+            traits::VtableUnboxedClosure(d) => traits::VtableUnboxedClosure(d),
             traits::VtableParam(ref p) => traits::VtableParam(p.fold_with(folder)),
             traits::VtableBuiltin(ref d) => traits::VtableBuiltin(d.fold_with(folder)),
         }