---

yaml
---
r: 234284
b: refs/heads/tmp
c: 3903ea9
h: refs/heads/master
v: v3

Author: petrochenkov

[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: 67616f71916c94b194164278f685fc7d82b3b4d0
+refs/heads/tmp: 3903ea96f557dc923cf73d3905554083cd921a01
 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/rust-inside-other-languages.md

@@ -217,17 +217,6 @@ And finally, we can try running it:
 
 ```bash
 $ ruby embed.rb
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-Thread finished with count=5000000
-done!
 done!
 $
 ```

branches/tmp/src/doc/trpl/structs.md

@@ -1,6 +1,6 @@
 % Structs
 
-`struct`s are a way of creating more complex data types. For example, if we were
+Structs are a way of creating more complex data types. For example, if we were
 doing calculations involving coordinates in 2D space, we would need both an `x`
 and a `y` value:
 
@@ -9,7 +9,7 @@ let origin_x = 0;
 let origin_y = 0;
 ```
 
-A `struct` lets us combine these two into a single, unified datatype:
+A struct lets us combine these two into a single, unified datatype:
 
 ```rust
 struct Point {
@@ -28,14 +28,14 @@ There’s a lot going on here, so let’s break it down. We declare a `struct` w
 the `struct` keyword, and then with a name. By convention, `struct`s begin with
 a capital letter and are camel cased: `PointInSpace`, not `Point_In_Space`.
 
-We can create an instance of our `struct` via `let`, as usual, but we use a `key:
+We can create an instance of our struct via `let`, as usual, but we use a `key:
 value` style syntax to set each field. The order doesn’t need to be the same as
 in the original declaration.
 
 Finally, because fields have names, we can access the field through dot
 notation: `origin.x`.
 
-The values in `struct`s are immutable by default, like other bindings in Rust.
+The values in structs are immutable by default, like other bindings in Rust.
 Use `mut` to make them mutable:
 
 ```rust
@@ -91,7 +91,7 @@ fn main() {
 # Update syntax
 
 A `struct` can include `..` to indicate that you want to use a copy of some
-other `struct` for some of the values. For example:
+other struct for some of the values. For example:
 
 ```rust
 struct Point3d {
@@ -121,7 +121,7 @@ let point = Point3d { z: 1, x: 2, .. origin };
 # Tuple structs
 
 Rust has another data type that’s like a hybrid between a [tuple][tuple] and a
-`struct`, called a ‘tuple struct’. Tuple structs have a name, but
+struct, called a ‘tuple struct’. Tuple structs have a name, but
 their fields don’t:
 
 ```rust
@@ -140,7 +140,7 @@ let black = Color(0, 0, 0);
 let origin = Point(0, 0, 0);
 ```
 
-It is almost always better to use a `struct` than a tuple struct. We would write
+It is almost always better to use a struct than a tuple struct. We would write
 `Color` and `Point` like this instead:
 
 ```rust
@@ -158,7 +158,7 @@ struct Point {
 ```
 
 Now, we have actual names, rather than positions. Good names are important,
-and with a `struct`, we have actual names.
+and with a struct, we have actual names.
 
 There _is_ one case when a tuple struct is very useful, though, and that’s a
 tuple struct with only one element. We call this the ‘newtype’ pattern, because
@@ -180,13 +180,13 @@ destructuring `let`, just as with regular tuples. In this case, the
 
 # Unit-like structs
 
-You can define a `struct` with no members at all:
+You can define a struct with no members at all:
 
 ```rust
 struct Electron;
 ```
 
-Such a `struct` is called ‘unit-like’ because it resembles the empty
+Such a struct is called ‘unit-like’ because it resembles the empty
 tuple, `()`, sometimes called ‘unit’. Like a tuple struct, it defines a
 new type.
 
@@ -195,6 +195,6 @@ marker type), but in combination with other features, it can become
 useful. For instance, a library may ask you to create a structure that
 implements a certain [trait][trait] to handle events. If you don’t have
 any data you need to store in the structure, you can just create a
-unit-like `struct`.
+unit-like struct.
 
 [trait]: traits.html

branches/tmp/src/doc/trpl/traits.md

@@ -390,7 +390,7 @@ fn normal<T: ConvertTo<i64>>(x: &T) -> i64 {
 
 // can be called with T == i64
 fn inverse<T>() -> T
-        // this is using ConvertTo as if it were "ConvertTo<i64>"
+        // this is using ConvertTo as if it were "ConvertFrom<i32>"
         where i32: ConvertTo<T> {
     42.convert()
 }

branches/tmp/src/libcore/ptr.rs

@@ -51,7 +51,7 @@ pub use intrinsics::write_bytes;
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn null<T>() -> *const T { 0 as *const T }
+pub const fn null<T>() -> *const T { 0 as *const T }
 
 /// Creates a null mutable raw pointer.
 ///
@@ -65,7 +65,7 @@ pub fn null<T>() -> *const T { 0 as *const T }
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn null_mut<T>() -> *mut T { 0 as *mut T }
+pub const fn null_mut<T>() -> *mut T { 0 as *mut T }
 
 /// Swaps the values at two mutable locations of the same type, without
 /// deinitialising either. They may overlap, unlike `mem::swap` which is
@@ -163,7 +163,7 @@ impl<T: ?Sized> *const T {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn is_null(self) -> bool where T: Sized {
-        self == 0 as *const T
+        self == null()
     }
 
     /// Returns `None` if the pointer is null, or else returns a reference to
@@ -212,7 +212,7 @@ impl<T: ?Sized> *mut T {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn is_null(self) -> bool where T: Sized {
-        self == 0 as *mut T
+        self == null_mut()
     }
 
     /// Returns `None` if the pointer is null, or else returns a reference to

branches/tmp/src/librustc/lib.rs

@@ -51,6 +51,7 @@
 #![feature(rustc_diagnostic_macros)]
 #![feature(rustc_private)]
 #![feature(scoped_tls)]
+#![feature(slice_bytes)]
 #![feature(slice_splits)]
 #![feature(slice_patterns)]
 #![feature(staged_api)]