---

yaml
---
r: 37810
b: refs/heads/try
c: ef2c404
h: refs/heads/master
v: v3

Author: rntz

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: 83a55ea73a985a331635fe5a8c505f7f74328c11
+refs/heads/try: ef2c404e01108a7bd7465bd23d40ff989848bffd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/AUTHORS.txt

@@ -4,13 +4,11 @@ Graydon Hoare <[email protected]>
 
 Other authors:
 
-
 Adam Bozanich <[email protected]>
 Aleksander Balicki <[email protected]>
 Alex Rønne Petersen <[email protected]>
 Alexander Stavonin <[email protected]>
 Andreas Gal <[email protected]>
-Andrew Dunham <[email protected]>
 Andrew Paseltiner <[email protected]>
 Arkaitz Jimenez <[email protected]>
 Armin Ronacher <[email protected]>
@@ -22,7 +20,6 @@ Benjamin Herr <[email protected]>
 Benjamin Jackman <[email protected]>
 Benjamin Kircher <[email protected]>
 Benjamin Peterson <[email protected]>
-Bilal Husain <[email protected]>
 Brendan Eich <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>
@@ -32,7 +29,6 @@ Chris Peterson <[email protected]>
 Chris Pressey <[email protected]>
 Damian Gryski <[email protected]>
 Damien Grassart <[email protected]>
-Damien Schoof <[email protected]>
 Daniel Brooks <[email protected]>
 Daniel Luz <[email protected]>
 Daniel Patterson <[email protected]>
@@ -76,7 +72,7 @@ Jyun-Yan You <[email protected]>
 Kelly Wilson <[email protected]>
 Kevin Atkinson <[email protected]>
 Kevin Cantu <[email protected]>
-Lennart Kudling <[email protected]>
+Lennart Kudling
 Lindsey Kuper <[email protected]>
 Luca Bruno <[email protected]>
 Luqman Aden <[email protected]>
@@ -95,7 +91,6 @@ Orphée Lafond-Lummis <[email protected]>
 Patrick Walton <[email protected]>
 Patrik Kårlin <[email protected]>
 Paul Stansifer <[email protected]>
-Paul Woolcock <[email protected]>
 Peter Hull <[email protected]>
 Philipp Brüschweiler <[email protected]>
 Rafael Ávila de Espíndola <[email protected]>
@@ -107,15 +102,14 @@ Roland Tanglao <[email protected]>
 Roy Frostig <[email protected]>
 Ryan Scheel <[email protected]>
 Sean Stangl <[email protected]>
-Simon Barber-Dueck <[email protected]>
+Simon BD
 startling <[email protected]>
 Stefan Plantikow <[email protected]>
 Taras Shpot <[email protected]>
 Ted Horst <[email protected]>
 Tim Chevalier <[email protected]>
 Tom Lee <[email protected]>
 Tomoki Aonuma <[email protected]>
-Tony Young <[email protected]>
 Tycho Sci <[email protected]>
 Viktor Dahl <[email protected]>
 Vincent Belliard <[email protected]>

branches/try/doc/README

@@ -494,7 +494,7 @@ transcriber : '(' transcriber * ')' | '[' transcriber * ']'
 
 User-defined syntax extensions are called "macros", and they can be defined
 with the `macro_rules!` syntax extension. User-defined macros can currently
-be invoked as expressions, statements, or items.
+only be invoked in expression position.
 
 (A `sep_token` is any token other than `*` and `+`. A `non_special_token` is
 any token other than a delimiter or `$`.)
@@ -510,8 +510,9 @@ 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` (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
+`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
 the name of a matched nonterminal comes after the dollar sign.
 
 In both the matcher and transcriber, the Kleene star-like operator indicates repetition.
@@ -798,7 +799,7 @@ extern mod ruststd (name = "std"); // linking to 'std' under another name
 ##### Use declarations
 
 ~~~~~~~~ {.ebnf .gram}
-use_decl : "pub"? "use" ident [ '=' path
+use_decl : "use" ident [ '=' path
                           | "::" path_glob ] ;
 
 path_glob : ident [ "::" path_glob ] ?
@@ -1103,27 +1104,6 @@ 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.
@@ -1195,9 +1175,6 @@ 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.
@@ -1327,8 +1304,9 @@ 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 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.
+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.
 
 An example of attributes:
 
@@ -1348,9 +1326,9 @@ mod bar {
   ...
 }
 
-// A lint attribute used to suppress a warning/error
-#[allow(non_camel_case_types)]
-pub type int8_t = i8;
+// A documentation attribute
+#[doc = "Add two numbers together."]
+fn add(x: int, y: int) { x + y }
 ~~~~~~~~
 
 > **Note:** In future versions of Rust, user-provided extensions to the compiler will be able to interpret attributes.
@@ -1363,8 +1341,6 @@ 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.
 
@@ -1570,9 +1546,7 @@ it is automatically derferenced to make the field access possible.
 ### Vector expressions
 
 ~~~~~~~~{.ebnf .gram}
-vec_expr : '[' "mut"? vec_elems? ']'
-
-vec_elems : [expr [',' expr]*] | [expr ',' ".." expr]
+vec_expr : '[' "mut" ? [ expr [ ',' expr ] * ] ? ']'
 ~~~~~~~~
 
 A [_vector_](#vector-types) _expression_ is written by enclosing zero or
@@ -1584,7 +1558,6 @@ 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];
 ~~~~
 
@@ -1916,7 +1889,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,
@@ -2197,6 +2170,17 @@ 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};
 # type player = {player: ~str, stats: (), options: options};
