---

yaml
---
r: 175673
b: refs/heads/auto
c: 48aa068
h: refs/heads/master
i:
  175671: 48d6e0f
v: v3

Author: richo

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: dc27d29297e704d89e1a7fadbeafd44552bb2b93
+refs/heads/auto: 48aa068286e2cbe38bb399c0f76c03546c4998c3
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/configure

@@ -509,6 +509,7 @@ opt optimize-tests 1 "build tests with optimizations"
 opt libcpp 1 "build with llvm with libc++ instead of libstdc++ when using clang"
 opt llvm-assertions 1 "build LLVM with assertions"
 opt debug 1 "build with extra debug fun"
+opt ratchet-bench 0 "ratchet benchmarks"
 opt fast-make 0 "use .gitmodules as timestamp for submodule deps"
 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"

branches/auto/mk/cfg/aarch64-linux-android.mk

@@ -141,8 +141,6 @@ else ifeq ($(OSTYPE_$(1)), apple-ios)
   JEMALLOC_ARGS_$(1) := --disable-tls
 else ifeq ($(OSTYPE_$(1)), linux-androideabi)
   JEMALLOC_ARGS_$(1) := --disable-tls
-else ifeq ($(OSTYPE_$(1)), linux-android)
-  JEMALLOC_ARGS_$(1) := --disable-tls
 endif
 
 ################################################################################

branches/auto/mk/rt.mk

@@ -300,7 +300,6 @@ tidy:
 		| grep '^$(S)src/libbacktrace' -v \
 		| grep '^$(S)src/rust-installer' -v \
 		| xargs $(CFG_PYTHON) $(S)src/etc/check-binaries.py
-		$(Q) $(CFG_PYTHON) $(S)src/etc/errorck.py $(S)src/
 
 
 endif

branches/auto/mk/tests.mk

@@ -13,7 +13,7 @@ use std::fmt;
 use std::str::FromStr;
 use regex::Regex;
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, PartialEq)]
 pub enum Mode {
     CompileFail,
     RunFail,
@@ -43,9 +43,9 @@ impl FromStr for Mode {
     }
 }
 
