---

yaml
---
r: 148407
b: refs/heads/try2
c: d37e2f7
h: refs/heads/master
i:
  148405: da340de
  148403: 8ead92f
  148399: bba374c
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 7d79cc73fb4c0fcbdf8bb47a3c96ae9dadbd1895
+refs/heads/try2: d37e2f79cc049331a6fbde3ae5cc75a8e08ecb08
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/guide-tasks.md

@@ -290,7 +290,7 @@ be distributed on the available cores.
 fn partial_sum(start: uint) -> f64 {
     let mut local_sum = 0f64;
     for num in range(start*100000, (start+1)*100000) {
-        local_sum += (num as f64 + 1.0).powf(&-2.0);
+        local_sum += (num as f64 + 1.0).pow(&-2.0);
     }
     local_sum
 }
@@ -326,7 +326,7 @@ a single large vector of floats. Each task needs the full vector to perform its
 use extra::arc::Arc;
 
 fn pnorm(nums: &~[f64], p: uint) -> f64 {
-    nums.iter().fold(0.0, |a,b| a+(*b).powf(&(p as f64)) ).powf(&(1.0 / (p as f64)))
+    nums.iter().fold(0.0, |a,b| a+(*b).pow(&(p as f64)) ).pow(&(1.0 / (p as f64)))
 }
 
 fn main() {

branches/try2/doc/guide-testing.md

@@ -63,8 +63,8 @@ mod tests {
 }
 ~~~
 
-Additionally `#[test]` items behave as if they also have the
-`#[cfg(test)]` attribute, and will not be compiled when the --test flag
+Additionally #[test] items behave as if they also have the
+#[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'

branches/try2/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

branches/try2/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.

branches/try2/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

branches/try2/mk/tests.mk

@@ -626,10 +626,9 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) :=						\
         --aux-base $$(S)src/test/auxiliary/                 \
         --stage-id stage$(1)-$(2)							\
         --target $(2)                                       \
-        --host $(3)                                       \
         --adb-path=$(CFG_ADB)                          \
         --adb-test-dir=$(CFG_ADB_TEST_DIR)                  \
-        --rustcflags "$(RUSTC_FLAGS_$(2)) $$(CTEST_RUSTC_FLAGS)" \
+        --rustcflags "$(RUSTC_FLAGS_$(2)) $$(CTEST_RUSTC_FLAGS) --target=$(2)" \
         $$(CTEST_TESTARGS)
 
 CTEST_DEPS_rpass_$(1)-T-$(2)-H-$(3) = $$(RPASS_TESTS)

branches/try2/src/compiletest/common.rs

@@ -86,9 +86,6 @@ pub struct config {
     // Target system to be tested
     target: ~str,
 
-    // Host triple for the compiler being invoked
-    host: ~str,
-
     // Extra parameter to run adb on arm-linux-androideabi
     adb_path: ~str,
 

branches/try2/src/compiletest/compiletest.rs

@@ -73,7 +73,6 @@ pub fn parse_config(args: ~[~str]) -> config {
                  "percent change in metrics to consider noise", "N"),
           optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
-          optopt("", "host", "the host to build for", "HOST"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
           optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B"),
@@ -135,7 +134,6 @@ pub fn parse_config(args: ~[~str]) -> config {
         rustcflags: matches.opt_str("rustcflags"),
         jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")).to_str(),
-        host: opt_str2(matches.opt_str("host")).to_str(),
         adb_path: opt_str2(matches.opt_str("adb-path")).to_str(),
         adb_test_dir:
             opt_str2(matches.opt_str("adb-test-dir")).to_str(),
@@ -169,7 +167,6 @@ pub fn log_config(config: &config) {
     logv(c, format!("rustcflags: {}", opt_str(&config.rustcflags)));
     logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
-    logv(c, format!("host: {}", config.host));
     logv(c, format!("adb_path: {}", config.adb_path));
     logv(c, format!("adb_test_dir: {}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}", config.adb_device_status));

branches/try2/src/compiletest/header.rs

@@ -28,8 +28,6 @@ pub struct TestProps {
     debugger_cmds: ~[~str],
     // Lines to check if they appear in the expected debugger output
     check_lines: ~[~str],
-    // Flag to force a crate to be built with the host architecture
-    force_host: bool,
 }
 
 // Load any test directives embedded in the file
@@ -41,7 +39,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut pp_exact = None;
     let mut debugger_cmds = ~[];
     let mut check_lines = ~[];
-    let mut force_host = false;
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -56,10 +53,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             pp_exact = parse_pp_exact(ln, testfile);
         }
 
-        if !force_host {
-            force_host = parse_force_host(ln);
-        }
-
         match parse_aux_build(ln) {
             Some(ab) => { aux_builds.push(ab); }
             None => {}
@@ -89,8 +82,7 @@ pub fn load_props(testfile: &Path) -> TestProps {
         aux_builds: aux_builds,
         exec_env: exec_env,
         debugger_cmds: debugger_cmds,
-        check_lines: check_lines,
-        force_host: force_host,
+        check_lines: check_lines
     };
 }
 
@@ -149,10 +141,6 @@ fn parse_check_line(line: &str) -> Option<~str> {
     parse_name_value_directive(line, ~"check")
 }
 
-fn parse_force_host(line: &str) -> bool {
-    parse_name_directive(line, "force-host")
-}
-
 fn parse_exec_env(line: &str) -> Option<(~str, ~str)> {
     parse_name_value_directive(line, ~"exec-env").map(|nv| {
         // nv is either FOO or FOO=BAR

branches/try2/src/compiletest/runtest.rs

@@ -691,9 +691,8 @@ fn compose_and_run_compiler(
 
     for rel_ab in props.aux_builds.iter() {
         let abs_ab = config.aux_base.join(rel_ab.as_slice());
-        let aux_props = load_props(&abs_ab);
         let aux_args =
-            make_compile_args(config, &aux_props, ~[~"--lib"] + extra_link_args,
+            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, None);
@@ -739,16 +738,10 @@ fn make_compile_args(config: &config,
                      testfile: &Path)
                      -> ProcArgs {
     let xform_file = xform(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 = ~[testfile.as_str().unwrap().to_owned(),
                      ~"-o", xform_file.as_str().unwrap().to_owned(),
-                     ~"-L", config.build_base.as_str().unwrap().to_owned(),
-                     ~"--target=" + target]
+                     ~"-L", config.build_base.as_str().unwrap().to_owned()]
         + extras;
     args.push_all_move(split_maybe_args(&config.rustcflags));
     args.push_all_move(split_maybe_args(&props.compile_flags));