---

yaml
---
r: 212923
b: refs/heads/master
c: 7721d46
h: refs/heads/master
i:
  212921: 3281ee9
  212919: cd5f062
v: v3

Author: Marwes

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 467e4a6681f8ac3b29fa28406ece66418e1b703d
+refs/heads/master: 7721d46bd76967e73a04b7944651094d3d2f9274
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: ba0e1cd8147d452c356aacb29fb87568ca26f111
 refs/heads/try: 1864973ae17213c5a58c4dd3f9af6d1b6c7d2e05

trunk/configure

@@ -521,7 +521,6 @@ fi
 DEFAULT_BUILD="${CFG_CPUTYPE}-${CFG_OSTYPE}"
 
 CFG_SRC_DIR="$(abs_path $(dirname $0))/"
-CFG_SRC_DIR_RELATIVE="$(dirname $0)/"
 CFG_BUILD_DIR="$(pwd)/"
 CFG_SELF="$0"
 CFG_CONFIGURE_ARGS="$@"
@@ -1559,7 +1558,6 @@ done
 step_msg "writing configuration"
 
 putvar CFG_SRC_DIR
-putvar CFG_SRC_DIR_RELATIVE
 putvar CFG_BUILD_DIR
 putvar CFG_OSTYPE
 putvar CFG_CPUTYPE

trunk/mk/cfg/x86_64-unknown-linux-musl.mk

@@ -3,7 +3,6 @@ CC_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc
 CXX_x86_64-unknown-linux-musl=notaprogram
 CPP_x86_64-unknown-linux-musl=$(CFG_MUSL_ROOT)/bin/musl-gcc -E
 AR_x86_64-unknown-linux-musl=$(AR)
-CFG_INSTALL_ONLY_RLIB_x86_64-unknown-linux-musl = 1
 CFG_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-linux-musl=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-linux-musl=lib$(1)-*.so

trunk/mk/crates.mk

@@ -134,7 +134,7 @@ DOC_CRATES := std alloc collections core libc rustc_unicode
 #
 # $(1) is the crate to generate variables for
 define RUST_CRATE
-CRATEFILE_$(1) := $$(SREL)src/lib$(1)/lib.rs
+CRATEFILE_$(1) := $$(S)src/lib$(1)/lib.rs
 RSINPUTS_$(1) := $$(call rwildcard,$(S)src/lib$(1)/,*.rs)
 RUST_DEPS_$(1) := $$(filter-out native:%,$$(DEPS_$(1)))
 NATIVE_DEPS_$(1) := $$(patsubst native:%,%,$$(filter native:%,$$(DEPS_$(1))))

trunk/mk/main.mk

