---

yaml
---
r: 127467
b: refs/heads/try
c: 50ffe0c
h: refs/heads/master
i:
  127465: bb83e60
  127463: 943ae72
v: v3

Author: steveklabnik

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: c4a63fabe345967e7d6b4570752ea081cae21785
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 12e0f72f517516ac4fce2aed85e6142e9b874bce
-refs/heads/try: 86decf638e95f93b60f2325263005c60e7d3183e
+refs/heads/try: 50ffe0ccabd9b67ded2116e6b428dfbfedce9f23
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/guide.md

@@ -3614,6 +3614,94 @@ guide](http://doc.rust-lang.org/guide-pointers.html#rc-and-arc).
 
 # Patterns
 
+# Method Syntax
+
+Functions are great, but if you want to call a bunch of them on some data, it
+can be awkward. Consider this code:
+
+```{rust,ignore}
+baz(bar(foo(x)));
+```
+
+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?
+
+```{rust,ignore}
+x.foo().bar().baz();
+```
+
+Luckily, as you may have guessed with the leading question, you can! Rust provides
+the ability to use this **method call syntax** via the `impl` keyword.
+
+Here's how it works:
+
+```
+struct Circle {
+    x: f64,
+    y: f64,
+    radius: f64,
+}
+
+impl Circle {
+    fn area(&self) -> f64 {
+        std::f64::consts::PI * (self.radius * self.radius)
+    }
+}
+
+fn main() {
+    let c = Circle { x: 0.0, y: 0.0, radius: 2.0 };
+    println!("{}", c.area());
+}
+```
+
+This will print `12.566371`.
+
+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, `&self`. There are three variants: `self`, `&self`, and `&mut self`.
+You can think of this first parameter as being the `x` in `x.foo()`. The three
+variants correspond to the three kinds of thing `x` 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. We should default to using `&self`, as it's the most
+common.
+
+Finally, as you may remember, the value of the area of a circle is `π*r²`.
+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. An import of π and some
+multiplications later, and we have our area.
+
+You can also define methods that do not take a `self` parameter. Here's a
+pattern that's very common in Rust code:
+
+```
+struct Circle {
+    x: f64,
+    y: f64,
+    radius: f64,
+}
+
+impl Circle {
+    fn new(x: f64, y: f64, radius: f64) -> Circle {
+        Circle {
+            x: x,
+            y: y,
+            radius: radius,
+        }
+    }
+}
+
+fn main() {
+    let c = Circle::new(0.0, 0.0, 2.0);
+}
+```
+
+This **static method** builds a new `Circle` for us. Note that static methods
+are called with the `Struct::method()` syntax, rather than the `ref.method()`
+syntax.
+
+
 # Closures
 
 So far, we've made lots of functions in Rust. But we've given them all names.

branches/try/src/libcore/char.rs

@@ -19,6 +19,9 @@ use mem::transmute;
 use option::{None, Option, Some};
 use iter::range_step;
 
+#[cfg(stage0)]
+use iter::Iterator; // NOTE(stage0): Remove after snapshot.
+
 // UTF-8 ranges and tags for encoding characters
 static TAG_CONT: u8    = 0b1000_0000u8;
 static TAG_TWO_B: u8   = 0b1100_0000u8;

branches/try/src/libcore/failure.rs

@@ -33,6 +33,29 @@
 use fmt;
 use intrinsics;
 
+#[cfg(stage0)]
+#[cold] #[inline(never)] // this is the slow path, always
+#[lang="fail_"]
+fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
+    format_args!(|args| -> () {
+        begin_unwind(args, &(file, line));
+    }, "{}", expr);
+
+    unsafe { intrinsics::abort() }
+}
+
+#[cfg(stage0)]
+#[cold]
+#[lang="fail_bounds_check"]
+fn fail_bounds_check(file: &'static str, line: uint,
+                     index: uint, len: uint) -> ! {
+    format_args!(|args| -> () {
+        begin_unwind(args, &(file, line));
+    }, "index out of bounds: the len is {} but the index is {}", len, index);
+    unsafe { intrinsics::abort() }
+}
+
+#[cfg(not(stage0))]
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
 fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
