---

yaml
---
r: 177526
b: refs/heads/master
c: d8e1236
h: refs/heads/master
v: v3

Author: dzamlo

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 42e4c1aef6594aac2d27b4bb31896e023863817d
+refs/heads/master: d8e12365cd489d16058c8f5b718ada62d69d0e5b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a45e117733b866302fa99390553d1c548508dcca
 refs/heads/try: fde4472848b662a4d1236388c4cf15e2450237e6

trunk/src/compiletest/common.rs

@@ -12,6 +12,20 @@ pub use self::Mode::*;
 use std::fmt;
 use std::str::FromStr;
 
+#[cfg(stage0)] // NOTE: remove impl after snapshot
+#[derive(Clone, Copy, PartialEq, Show)]
+pub enum Mode {
+    CompileFail,
+    RunFail,
+    RunPass,
+    RunPassValgrind,
+    Pretty,
+    DebugInfoGdb,
+    DebugInfoLldb,
+    Codegen
+}
+
+#[cfg(not(stage0))] // NOTE: remove cfg after snapshot
 #[derive(Clone, Copy, PartialEq, Debug)]
 pub enum Mode {
     CompileFail,
@@ -25,18 +39,17 @@ pub enum Mode {
 }
 
 impl FromStr for Mode {
-    type Err = ();
-    fn from_str(s: &str) -> Result<Mode, ()> {
+    fn from_str(s: &str) -> Option<Mode> {
         match s {
-          "compile-fail" => Ok(CompileFail),
-          "run-fail" => Ok(RunFail),
-          "run-pass" => Ok(RunPass),
-          "run-pass-valgrind" => Ok(RunPassValgrind),
-          "pretty" => Ok(Pretty),
-          "debuginfo-lldb" => Ok(DebugInfoLldb),
-          "debuginfo-gdb" => Ok(DebugInfoGdb),
-          "codegen" => Ok(Codegen),
-          _ => Err(()),
+          "compile-fail" => Some(CompileFail),
+          "run-fail" => Some(RunFail),
+          "run-pass" => Some(RunPass),
+          "run-pass-valgrind" => Some(RunPassValgrind),
+          "pretty" => Some(Pretty),
+          "debuginfo-lldb" => Some(DebugInfoLldb),
+          "debuginfo-gdb" => Some(DebugInfoGdb),
+          "codegen" => Some(Codegen),
+          _ => None,
         }
     }
 }

trunk/src/compiletest/compiletest.rs

@@ -23,7 +23,6 @@
 #![feature(os)]
 #![feature(unicode)]
 
-#![allow(unstable)]
 #![deny(warnings)]
 
 extern crate test;
@@ -35,6 +34,7 @@ extern crate log;
 use std::os;
 use std::old_io;
 use std::old_io::fs;
+use std::str::FromStr;
 use std::thunk::Thunk;
 use getopts::{optopt, optflag, reqopt};
 use common::Config;
@@ -139,7 +139,9 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: matches.opt_str("stage-id").unwrap(),
-        mode: matches.opt_str("mode").unwrap().parse().ok().expect("invalid mode"),
+        mode: FromStr::from_str(matches.opt_str("mode")
+                                       .unwrap()
+                                       .as_slice()).expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
         filter: filter,
         logfile: matches.opt_str("logfile").map(|s| Path::new(s)),

trunk/src/compiletest/errors.rs

@@ -17,7 +17,7 @@ pub struct ExpectedError {
     pub msg: String,
 }
 
-#[derive(PartialEq, Debug)]
+#[derive(PartialEq, Show)]
 enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
 
 /// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"

trunk/src/compiletest/header.rs

@@ -352,8 +352,8 @@ pub fn gdb_version_to_int(version_string: &str) -> int {
         panic!("{}", error_string);
     }
 
-    let major: int = components[0].parse().ok().expect(error_string);
-    let minor: int = components[1].parse().ok().expect(error_string);
+    let major: int = components[0].parse().expect(error_string);
+    let minor: int = components[1].parse().expect(error_string);
 
     return major * 1000 + minor;
 }
@@ -363,6 +363,6 @@ pub fn lldb_version_to_int(version_string: &str) -> int {
         "Encountered LLDB version string with unexpected format: {}",
         version_string);
     let error_string = error_string.as_slice();
-    let major: int = version_string.parse().ok().expect(error_string);
+    let major: int = version_string.parse().expect(error_string);
     return major;
 }

trunk/src/doc/reference.md

@@ -2994,7 +2994,7 @@ Some examples of call expressions:
 # fn add(x: i32, y: i32) -> i32 { 0 }
 
 let x: i32 = add(1i32, 2i32);
-let pi: Option<f32> = "3.14".parse().ok();
+let pi: Option<f32> = "3.14".parse();
 ```
 
 ### Lambda expressions

trunk/src/doc/trpl/error-handling.md

@@ -147,10 +147,10 @@ for all but the most trivial of situations.
 Here's an example of using `Result`:
 
 ```rust
-#[derive(Debug)]
+#[derive(Show)]
 enum Version { Version1, Version2 }
 
