---

yaml
---
r: 228331
b: refs/heads/try
c: 3f636c3
h: refs/heads/master
i:
  228329: e012456
  228327: ba57893
v: v3

Author: solson

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 9ff2d19c45f8e110bdcded982c6612ff825e17cb
+refs/heads/try: 3f636c3ccbecffbaa1d6a90753f8296112ada5fd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/AUTHORS.txt

@@ -958,7 +958,7 @@ Santiago Rodriguez <[email protected]>
 Saurabh Anand <[email protected]>
 Scott Jenkins <[email protected]>
 Scott Lawrence <[email protected]>
-Scott Olson <scott@scott-olson.org>
+Scott Olson <scott@solson.me>
 Sean Bowe <[email protected]>
 Sean Chalmers <[email protected]>
 Sean Collins <[email protected]>

branches/try/src/doc/trpl/dining-philosophers.md

@@ -151,15 +151,15 @@ look at `main()` again:
 # struct Philosopher {
 #     name: String,
 # }
-#
+# 
 # impl Philosopher {
 #     fn new(name: &str) -> Philosopher {
 #         Philosopher {
 #             name: name.to_string(),
 #         }
 #     }
 # }
-#
+# 
 fn main() {
     let p1 = Philosopher::new("Judith Butler");
     let p2 = Philosopher::new("Gilles Deleuze");
@@ -197,15 +197,15 @@ a method, and then loop through all the philosophers, calling it:
 ```rust
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is done eating.", self.name);
     }
@@ -267,15 +267,15 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
         }
     }
-
+    
     fn eat(&self) {
         println!("{} is eating.", self.name);
 
@@ -348,9 +348,9 @@ use std::thread;
 
 struct Philosopher {
     name: String,
-}
+}   
 
-impl Philosopher {
+impl Philosopher { 
     fn new(name: &str) -> Philosopher {
         Philosopher {
             name: name.to_string(),
@@ -401,7 +401,7 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 While this is only five lines, they’re a dense five. Let’s break it down.
 
 ```rust,ignore
-let handles: Vec<_> =
+let handles: Vec<_> = 
 ```
 
 We introduce a new binding, called `handles`. We’ve given it this name because
@@ -460,15 +460,15 @@ If you run this program, you’ll see that the philosophers eat out of order!
 We have multi-threading!
 
 ```text
-Judith Butler is eating.
 Gilles Deleuze is eating.
-Karl Marx is eating.
+Gilles Deleuze is done eating.
 Emma Goldman is eating.
+Emma Goldman is done eating.
 Michel Foucault is eating.
+Judith Butler is eating.
 Judith Butler is done eating.
-Gilles Deleuze is done eating.
+Karl Marx is eating.
 Karl Marx is done eating.
-Emma Goldman is done eating.
 Michel Foucault is done eating.
 ```
 

branches/try/src/liballoc/boxed.rs

@@ -71,7 +71,7 @@ use core::raw::{TraitObject};
 /// The following two examples are equivalent:
 ///
 /// ```
-/// # #![feature(box_heap)]
+/// #![feature(box_heap)]
 /// #![feature(box_syntax)]
 /// use std::boxed::HEAP;
 ///
@@ -162,7 +162,7 @@ impl<T : ?Sized> Box<T> {
 ///
 /// # Examples
 /// ```
-/// # #![feature(box_raw)]
+/// #![feature(box_raw)]
 /// use std::boxed;
 ///
 /// let seventeen = Box::new(17u32);

branches/try/src/libcore/num/mod.rs

@@ -459,15 +459,15 @@ macro_rules! int_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `self / other`,
+        /// Wrapping (modular) division. Computes `floor(self / other)`,
         /// wrapping around at the boundary of the type.
         ///
         /// The only case where such wrapping can occur is when one
         /// divides `MIN / -1` on a signed type (where `MIN` is the
         /// negative minimal value for the type); this is equivalent
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
-        /// itself.
+        /// itself..
         #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {
@@ -1031,15 +1031,15 @@ macro_rules! uint_impl {
             }
         }
 
-        /// Wrapping (modular) division. Computes `self / other`,
+        /// Wrapping (modular) division. Computes `floor(self / other)`,
         /// wrapping around at the boundary of the type.
         ///
         /// The only case where such wrapping can occur is when one
         /// divides `MIN / -1` on a signed type (where `MIN` is the
         /// negative minimal value for the type); this is equivalent
         /// to `-MIN`, a positive value that is too large to represent
         /// in the type. In such a case, this function returns `MIN`
-        /// itself.
+        /// itself..
         #[stable(feature = "num_wrapping", since = "1.2.0")]
         #[inline(always)]
         pub fn wrapping_div(self, rhs: Self) -> Self {

branches/try/src/libcore/ops.rs

@@ -351,10 +351,8 @@ pub trait Div<RHS=Self> {
     fn div(self, rhs: RHS) -> Self::Output;
 }
 
-macro_rules! div_impl_integer {
+macro_rules! div_impl {
     ($($t:ty)*) => ($(
-        /// This operation rounds towards zero, truncating any
-        /// fractional part of the exact result.
         #[stable(feature = "rust1", since = "1.0.0")]
         impl Div for $t {
             type Output = $t;
@@ -367,23 +365,7 @@ macro_rules! div_impl_integer {
     )*)
 }
 
-div_impl_integer! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
-
-macro_rules! div_impl_float {
-    ($($t:ty)*) => ($(
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl Div for $t {
-            type Output = $t;
-
-            #[inline]
-            fn div(self, other: $t) -> $t { self / other }
-        }
-
-        forward_ref_binop! { impl Div, div for $t, $t }
-    )*)
-}
-
-div_impl_float! { f32 f64 }
+div_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 
 /// The `Rem` trait is used to specify the functionality of `%`.
 ///
@@ -425,8 +407,6 @@ pub trait Rem<RHS=Self> {
 
 macro_rules! rem_impl {
     ($($t:ty)*) => ($(
-        /// This operation satisfies `n % d == n - (n / d) * d`.  The
-        /// result has the same sign as the left operand.
         #[stable(feature = "rust1", since = "1.0.0")]
         impl Rem for $t {
             type Output = $t;

branches/try/src/librustc/middle/fast_reject.rs

@@ -71,10 +71,8 @@ pub fn simplify_type(tcx: &ty::ctxt,
         }
         ty::TyBox(_) => {
             // treat like we would treat `Box`
-            match tcx.lang_items.require_owned_box() {
-                Ok(def_id) => Some(StructSimplifiedType(def_id)),
-                Err(msg) => tcx.sess.fatal(&msg),
-            }
+            let def_id = tcx.lang_items.owned_box().unwrap();
+            Some(StructSimplifiedType(def_id))
         }
         ty::TyClosure(def_id, _) => {
             Some(ClosureSimplifiedType(def_id))

branches/try/src/librustc/middle/lang_items.rs

@@ -90,10 +90,6 @@ impl LanguageItems {
         }
     }
 
-    pub fn require_owned_box(&self) -> Result<ast::DefId, String> {
-        self.require(OwnedBoxLangItem)
-    }
-
     pub fn from_builtin_kind(&self, bound: ty::BuiltinBound)
                              -> Result<ast::DefId, String>
     {

branches/try/src/librustc_trans/trans/_match.rs

@@ -1384,8 +1384,7 @@ impl<'tcx> euv::Delegate<'tcx> for ReassignmentChecker {
                 match base_cmt.cat {
                     mc::cat_upvar(mc::Upvar { id: ty::UpvarId { var_id: vid, .. }, .. }) |
                     mc::cat_local(vid) => {
-                        self.reassigned |= self.node == vid &&
-                            (self.field.is_none() || Some(field) == self.field)
+                        self.reassigned |= self.node == vid && Some(field) == self.field
                     },
                     _ => {}
                 }

branches/try/src/librustc_typeck/coherence/orphan.rs

@@ -77,10 +77,7 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
                         self.check_def_id(item, data.principal_def_id());
                     }
                     ty::TyBox(..) => {
-                        match self.tcx.lang_items.require_owned_box() {
-                            Ok(trait_id) => self.check_def_id(item, trait_id),
-                            Err(msg) => self.tcx.sess.span_fatal(item.span, &msg),
-                        }
+                        self.check_def_id(item, self.tcx.lang_items.owned_box().unwrap());
                     }
                     ty::TyChar => {
                         self.check_primitive_impl(def_id,

branches/try/src/libstd/thread/local.rs

@@ -275,7 +275,6 @@ mod imp {
 
     use cell::{Cell, UnsafeCell};
     use intrinsics;
-    use ptr;
 
     pub struct Key<T> {
         inner: UnsafeCell<Option<T>>,
@@ -328,6 +327,7 @@ mod imp {
     #[cfg(target_os = "linux")]
     unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) {
         use mem;
+        use ptr;
         use libc;
         use sys_common::thread_local as os;
 
@@ -394,24 +394,7 @@ mod imp {
         // destructor as running for this thread so calls to `get` will return
         // `None`.
         (*ptr).dtor_running.set(true);
-
-        // The OSX implementation of TLS apparently had an odd aspect to it
-        // where the pointer we have may be overwritten while this destructor
-        // is running. Specifically if a TLS destructor re-accesses TLS it may
-        // trigger a re-initialization of all TLS variables, paving over at
-        // least some destroyed ones with initial values.
-        //
-        // This means that if we drop a TLS value in place on OSX that we could
-        // revert the value to its original state halfway through the
-        // destructor, which would be bad!
-        //
-        // Hence, we use `ptr::read` on OSX (to move to a "safe" location)
-        // instead of drop_in_place.
-        if cfg!(target_os = "macos") {
-            ptr::read((*ptr).inner.get());
-        } else {
-            intrinsics::drop_in_place((*ptr).inner.get());
-        }
+        intrinsics::drop_in_place((*ptr).inner.get());
     }
 }
 

branches/try/src/libsyntax/ext/tt/macro_rules.rs

@@ -501,7 +501,7 @@ fn is_in_follow(_: &ExtCtxt, tok: &Token, frag: &str) -> Result<bool, String> {
             },
             "path" | "ty" => {
                 match *tok {
-                    Comma | FatArrow | Colon | Eq | Gt | Semi => Ok(true),
+                    Comma | FatArrow | Colon | Eq | Gt => Ok(true),
                     Ident(i, _) if i.as_str() == "as" => Ok(true),
                     _ => Ok(false)
                 }