@@ -2228,22 +2212,6 @@ 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:
 
@@ -2726,12 +2694,11 @@ The kinds are:
     structural types containing only other sendable types.
 `Owned`
   : Types of this kind do not contain any borrowed pointers;
-    this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).
+    this can be a useful guarantee for code that breaks borrowing assumptions using [`unsafe` operations](#unsafe-functions).    
 `Copy`
   : This kind includes all types that can be copied. All types with
     sendable kind are copyable, as are managed boxes, managed closures,
     trait types, and structural types built out of these.
-    Types with destructors (types that implement `Drop`) can not implement `Copy`.
 _Default_
   : Types with destructors, closure environments,
     and various other _non-first-class_ types,

branches/try/doc/rust.md

@@ -1540,7 +1540,8 @@ them. In the rare case where the compiler needs assistance, though, the
 arguments and return types may be annotated.
 
 ~~~~
-let square = |x: int| -> uint { x * x as uint };
+# type mygoodness = fn(~str) -> ~str; type what_the = int;
+let bloop = |well, oh: mygoodness| -> what_the { fail oh(well) };
 ~~~~
 
 There are several forms of closure, each with its own role. The most
@@ -1913,7 +1914,7 @@ struct TimeBomb {
 }
 
 impl TimeBomb : Drop {
-    fn finalize(&self) {
+    fn finalize() {
         for iter::repeat(self.explosivity) {
             io::println("blam!");
         }
@@ -2042,9 +2043,8 @@ 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[i];
+        let copy_of_thing = printable_things[0];
         copy_of_thing.print();
-        i += 1;
     }
 }
 ~~~

branches/try/doc/tutorial.md

@@ -110,7 +110,6 @@ clean$(1)_T_$(2)_H_$(3):
 	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/$(CFG_RUSTLLVM)
 	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/libstd.rlib
 	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/libmorestack.a
-	$(Q)rm -f $$(TLIB$(1)_T_$(2)_H_$(3))/librun_pass*
 endef
 
 $(foreach host, $(CFG_TARGET_TRIPLES), \

branches/try/mk/clean.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/libcargo/*rs)
+CARGO_INPUTS := $(wildcard $(S)src/cargo/*rs)
 
 # Rustdoc, the documentation tool
 RUSTDOC_LIB := $(S)src/librustdoc/rustdoc.rc
-RUSTDOC_INPUTS := $(wildcard $(S)src/librustdoc/*.rs)
+RUSTDOC_INPUTS := $(wildcard $(S)src/rustdoc/*.rs)
 
 # Rusti, the JIT REPL
 RUSTI_LIB := $(S)src/librusti/rusti.rc

branches/try/mk/tools.mk

@@ -2,7 +2,7 @@ This is a preliminary version of the Rust compiler, libraries and tools
 
 Source layout:
 
-librustc/          The self-hosted compiler
+rustc/             The self-hosted compiler
 
 libcore/           The core library (imported and linked by default)
 libstd/            The standard library (slightly more peripheral code)
@@ -28,18 +28,18 @@ test/auxiliary     - Dependencies of tests
 
 compiletest/       The test runner
 
-libcargo/          The package manager
+cargo/             The package manager
 
-librusti/          The JIT REPL
+rusti/             The JIT REPL
 
-librustdoc/        The Rust API documentation tool
+rustdoc/           The Rust API documentation tool
 
 llvm/              The LLVM submodule
 
 libuv/             The libuv submodule
 
 rustllvm/          LLVM support code
 
-libfuzzer/         A collection of fuzz testers
+fuzzer/            A collection of fuzz testers
 
 etc/               Scripts, editor support, misc

branches/try/src/README.txt

@@ -1,10 +1,10 @@
 enum mode { mode_compile_fail, mode_run_fail, mode_run_pass, mode_pretty, }
 
 impl mode : cmp::Eq {
-    pure fn eq(&self, other: &mode) -> bool {
-        (*other) as int == (*self) as int
+    pure fn eq(other: &mode) -> bool {
+        (*other) as int == self as int
     }
-    pure fn ne(&self, other: &mode) -> bool { !(*self).eq(other) }
+    pure fn ne(other: &mode) -> bool { !self.eq(other) }
 }
 
 type config = {