---

yaml
---
r: 225819
b: refs/heads/stable
c: 7f04b8f
h: refs/heads/master
i:
  225817: 542fb83
  225815: 7f138cb
v: v3

Author: tamird

[refs]

@@ -29,6 +29,6 @@ refs/heads/tmp: e5d90d98402475b6e154ce216f9efcb80da1a747
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: 1fe32ca12c51afcd761d9962f51a74ff0d07a591
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 5f3233f0924ccff5e94cddd7fa9355f4e9ad78f3
+refs/heads/stable: 7f04b8ff07ba0c27c2aef957d7aa3ed4404fc877
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b

branches/stable/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))

branches/stable/src/compiletest/common.rs

@@ -124,9 +124,6 @@ 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,
 

branches/stable/src/compiletest/compiletest.rs

@@ -79,7 +79,6 @@ 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"),
@@ -146,7 +145,6 @@ 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")),
@@ -186,7 +184,6 @@ 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: {:?}",

branches/stable/src/compiletest/runtest.rs

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

branches/stable/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!

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

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

branches/stable/src/librustc_unicode/char.rs

@@ -187,16 +187,22 @@ impl char {
     /// # Examples
     ///
     /// ```
-    /// for c in '❤'.escape_unicode() {
-    ///     print!("{}", c);
+    /// for i in '❤'.escape_unicode() {
+    ///     println!("{}", i);
     /// }
-    /// println!("");
     /// ```
     ///
     /// This prints:
     ///
     /// ```text
-    /// \u{2764}
+    /// \
+    /// u
+    /// {
+    /// 2
+    /// 7
+    /// 6
+    /// 4
+    /// }
     /// ```
     ///
     /// Collecting into a `String`:
@@ -461,12 +467,6 @@ impl char {
     /// Returns an iterator which yields the characters corresponding to the
     /// lowercase equivalent of the character. If no conversion is possible then
     /// an iterator with just the input character is returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(Some('c'), 'C'.to_lowercase().next());
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn to_lowercase(self) -> ToLowercase {
@@ -515,12 +515,6 @@ impl char {
     /// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
     ///
     /// [2]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(Some('C'), 'c'.to_uppercase().next());
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
     pub fn to_uppercase(self) -> ToUppercase {

branches/stable/src/test/run-fail/extern-panic.rs

@@ -0,0 +1,52 @@
+// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// ignore-test linked failure
+// error-pattern:explicit failure
+// Testing that runtime failure doesn't cause callbacks to abort abnormally.
+// Instead the failure will be delivered after the callbacks return.
+#![feature(std_misc, libc)]
+
+extern crate libc;
+use std::task;
+
+mod rustrt {
+    extern crate libc;
+
+    extern {
+        pub fn rust_dbg_call(cb: *u8, data: libc::uintptr_t)
+                             -> libc::uintptr_t;
+    }
+}
+
+extern fn cb(data: libc::uintptr_t) -> libc::uintptr_t {
+    if data == 1 {
+        data
+    } else {
+        count(data - 1) + count(data - 1)
+    }
+}
+
+fn count(n: usize) -> usize {
+    unsafe {
+        task::deschedule();
+        rustrt::rust_dbg_call(cb, n)
+    }
+}
+
+fn main() {
+    for _ in 0..10 {
+        task::spawn(move|| {
+            let result = count(5);
+            println!("result = %?", result);
+            panic!();
+        });
+    }
+}

branches/stable/src/test/run-pass/html-literals.rs

@@ -10,6 +10,8 @@
 
 // A test of the macro system. Can we do HTML literals?
 
+// ignore-test FIXME #20673
+
 /*
 
 This is an HTML parser written as a macro. It's all CPS, and we have