---

yaml
---
r: 234377
b: refs/heads/tmp
c: f7ffd50
h: refs/heads/master
i:
  234375: 4603bf3
v: v3

Author: murarth

[refs]

@@ -25,7 +25,7 @@ refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/beta: d2e13e822a73e0ea46ae9e21afdd3155fc997f6d
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: d7afefcbd18f78edad147aad250571d80effd4d0
+refs/heads/tmp: f7ffd502e57c0e53c77f47a7c80d2fdc67559fd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: ab792abf1fcc28afbd315426213f6428da25c085
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828

branches/tmp/src/doc/trpl/method-syntax.md

@@ -7,7 +7,7 @@ can be awkward. Consider this code:
 baz(bar(foo));
 ```
 
-We would read this left-to-right, and so we see ‘baz bar foo’. But this isn’t the
+We would read this left-to right, and so we see ‘baz bar foo’. But this isn’t the
 order that the functions would get called in, that’s inside-out: ‘foo bar baz’.
 Wouldn’t it be nice if we could do this instead?
 
@@ -45,17 +45,17 @@ This will print `12.566371`.
 
 
 
-We’ve made a `struct` that represents a circle. We then write an `impl` block,
+We’ve made a struct that represents a circle. We then write an `impl` block,
 and inside it, define a method, `area`.
 
-Methods take a special first parameter, of which there are three variants:
+Methods take a  special first parameter, of which there are three variants:
 `self`, `&self`, and `&mut self`. You can think of this first parameter as
 being the `foo` in `foo.bar()`. The three variants correspond to the three
 kinds of things `foo` could be: `self` if it’s just a value on the stack,
 `&self` if it’s a reference, and `&mut self` if it’s a mutable reference.
 Because we took the `&self` parameter to `area`, we can use it just like any
 other parameter. Because we know it’s a `Circle`, we can access the `radius`
-just like we would with any other `struct`. 
+just like we would with any other struct. 
 
 We should default to using `&self`, as you should prefer borrowing over taking
 ownership, as well as taking immutable references over mutable ones. Here’s an
@@ -120,12 +120,12 @@ Check the return type:
 ```rust
 # struct Circle;
 # impl Circle {