@@ -45,6 +68,7 @@ fn fail_(expr_file_line: &(&'static str, &'static str, uint)) -> ! {
     unsafe { intrinsics::abort() }
 }
 
+#[cfg(not(stage0))]
 #[cold] #[inline(never)]
 #[lang="fail_bounds_check"]
 fn fail_bounds_check(file_line: &(&'static str, uint),

branches/try/src/libcore/fmt/float.rs

@@ -21,6 +21,11 @@ use slice::{ImmutableVector, MutableVector};
 use slice;
 use str::StrSlice;
 
+#[cfg(stage0)]
+use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
+#[cfg(stage0)]
+use option::{Some, None};   // NOTE(stage0): Remove after snapshot.
+
 /// A flag that specifies whether to use exponential (scientific) notation.
 pub enum ExponentFormat {
     /// Do not use exponential notation.

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

@@ -20,6 +20,11 @@ use iter::DoubleEndedIterator;
 use num::{Int, cast, zero};
 use slice::{ImmutableVector, MutableVector};
 
+#[cfg(stage0)]
+use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
+#[cfg(stage0)]
+use option::{Some, None};   // NOTE(stage0): Remove after snapshot.
+
 /// A type that represents a specific radix
 #[doc(hidden)]
 trait GenericRadix {

branches/try/src/libcore/ops.rs

@@ -771,6 +771,7 @@ pub trait FnOnce<Args,Result> {
 
 macro_rules! def_fn_mut(
     ($($args:ident)*) => (
+        #[cfg(not(stage0))]
         impl<Result$(,$args)*>
         FnMut<($($args,)*),Result>
         for extern "Rust" fn($($args: $args,)*) -> Result {

branches/try/src/libcore/ptr.rs

@@ -95,6 +95,9 @@ use option::{Some, None, Option};
 
 use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};
 
+#[cfg(stage0)]
+use iter::Iterator; // NOTE(stage0): Remove after snapshot.
+
 pub use intrinsics::copy_memory;
 pub use intrinsics::copy_nonoverlapping_memory;
 pub use intrinsics::set_memory;

branches/try/src/libcore/str.rs

@@ -1030,6 +1030,9 @@ pub mod traits {
     use option::{Option, Some};
     use str::{Str, StrSlice, eq_slice};
 
+    #[cfg(stage0)]
+    use option::None;   // NOTE(stage0): Remove after snapshot.
+
     impl<'a> Ord for &'a str {
         #[inline]
         fn cmp(&self, other: & &'a str) -> Ordering {

branches/try/src/librustrt/unwind.rs

@@ -523,6 +523,22 @@ pub fn begin_unwind_fmt(msg: &fmt::Arguments, file_line: &(&'static str, uint))
 }
 
 /// This is the entry point of unwinding for fail!() and assert!().
+#[cfg(stage0)]
+#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
+pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> ! {
+    // Note that this should be the only allocation performed in this code path.
+    // Currently this means that fail!() on OOM will invoke this code path,
+    // but then again we're not really ready for failing on OOM anyway. If
+    // we do start doing this, then we should propagate this allocation to
+    // be performed in the parent of this task instead of the task that's
+    // failing.
+
+    // see below for why we do the `Any` coercion here.
+    begin_unwind_inner(box msg, &(file, line))
+}
+
+/// This is the entry point of unwinding for fail!() and assert!().
+#[cfg(not(stage0))]
 #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
 pub fn begin_unwind<M: Any + Send>(msg: M, file_line: &(&'static str, uint)) -> ! {
     // Note that this should be the only allocation performed in this code path.

branches/try/src/libstd/io/tempfile.rs

@@ -21,6 +21,9 @@ use path::{Path, GenericPath};
 use result::{Ok, Err};
 use sync::atomic;
 
+#[cfg(stage0)]
+use iter::Iterator; // NOTE(stage0): Remove after snapshot.
+
 /// A wrapper for a path to temporary directory implementing automatic
 /// scope-based deletion.
 pub struct TempDir {

branches/try/src/libstd/macros.rs

@@ -37,6 +37,7 @@
 /// fail!("this is a {} {message}", "fancy", message = "message");
 /// ```
 #[macro_export]
+#[cfg(not(stage0))]
 macro_rules! fail(
     () => ({
         fail!("explicit failure")
@@ -67,6 +68,39 @@ macro_rules! fail(
     });
 )
 
+#[macro_export]
+#[cfg(stage0)]
+macro_rules! fail(
+    () => ({
+        fail!("explicit failure")
+    });
+    ($msg:expr) => ({
+        // static requires less code at runtime, more constant data
+        static FILE_LINE: (&'static str, uint) = (file!(), line!());
+        let (file, line) = FILE_LINE;
+        ::std::rt::begin_unwind($msg, file, line)
+    });
+    ($fmt:expr, $($arg:tt)*) => ({
+        // a closure can't have return type !, so we need a full
+        // function to pass to format_args!, *and* we need the
+        // file and line numbers right here; so an inner bare fn
+        // is our only choice.
+        //
+        // LLVM doesn't tend to inline this, presumably because begin_unwind_fmt
+        // is #[cold] and #[inline(never)] and because this is flagged as cold
+        // as returning !. We really do want this to be inlined, however,
+        // because it's just a tiny wrapper. Small wins (156K to 149K in size)
+        // were seen when forcing this to be inlined, and that number just goes
+        // up with the number of calls to fail!()
+        #[inline(always)]
+        fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+            static FILE_LINE: (&'static str, uint) = (file!(), line!());
+            ::std::rt::begin_unwind_fmt(fmt, &FILE_LINE)
+        }
+        format_args!(run_fmt, $fmt, $($arg)*)
+    });
+)
+
 /// Ensure that a boolean expression is `true` at runtime.
 ///
 /// This will invoke the `fail!` macro if the provided expression cannot be

branches/try/src/libstd/sync/mod.rs

@@ -10,7 +10,7 @@
 
 //! Useful synchronization primitives
 //!
-//! This module contains useful safe and unsafe synchronization primitives.
+//! This modules contains useful safe and unsafe synchronization primitives.
 //! Most of the primitives in this module do not provide any sort of locking
 //! and/or blocking at all, but rather provide the necessary tools to build
 //! other types of concurrent primitives.

branches/try/src/libunicode/normalize.rs

@@ -39,6 +39,9 @@ pub fn decompose_canonical(c: char, i: |char|) { d(c, i, false); }
 pub fn decompose_compatible(c: char, i: |char|) { d(c, i, true); }
 
 fn d(c: char, i: |char|, k: bool) {
+    #[cfg(stage0)]
+    use core::iter::Iterator;
+
     // 7-bit ASCII never decomposes
     if c <= '\x7f' { i(c); return; }
 

branches/try/src/snapshots.txt

@@ -1,11 +1,3 @@
-S 2014-08-07 12e0f72
-  freebsd-x86_64 e55055a876ebbde0d3ed3bcb97579afab9264def
-  linux-i386 2665e45879f2ef77ce0c9015f971642fe424ac33
-  linux-x86_64 51ed1f4cf0707585a136bb149a443394067c074c
-  macos-i386 78f1996954a6e0718d684a3756b4870a6f8771ee
-  macos-x86_64 216f46f65866207a9f41c3ed654f5c1e085cb7f3
-  winnt-i386 95a9b8a8bf587761ae954392aee2ccee3758a533
-
 S 2014-07-17 9fc8394
   freebsd-x86_64 5a4b645e2b42ae06224cc679d4a43b3d89be1482
   linux-i386 a5e1bb723020ac35173d49600e76b0935e257a6a