-impl fmt::Display for Mode {
+impl fmt::String for Mode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(match *self {
+        fmt::String::fmt(match *self {
             CompileFail => "compile-fail",
             RunFail => "run-fail",
             RunPass => "run-pass",
@@ -58,6 +58,12 @@ impl fmt::Display for Mode {
     }
 }
 
+impl fmt::Show for Mode {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::String::fmt(self, f)
+    }
+}
+
 #[derive(Clone)]
 pub struct Config {
     // The library paths required for running the compiler
@@ -109,6 +115,20 @@ pub struct Config {
     // Write out a parseable log of tests that were run
     pub logfile: Option<Path>,
 
+    // Write out a json file containing any metrics of the run
+    pub save_metrics: Option<Path>,
+
+    // Write and ratchet a metrics file
+    pub ratchet_metrics: Option<Path>,
+
+    // Percent change in metrics to consider noise
+    pub ratchet_noise_percent: Option<f64>,
+
+    // "Shard" of the testsuite to pub run: this has the form of
+    // two numbers (a,b), and causes only those tests with
+    // positional order equal to a mod b to run.
+    pub test_shard: Option<(uint,uint)>,
+
     // A command line to prefix program execution with,
     // for running under valgrind
     pub runtool: Option<String>,

branches/auto/src/compiletest/common.rs

@@ -77,6 +77,10 @@ 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"),
+          optopt("", "save-metrics", "file to save metrics to", "FILE"),
+          optopt("", "ratchet-metrics", "file to ratchet metrics against", "FILE"),
+          optopt("", "ratchet-noise-percent",
+                 "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"),
@@ -86,6 +90,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
           optopt("", "lldb-python-dir", "directory containing LLDB's python module", "PATH"),
+          optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B"),
           optflag("h", "help", "show this message"));
 
     assert!(!args.is_empty());
@@ -147,6 +152,12 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         filter: filter,
         cfail_regex: Regex::new(errors::EXPECTED_PATTERN).unwrap(),
         logfile: matches.opt_str("logfile").map(|s| Path::new(s)),
+        save_metrics: matches.opt_str("save-metrics").map(|s| Path::new(s)),
+        ratchet_metrics:
+            matches.opt_str("ratchet-metrics").map(|s| Path::new(s)),
+        ratchet_noise_percent:
+            matches.opt_str("ratchet-noise-percent")
+                   .and_then(|s| s.as_slice().parse::<f64>()),
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),
@@ -165,6 +176,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
                 opt_str2(matches.opt_str("adb-test-dir")).as_slice() &&
             !opt_str2(matches.opt_str("adb-test-dir")).is_empty(),
         lldb_python_dir: matches.opt_str("lldb-python-dir"),
+        test_shard: test::opt_shard(matches.opt_str("test-shard")),
         verbose: matches.opt_present("verbose"),
     }
 }
@@ -198,6 +210,10 @@ pub fn log_config(config: &Config) {
     logv(c, format!("adb_test_dir: {:?}", config.adb_test_dir));
     logv(c, format!("adb_device_status: {}",
                     config.adb_device_status));
+    match config.test_shard {
+        None => logv(c, "test_shard: (all)".to_string()),
+        Some((a,b)) => logv(c, format!("test_shard: {}.{}", a, b))
+    }
     logv(c, format!("verbose: {}", config.verbose));
     logv(c, format!("\n"));
 }
@@ -248,9 +264,6 @@ pub fn run_tests(config: &Config) {
     // parallel (especially when we have lots and lots of child processes).
     // For context, see #8904
     io::test::raise_fd_limit();
-    // Prevent issue #21352 UAC blocking .exe containing 'patch' etc. on Windows
-    // If #11207 is resolved (adding manifest to .exe) this becomes unnecessary
-    os::setenv("__COMPAT_LAYER", "RunAsInvoker");
     let res = test::run_tests_console(&opts, tests.into_iter().collect());
     match res {
         Ok(true) => {}
@@ -271,8 +284,15 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         logfile: config.logfile.clone(),
         run_tests: true,
         run_benchmarks: true,
+        ratchet_metrics: config.ratchet_metrics.clone(),
+        ratchet_noise_percent: config.ratchet_noise_percent.clone(),
+        save_metrics: config.save_metrics.clone(),
+        test_shard: config.test_shard.clone(),
         nocapture: false,
         color: test::AutoColor,
+        show_boxplot: false,
+        boxplot_width: 50,
+        show_all_stats: false,
     }
 }
 

branches/auto/src/compiletest/compiletest.rs

@@ -332,7 +332,8 @@ pub fn parse_name_value_directive(line: &str, directive: &str)
     let keycolon = format!("{}:", directive);
     match line.find_str(keycolon.as_slice()) {
         Some(colon) => {
-            let value = line[(colon + keycolon.len()) .. line.len()].to_string();
+            let value = line.slice(colon + keycolon.len(),
+                                   line.len()).to_string();
             debug!("{}: {}", directive, value);
             Some(value)
         }

branches/auto/src/compiletest/header.rs

@@ -294,7 +294,6 @@ fn run_pretty_test(config: &Config, props: &TestProps, testfile: &Path) {
         let aux_dir = aux_output_dir_name(config, testfile);
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = vec!("-".to_string(),
-                            "-Zunstable-options".to_string(),
                             "--pretty".to_string(),
                             pretty_type,
                             format!("--target={}", config.target),
@@ -341,7 +340,7 @@ actual:\n\
         };
         // FIXME (#9639): This needs to handle non-utf8 paths
         let mut args = vec!("-".to_string(),
-                            "-Zno-trans".to_string(),
+                            "--no-trans".to_string(),
                             "--crate-type=lib".to_string(),
                             format!("--target={}", target),
                             "-L".to_string(),
@@ -548,7 +547,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 
             // Add line breakpoints
             for line in breakpoint_lines.iter() {
-                script_str.push_str(&format!("break '{}':{}\n",
+                script_str.push_str(&format!("break '{:?}':{}\n",
                                              testfile.filename_display(),
                                              *line)[]);
             }
@@ -751,7 +750,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
             status: status,
             stdout: out,
             stderr: err,
-            cmdline: format!("{:?}", cmd)
+            cmdline: format!("{}", cmd)
         };
     }
 }
@@ -863,7 +862,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                         break;
                     }
                     Some(i) => {
-                        rest = &rest[(i + frag.len())..];
+                        rest = rest.slice_from(i + frag.len());
                     }
                 }
                 first = false;
@@ -954,7 +953,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
     }
 
     let prefixes = expected_errors.iter().map(|ee| {
-        format!("{}:{}:", testfile.display(), ee.line)
+        format!("{:?}:{}:", testfile.display(), ee.line)
     }).collect::<Vec<String> >();
 
     #[cfg(windows)]
@@ -1046,7 +1045,7 @@ fn scan_until_char(haystack: &str, needle: char, idx: &mut uint) -> bool {
     if *idx >= haystack.len() {
         return false;
     }
-    let opt = haystack[(*idx)..].find(needle);
+    let opt = haystack.slice_from(*idx).find(needle);
     if opt.is_none() {
         return false;
     }

branches/auto/src/compiletest/runtest.rs

@@ -480,12 +480,14 @@ use std::sync::{Arc,Mutex};
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1is, 2, 3]));
 
