---

yaml
---
r: 158987
b: refs/heads/auto
c: 1971e02
h: refs/heads/master
i:
  158985: 617678e
  158983: f8e4968
v: v3

Author: chris-morgan

[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: ebc625ad3eaa2ee630c6c8203106826ad23abc98
+refs/heads/auto: 1971e02ec62bfe50963d1986552e241602c3dc20
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -76,24 +76,6 @@ putvar() {
     printf "%-20s := %s\n" $1 "$T" >>config.tmp
 }
 
-putpathvar() {
-    local T
-    eval T=\$$1
-    eval TLEN=\${#$1}
-    if [ $TLEN -gt 35 ]
-    then
-        printf "configure: %-20s := %.35s ...\n" $1 "$T"
-    else
-        printf "configure: %-20s := %s %s\n" $1 "$T" "$2"
-    fi
-    if [ -z "$T" ]
-    then
-        printf "%-20s := \n" $1 >>config.tmp
-    else
-        printf "%-20s := \"%s\"\n" $1 "$T" >>config.tmp
-    fi
-}
-
 probe() {
     local V=$1
     shift
@@ -119,7 +101,7 @@ probe() {
         fi
     done
     eval $V=\$T
-    putpathvar $V "$VER"
+    putvar $V "$VER"
 }
 
 probe_need() {
@@ -656,9 +638,9 @@ probe CFG_ADB        adb
 
 if [ ! -z "$CFG_PANDOC" ]
 then
-    PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc\(.exe\)\? ' |
+    PV_MAJOR_MINOR=$(pandoc --version | grep '^pandoc ' |
         # extract the first 2 version fields, ignore everything else
-        sed 's/pandoc\(.exe\)\? \([0-9]*\)\.\([0-9]*\).*/\2 \3/')
+        sed 's/pandoc \([0-9]*\)\.\([0-9]*\).*/\1 \2/')
 
     MIN_PV_MAJOR="1"
     MIN_PV_MINOR="9"
@@ -1348,7 +1330,8 @@ do
 done
 
 # Munge any paths that appear in config.mk back to posix-y
-perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' config.tmp
+perl -i.bak -p -e 's@ ([a-zA-Z]):[/\\]@ /\1/@go;' \
+               -e 's@\\@/@go;' config.tmp
 rm -f config.tmp.bak
 
 msg

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/mk/reconfig.mk

@@ -19,7 +19,7 @@ ifndef CFG_DISABLE_MANAGE_SUBMODULES
 # (nothing checked out at all).  `./configure --{llvm,jemalloc}-root`
 # will explicitly deinitialize the corresponding submodules, and we don't
 # want to force constant rebuilds in that case.
-NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && $(CFG_GIT) submodule status | grep -c '^+')
+NEED_GIT_RECONFIG=$(shell cd "$(CFG_SRC_DIR)" && "$(CFG_GIT)" submodule status | grep -c '^+')
 else
 NEED_GIT_RECONFIG=0
 endif

branches/auto/src/liballoc/arc.rs

@@ -166,7 +166,7 @@ impl<T: Send + Sync + Clone> Arc<T> {
         // additional reference of either kind.
         if self.inner().strong.load(atomic::SeqCst) != 1 ||
            self.inner().weak.load(atomic::SeqCst) != 1 {
-            *self = Arc::new((**self).clone())
+            *self = Arc::new(self.deref().clone())
         }
         // This unsafety is ok because we're guaranteed that the pointer
         // returned is the *only* pointer that will ever be returned to T. Our

branches/auto/src/libcollections/enum_set.rs

@@ -43,27 +43,7 @@ impl<E:CLike+fmt::Show> fmt::Show for EnumSet<E> {
     }
 }
 
-/**
-An interface for casting C-like enum to uint and back.
-A typically implementation is as below.
-
-```{rust,ignore}
-#[repr(uint)]
-enum Foo {
-    A, B, C
-}
-
-impl CLike for Foo {
-    fn to_uint(&self) -> uint {
-        *self as uint
-    }
-
-    fn from_uint(v: uint) -> Foo {
-        unsafe { mem::transmute(v) }
-    }
-}
-```
-*/
+/// An interface for casting C-like enum to uint and back.
 pub trait CLike {
     /// Converts a C-like enum to a `uint`.
     fn to_uint(&self) -> uint;
@@ -72,11 +52,7 @@ pub trait CLike {
 }
 
 fn bit<E:CLike>(e: &E) -> uint {
-    use core::uint;
-    let value = e.to_uint();
-    assert!(value < uint::BITS,
-            "EnumSet only supports up to {} variants.", uint::BITS - 1);
-    1 << value
+    1 << e.to_uint()
 }
 
 impl<E:CLike> EnumSet<E> {
@@ -402,31 +378,4 @@ mod test {
         let elems = e_subtract.iter().collect();
         assert_eq!(vec![A], elems)
     }
-
-    #[test]
-    #[should_fail]
-    fn test_overflow() {
-        #[allow(dead_code)]
-        #[repr(uint)]
-        enum Bar {
-            V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
-            V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
-            V20, V21, V22, V23, V24, V25, V26, V27, V28, V29,
-            V30, V31, V32, V33, V34, V35, V36, V37, V38, V39,
-            V40, V41, V42, V43, V44, V45, V46, V47, V48, V49,
-            V50, V51, V52, V53, V54, V55, V56, V57, V58, V59,
-            V60, V61, V62, V63, V64, V65, V66, V67, V68, V69,
-        }
-        impl CLike for Bar {
-            fn to_uint(&self) -> uint {
-                *self as uint
-            }
-
-            fn from_uint(v: uint) -> Bar {
-                unsafe { mem::transmute(v) }
-            }
-        }
-        let mut set = EnumSet::empty();
-        set.add(V64);
-    }
 }

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(PartialEq, Eq, Show)]
+#[deriving(Clone, PartialEq, Eq, Show)]
 pub struct TypeId {
     t: u64,
 }

branches/auto/src/libcore/ops.rs

@@ -638,7 +638,7 @@ shr_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
  * ```
  */
 #[lang="index"]
-pub trait Index<Index, Sized? Result> for Sized? {
+pub trait Index<Index, Sized? Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index<'a>(&'a self, index: &Index) -> &'a Result;
 }
@@ -669,7 +669,7 @@ pub trait Index<Index, Sized? Result> for Sized? {
  * ```
  */
 #[lang="index_mut"]
-pub trait IndexMut<Index, Result> for Sized? {
+pub trait IndexMut<Index, Result> {
     /// The method for the indexing (`Foo[Bar]`) operation
     fn index_mut<'a>(&'a mut self, index: &Index) -> &'a mut Result;
 }
@@ -805,16 +805,6 @@ pub trait Deref<Sized? Result> {
     fn deref<'a>(&'a self) -> &'a Result;
 }
 
-#[cfg(not(stage0))]
-impl<'a, Sized? T> Deref<T> for &'a T {
-    fn deref(&self) -> &T { *self }
-}
-
-#[cfg(not(stage0))]
-impl<'a, Sized? T> Deref<T> for &'a mut T {
-    fn deref(&self) -> &T { *self }
-}
-
 /**
  *
  * The `DerefMut` trait is used to specify the functionality of dereferencing
@@ -855,11 +845,6 @@ pub trait DerefMut<Sized? Result>: Deref<Result> {
     fn deref_mut<'a>(&'a mut self) -> &'a mut Result;
 }
 
-#[cfg(not(stage0))]
-impl<'a, Sized? T> DerefMut<T> for &'a mut T {
-    fn deref_mut(&mut self) -> &mut T { *self }
-}
-
 /// A version of the call operator that takes an immutable receiver.
 #[lang="fn"]
 pub trait Fn<Args,Result> {

branches/auto/src/libcore/slice.rs

@@ -256,6 +256,7 @@ pub trait SlicePrelude<T> for Sized? {
     #[inline]
     #[experimental = "not triaged yet"]
     fn is_empty(&self) -> bool { self.len() == 0 }
+
     /// Returns a mutable reference to the element at the given index,
     /// or `None` if the index is out of bounds
     #[unstable = "waiting on final error conventions"]
@@ -697,22 +698,6 @@ impl<T> SlicePrelude<T> for [T] {
     }
 }
 
-impl<T> ops::Index<uint, T> for [T] {
-    fn index(&self, &index: &uint) -> &T {
-        assert!(index < self.len());
-
-        unsafe { mem::transmute(self.repr().data.offset(index as int)) }
-    }
-}
-
-impl<T> ops::IndexMut<uint, T> for [T] {
-    fn index_mut(&mut self, &index: &uint) -> &mut T {
-        assert!(index < self.len());
-
-        unsafe { mem::transmute(self.repr().data.offset(index as int)) }
-    }
-}
-
 impl<T> ops::Slice<uint, [T]> for [T] {
     #[inline]
     fn as_slice_<'a>(&'a self) -> &'a [T] {

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/cfg/construct.rs

@@ -448,8 +448,8 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
             }
 
             ast::ExprStruct(_, ref fields, ref base) => {
-                let field_cfg = self.straightline(expr, pred, fields.iter().map(|f| &*f.expr));
-                self.opt_expr(base, field_cfg)
+                let base_exit = self.opt_expr(base, pred);
+                self.straightline(expr, base_exit, fields.iter().map(|f| &*f.expr))
             }
 
             ast::ExprRepeat(ref elem, ref count) => {

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

@@ -672,10 +672,6 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
             }
         }
 
-        // walk the with expression so that complex expressions
-        // are properly handled.
-        self.walk_expr(with_expr);
-
         fn contains_field_named(field: &ty::field,
                                 fields: &Vec<ast::Field>)
                                 -> bool

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)),