-#[derive(Debug)]
+#[derive(Show)]
 enum ParseError { InvalidHeaderLength, InvalidVersion }
 
 fn parse_version(header: &[u8]) -> Result<Version, ParseError> {

trunk/src/doc/trpl/guessing-game.md

@@ -400,7 +400,7 @@ a function for that:
 let input = old_io::stdin().read_line()
                        .ok()
                        .expect("Failed to read line");
-let input_num: Option<u32> = input.parse().ok();
+let input_num: Option<u32> = input.parse();
 ```
 
 The `parse` function takes in a `&str` value and converts it into something.
@@ -422,13 +422,11 @@ In this case, we say `x` is a `u32` explicitly, so Rust is able to properly
 tell `random()` what to generate. In a similar fashion, both of these work:
 
 ```{rust,ignore}
-let input_num = "5".parse::<u32>().ok(); // input_num: Option<u32>
-let input_num: Option<u32> = "5".parse().ok(); // input_num: Option<u32>
+let input_num = "5".parse::<u32>(); // input_num: Option<u32>
+let input_num: Option<u32> = "5".parse(); // input_num: Option<u32>
 ```
 
-Here we're converting the `Result` returned by `parse` to an `Option` by using
-the `ok` method as well.  Anyway, with us now converting our input to a number,
-our code looks like this:
+Anyway, with us now converting our input to a number, our code looks like this:
 
 ```{rust,ignore}
 use std::old_io;
@@ -447,7 +445,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.parse().ok();
+    let input_num: Option<u32> = input.parse();
 
     println!("You guessed: {}", input_num);
 
@@ -497,7 +495,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.parse().ok();
+    let input_num: Option<u32> = input.parse();
 
     let num = match input_num {
         Some(num) => num,
@@ -564,7 +562,7 @@ fn main() {
     let input = old_io::stdin().read_line()
                            .ok()
                            .expect("Failed to read line");
-    let input_num: Option<u32> = input.trim().parse().ok();
+    let input_num: Option<u32> = input.trim().parse();
 
     let num = match input_num {
         Some(num) => num,
@@ -640,7 +638,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -716,7 +714,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -772,7 +770,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,
@@ -849,7 +847,7 @@ fn main() {
         let input = old_io::stdin().read_line()
                                .ok()
                                .expect("Failed to read line");
-        let input_num: Option<u32> = input.trim().parse().ok();
+        let input_num: Option<u32> = input.trim().parse();
 
         let num = match input_num {
             Some(num) => num,

trunk/src/doc/trpl/pointers.md

@@ -605,7 +605,7 @@ Sometimes, you need a recursive data structure. The simplest is known as a
 
 
 ```{rust}
-#[derive(Debug)]
+#[derive(Show)]
 enum List<T> {
     Cons(T, Box<List<T>>),
     Nil,

trunk/src/doc/trpl/unsafe.md

@@ -576,10 +576,6 @@ extern fn panic_fmt(args: &core::fmt::Arguments,
 #[lang = "eh_personality"] extern fn eh_personality() {}
 # #[start] fn start(argc: isize, argv: *const *const u8) -> isize { 0 }
 # fn main() {}
-# mod std {  // for-loops
-#     pub use core::iter;
-#     pub use core::option;
-# }
 ```
 
 Note that there is one extra lang item here which differs from the examples

trunk/src/etc/emacs/README.md

@@ -0,0 +1,79 @@
+`rust-mode`: A major Emacs mode for editing Rust source code
+============================================================
+
+`rust-mode` makes editing [Rust](http://rust-lang.org) code with Emacs
+enjoyable.
+
+
+### Manual Installation
+
+To install manually, check out this repository and add this to your
+`.emacs` file:
+
+```lisp
+(add-to-list 'load-path "/path/to/rust-mode/")
+(autoload 'rust-mode "rust-mode" nil t)
+(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
+```
+
+This associates `rust-mode` with `.rs` files. To enable it explicitly, do
+<kbd>M-x rust-mode</kbd>.
+
+### `package.el` installation via Marmalade or MELPA
+
+It can be more convenient to use Emacs's package manager to handle
+installation for you if you use many elisp libraries. If you have
+`package.el` but haven't added Marmalade or MELPA, the community
+package source, yet, add this to `~/.emacs.d/init.el`:
+
+Using Marmalade:
+
+```lisp
+(require 'package)
+(add-to-list 'package-archives
+             '("marmalade" . "http://marmalade-repo.org/packages/"))
+(package-initialize)
+```
+
+Using MELPA:
+
+```lisp
+(require 'package)
+(add-to-list 'package-archives
+             '("melpa" . "http://melpa.milkbox.net/packages/") t)
+(package-initialize)
+```
+
+Then do this to load the package listing:
+
+* <kbd>M-x eval-buffer</kbd>
+* <kbd>M-x package-refresh-contents</kbd>
+
+If you use a version of Emacs prior to 24 that doesn't include
+`package.el`, you can get it from [here](http://bit.ly/pkg-el23).
+
+If you have an older ELPA `package.el` installed from tromey.com, you
+should upgrade in order to support installation from multiple sources.
+The ELPA archive is deprecated and no longer accepting new packages,
+so the version there (1.7.1) is very outdated.
+
+#### Install `rust-mode`
+
+One you have `package.el`, you can install `rust-mode` or any other
+modes by choosing them from a list:
+
+* <kbd>M-x package-list-packages</kbd>
+
+Now, to install packages, move your cursor to them and press
+<kbd>i</kbd>. This will mark the packages for installation. When
+you're done with marking, press <kbd>x</kbd>, and ELPA will install
+the packages for you (under `~/.emacs.d/elpa/`).
+
+* or using <kbd>M-x package-install rust-mode</kbd>
+
+### Tests via ERT
+
+The file `rust-mode-tests.el` contains tests that can be run via
+[ERT](http://www.gnu.org/software/emacs/manual/html_node/ert/index.html).
+You can use `run_rust_emacs_tests.sh` to run them in batch mode, if
+Emacs is somewhere in your `$PATH`.

trunk/src/etc/emacs/run_rust_emacs_tests.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# Copyright 2014 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.
+#
+# This runs the test for emacs rust-mode.
+# It must be possible to find emacs via PATH.
+emacs -batch -l rust-mode.el -l rust-mode-tests.el -f ert-run-tests-batch-and-exit