---

yaml
---
r: 98254
b: refs/heads/master
c: a0ecb15
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 99cde8482efaed4757422d24cd46de8fa64c92cb
+refs/heads/master: a0ecb154110d397aa241ee95da89b3a35ff6e503
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b6400f998497c3958f40997a71756ead344a776d
 refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36

trunk/doc/rust.md

@@ -2211,12 +2211,9 @@ 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),
-[binary move](#binary-move-expressions) or
+The left operand of an [assignment](#assignment-expressions) or
 [compound-assignment](#compound-assignment-expressions) expression is an lvalue context,
-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.
+as is the single operand of a unary [borrow](#unary-operator-expressions).
 All other expression contexts are rvalue contexts.
 
 When an lvalue is evaluated in an _lvalue context_, it denotes a memory location;
@@ -2229,9 +2226,8 @@ 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](#move-expressions) or copied,
-depending on its type.
-For types that contain [owning pointers](#owning-pointers)
+the variable will either be moved or copied, depending on its type.
+For types that contain [owning pointers](#pointer-types)
 or values that implement the special trait `Drop`,
 the variable is moved.
 All other types are copied.
@@ -2890,16 +2886,26 @@ 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.
-
-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
+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
 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.
 
-An example of an `match` expression:
+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:
 
 ~~~~
 # fn process_pair(a: int, b: int) { }
@@ -2929,19 +2935,31 @@ 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```.
-
-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`.
+
+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.
 
 Multiple match patterns may be joined with the `|` operator.
 A range of values may be specified with `..`.
@@ -3122,19 +3140,20 @@ 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](#struct-expressions).
+New instances of a `struct` can be constructed with a [struct expression](#structure-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](#visibility-modifiers),
+The fields of a `struct` may be qualified by [visibility modifiers](#re-exporting-and-visibility),
 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-expression) is the only value that inhabits such a type.
+The one value constructed by the associated [structure expression](#structure-expressions)
+is the only value that inhabits such a type.
 
 ### Enumerated types
 
@@ -3805,7 +3824,7 @@ over the output format of a Rust crate.
 ### Logging system
 
 The runtime contains a system for directing [logging
-expressions](#log-expressions) to a logging console and/or internal logging
+expressions](#logging-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,10 +1020,15 @@ 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:
 
-      Cons cell        Cons cell        Cons cell
-    +-----------+    +-----+-----+    +-----+-----+
-    |  1  |  ~  | -> |  2  |  ~  | -> |  3  |  ~  | -> Nil
-    +-----------+    +-----+-----+    +-----+-----+
+              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.
 
 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 := --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
+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
 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/version_info.html doc/rust.css
+doc/rust.epub: rust.md
 	@$(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/version_info.html doc/rust.css
+doc/tutorial.epub: tutorial.md
 	@$(call E, pandoc: $@)
 	$(Q)$(CFG_NODE) $(S)doc/prep.js --highlight $< | \
 	$(CFG_PANDOC) $(EPUB_OPTS) --output=$@
@@ -265,6 +265,7 @@ endif # No pandoc / node
 ######################################################################
 # LLnextgen (grammar analysis from refman)
 ######################################################################
+
 ifeq ($(CFG_LLNEXTGEN),)
   $(info cfg: no llnextgen found, omitting grammar-verification)
 else

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:  2013 Dec 10
+" Last Change:  2014 Jan 4
 
 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
-syn region    rustString      start='r\z(#*\)"' end='"\z1'
+syn region    rustString      start=+"+ skip=+\\\\\|\\"+ end=+"+ contains=rustSpecial,rustSpecialError,rustStringContinuation,@Spell
+syn region    rustString      start='r\z(#*\)"' end='"\z1' contains=@Spell
 
 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
-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
+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
 " 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/bitv.rs

@@ -269,14 +269,23 @@ impl Bitv {
 
 impl Bitv {
     pub fn new(nbits: uint, init: bool) -> Bitv {
-        let rep = if nbits <= uint::bits {
+        let rep = if nbits < uint::bits {
+            Small(SmallBitv::new(if init {(1<<nbits)-1} else {0}))
+        } else if nbits == uint::bits {
             Small(SmallBitv::new(if init {!0} else {0}))
-        }
-        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);
+        } 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)};
             Big(BigBitv::new(s))
         };
         Bitv {rep: rep, nbits: nbits}
@@ -1329,6 +1338,20 @@ 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);

trunk/src/libextra/c_vec.rs

@@ -160,21 +160,19 @@ impl <T> Container for CVec<T> {
 
 #[cfg(test)]
 mod tests {
-
     use super::*;
 
     use std::libc::*;
     use std::libc;
     use std::ptr;
+    use std::rt::global_heap::malloc_raw;
 
     fn malloc(n: uint) -> CVec<u8> {
         unsafe {
-            let mem = libc::malloc(n as size_t);
-
-            assert!(mem as int != 0);
+            let mem = malloc_raw(n);
 
             CVec::new_with_dtor(mem as *mut u8, n,
-                proc() { libc::free(mem); })
+                proc() { libc::free(mem as *c_void); })
         }
     }