---

yaml
---
r: 98262
b: refs/heads/master
c: dac3c53
h: refs/heads/master
v: v3

Author: sfackler

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e83e5769ee01ab7b8ede809618131517aaafe72c
+refs/heads/master: dac3c53ee1e5dfaea674a9345b8d357c0e4d0f37
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/doc/guide-testing.md

@@ -33,7 +33,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 # Unit testing in Rust
 
 Rust has built in support for simple unit testing. Functions can be
-marked as unit tests using the `test` attribute.
+marked as unit tests using the 'test' attribute.
 
 ~~~
 #[test]
@@ -44,13 +44,13 @@ fn return_none_if_empty() {
 
 A test function's signature must have no arguments and no return
 value. To run the tests in a crate, it must be compiled with the
-`--test` flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
+'--test' flag: `rustc myprogram.rs --test -o myprogram-tests`. Running
 the resulting executable will run all the tests in the crate. A test
 is considered successful if its function returns; if the task running
 the test fails, through a call to `fail!`, a failed `check` or
 `assert`, or some other (`assert_eq`, ...) means, then the test fails.
 
-When compiling a crate with the `--test` flag `--cfg test` is also
+When compiling a crate with the '--test' flag '--cfg test' is also
 implied, so that tests can be conditionally compiled.
 
 ~~~
@@ -64,17 +64,17 @@ mod tests {
 ~~~
 
 Additionally `#[test]` items behave as if they also have the
-`#[cfg(test)]` attribute, and will not be compiled when the `--test` flag
+`#[cfg(test)]` attribute, and will not be compiled when the --test flag
 is not used.
 
-Tests that should not be run can be annotated with the `ignore`
+Tests that should not be run can be annotated with the 'ignore'
 attribute. The existence of these tests will be noted in the test
 runner output, but the test will not be run. Tests can also be ignored
 by configuration so, for example, to ignore a test on windows you can
 write `#[ignore(cfg(target_os = "win32"))]`.
 
 Tests that are intended to fail can be annotated with the
-`should_fail` attribute. The test will be run, and if it causes its
+'should_fail' attribute. The test will be run, and if it causes its
 task to fail then the test will be counted as successful; otherwise it
 will be counted as a failure. For example:
 
@@ -87,11 +87,11 @@ fn test_out_of_bounds_failure() {
 }
 ~~~
 
-A test runner built with the `--test` flag supports a limited set of
+A test runner built with the '--test' flag supports a limited set of
 arguments to control which tests are run: the first free argument
 passed to a test runner specifies a filter used to narrow down the set
-of tests being run; the `--ignored` flag tells the test runner to run
-only tests with the `ignore` attribute.
+of tests being run; the '--ignored' flag tells the test runner to run
+only tests with the 'ignore' attribute.
 
 ## Parallelism
 

trunk/doc/rust.md

@@ -2211,9 +2211,12 @@ dereferences (`*expr`), [indexing expressions](#index-expressions)
 (`expr[expr]`), and [field references](#field-expressions) (`expr.f`).
 All other expressions are rvalues.
 
-The left operand of an [assignment](#assignment-expressions) or
+The left operand of an [assignment](#assignment-expressions),
+[binary move](#binary-move-expressions) or
 [compound-assignment](#compound-assignment-expressions) expression is an lvalue context,
-as is the single operand of a unary [borrow](#unary-operator-expressions).
+as is the single operand of a unary [borrow](#unary-operator-expressions),
+or [move](#unary-move-expressions) expression,
+and _both_ operands of a [swap](#swap-expressions) expression.
 All other expression contexts are rvalue contexts.
 
 When an lvalue is evaluated in an _lvalue context_, it denotes a memory location;
@@ -2226,8 +2229,9 @@ A temporary's lifetime equals the largest lifetime of any reference that points
 
 When a [local variable](#memory-slots) is used
 as an [rvalue](#lvalues-rvalues-and-temporaries)
-the variable will either be moved or copied, depending on its type.
-For types that contain [owning pointers](#pointer-types)
+the variable will either be [moved](#move-expressions) or copied,
+depending on its type.
+For types that contain [owning pointers](#owning-pointers)
 or values that implement the special trait `Drop`,
 the variable is moved.
 All other types are copied.
@@ -2886,26 +2890,16 @@ match x {
 
 The first pattern matches lists constructed by applying `Cons` to any head value, and a
 tail value of `~Nil`. The second pattern matches _any_ list constructed with `Cons`,
-ignoring the values of its arguments. The difference between `_` and `*` is that the pattern
-`C(_)` is only type-correct if `C` has exactly one argument, while the pattern `C(..)` is
-type-correct for any enum variant `C`, regardless of how many arguments `C` has.
-
-A `match` behaves differently depending on whether or not the head expression
-is an [lvalue or an rvalue](#lvalues-rvalues-and-temporaries).
-If the head expression is an rvalue, it is
-first evaluated into a temporary location, and the resulting value
-is sequentially compared to the patterns in the arms until a match
+ignoring the values of its arguments. The difference between `_` and `*` is that the pattern `C(_)` is only type-correct if
+`C` has exactly one argument, while the pattern `C(..)` is type-correct for any enum variant `C`, regardless of how many arguments `C` has.
+
+To execute an `match` expression, first the head expression is evaluated, then
+its value is sequentially compared to the patterns in the arms until a match
 is found. The first arm with a matching pattern is chosen as the branch target
 of the `match`, any variables bound by the pattern are assigned to local
 variables in the arm's block, and control enters the block.
 
-When the head expression is an lvalue, the match does not allocate a
-temporary location (however, a by-value binding may copy or move from
-the lvalue). When possible, it is preferable to match on lvalues, as the
-lifetime of these matches inherits the lifetime of the lvalue, rather
-than being restricted to the inside of the match.
-
-An example of a `match` expression:
+An example of an `match` expression:
 
 ~~~~
 # fn process_pair(a: int, b: int) { }
@@ -2935,31 +2929,19 @@ Patterns that bind variables
 default to binding to a copy or move of the matched value
 (depending on the matched value's type).
 This can be changed to bind to a reference by
-using the `ref` keyword,
-or to a mutable reference using `ref mut`.
-
-Patterns can also dereference pointers by using the `&`,
-`~` or `@` symbols, as appropriate. For example, these two matches
-on `x: &int` are equivalent:
-
-~~~~
-# let x = &3;
-let y = match *x { 0 => "zero", _ => "some" };
-let z = match x { &0 => "zero", _ => "some" };
-
-assert_eq!(y, z);
-~~~~
-
-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.
+using the ```ref``` keyword,
+or to a mutable reference using ```ref mut```.
+
+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 `..`.
@@ -3140,20 +3122,19 @@ A `struct` *type* is a heterogeneous product of other types, called the *fields*
 the *record* types of the ML family,
 or the *structure* types of the Lisp family.]
 
-New instances of a `struct` can be constructed with a [struct expression](#structure-expressions).
+New instances of a `struct` can be constructed with a [struct expression](#struct-expressions).
 
 The memory order of fields in a `struct` is given by the item defining it.
 Fields may be given in any order in a corresponding struct *expression*;
 the resulting `struct` value will always be laid out in memory in the order specified by the corresponding *item*.
 
-The fields of a `struct` may be qualified by [visibility modifiers](#re-exporting-and-visibility),
+The fields of a `struct` may be qualified by [visibility modifiers](#visibility-modifiers),
 to restrict access to implementation-private data in a structure.
 
 A _tuple struct_ type is just like a structure type, except that the fields are anonymous.
 
 A _unit-like struct_ type is like a structure type, except that it has no fields.
-The one value constructed by the associated [structure expression](#structure-expressions)
-is the only value that inhabits such a type.
+The one value constructed by the associated [structure expression](#structure-expression) is the only value that inhabits such a type.
 
 ### Enumerated types
 
@@ -3824,7 +3805,7 @@ over the output format of a Rust crate.
 ### Logging system
 
 The runtime contains a system for directing [logging
-expressions](#logging-expressions) to a logging console and/or internal logging
+expressions](#log-expressions) to a logging console and/or internal logging
 buffers. Logging can be enabled per module.
 
 Logging output is enabled by setting the `RUST_LOG` environment

trunk/doc/tutorial.md

@@ -1020,15 +1020,10 @@ being destroyed along with the owner. Since the `list` variable above is
 immutable, the whole list is immutable. The memory allocation itself is the
 box, while the owner holds onto a pointer to it:
 
-              List box             List box           List box            List box
-            +--------------+    +--------------+    +--------------+    +--------------+
-    list -> | Cons | 1 | ~ | -> | Cons | 2 | ~ | -> | Cons | 3 | ~ | -> | Nil          |
-            +--------------+    +--------------+    +--------------+    +--------------+
-
-> Note: the above diagram shows the logical contents of the enum. The actual
-> memory layout of the enum may vary. For example, for the `List` enum shown
-> above, Rust guarantees that there will be no enum tag field in the actual
-> structure. See the language reference for more details.
+      Cons cell        Cons cell        Cons cell
+    +-----------+    +-----+-----+    +-----+-----+
+    |  1  |  ~  | -> |  2  |  ~  | -> |  3  |  ~  | -> Nil
+    +-----------+    +-----+-----+    +-----+-----+
 
 An owned box is a common example of a type with a destructor. The allocated
 memory is cleaned up when the box is destroyed.

trunk/mk/docs.mk

@@ -17,16 +17,16 @@ CDOCS :=
 DOCS_L10N :=
 HTML_DEPS :=
 
-BASE_DOC_OPTS := --standalone --toc --number-sections
-HTML_OPTS = $(BASE_DOC_OPTS) --to=html5 --section-divs --css=rust.css \
-    --include-before-body=doc/version_info.html --include-in-header=doc/favicon.inc
-TEX_OPTS = $(BASE_DOC_OPTS) --include-before-body=doc/version.md --to=latex
+BASE_DOC_OPTS := --include-before-body=doc/version_info.html --standalone  \
+                                --toc --number-sections
+HTML_OPTS = $(BASE_DOC_OPTS) 	--to=html5  --section-divs --css=rust.css  \
+								--include-in-header=doc/favicon.inc
+TEX_OPTS = $(BASE_DOC_OPTS) --to=latex
 EPUB_OPTS = $(BASE_DOC_OPTS) --to=epub
 
 ######################################################################
 # Rust version
 ######################################################################
-
 doc/version.md: $(MKFILE_DEPS) $(wildcard $(S)doc/*.*)
 	@$(call E, version-stamp: $@)
 	$(Q)echo "$(CFG_VERSION)" >$@
@@ -84,7 +84,7 @@ doc/rust.tex: rust.md doc/version.md
 	$(CFG_PANDOC) $(TEX_OPTS) --output=$@
 
 DOCS += doc/rust.epub
-doc/rust.epub: rust.md
+doc/rust.epub: rust.md doc/version_info.html doc/rust.css
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
 	$(CFG_PANDOC) $(EPUB_OPTS) --output=$@
@@ -114,7 +114,7 @@ doc/tutorial.tex: tutorial.md doc/version.md
 	$(CFG_PANDOC) $(TEX_OPTS) --output=$@
 
 DOCS += doc/tutorial.epub
-doc/tutorial.epub: tutorial.md
+doc/tutorial.epub: tutorial.md doc/version_info.html doc/rust.css
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
 	$(CFG_PANDOC) $(EPUB_OPTS) --output=$@
@@ -265,7 +265,6 @@ endif # No pandoc / node
 ######################################################################
 # LLnextgen (grammar analysis from refman)
 ######################################################################
-
 ifeq ($(CFG_LLNEXTGEN),)
   $(info cfg: no llnextgen found, omitting grammar-verification)
 else

trunk/src/compiletest/runtest.rs

@@ -237,15 +237,9 @@ actual:\n\
 
     fn make_typecheck_args(config: &config, props: &TestProps, testfile: &Path) -> ProcArgs {
         let aux_dir = aux_output_dir_name(config, testfile);
-        let target = if props.force_host {
-            config.host.as_slice()
-        } else {
-            config.target.as_slice()
-        };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = ~[~"-",
                          ~"--no-trans", ~"--lib",
-                         ~"--target=" + target,
                          ~"-L", config.build_base.as_str().unwrap().to_owned(),
                          ~"-L",
                          aux_dir.as_str().unwrap().to_owned()];

trunk/src/etc/vim/syntax/rust.vim

@@ -3,7 +3,7 @@
 " Maintainer:   Patrick Walton <[email protected]>
 " Maintainer:   Ben Blum <[email protected]>
 " Maintainer:   Chris Morgan <[email protected]>
-" Last Change:  2014 Jan 4
+" Last Change:  2013 Dec 10
 
 if version < 600
   syntax clear
@@ -147,8 +147,8 @@ syn match     rustMacro       '#\w\(\w\)*' contains=rustAssert,rustFail
 syn match     rustSpecialError display contained /\\./
 syn match     rustSpecial     display contained /\\\([nrt0\\'"]\|x\x\{2}\|u\x\{4}\|U\x\{8}\)/
 syn match     rustStringContinuation display contained /\\\n\s*/
-syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation,@Spell
-syn region    rustString      start='r\z(#*\)"' end='"\z1' contains=@Spell
+syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation
+syn region    rustString      start='r\z(#*\)"' end='"\z1'
 
 syn region    rustAttribute   start="#\[" end="\]" contains=rustString,rustDeriving
 syn region    rustDeriving    start="deriving(" end=")" contained contains=rustTrait
@@ -179,10 +179,10 @@ syn match     rustLifetime    display "\'\%([^[:cntrl:][:space:][:punct:][:digit
 syn match   rustCharacter   /'\([^'\\]\|\\\(.\|x\x\{2}\|u\x\{4}\|U\x\{8}\)\)'/ contains=rustSpecial,rustSpecialError
 
 syn cluster rustComment contains=rustCommentLine,rustCommentLineDoc,rustCommentBlock,rustCommentBlockDoc
-syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo,@Spell
-syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo,@Spell
-syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
-syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment,@Spell keepend extend
+syn region rustCommentLine                                    start="//"                      end="$"   contains=rustTodo
+syn region rustCommentLineDoc                                 start="//\%(//\@!\|!\)"         end="$"   contains=rustTodo
+syn region rustCommentBlock    matchgroup=rustCommentBlock    start="/\*\%(!\|\*[*/]\@!\)\@!" end="\*/" contains=rustTodo,@rustComment keepend extend
+syn region rustCommentBlockDoc matchgroup=rustCommentBlockDoc start="/\*\%(!\|\*[*/]\@!\)"    end="\*/" contains=rustTodo,@rustComment keepend extend
 " FIXME: this is a really ugly and not fully correct implementation. Most
 " importantly, a case like ``/* */*`` should have the final ``*`` not being in
 " a comment, but in practice at present it leaves comments open two levels

trunk/src/libextra/base64.rs

@@ -237,9 +237,8 @@ impl<'a> FromBase64 for &'a str {
         }
 
         for (idx, byte) in it {
-            match byte as char {
-                '='|'\r'|'\n' => continue,
-                _ => return Err(InvalidBase64Character(self.char_at(idx), idx)),
+            if (byte as char) != '=' {
+                return Err(InvalidBase64Character(self.char_at(idx), idx));
             }
         }
 
@@ -311,8 +310,6 @@ mod test {
     fn test_from_base64_newlines() {
         assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
                    "foobar".as_bytes().to_owned());
-        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
-                   "foob".as_bytes().to_owned());
     }
 
     #[test]

trunk/src/libextra/bitv.rs

@@ -269,23 +269,14 @@ impl Bitv {
 
 impl Bitv {
     pub fn new(nbits: uint, init: bool) -> Bitv {
-        let rep = if nbits < uint::bits {
-            Small(SmallBitv::new(if init {(1<<nbits)-1} else {0}))
-        } else if nbits == uint::bits {
+        let rep = if nbits <= uint::bits {
             Small(SmallBitv::new(if init {!0} else {0}))
-        } else {
-            let exact = nbits % uint::bits == 0;
-            let nelems = nbits/uint::bits + if exact {0} else {1};
-            let s =
-                if init {
-                    if exact {
-                        vec::from_elem(nelems, !0u)
-                    } else {
-                        let mut v = vec::from_elem(nelems-1, !0u);
-                        v.push((1<<nbits % uint::bits)-1);
-                        v
-                    }
-                } else { vec::from_elem(nelems, 0u)};
+        }
+        else {
+            let nelems = nbits/uint::bits +
+                         if nbits % uint::bits == 0 {0} else {1};
+            let elem = if init {!0u} else {0u};
+            let s = vec::from_elem(nelems, elem);
             Big(BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -1338,20 +1329,6 @@ mod tests {
         assert_eq!(idxs, ~[0, 2, 3]);
     }
 
-    #[test]
-    fn test_bitv_set_frombitv_init() {
-        let bools = [true, false];
-        let lengths = [10, 64, 100];
-        for &b in bools.iter() {
-            for &l in lengths.iter() {
-                let bitset = BitvSet::from_bitv(Bitv::new(l, b));
-                assert_eq!(bitset.contains(&1u), b)
-                assert_eq!(bitset.contains(&(l-1u)), b)
-                assert!(!bitset.contains(&l))
-            }
-        }
-    }
-
     #[test]
     fn test_small_difference() {
         let mut b1 = Bitv::new(3, false);