---

yaml
---
r: 159871
b: refs/heads/try
c: 1fdb759
h: refs/heads/master
i:
  159869: f3bed4d
  159867: 039929e
  159863: c855f9f
  159855: 7db24f0
  159839: 32e73ac
  159807: c71dcf2
  159743: 7152e79
v: v3

Author: SimonSapin

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
-refs/heads/try: 97a57ec909e61ecabadfce11fb9b36b2fe3783df
+refs/heads/try: 1fdb7595278df6568cc73028a734ca7d0615e622
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/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/try/src/libcollections/enum_set.rs

@@ -52,7 +52,9 @@ pub trait CLike {
 }
 
 fn bit<E:CLike>(e: &E) -> uint {
-    1 << e.to_uint()
+    let value = e.to_uint();
+    assert!(value < ::core::uint::BITS);
+    1 << value
 }
 
 impl<E:CLike> EnumSet<E> {
@@ -378,4 +380,31 @@ 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/try/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/try/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/try/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/try/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/try/src/librustc/middle/typeck/check/method.rs

@@ -1702,18 +1702,13 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
                             PreferMutLvalue);
                     }
                     ast::ExprUnary(ast::UnDeref, ref base_expr) => {
-                        // if this is an overloaded deref, then re-evaluate with
-                        // a preference for mut
-                        let method_call = MethodCall::expr(expr.id);
-                        if self.fcx.inh.method_map.borrow().contains_key(&method_call) {
-                            check::try_overloaded_deref(
-                                self.fcx,
-                                expr.span,
-                                Some(method_call),
-                                Some(&**base_expr),
-                                self.fcx.expr_ty(&**base_expr),
-                                PreferMutLvalue);
-                        }
+                        check::try_overloaded_deref(
+                            self.fcx,
+                            expr.span,
+                            Some(MethodCall::expr(expr.id)),
+                            Some(&**base_expr),
+                            self.fcx.expr_ty(&**base_expr),
+                            PreferMutLvalue);
                     }
                     _ => {}
                 }

branches/try/src/libstd/collections/hash/table.rs

@@ -166,22 +166,18 @@ impl<K, V> RawBucket<K, V> {
 }
 
 // For parameterizing over mutability.
-
-#[cfg(stage0)]
 impl<'t, K, V> Deref<RawTable<K, V>> for &'t RawTable<K, V> {
     fn deref(&self) -> &RawTable<K, V> {
         &**self
     }
 }
 
-#[cfg(stage0)]
 impl<'t, K, V> Deref<RawTable<K, V>> for &'t mut RawTable<K, V> {
     fn deref(&self) -> &RawTable<K,V> {
         &**self
     }
 }
 
-#[cfg(stage0)]
 impl<'t, K, V> DerefMut<RawTable<K, V>> for &'t mut RawTable<K, V> {
     fn deref_mut(&mut self) -> &mut RawTable<K,V> {
         &mut **self

branches/try/src/libstd/num/strconv.rs

@@ -451,7 +451,7 @@ pub fn from_str_radix_float<T: Float>(src: &str, radix: uint) -> Option<T> {
     };
 
     // The significand to accumulate
-    let mut sig = if is_positive { _0 } else { -_0 };
+    let mut sig = if is_positive { _0 } else { -_1 };
     // Necessary to detect overflow
     let mut prev_sig = sig;
     let mut cs = src.chars().enumerate();
@@ -647,22 +647,6 @@ mod test {
         let fe : Option<f32> = from_str_radix_float("1e40", 10);
         assert_eq!(fe, Some(Float::infinity()))
     }
-
-    #[test]
-    fn test_from_str_radix_float() {
-        let x1 : Option<f64> = from_str_radix_float("-123.456", 10);
-        assert_eq!(x1, Some(-123.456));
-        let x2 : Option<f32> = from_str_radix_float("123.456", 10);
-        assert_eq!(x2, Some(123.456));
-        let x3 : Option<f32> = from_str_radix_float("-0.0", 10);
-        assert_eq!(x3, Some(-0.0));
-        let x4 : Option<f32> = from_str_radix_float("0.0", 10);
-        assert_eq!(x4, Some(0.0));
-        let x4 : Option<f32> = from_str_radix_float("1.0", 10);
-        assert_eq!(x4, Some(1.0));
-        let x5 : Option<f32> = from_str_radix_float("-1.0", 10);
-        assert_eq!(x5, Some(-1.0));
-    }
 }
 
 #[cfg(test)]