---

yaml
---
r: 228339
b: refs/heads/try
c: 72483f5
h: refs/heads/master
i:
  228337: a37bb90
  228335: 96786d2
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 7131e6f378af212b86e6bc0ddbc632c3f2e5d255
+refs/heads/try: 72483f58e355c6ec9016cbaba4d9b8d3adbd3867
 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.
-Gilles Deleuze is done eating.
+Karl Marx is eating.
 Emma Goldman is eating.
-Emma Goldman is done eating.
 Michel Foucault is eating.
-Judith Butler is eating.
 Judith Butler is done eating.
-Karl Marx is eating.
+Gilles Deleuze is done eating.
 Karl Marx is done eating.
+Emma Goldman is done eating.
 Michel Foucault is done eating.
 ```
 

branches/try/src/etc/errorck.py

@@ -23,6 +23,18 @@
 errcode_map = {}
 error_re = re.compile("(E\d\d\d\d)")
 
+# In the register_long_diagnostics! macro, entries look like this:
+#
+# EXXXX: r##"
+# <Long diagnostic message>
+# "##,
+#
+# These two variables are for detecting the beginning and end of diagnostic
+# messages so that duplicate error codes are not reported when a code occurs
+# inside a diagnostic message
+long_diag_begin = "r##\""
+long_diag_end = "\"##"
+
 for (dirpath, dirnames, filenames) in os.walk(src_dir):
     if "src/test" in dirpath or "src/llvm" in dirpath:
         # Short circuit for fast
@@ -35,7 +47,14 @@
         path = os.path.join(dirpath, filename)
 
         with open(path, 'r') as f:
+            inside_long_diag = False
             for line_num, line in enumerate(f, start=1):
+                if inside_long_diag:
+                    # Skip duplicate error code checking for this line
+                    if long_diag_end in line:
+                        inside_long_diag = False
+                    continue
+
                 match = error_re.search(line)
                 if match:
                     errcode = match.group(1)
@@ -47,6 +66,9 @@
                     else:
                         errcode_map[errcode] = new_record
 
+                if long_diag_begin in line:
+                    inside_long_diag = True
+
 errors = False
 all_errors = []
 

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 `floor(self / other)`,
+        /// Wrapping (modular) division. Computes `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 `floor(self / other)`,
+        /// Wrapping (modular) division. Computes `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,8 +351,10 @@ pub trait Div<RHS=Self> {
     fn div(self, rhs: RHS) -> Self::Output;
 }
 
-macro_rules! div_impl {
+macro_rules! div_impl_integer {
     ($($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;
@@ -365,7 +367,23 @@ macro_rules! div_impl {
     )*)
 }
 
-div_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
+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 }
 
 /// The `Rem` trait is used to specify the functionality of `%`.
 ///
@@ -407,6 +425,8 @@ 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,8 +71,10 @@ pub fn simplify_type(tcx: &ty::ctxt,
         }
         ty::TyBox(_) => {
             // treat like we would treat `Box`
-            let def_id = tcx.lang_items.owned_box().unwrap();
-            Some(StructSimplifiedType(def_id))
+            match tcx.lang_items.require_owned_box() {
+                Ok(def_id) => Some(StructSimplifiedType(def_id)),
+                Err(msg) => tcx.sess.fatal(&msg),
+            }
         }
         ty::TyClosure(def_id, _) => {
             Some(ClosureSimplifiedType(def_id))

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

@@ -90,6 +90,10 @@ 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/back/link.rs

@@ -954,6 +954,9 @@ fn link_args(cmd: &mut Linker,
     // Pass optimization flags down to the linker.
     cmd.optimize();
 
+    // Pass debuginfo flags down to the linker.
+    cmd.debuginfo();
+
     // We want to prevent the compiler from accidentally leaking in any system
     // libraries, so we explicitly ask gcc to not link to any libraries by
     // default. Note that this does not happen for windows because windows pulls

branches/try/src/librustc_trans/back/linker.rs

@@ -16,6 +16,7 @@ use std::fs;
 use back::archive;
 use session::Session;
 use session::config;
+use session::config::DebugInfoLevel::{NoDebugInfo, LimitedDebugInfo, FullDebugInfo};
 
 /// Linker abstraction used by back::link to build up the command to invoke a
 /// linker.
@@ -39,6 +40,7 @@ pub trait Linker {
     fn gc_sections(&mut self, is_dylib: bool);
     fn position_independent_executable(&mut self);
     fn optimize(&mut self);
+    fn debuginfo(&mut self);
     fn no_default_libraries(&mut self);
     fn build_dylib(&mut self, out_filename: &Path);
     fn args(&mut self, args: &[String]);
@@ -143,6 +145,10 @@ impl<'a> Linker for GnuLinker<'a> {
         }
     }
 
+    fn debuginfo(&mut self) {
+        // Don't do anything special here for GNU-style linkers.
+    }
+
     fn no_default_libraries(&mut self) {
         // Unfortunately right now passing -nodefaultlibs to gcc on windows
         // doesn't work so hot (in terms of native dependencies). This if
@@ -265,6 +271,21 @@ impl<'a> Linker for MsvcLinker<'a> {
     fn optimize(&mut self) {
         // Needs more investigation of `/OPT` arguments
     }
+
+    fn debuginfo(&mut self) {
+        match self.sess.opts.debuginfo {
+            NoDebugInfo => {
+                // Do nothing if debuginfo is disabled
+            },
+            LimitedDebugInfo |
+            FullDebugInfo    => {
+                // This will cause the Microsoft linker to generate a PDB file
+                // from the CodeView line tables in the object files.
+                self.cmd.arg("/DEBUG");
+            }
+        }
+    }
+
     fn whole_archives(&mut self) {
         // hints not supported?
     }

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

@@ -1384,7 +1384,8 @@ 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 && Some(field) == self.field
+                        self.reassigned |= self.node == vid &&
+                            (self.field.is_none() || Some(field) == self.field)
                     },
                     _ => {}
                 }

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

@@ -77,7 +77,10 @@ impl<'cx, 'tcx> OrphanChecker<'cx, 'tcx> {
                         self.check_def_id(item, data.principal_def_id());
                     }
                     ty::TyBox(..) => {
-                        self.check_def_id(item, self.tcx.lang_items.owned_box().unwrap());
+                        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),
+                        }
                     }
                     ty::TyChar => {
                         self.check_primitive_impl(def_id,

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 => Ok(true),
+                    Comma | FatArrow | Colon | Eq | Gt | Semi => Ok(true),
                     Ident(i, _) if i.as_str() == "as" => Ok(true),
                     _ => Ok(false)
                 }

branches/try/src/test/compile-fail/no_owned_box_lang_item.rs

@@ -0,0 +1,26 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that we don't ICE when we are missing the owned_box lang item.
+
+// error-pattern: requires `owned_box` lang_item
+
+#![no_std]
+#![feature(lang_items, no_std, box_syntax)]
+
+extern crate core;
+
+fn main() {
+    let x = box 1i32;
+}
+
+#[lang = "stack_exhausted"] extern fn stack_exhausted() {}
+#[lang = "eh_personality"] extern fn eh_personality() {}
+#[lang = "panic_fmt"] fn panic_fmt() -> ! { loop {} }