---

yaml
---
r: 33842
b: refs/heads/snap-stage3
c: ca6970a
h: refs/heads/master
v: v3

Author: pcwalton

[refs]

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

branches/snap-stage3/doc/README

@@ -0,0 +1,13 @@
+The markdown docs are only generated by make when node is installed (use
+`make doc`). If you don't have node installed you can generate them yourself. 
+Unfortunately there's no real standard for markdown and all the tools work 
+differently. pandoc is one that seems to work well.
+
+To generate an html version of a doc do something like:
+pandoc --from=markdown --to=html --number-sections -o build/doc/rust.html doc/rust.md && git web--browse build/doc/rust.html
+
+The syntax for pandoc flavored markdown can be found at:
+http://johnmacfarlane.net/pandoc/README.html#pandocs-markdown
+
+A nice quick reference (for non-pandoc markdown) is at:
+http://kramdown.rubyforge.org/quickref.html

branches/snap-stage3/doc/rust.md

@@ -510,9 +510,8 @@ For parsing reasons, delimiters must be balanced, but they are otherwise not spe
 
 In the matcher, `$` _name_ `:` _designator_ matches the nonterminal in the
 Rust syntax named by _designator_. Valid designators are `item`, `block`,
-`stmt`, `pat`, `expr`, `ty`, `ident`, `path`, `tt`, `matchers`. The last two
-are the right-hand side and the left-hand side respectively of the `=>` in
-macro rules. In the transcriber, the designator is already known, and so only
+`stmt`, `pat`, `expr`, `ty` (type), `ident`, `path`, `matchers` (lhs of the `=>` in macro rules), 
+`tt` (rhs of the `=>` in macro rules). In the transcriber, the designator is already known, and so only
 the name of a matched nonterminal comes after the dollar sign.
 
 In both the matcher and transcriber, the Kleene star-like operator indicates repetition.
@@ -799,7 +798,7 @@ extern mod ruststd (name = "std"); // linking to 'std' under another name
 ##### Use declarations
 
 ~~~~~~~~ {.ebnf .gram}
