---

yaml
---
r: 34334
b: refs/heads/snap-stage3
c: 5b2b13b
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 5ec3aba8cc977f5b396a8e2636bd0ddbbfa9af66
+refs/heads/snap-stage3: 5b2b13bff81d341f243a9a902d8779ef82e2d7fd
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/CONTRIBUTING.md

@@ -0,0 +1,12 @@
+## Pull request procedure
+
+Pull requests should be targeted at Rust's `incoming` branch (note that by default Github will aim them at the `master` branch) -- see "Changing The Commit Range and Destination Repository" in Github's documentation on [pull requests](https://help.github.com/articles/using-pull-requests). Before pushing to your Github repo and issuing the pull request, please do two things:
+
+1. [Rebase](http://git-scm.com/book/en/Git-Branching-Rebasing) your local changes against the `incoming` branch. Resolve any conflicts that arise.
+2. Run the full Rust test suite with the `make check` command. You're not off the hook even if you just stick to documentation; code examples in the docs are tested as well!
+
+Pull requests will be treated as "review requests", and we will give feedback we expect to see corrected on [style](https://github.com/mozilla/rust/wiki/Note-style-guide) and substance before pulling. Changes contributed via pull request should focus on a single issue at a time, like any other. We will not look kindly on pull-requests that try to "sneak" unrelated changes in.
+
+Normally, all pull requests must include regression tests (see [[Note-testsuite]]) that test your change. Occasionally, a change will be very difficult to test for. In those cases, please include a note in your commit message explaining why.
+
+For more details, please refer to [[Note-development-policy]].

branches/snap-stage3/doc/rust.md

@@ -1107,6 +1107,19 @@ let mut a: Animal = Dog;
 a = Cat;
 ~~~~
 
+Enumeration constructors can have either named or unnamed fields:
+~~~~
+enum Animal {
+    Dog (~str, float),
+    Cat { name: ~str, weight: float }
+}
+
+let mut a: Animal = Dog(~"Cocoa", 37.2);
+a = Cat{ name: ~"Spotty", weight: 2.7 };
+~~~~
+
+In this example, `Cat` is a _struct-like enum variant_,
+whereas `Dog` is simply called an enum variant.
 ### Constants
 
 ~~~~~~~~ {.ebnf .gram}

branches/snap-stage3/doc/tutorial.md

@@ -733,6 +733,24 @@ fn point_from_direction(dir: Direction) -> Point {
 }
 ~~~~
 
+A special kind of enum variant, called _struct-like enums_,
+can have its fields extracted with dot notation and not just destructuring.
+For example:
+
+~~~~
+# struct Point {x: float, y: float}
+# fn square(x: float) -> float { x * x }
+enum Shape {
+    Circle { center: Point, radius: float },
+    Rectangle { left: Point, right: Point }
+}
+fn area(sh: Shape) -> float {
+   match sh {
+      Circle(c) => float::consts::pi * square(c.radius),
+      Rectangle(r) => r.right.x - r.left.x * r.right.y - r.right.y
+   }
+}
+~~~~
 ## Tuples
 
 Tuples in Rust behave exactly like structs, except that their fields

branches/snap-stage3/src/compiletest/errors.rs

@@ -33,8 +33,8 @@ fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe {
     let error_tag = ~"//~";
     let mut idx;
     match str::find_str(line, error_tag) {
-      option::None => return ~[],
-      option::Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
+      None => return ~[],
+      Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
     }
 
     // "//~^^^ kind msg" denotes a message expected

branches/snap-stage3/src/compiletest/header.rs

@@ -34,12 +34,12 @@ fn load_props(testfile: &Path) -> test_props {
     let mut error_patterns = ~[];
     let mut aux_builds = ~[];
     let mut exec_env = ~[];
-    let mut compile_flags = option::None;
-    let mut pp_exact = option::None;
+    let mut compile_flags = None;
+    let mut pp_exact = None;
     for iter_header(testfile) |ln| {
         match parse_error_pattern(ln) {
-          option::Some(ep) => error_patterns.push(ep),
-          option::None => ()
+          Some(ep) => error_patterns.push(ep),
+          None => ()
         };
 
         if compile_flags.is_none() {
@@ -124,12 +124,12 @@ fn parse_exec_env(line: ~str) -> Option<(~str, ~str)> {
 
 fn parse_pp_exact(line: ~str, testfile: &Path) -> Option<Path> {
     match parse_name_value_directive(line, ~"pp-exact") {
-      option::Some(s) => option::Some(Path(s)),
-      option::None => {
+      Some(s) => Some(Path(s)),
+      None => {
         if parse_name_directive(line, ~"pp-exact") {
-            option::Some(testfile.file_path())
+            Some(testfile.file_path())
         } else {
-            option::None
+            None
         }
       }
     }
@@ -143,12 +143,12 @@ fn parse_name_value_directive(line: ~str,
                               directive: ~str) -> Option<~str> unsafe {
     let keycolon = directive + ~":";
     match str::find_str(line, keycolon) {
-        option::Some(colon) => {
+        Some(colon) => {
             let value = str::slice(line, colon + str::len(keycolon),
                                    str::len(line));
             debug!("%s: %s", directive,  value);
-            option::Some(value)
+            Some(value)
         }
-        option::None => option::None
+        None => None
     }
 }

branches/snap-stage3/src/compiletest/runtest.rs

@@ -117,7 +117,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
     } else { logv(config, ~"testing for converging pretty-printing"); }
 
     let rounds =
-        match props.pp_exact { option::Some(_) => 1, option::None => 2 };
+        match props.pp_exact { Some(_) => 1, None => 2 };
 
     let mut srcs = ~[io::read_whole_file_str(testfile).get()];
 
@@ -137,11 +137,11 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
 
     let mut expected =
         match props.pp_exact {
-          option::Some(file) => {
+          Some(file) => {
             let filepath = testfile.dir_path().push_rel(&file);
             io::read_whole_file_str(&filepath).get()
           }
-          option::None => { srcs[vec::len(srcs) - 2u] }
+          None => { srcs[vec::len(srcs) - 2u] }
         };
     let mut actual = srcs[vec::len(srcs) - 1u];
 
@@ -165,7 +165,7 @@ fn run_pretty_test(config: config, props: test_props, testfile: &Path) {
 
     fn print_source(config: config, testfile: &Path, src: ~str) -> procres {
         compose_and_run(config, testfile, make_pp_args(config, testfile),
-                        ~[], config.compile_lib_path, option::Some(src))
+                        ~[], config.compile_lib_path, Some(src))
     }
 
     fn make_pp_args(config: config, _testfile: &Path) -> procargs {
@@ -199,7 +199,7 @@ actual:\n\
         compose_and_run_compiler(
             config, props, testfile,
             make_typecheck_args(config, testfile),
-            option::Some(src))
+            Some(src))
     }
 
     fn make_typecheck_args(config: config, testfile: &Path) -> procargs {
@@ -418,7 +418,7 @@ fn exec_compiled_test(config: config, props: test_props,
     compose_and_run(config, testfile,
                     make_run_args(config, props, testfile),
                     props.exec_env,
-                    config.run_lib_path, option::None)
+                    config.run_lib_path, None)
 }
 
 fn compose_and_run_compiler(
@@ -441,7 +441,7 @@ fn compose_and_run_compiler(
             make_compile_args(config, props, ~[~"--lib"] + extra_link_args,
                               |a,b| make_lib_name(a, b, testfile), &abs_ab);
         let auxres = compose_and_run(config, &abs_ab, aux_args, ~[],
-                                     config.compile_lib_path, option::None);
+                                     config.compile_lib_path, None);
         if auxres.status != 0 {
             fatal_procres(
                 fmt!("auxiliary build of %s failed to compile: ",
@@ -501,8 +501,8 @@ fn make_run_args(config: config, _props: test_props, testfile: &Path) ->
             // then split apart its command
             let runtool =
                 match config.runtool {
-                  option::Some(s) => option::Some(s),
-                  option::None => option::None
+                  Some(s) => Some(s),
+                  None => None
                 };
             split_maybe_args(runtool)
         };
@@ -517,8 +517,8 @@ fn split_maybe_args(argstr: Option<~str>) -> ~[~str] {
     }
 
     match argstr {
-      option::Some(s) => rm_whitespace(str::split_char(s, ' ')),
-      option::None => ~[]
+      Some(s) => rm_whitespace(str::split_char(s, ' ')),
+      None => ~[]
     }
 }
 

branches/snap-stage3/src/compiletest/util.rs

@@ -17,10 +17,10 @@ fn make_new_path(path: ~str) -> ~str {
     // Windows just uses PATH as the library search path, so we have to
     // maintain the current value while adding our own
     match getenv(lib_path_env_var()) {
-      option::Some(curr) => {
+      Some(curr) => {
         fmt!("%s%s%s", path, path_div(), curr)
       }
-      option::None => path
+      None => path
     }
 }
 

branches/snap-stage3/src/driver/driver.rs

@@ -12,18 +12,18 @@
 extern mod core(vers = "0.6");
 
 #[cfg(cargo)]
-extern mod self(name = "cargo", vers = "0.6");
+extern mod this(name = "cargo", vers = "0.6");
 
 #[cfg(fuzzer)]
-extern mod self(name = "fuzzer", vers = "0.6");
+extern mod this(name = "fuzzer", vers = "0.6");
 
 #[cfg(rustdoc)]
-extern mod self(name = "rustdoc", vers = "0.6");
+extern mod this(name = "rustdoc", vers = "0.6");
 
 #[cfg(rusti)]
-extern mod self(name = "rusti", vers = "0.6");
+extern mod this(name = "rusti", vers = "0.6");
 
 #[cfg(rustc)]
-extern mod self(name = "rustc", vers = "0.6");
+extern mod this(name = "rustc", vers = "0.6");
 
-fn main() { self::main() }
+fn main() { this::main() }

branches/snap-stage3/src/etc/vim/syntax/rust.vim

@@ -2,7 +2,7 @@
 " Language:     Rust
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
-" Last Change:  2012 Dec 14
+" Last Change:  2012 Dec 25
 
 if version < 600
   syntax clear
@@ -44,8 +44,8 @@ syn keyword   rustType        off_t dev_t ino_t pid_t mode_t ssize_t
 
 syn keyword   rustTrait       Const Copy Send Owned " inherent traits
 syn keyword   rustTrait       Eq Ord Num Ptr
-syn keyword   rustTrait       Add Sub Mul Div Modulo Neg BitAnd BitOr BitXor
-syn keyword   rustTrait       Shl Shr Index
+syn keyword   rustTrait       Drop Add Sub Mul Div Modulo Neg BitAnd BitOr
+syn keyword   rustTrait       BitXor Shl Shr Index
 
 syn keyword   rustSelf        self
 syn keyword   rustBoolean     true false

branches/snap-stage3/src/libcargo/pgp.rs

@@ -8,6 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use core::os;
+use core::run;
+
 fn gpgv(args: ~[~str]) -> { status: int, out: ~str, err: ~str } {
     return run::program_output(~"gpgv", args);
 }

branches/snap-stage3/src/libcore/at_vec.rs

@@ -15,21 +15,26 @@
 #[forbid(deprecated_pattern)];
 
 use cast::transmute;
+use iter;
+use libc;
 use ptr::addr_of;
+use sys;
+use uint;
+use vec;
 
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
 
 #[abi = "cdecl"]
-extern mod rustrt {
+pub extern mod rustrt {
     #[legacy_exports];
     fn vec_reserve_shared_actual(++t: *sys::TypeDesc,
                                  ++v: **vec::raw::VecRepr,
                                  ++n: libc::size_t);
 }
 
 #[abi = "rust-intrinsic"]
-extern mod rusti {
+pub extern mod rusti {
     #[legacy_exports];
     fn move_val_init<T>(dst: &mut T, -src: T);
 }
@@ -157,6 +162,13 @@ pub mod traits {
 pub mod traits {}
 
 pub mod raw {
+    use at_vec::{rusti, rustrt};
+    use libc;
+    use ptr;
+    use sys;
+    use uint;
+    use vec;
+
     pub type VecRepr = vec::raw::VecRepr;
     pub type SliceRepr = vec::raw::SliceRepr;
 

branches/snap-stage3/src/libcore/bool.rs

@@ -16,6 +16,8 @@
 
 //! Boolean logic
 
+use bool;
+use cmp;
 use cmp::Eq;
 
 /// Negation / inverse

branches/snap-stage3/src/libcore/char.rs

@@ -14,7 +14,12 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use char;
 use cmp::Eq;
+use str;
+use u32;
+use uint;
+use unicode;
 
 /*
     Lu  Uppercase_Letter    an uppercase letter

branches/snap-stage3/src/libcore/condition.rs

@@ -8,6 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use task;
+
 // helper for transmutation, shown below.
 type RustClosure = (int,int);
 pub struct Handler<T, U> {

branches/snap-stage3/src/libcore/core.rc

@@ -235,7 +235,7 @@ mod stackwalk;
 // 'core' so that macro-expanded references to core::error and such
 // can be resolved within libcore.
 #[doc(hidden)] // FIXME #3538
-mod core {
+pub mod core {
     pub const error : u32 = 1_u32;
     pub const warn : u32 = 2_u32;
     pub const info : u32 = 3_u32;

branches/snap-stage3/src/libcore/dlist.rs

@@ -22,6 +22,10 @@ Do not use ==, !=, <, etc on doubly-linked lists -- it may not terminate.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use managed;
+use option;
+use vec;
+
 type DListLink<T> = Option<DListNode<T>>;
 
 enum DListNode<T> = @{
@@ -469,6 +473,10 @@ impl<T: Copy> DList<T> {
 #[cfg(test)]
 mod tests {
     #[legacy_exports];
+
+    use iter;
+    use vec;
+
     #[test]
     fn test_dlist_concat() {
         let a = from_vec(~[1,2]);

branches/snap-stage3/src/libcore/dvec.rs

@@ -23,8 +23,10 @@ Note that recursive use is not permitted.
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
+use cast;
 use cast::reinterpret_cast;
 use ptr::null;
+use vec;
 
 /**
  * A growable, modifiable vector type that accumulates elements into a