-fn grow(&self, increment: f64) -> Circle {
+fn grow(&self) -> Circle {
 # Circle } }
 ```
 
 We just say we’re returning a `Circle`. With this method, we can grow a new
-`Circle` to any arbitrary size.
+circle to any arbitrary size.
 
 # Associated functions
 
@@ -161,7 +161,7 @@ methods’.
 
 # Builder Pattern
 
-Let’s say that we want our users to be able to create `Circle`s, but we will
+Let’s say that we want our users to be able to create Circles, but we will
 allow them to only set the properties they care about. Otherwise, the `x`
 and `y` attributes will be `0.0`, and the `radius` will be `1.0`. Rust doesn’t
 have method overloading, named arguments, or variable arguments. We employ
@@ -224,7 +224,7 @@ fn main() {
 }
 ```
 
-What we’ve done here is make another `struct`, `CircleBuilder`. We’ve defined our
+What we’ve done here is make another struct, `CircleBuilder`. We’ve defined our
 builder methods on it. We’ve also defined our `area()` method on `Circle`. We
 also made one more method on `CircleBuilder`: `finalize()`. This method creates
 our final `Circle` from the builder. Now, we’ve used the type system to enforce

branches/tmp/src/librustc/diagnostics.rs

@@ -44,7 +44,7 @@ E0002: r##"
 This error indicates that an empty match expression is invalid because the type
 it is matching on is non-empty (there exist values of this type). In safe code
 it is impossible to create an instance of an empty type, so empty match
-expressions are almost never desired. This error is typically fixed by adding
+expressions are almost never desired.  This error is typically fixed by adding
 one or more cases to the match expression.
 
 An example of an empty type is `enum Empty { }`. So, the following will work:
@@ -218,14 +218,7 @@ match x {
 E0010: r##"
 The value of statics and constants must be known at compile time, and they live
 for the entire lifetime of a program. Creating a boxed value allocates memory on
-the heap at runtime, and therefore cannot be done at compile time. Erroneous
-code example:
-
-```
-#![feature(box_syntax)]
-
-const CON : Box<i32> = box 0;
-```
+the heap at runtime, and therefore cannot be done at compile time.
 "##,
 
 E0011: r##"
@@ -342,6 +335,7 @@ is not allowed.
 
 If you really want global mutable state, try using `static mut` or a global
 `UnsafeCell`.
+
 "##,
 
 E0018: r##"
@@ -405,13 +399,7 @@ fn main() {
 
 E0020: r##"
 This error indicates that an attempt was made to divide by zero (or take the
-remainder of a zero divisor) in a static or constant expression. Erroneous
-code example:
-
-```
-const X: i32 = 42 / 0;
-// error: attempted to divide by zero in a constant expression
-```
+remainder of a zero divisor) in a static or constant expression.
 "##,
 
 E0022: r##"

branches/tmp/src/librustc/middle/check_match.rs

@@ -218,9 +218,6 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &hir::Expr) {
                     span_err!(cx.tcx.sess, ex.span, E0002,
                               "non-exhaustive patterns: type {} is non-empty",
                               pat_ty);
-                    span_help!(cx.tcx.sess, ex.span,
-                        "Please ensure that all possible cases are being handled; \
-                         possibly adding wildcards or more match arms.");
                 }
                 // If the type *is* empty, it's vacuously exhaustive
                 return;

branches/tmp/src/librustc_typeck/diagnostics.rs

@@ -2475,24 +2475,6 @@ struct Bar<S, T> { x: Foo<S, T> }
 ```
 "##,
 
-//NB: not currently reachable
-E0247: r##"
-This error indicates an attempt to use a module name where a type is expected.
-For example:
-
-```
-mod MyMod {
-    mod MySubMod { }
-}
-
-fn do_something(x: MyMod::MySubMod) { }
-```
-
-In this example, we're attempting to take a parameter of type `MyMod::MySubMod`
-in the do_something function. This is not legal: `MyMod::MySubMod` is a module
-name, not a type.
-"##,
-
 E0248: r##"
 This error indicates an attempt to use a value where a type is expected. For
 example:
@@ -3309,6 +3291,7 @@ register_diagnostics! {
     E0242, // internal error looking up a definition
     E0245, // not a trait
 //  E0246, // invalid recursive type
+    E0247, // found module name used as a type
 //  E0319, // trait impls for defaulted traits allowed just for structs/enums
     E0320, // recursive overflow during dropck
     E0321, // extended coherence rules for defaulted traits violated

branches/tmp/src/libstd/prelude/mod.rs

@@ -103,8 +103,8 @@
 //!   `Some` and `None`.
 //! * `std::result::Result::`{
 //!     [`self`](../result/enum.Result.html),
-//!     [`Some`](../result/enum.Result.html),
-//!     [`None`](../result/enum.Result.html)
+//!     [`Ok`](../result/enum.Result.html),
+//!     [`Err`](../result/enum.Result.html)
 //!   }.
 //!   The ubiquitous `Result` type and its two [variants][book-enums],
 //!   `Ok` and `Err`.

branches/tmp/src/libstd/sys/windows/backtrace.rs

@@ -60,9 +60,6 @@ extern "system" {
 type SymFromAddrFn =
     extern "system" fn(libc::HANDLE, u64, *mut u64,
                        *mut SYMBOL_INFO) -> libc::BOOL;
-type SymGetLineFromAddr64Fn =
-    extern "system" fn(libc::HANDLE, u64, *mut u32,
-                       *mut IMAGEHLP_LINE64) -> libc::BOOL;
 type SymInitializeFn =
     extern "system" fn(libc::HANDLE, *mut libc::c_void,
                        libc::BOOL) -> libc::BOOL;
@@ -102,14 +99,6 @@ struct SYMBOL_INFO {
     Name: [libc::c_char; MAX_SYM_NAME],
 }
 
-#[repr(C)]
-struct IMAGEHLP_LINE64 {
-    SizeOfStruct: u32,
-    Key: *const libc::c_void,
-    LineNumber: u32,
-    Filename: *const libc::c_char,
-    Address: u64,
-}
 
 #[repr(C)]
 enum ADDRESS_MODE {

branches/tmp/src/libstd/sys/windows/printing/msvc.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use sys_common::backtrace::{output, output_fileline};
+use sys_common::backtrace::output;
 use ffi::CStr;
 use dynamic_lib::DynamicLibrary;
-use super::{SymFromAddrFn, SymGetLineFromAddr64Fn, SYMBOL_INFO, MAX_SYM_NAME, IMAGEHLP_LINE64};
+use super::{SymFromAddrFn, SYMBOL_INFO, MAX_SYM_NAME};
 use io;
 use io::prelude::*;
 use intrinsics;
@@ -20,7 +20,6 @@ use libc;
 pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, process: libc::HANDLE)
         -> io::Result<()> {
     let SymFromAddr = sym!(dbghelp, "SymFromAddr", SymFromAddrFn);
-    let SymGetLineFromAddr64 = sym!(dbghelp, "SymGetLineFromAddr64", SymGetLineFromAddr64Fn);
 
     let mut info: SYMBOL_INFO = unsafe { intrinsics::init() };
     info.MaxNameLen = MAX_SYM_NAME as libc::c_ulong;
@@ -30,7 +29,7 @@ pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, proce
     info.SizeOfStruct = 88;
 
     let mut displacement = 0u64;
-    let ret = SymFromAddr(process, addr, &mut displacement, &mut info);
+    let ret = SymFromAddr(process, addr as u64, &mut displacement, &mut info);
 
     let name = if ret == libc::TRUE {
         let ptr = info.Name.as_ptr() as *const libc::c_char;
@@ -39,20 +38,5 @@ pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, proce
         None
     };
 
-    try!(output(w, i, addr as usize as *mut libc::c_void, name));
-
-    // Now find out the filename and line number
-    let mut line: IMAGEHLP_LINE64 = unsafe { intrinsics::init() };
-    line.SizeOfStruct = ::mem::size_of::<IMAGEHLP_LINE64>() as u32;
-
-    let mut displacement = 0u32;
-    let ret = SymGetLineFromAddr64(process, addr, &mut displacement, &mut line);
-    if ret == libc::TRUE {
-        output_fileline(w,
-                        unsafe { CStr::from_ptr(line.Filename).to_bytes() },
-                        line.LineNumber as libc::c_int,
-                        false)
-    } else {
-        Ok(())
-    }
+    output(w, i, addr as usize as *mut libc::c_void, name)
 }

branches/tmp/src/rustbook/book.rs

@@ -102,7 +102,7 @@ pub fn parse_summary(input: &mut Read, src: &Path) -> Result<Book, Vec<String>>
     top_items.push(BookItem {
         title: "Introduction".to_string(),
         path: PathBuf::from("README.md"),
-        path_to_root: PathBuf::from(""),
+        path_to_root: PathBuf::from("."),
         children: vec!(),
     });
 

branches/tmp/src/rustbook/build.rs

@@ -52,16 +52,16 @@ fn write_toc(book: &Book, current_page: &BookItem, out: &mut Write) -> io::Resul
                  current_page: &BookItem,
                  out: &mut Write) -> io::Result<()> {
         let class_string = if item.path == current_page.path {
-            "class='active'"
+          "class='active'"
         } else {
-            ""
+        ""
         };
 
         try!(writeln!(out, "<li><a {} href='{}'><b>{}</b> {}</a>",
-                      class_string,
-                      current_page.path_to_root.join(&item.path).with_extension("html").display(),
-                      section,
-                      item.title));
+                 class_string,
+                 current_page.path_to_root.join(&item.path).with_extension("html").display(),
+                 section,
+                 item.title));
         if !item.children.is_empty() {
             try!(writeln!(out, "<ul class='section'>"));
             let _ = walk_items(&item.children[..], section, current_page, out);

branches/tmp/src/test/run-pass/backtrace-debuginfo-aux.rs

@@ -15,11 +15,7 @@ pub fn callback<F>(f: F) where F: FnOnce((&'static str, u32)) {
     f((file!(), line!()))
 }
 
-// LLVM does not yet output the required debug info to support showing inlined
-// function calls in backtraces when targetting MSVC, so disable inlining in
-// this case.
-#[cfg_attr(not(target_env = "msvc"), inline(always))]
-#[cfg_attr(target_env = "msvc", inline(never))]
+#[inline(always)]
 pub fn callback_inlined<F>(f: F) where F: FnOnce((&'static str, u32)) {
     f((file!(), line!()))
 }

branches/tmp/src/test/run-pass/backtrace-debuginfo.rs

@@ -32,7 +32,7 @@ macro_rules! pos {
               not(target_os = "ios"),
               not(target_os = "android"),
               not(all(target_os = "linux", target_arch = "arm"))),
-          all(windows, not(target_arch = "x86"))))]
+          all(windows, target_env = "gnu", not(target_arch = "x86"))))]
 macro_rules! dump_and_die {
     ($($pos:expr),*) => ({
         // FIXME(#18285): we cannot include the current position because
@@ -48,7 +48,7 @@ macro_rules! dump_and_die {
               not(target_os = "ios"),
               not(target_os = "android"),
               not(all(target_os = "linux", target_arch = "arm"))),
-          all(windows, not(target_arch = "x86")))))]
+          all(windows, target_env = "gnu", not(target_arch = "x86")))))]
 macro_rules! dump_and_die {
     ($($pos:expr),*) => ({ let _ = [$($pos),*]; })
 }
@@ -69,10 +69,7 @@ type Pos = (&'static str, u32);
 // this goes to stdout and each line has to be occurred
 // in the following backtrace to stderr with a correct order.
 fn dump_filelines(filelines: &[Pos]) {
-    // Skip top frame for MSVC, because it sees the macro rather than
-    // the containing function.
-    let skip = if cfg!(target_env = "msvc") {1} else {0};
-    for &(file, line) in filelines.iter().rev().skip(skip) {
+    for &(file, line) in filelines.iter().rev() {
         // extract a basename
         let basename = file.split(&['/', '\\'][..]).last().unwrap();
         println!("{}:{}", basename, line);
@@ -91,18 +88,12 @@ fn inner(counter: &mut i32, main_pos: Pos, outer_pos: Pos) {
     });
 }
 
-// LLVM does not yet output the required debug info to support showing inlined
-// function calls in backtraces when targetting MSVC, so disable inlining in
-// this case.
-#[cfg_attr(not(target_env = "msvc"), inline(always))]
-#[cfg_attr(target_env = "msvc", inline(never))]
+#[inline(always)]
 fn inner_inlined(counter: &mut i32, main_pos: Pos, outer_pos: Pos) {
     check!(counter; main_pos, outer_pos);
     check!(counter; main_pos, outer_pos);
 
-    // Again, disable inlining for MSVC.
-    #[cfg_attr(not(target_env = "msvc"), inline(always))]
-    #[cfg_attr(target_env = "msvc", inline(never))]
+    #[inline(always)]
     fn inner_further_inlined(counter: &mut i32, main_pos: Pos, outer_pos: Pos, inner_pos: Pos) {
         check!(counter; main_pos, outer_pos, inner_pos);
     }