-use_decl : "use" ident [ '=' path
+use_decl : "pub"? "use" ident [ '=' path
                           | "::" path_glob ] ;
 
 path_glob : ident [ "::" path_glob ] ?
@@ -1104,6 +1103,27 @@ Constants are declared with the `const` keyword.
 A constant item must have an expression giving its definition.
 The definition expression of a constant is limited to expression forms that can be evaluated at compile time.
 
+Constants must be explicitly typed. The type may be ```bool```, ```char```, a number, or a type derived from
+those primitive types. The derived types are borrowed pointers, static arrays, tuples, and structs.
+
+~~~~
+const bit1: uint = 1 << 0;
+const bit2: uint = 1 << 1;
+
+const bits: [uint * 2] = [bit1, bit2];
+const string: &str = "bitstring";
+
+struct BitsNStrings {
+    mybits: [uint *2],
+    mystring: &str
+}
+
+const bits_n_strings: BitsNStrings = BitsNStrings {
+    mybits: bits,
+    mystring: string
+};
+~~~~
+
 ### Traits
 
 A _trait_ describes a set of method types.
@@ -1175,6 +1195,9 @@ Values with a trait type can have [methods called](#method-call-expressions) on
 for any method in the trait,
 and can be used to instantiate type parameters that are bounded by the trait.
 
+Trait methods may be static. Currently implementations of static methods behave like
+functions declared in the implentation's module.
+
 ### Implementations
 
 An _implementation_ is an item that implements a [trait](#traits) for a specific type.
@@ -1304,9 +1327,8 @@ Attributes may appear as any of
 * An identifier followed by the equals sign '=' and a literal, providing a key/value pair
 * An identifier followed by a parenthesized list of sub-attribute arguments
 
-Attributes are applied to an entity by placing them within a hash-list
-(`#[...]`) as either a prefix to the entity or as a semicolon-delimited
-declaration within the entity body.
+Attributes terminated by a semi-colon apply to the entity that the attribute is declared
+within. Attributes that are not terminated by a semi-colon apply to the next entity.
 
 An example of attributes:
 
@@ -1326,9 +1348,9 @@ mod bar {
   ...
 }
 
-// A documentation attribute
-#[doc = "Add two numbers together."]
-fn add(x: int, y: int) { x + y }
+// A lint attribute used to suppress a warning/error
+#[allow(non_camel_case_types)]
+pub type int8_t = i8;
 ~~~~~~~~
 
 > **Note:** In future versions of Rust, user-provided extensions to the compiler will be able to interpret attributes.
@@ -1341,6 +1363,8 @@ names are effectively reserved. Some significant attributes include:
 * The `cfg` attribute, for conditional-compilation by build-configuration.
 * The `link` attribute, for describing linkage metadata for a crate.
 * The `test` attribute, for marking functions as unit tests.
+* The `allow`, `warn`, `forbid`, and `deny` attributes, for controling lint checks. Lint checks supported
+by the compiler can be found via `rustc -W help`.
 
 Other attributes may be added or removed during development of the language.
 
@@ -1546,7 +1570,9 @@ it is automatically derferenced to make the field access possible.
 ### Vector expressions
 
 ~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mut" ? [ expr [ ',' expr ] * ] ? ']'
+vec_expr : '[' "mut"? vec_elems? ']'
+
+vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
 ~~~~~~~~
 
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
@@ -1558,6 +1584,7 @@ When no mutability is specified, the vector is immutable.
 ~~~~
 [1, 2, 3, 4];
 ["a", "b", "c", "d"];
+[0, ..128];             // vector with 128 zeros
 [mut 0u8, 0u8, 0u8, 0u8];
 ~~~~
 
@@ -1889,7 +1916,7 @@ let x: int = add(1, 2);
 
 ~~~~~~~~ {.abnf .gram}
 ident_list : [ ident [ ',' ident ]* ] ? ;
-lambda_expr : '|' ident_list '| expr ;
+lambda_expr : '|' ident_list '|' expr ;
 ~~~~~~~~
 
 A _lambda expression_ (a.k.a. "anonymous function expression") defines a function and denotes it as a value,
@@ -2169,17 +2196,6 @@ Records and structures can also be pattern-matched and their fields bound to var
 When matching fields of a record,
 the fields being matched are specified first,
 then a placeholder (`_`) represents the remaining fields.
-
-A pattern that's just a variable binding,
-like `Nil` in the previous answer,
-could either refer to an enum variant that's in scope,
-or bind a new variable.
-The compiler resolves this ambiguity by forbidding variable bindings that occur in ```match``` patterns from shadowing names of variants that are in scope.
-For example, wherever ```List``` is in scope,
-a ```match``` pattern would not be able to bind ```Nil``` as a new name.
-The compiler interprets a variable pattern `x` as a binding _only_ if there is no variant named `x` in scope.
-A convention you can use to avoid conflicts is simply to name variants with upper-case letters,
-and local variables with lower-case letters.
 
 ~~~~
 # type options = {choose: bool, size: ~str};
@@ -2212,6 +2228,22 @@ fn main() {
 }
 ~~~~
 
+Patterns that bind variables default to binding to a copy of the matched value. This can be made
+explicit using the ```copy``` keyword, changed to bind to a borrowed pointer by using the ```ref```
+keyword, or to a mutable borrowed pointer using ```ref mut```, or the value can be moved into
+the new binding using ```move```.
+
+A pattern that's just an identifier,
+like `Nil` in the previous answer,
+could either refer to an enum variant that's in scope,
+or bind a new variable.
+The compiler resolves this ambiguity by forbidding variable bindings that occur in ```match``` patterns from shadowing names of variants that are in scope.
+For example, wherever ```List``` is in scope,
+a ```match``` pattern would not be able to bind ```Nil``` as a new name.
+The compiler interprets a variable pattern `x` as a binding _only_ if there is no variant named `x` in scope.
+A convention you can use to avoid conflicts is simply to name variants with upper-case letters,
+and local variables with lower-case letters.
+
 Multiple match patterns may be joined with the `|` operator.  A
 range of values may be specified with `..`. For example:
 

branches/snap-stage3/doc/tutorial.md

@@ -1540,8 +1540,7 @@ them. In the rare case where the compiler needs assistance, though, the
 arguments and return types may be annotated.
 
 ~~~~
-# type mygoodness = fn(~str) -> ~str; type what_the = int;
-let bloop = |well, oh: mygoodness| -> what_the { fail oh(well) };
+let square = |x: int| -> uint { x * x as uint };
 ~~~~
 
 There are several forms of closure, each with its own role. The most
@@ -2043,8 +2042,9 @@ as in this version of `print_all` that copies elements.
 fn print_all<T: Printable Copy>(printable_things: ~[T]) {
     let mut i = 0;
     while i < printable_things.len() {
-        let copy_of_thing = printable_things[0];
+        let copy_of_thing = printable_things[i];
         copy_of_thing.print();
+        i += 1;
     }
 }
 ~~~

branches/snap-stage3/mk/tools.mk

@@ -10,11 +10,11 @@ COMPILETEST_INPUTS := $(wildcard $(S)src/compiletest/*rs)
 
 # Cargo, the package manager
 CARGO_LIB := $(S)src/libcargo/cargo.rc
-CARGO_INPUTS := $(wildcard $(S)src/cargo/*rs)
+CARGO_INPUTS := $(wildcard $(S)src/libcargo/*rs)
 
 # Rustdoc, the documentation tool
 RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rc
-RUSTDOC_INPUTS := $(wildcard $(S)src/rustdoc/*.rs)
+RUSTDOC_INPUTS := $(wildcard $(S)src/librustdoc/*.rs)
 
 # Rusti, the JIT REPL
 RUSTI_LIB := $(S)src/librusti/rusti.rc

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

@@ -1,11 +1,20 @@
 enum mode { mode_compile_fail, mode_run_fail, mode_run_pass, mode_pretty, }
 
+#[cfg(stage0)]
 impl mode : cmp::Eq {
     pure fn eq(other: &mode) -> bool {
         (*other) as int == self as int
     }
     pure fn ne(other: &mode) -> bool { !self.eq(other) }
 }
+#[cfg(stage1)]
+#[cfg(stage2)]
+impl mode : cmp::Eq {
+    pure fn eq(&self, other: &mode) -> bool {
+        (*other) as int == (*self) as int
+    }
+    pure fn ne(&self, other: &mode) -> bool { !(*self).eq(other) }
+}
 
 type config = {
     // The library paths required for running the compiler

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

@@ -35,12 +35,12 @@ fn parse_config(args: ~[~str]) -> config {
     assert (vec::is_not_empty(args));
     let args_ = vec::tail(args);
     let matches =
-        match getopts::getopts(args_, opts) {
+        &match getopts::getopts(args_, opts) {
           Ok(m) => m,
           Err(f) => fail getopts::fail_str(f)
         };
 
-    fn opt_path(m: getopts::Matches, nm: ~str) -> Path {
+    fn opt_path(m: &getopts::Matches, nm: ~str) -> Path {
         Path(getopts::opt_str(m, nm))
     }
 

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

@@ -30,6 +30,7 @@ struct Package {
 }
 
 impl Package : cmp::Ord {
+    #[cfg(stage0)]
     pure fn lt(other: &Package) -> bool {
         if self.name.lt(&(*other).name) { return true; }
         if (*other).name.lt(&self.name) { return false; }
@@ -46,9 +47,39 @@ impl Package : cmp::Ord {
         if self.versions.lt(&(*other).versions) { return true; }
         return false;
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &Package) -> bool {
+        if (*self).name.lt(&(*other).name) { return true; }
+        if (*other).name.lt(&(*self).name) { return false; }
+        if (*self).uuid.lt(&(*other).uuid) { return true; }
+        if (*other).uuid.lt(&(*self).uuid) { return false; }
+        if (*self).url.lt(&(*other).url) { return true; }
+        if (*other).url.lt(&(*self).url) { return false; }
+        if (*self).method.lt(&(*other).method) { return true; }
+        if (*other).method.lt(&(*self).method) { return false; }
+        if (*self).description.lt(&(*other).description) { return true; }
+        if (*other).description.lt(&(*self).description) { return false; }
+        if (*self).tags.lt(&(*other).tags) { return true; }
+        if (*other).tags.lt(&(*self).tags) { return false; }
+        if (*self).versions.lt(&(*other).versions) { return true; }
+        return false;
+    }
+    #[cfg(stage0)]
     pure fn le(other: &Package) -> bool { !(*other).lt(&self) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &Package) -> bool { !(*other).lt(&(*self)) }
+    #[cfg(stage0)]
     pure fn ge(other: &Package) -> bool { !self.lt(other)     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &Package) -> bool { !(*self).lt(other)     }
+    #[cfg(stage0)]
     pure fn gt(other: &Package) -> bool { (*other).lt(&self)  }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &Package) -> bool { (*other).lt(&(*self))  }
 }
 
 struct Source {
@@ -94,10 +125,20 @@ struct Options {
 enum Mode { SystemMode, UserMode, LocalMode }
 
 impl Mode : cmp::Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &Mode) -> bool {
         (self as uint) == ((*other) as uint)
     }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &Mode) -> bool {
+        ((*self) as uint) == ((*other) as uint)
+    }
+    #[cfg(stage0)]
     pure fn ne(other: &Mode) -> bool { !self.eq(other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &Mode) -> bool { !(*self).eq(other) }
 }
 
 fn opts() -> ~[getopts::Opt] {
@@ -620,7 +661,7 @@ fn load_source_packages(c: &Cargo, src: @Source) {
 }
 
 fn build_cargo_options(argv: ~[~str]) -> Options {
-    let matches = match getopts::getopts(argv, opts()) {
+    let matches = &match getopts::getopts(argv, opts()) {
         result::Ok(m) => m,
         result::Err(f) => {
             fail fmt!("%s", getopts::fail_str(f));

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

@@ -66,8 +66,16 @@ pub fn all_values(blk: fn(v: bool)) {
 pub pure fn to_bit(v: bool) -> u8 { if v { 1u8 } else { 0u8 } }
 
 impl bool : cmp::Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &bool) -> bool { self == (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &bool) -> bool { (*self) == (*other) }
+    #[cfg(stage0)]
     pure fn ne(other: &bool) -> bool { self != (*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &bool) -> bool { (*self) != (*other) }
 }
 
 #[test]

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

@@ -28,15 +28,39 @@ pub pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
 }
 
 impl<T:Eq> @const T : Eq {
+    #[cfg(stage0)]
     pure fn eq(other: &@const T) -> bool { *self == *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn eq(&self, other: &@const T) -> bool { *(*self) == *(*other) }
+    #[cfg(stage0)]
     pure fn ne(other: &@const T) -> bool { *self != *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ne(&self, other: &@const T) -> bool { *(*self) != *(*other) }
 }
 
 impl<T:Ord> @const T : Ord {
+    #[cfg(stage0)]
     pure fn lt(other: &@const T) -> bool { *self < *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn lt(&self, other: &@const T) -> bool { *(*self) < *(*other) }
+    #[cfg(stage0)]
     pure fn le(other: &@const T) -> bool { *self <= *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn le(&self, other: &@const T) -> bool { *(*self) <= *(*other) }
+    #[cfg(stage0)]
     pure fn ge(other: &@const T) -> bool { *self >= *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn ge(&self, other: &@const T) -> bool { *(*self) >= *(*other) }
+    #[cfg(stage0)]
     pure fn gt(other: &@const T) -> bool { *self > *(*other) }
+    #[cfg(stage1)]
+    #[cfg(stage2)]
+    pure fn gt(&self, other: &@const T) -> bool { *(*self) > *(*other) }
 }
 
 #[test]