-    for i in 0us..3 {
+    for i in 0..3 {
         let number = numbers.clone();
         Thread::spawn(move || {
             let mut array = number.lock().unwrap();
-            array[i] += 1;
-            println!("numbers[{}] is {}", i, array[i]);
+
+            (*array)[i] += 1;
+
+            println!("numbers[{}] is {}", i, (*array)[i]);
         });
     }
 }

branches/auto/src/doc/intro.md

@@ -739,15 +739,6 @@ Rust syntax is restricted in two ways:
 * `concat!` : concatenates a comma-separated list of literals
 * `concat_idents!` : create a new identifier by concatenating the arguments
 
-The following attributes are used for quasiquoting in procedural macros:
-
-* `quote_expr!`
-* `quote_item!`
-* `quote_pat!`
-* `quote_stmt!`
-* `quote_tokens!`
-* `quote_ty!`
-
 # Crates and source files
 
 Rust is a *compiled* language. Its semantics obey a *phase distinction*
@@ -812,9 +803,8 @@ Crates contain [items](#items), each of which may have some number of
 ## Items
 
 ```{.ebnf .gram}
-item : extern_crate_decl | use_decl | mod_item | fn_item | type_item
-     | struct_item | enum_item | static_item | trait_item | impl_item
-     | extern_block ;
+item : mod_item | fn_item | type_item | struct_item | enum_item
+     | static_item | trait_item | impl_item | extern_block ;
 ```
 
 An _item_ is a component of a crate; some module items can be defined in crate
@@ -828,8 +818,6 @@ execution, and may reside in read-only memory.
 
 There are several kinds of item:
 
-* [`extern crate` declarations](#extern-crate-declarations)
-* [`use` declarations](#use-declarations)
 * [modules](#modules)
 * [functions](#functions)
 * [type definitions](#type-definitions)
@@ -866,10 +854,13 @@ no notion of type abstraction: there are no first-class "forall" types.
 
 ```{.ebnf .gram}
 mod_item : "mod" ident ( ';' | '{' mod '}' );
-mod : item * ;
+mod : [ view_item | item ] * ;
 ```
 
-A module is a container for zero or more [items](#items).
+A module is a container for zero or more [view items](#view-items) and zero or
+more [items](#items). The view items manage the visibility of the items defined
+within the module, as well as the visibility of names from outside the module
+when referenced from inside the module.
 
 A _module item_ is a module, surrounded in braces, named, and prefixed with the
 keyword `mod`. A module item introduces a new, named module into the tree of
@@ -927,6 +918,19 @@ mod thread {
 }
 ```
 
+#### View items
+
+```{.ebnf .gram}
+view_item : extern_crate_decl | use_decl ;
+```
+
+A view item manages the namespace of a module. View items do not define new
+items, but rather, simply change other items' visibility. There are two
+kinds of view items:
+
+* [`extern crate` declarations](#extern-crate-declarations)
+* [`use` declarations](#use-declarations)
+
 ##### Extern crate declarations
 
 ```{.ebnf .gram}
@@ -2037,9 +2041,6 @@ type int8_t = i8;
   item](#language-items) for more details.
 - `test` - indicates that this function is a test function, to only be compiled
   in case of `--test`.
-- `should_fail` - indicates that this test function should panic, inverting the success condition.
-- `cold` - The function is unlikely to be executed, so optimize it (and calls
-  to it) differently.
 
 ### Static-only attributes
 
@@ -2376,6 +2377,10 @@ These types help drive the compiler's analysis
   : ___Needs filling in___
 * `no_copy_bound`
   : This type does not implement "copy", even if eligible.
+* `no_send_bound`
+  : This type does not implement "send", even if eligible.
+* `no_sync_bound`
+  : This type does not implement "sync", even if eligible.
 * `eh_personality`
   : ___Needs filling in___
 * `exchange_free`
@@ -2886,12 +2891,13 @@ Point3d {y: 0, z: 10, .. base};
 ### Block expressions
 
 ```{.ebnf .gram}
-block_expr : '{' [ stmt ';' | item ] *
+block_expr : '{' [ view_item ] *
+                 [ stmt ';' | item ] *
                  [ expr ] '}' ;
 ```
 
 A _block expression_ is similar to a module in terms of the declarations that
-are possible. Each block conceptually introduces a new namespace scope. Use
+are possible. Each block conceptually introduces a new namespace scope. View
 items can bring new names into scopes and declared items are in scope for only
 the block itself.