@@ -322,7 +322,6 @@ $(foreach host,$(CFG_HOST), \
 # exported
 
 export CFG_SRC_DIR
-export CFG_SRC_DIR_RELATIVE
 export CFG_BUILD_DIR
 ifdef CFG_VER_DATE
 export CFG_VER_DATE

trunk/mk/prepare.mk

@@ -29,34 +29,30 @@ DEFAULT_PREPARE_MAN_CMD = install -m644
 
 # Create a directory
 # $(1) is the directory
-#
-# XXX: These defines are called to generate make steps.
-# Adding blank lines means two steps from different defines will not end up on
-# the same line.
 define PREPARE_DIR
-
-	@$(call E, prepare: $(1))
+	@$(Q)$(call E, prepare: $(1))
 	$(Q)$(PREPARE_DIR_CMD) $(1)
-
 endef
 
 # Copy an executable
 # $(1) is the filename/libname-glob
 #
-# See above for an explanation on the surrounding blank lines
+# Gee, what's up with that $(nop)? See comment below.
 define PREPARE_BIN
-
+	$(nop)
 	@$(call E, prepare: $(PREPARE_DEST_BIN_DIR)/$(1))
 	$(Q)$(PREPARE_BIN_CMD) $(PREPARE_SOURCE_BIN_DIR)/$(1) $(PREPARE_DEST_BIN_DIR)/$(1)
-
 endef
 
 # Copy a dylib or rlib
 # $(1) is the filename/libname-glob
 #
-# See above for an explanation on the surrounding blank lines
+# XXX: Don't remove the $(nop) command below!
+# Yeah, that's right, it's voodoo. Something in the way this macro is being expanded
+# causes it to parse incorrectly. Throwing in that empty command seems to fix the
+# problem. I'm sorry, just don't remove the $(nop), alright?
 define PREPARE_LIB
-
+	$(nop)
 	@$(call E, prepare: $(PREPARE_WORKING_DEST_LIB_DIR)/$(1))
 	$(Q)LIB_NAME="$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1))))"; \
 	MATCHES="$(filter-out %$(notdir $(lastword $(wildcard $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)))), \
@@ -68,18 +64,13 @@ define PREPARE_LIB
 	  echo $$MATCHES ; \
 	fi
 	$(Q)$(PREPARE_LIB_CMD) `ls -drt1 $(PREPARE_WORKING_SOURCE_LIB_DIR)/$(1)` $(PREPARE_WORKING_DEST_LIB_DIR)/
-
 endef
 
 # Copy a man page
 # $(1) - source dir
-#
-# See above for an explanation on the surrounding blank lines
 define PREPARE_MAN
-
 	@$(call E, prepare: $(PREPARE_DEST_MAN_DIR)/$(1))
 	$(Q)$(PREPARE_MAN_CMD) $(PREPARE_SOURCE_MAN_DIR)/$(1) $(PREPARE_DEST_MAN_DIR)/$(1)
-
 endef
 
 PREPARE_TOOLS = $(filter-out compiletest rustbook error-index-generator, $(TOOLS))

trunk/mk/reconfig.mk

@@ -34,4 +34,4 @@ Makefile config.mk: config.stamp
 
 config.stamp: $(S)configure $(S)Makefile.in $(S)src/snapshots.txt
 	@$(call E, cfg: reconfiguring)
-	$(SREL)configure $(CFG_CONFIGURE_ARGS)
+	$(S)configure $(CFG_CONFIGURE_ARGS)

trunk/mk/util.mk

@@ -20,4 +20,3 @@ print-%:
 	@echo $*=$($*)
 
 S := $(CFG_SRC_DIR)
-SREL := $(CFG_SRC_DIR_RELATIVE)

trunk/src/compiletest/common.rs

@@ -124,6 +124,9 @@ pub struct Config {
     // Flags to pass to the compiler when building for the target
     pub target_rustcflags: Option<String>,
 
+    // Run tests using the JIT
+    pub jit: bool,
+
     // Target system to be tested
     pub target: String,
 

trunk/src/compiletest/compiletest.rs

@@ -79,6 +79,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optopt("", "target-rustcflags", "flags to pass to rustc for target", "FLAGS"),
           optflag("", "verbose", "run tests verbosely, showing all output"),
           optopt("", "logfile", "file to log test execution to", "FILE"),
+          optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
           optopt("", "gdb-version", "the version of GDB used", "VERSION STRING"),
@@ -145,6 +146,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),
+        jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")),
         host: opt_str2(matches.opt_str("host")),
         gdb_version: extract_gdb_version(matches.opt_str("gdb-version")),
@@ -184,6 +186,7 @@ pub fn log_config(config: &Config) {
                     opt_str(&config.host_rustcflags)));
     logv(c, format!("target-rustcflags: {}",
                     opt_str(&config.target_rustcflags)));
+    logv(c, format!("jit: {}", config.jit));
     logv(c, format!("target: {}", config.target));
     logv(c, format!("host: {}", config.host));
     logv(c, format!("android-cross-path: {:?}",

trunk/src/compiletest/runtest.rs

@@ -98,13 +98,17 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
 }
 
 fn run_rfail_test(config: &Config, props: &TestProps, testfile: &Path) {
-    let proc_res = compile_test(config, props, testfile);
+    let proc_res = if !config.jit {
+        let proc_res = compile_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!", &proc_res);
-    }
+        if !proc_res.status.success() {
+            fatal_proc_rec("compilation failed!", &proc_res);
+        }
 
-    let proc_res = exec_compiled_test(config, props, testfile);
+        exec_compiled_test(config, props, testfile)
+    } else {
+        jit_test(config, props, testfile)
+    };
 
     // The value our Makefile configures valgrind to return on failure
     const VALGRIND_ERR: i32 = 100;
@@ -129,16 +133,24 @@ fn check_correct_failure_status(proc_res: &ProcRes) {
 }
 
 fn run_rpass_test(config: &Config, props: &TestProps, testfile: &Path) {
-    let proc_res = compile_test(config, props, testfile);
+    if !config.jit {
+        let mut proc_res = compile_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("compilation failed!", &proc_res);
-    }
+        if !proc_res.status.success() {
+            fatal_proc_rec("compilation failed!", &proc_res);
+        }
 
-    let proc_res = exec_compiled_test(config, props, testfile);
+        proc_res = exec_compiled_test(config, props, testfile);
 
-    if !proc_res.status.success() {
-        fatal_proc_rec("test run failed!", &proc_res);
+        if !proc_res.status.success() {
+            fatal_proc_rec("test run failed!", &proc_res);
+        }
+    } else {
+        let proc_res = jit_test(config, props, testfile);
+
+        if !proc_res.status.success() {
+            fatal_proc_rec("jit failed!", &proc_res);
+        }
     }
 }
 
@@ -1129,6 +1141,10 @@ fn compile_test(config: &Config, props: &TestProps,
     compile_test_(config, props, testfile, &[])
 }
 
+fn jit_test(config: &Config, props: &TestProps, testfile: &Path) -> ProcRes {
+    compile_test_(config, props, testfile, &["--jit".to_string()])
+}
+
 fn compile_test_(config: &Config, props: &TestProps,
                  testfile: &Path, extra_args: &[String]) -> ProcRes {
     let aux_dir = aux_output_dir_name(config, testfile);

trunk/src/doc/reference.md

@@ -638,7 +638,7 @@ apply to the crate as a whole.
 ```
 
 A crate that contains a `main` function can be compiled to an executable. If a
-`main` function is present, its return type must be [`unit`](#tuple-types)
+`main` function is present, its return type must be [`unit`](#primitive-types)
 and it must take no arguments.
 
 # Items and attributes
@@ -928,20 +928,21 @@ A _generic function_ allows one or more _parameterized types_ to appear in its
 signature. Each type parameter must be explicitly declared, in an
 angle-bracket-enclosed, comma-separated list following the function name.
 
-```rust,ignore
-// foo is generic over A and B
-
-fn foo<A, B>(x: A, y: B) {
+```{.ignore}
+fn iter<T, F>(seq: &[T], f: F) where T: Copy, F: Fn(T) {
+    for elt in seq { f(*elt); }
+}
+fn map<T, U, F>(seq: &[T], f: F) -> Vec<U> where T: Copy, U: Copy, F: Fn(T) -> U {
+    let mut acc = vec![];
+    for elt in seq { acc.push(f(*elt)); }
+    acc
+}
 ```
 
 Inside the function signature and body, the name of the type parameter can be
 used as a type name. [Trait](#traits) bounds can be specified for type parameters
 to allow methods with that trait to be called on values of that type. This is
-specified using the `where` syntax:
-
-```rust,ignore
-fn foo<T>(x: T) where T: Debug {
-```
+specified using the `where` syntax, as in the above example.
 
 When a generic function is referenced, its type is instantiated based on the
 context of the reference. For example, calling the `iter` function defined
@@ -2873,7 +2874,7 @@ The `+`, `-`, `*`, `/`, `%`, `&`, `|`, `^`, `<<`, and `>>` operators may be
 composed with the `=` operator. The expression `lval OP= val` is equivalent to
 `lval = lval OP val`. For example, `x = x + 1` may be written as `x += 1`.
 
-Any such expression always has the [`unit`](#tuple-types) type.
+Any such expression always has the [`unit`](#primitive-types) type.
 
 #### Operator precedence
 
@@ -3315,9 +3316,6 @@ assert!(b != "world");
 assert!(p.0 == 10);
 ```
 
-For historical reasons and convenience, the tuple type with no elements (`()`)
-is often called ‘unit’ or ‘the unit type’.
-
 ### Array, and Slice types
 
 Rust has two different types for a list of items:

trunk/src/doc/trpl/associated-types.md

@@ -43,7 +43,7 @@ trait Graph {
 Now, our clients can be abstract over a given `Graph`:
 
 ```rust,ignore
-fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> u32 { ... }
+fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> usize { ... }
 ```
 
 No need to deal with the `E`dge type here!

trunk/src/doc/trpl/closures.md

@@ -120,7 +120,7 @@ let y = &mut num;
 ```
 
 If your closure requires it, however, Rust will take ownership and move
-the environment instead. This doesn’t work:
+the environment instead:
 
 ```rust,ignore
 let nums = vec![1, 2, 3];
@@ -130,7 +130,7 @@ let takes_nums = || nums;
 println!("{:?}", nums);
 ```
 
-We get this error:
+This gives us:
 
 ```text
 note: `nums` moved into closure environment here because it has type

trunk/src/doc/trpl/iterators.md

@@ -285,7 +285,8 @@ has no side effect on the original iterator. Let's try it out with our infinite
 iterator from before:
 
 ```rust
-for i in (1..).take(5) {
+# #![feature(step_by)]
+for i in (1..).step_by(5).take(5) {
     println!("{}", i);
 }
 ```
@@ -294,10 +295,10 @@ This will print
 
 ```text
 1
-2
-3
-4
-5
+6
+11
+16
+21
 ```
 
 `filter()` is an adapter that takes a closure as an argument. This closure

trunk/src/doc/trpl/lifetimes.md

@@ -305,7 +305,7 @@ fn substr<'a>(s: &'a str, until: u32) -> &'a str; // expanded
 fn get_str() -> &str; // ILLEGAL, no inputs
 
 fn frob(s: &str, t: &str) -> &str; // ILLEGAL, two inputs
-fn frob<'a, 'b>(s: &'a str, t: &'b str) -> &str; // Expanded: Output lifetime is ambiguous
+fn frob<'a, 'b>(s: &'a str, t: &'b str) -> &str; // Expanded: Output lifetime is unclear
 
 fn get_mut(&mut self) -> &mut T; // elided
 fn get_mut<'a>(&'a mut self) -> &'a mut T; // expanded