---

yaml
---
r: 144569
b: refs/heads/try2
c: 20def31
h: refs/heads/master
i:
  144567: 586790b
v: v3

Author: MicahChalmer

[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: f9142536a6e500c4f0fa70c433ef8026757bb9f0
+refs/heads/try2: 20def317685b39a35416397b35940a4d040bf72f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/tests.mk

@@ -870,8 +870,7 @@ $(foreach host,$(CFG_HOST_TRIPLES), \
  $(eval $(foreach target,$(CFG_TARGET_TRIPLES), \
    $(eval $(call DEF_CHECK_FAST_FOR_T_H,,$(target),$(host))))))
 
-check-fast: tidy check-fast-H-$(CFG_BUILD_TRIPLE) check-stage2-std check-stage2-extra
-	$(Q)$(CFG_PYTHON) $(S)src/etc/check-summary.py tmp/*.log
+check-fast: tidy check-fast-H-$(CFG_BUILD_TRIPLE)
 
 define DEF_CHECK_FAST_FOR_H
 

branches/try2/src/compiletest/common.rs

@@ -83,6 +83,9 @@ pub struct config {
     // Run tests using the JIT
     jit: bool,
 
+    // Run tests using the new runtime
+    newrt: bool,
+
     // Target system to be tested
     target: ~str,
 

branches/try2/src/compiletest/compiletest.rs

@@ -71,6 +71,7 @@ pub fn parse_config(args: ~[~str]) -> config {
           optopt("", "ratchet-noise-percent",
                  "percent change in metrics to consider noise", "N"),
           optflag("", "jit", "run tests under the JIT"),
+          optflag("", "newrt", "run tests on the new runtime / scheduler"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
@@ -136,6 +137,7 @@ pub fn parse_config(args: ~[~str]) -> config {
         runtool: getopts::opt_maybe_str(matches, "runtool"),
         rustcflags: getopts::opt_maybe_str(matches, "rustcflags"),
         jit: getopts::opt_present(matches, "jit"),
+        newrt: getopts::opt_present(matches, "newrt"),
         target: opt_str2(getopts::opt_maybe_str(matches, "target")).to_str(),
         adb_path: opt_str2(getopts::opt_maybe_str(matches, "adb-path")).to_str(),
         adb_test_dir:
@@ -169,6 +171,7 @@ pub fn log_config(config: &config) {
     logv(c, fmt!("runtool: %s", opt_str(&config.runtool)));
     logv(c, fmt!("rustcflags: %s", opt_str(&config.rustcflags)));
     logv(c, fmt!("jit: %b", config.jit));
+    logv(c, fmt!("newrt: %b", config.newrt));
     logv(c, fmt!("target: %s", config.target));
     logv(c, fmt!("adb_path: %s", config.adb_path));
     logv(c, fmt!("adb_test_dir: %s", config.adb_test_dir));

branches/try2/src/compiletest/runtest.rs

@@ -547,13 +547,15 @@ fn compile_test_(config: &config, props: &TestProps,
 fn exec_compiled_test(config: &config, props: &TestProps,
                       testfile: &Path) -> ProcRes {
 
+    // If testing the new runtime then set the RUST_NEWRT env var
     let env = props.exec_env.clone();
+    let env = if config.newrt { env + &[(~"RUST_NEWRT", ~"1")] } else { env };
 
     match config.target {
 
         ~"arm-linux-androideabi" => {
             if (config.adb_device_status) {
-                _arm_exec_compiled_test(config, props, testfile, env)
+                _arm_exec_compiled_test(config, props, testfile)
             } else {
                 _dummy_exec_compiled_test(config, props, testfile)
             }
@@ -779,7 +781,7 @@ stderr:\n\
 }
 
 fn _arm_exec_compiled_test(config: &config, props: &TestProps,
-                      testfile: &Path, env: ~[(~str, ~str)]) -> ProcRes {
+                      testfile: &Path) -> ProcRes {
 
     let args = make_run_args(config, props, testfile);
     let cmdline = make_cmdline("", args.prog, args.args);
@@ -805,9 +807,6 @@ fn _arm_exec_compiled_test(config: &config, props: &TestProps,
 
     // run test via adb_run_wrapper
     runargs.push(~"shell");
-    for (key, val) in env.move_iter() {
-        runargs.push(fmt!("%s=%s", key, val));
-    }
     runargs.push(fmt!("%s/adb_run_wrapper.sh", config.adb_test_dir));
     runargs.push(fmt!("%s", config.adb_test_dir));
     runargs.push(fmt!("%s", prog_short));

branches/try2/src/etc/emacs/rust-mode.el

@@ -62,7 +62,8 @@
               ;;  - { means indent to either nesting-level * rust-indent-offset,
               ;;    or one further indent from that if either current line
               ;;    begins with 'else', or previous line didn't end in
-              ;;    semi, comma or brace, and wasn't an attribute. PHEW.
+              ;;    semi, comma or brace (other than whitespace and line
+              ;;    comments) , and wasn't an attribute. PHEW.
               ((> level 0)
                (let ((pt (point)))
                  (rust-rewind-irrelevant)
@@ -79,7 +80,7 @@
                          (beginning-of-line)
                          (rust-rewind-irrelevant)
                          (end-of-line)
-                         (if (looking-back "[{};,]")
+                         (if (looking-back "[,;{}][[:space:]]*\\(?://.*\\)?")
                              (* rust-indent-offset level)
                            (back-to-indentation)
                            (if (looking-at "#")

branches/try2/src/libextra/test.rs

@@ -745,7 +745,7 @@ fn get_concurrency() -> uint {
             let opt_n: Option<uint> = FromStr::from_str(s);
             match opt_n {
                 Some(n) if n > 0 => n,
-                _ => fail!("RUST_TEST_TASKS is `%s`, should be a positive integer.", s)
+                _ => fail!("RUST_TEST_TASKS is `%s`, should be a non-negative integer.", s)
             }
         }
         None => {

branches/try2/src/librustc/middle/resolve.rs

@@ -2585,13 +2585,11 @@ impl Resolver {
                 debug!("(resolving glob import) ... for value target");
                 dest_import_resolution.value_target =
                     Some(Target(containing_module, name_bindings));
-                dest_import_resolution.value_id = id;
             }
             if name_bindings.defined_in_public_namespace(TypeNS) {
                 debug!("(resolving glob import) ... for type target");
                 dest_import_resolution.type_target =
                     Some(Target(containing_module, name_bindings));
-                dest_import_resolution.type_id = id;
             }
         };
 

branches/try2/src/librustc/middle/trans/base.rs

@@ -87,7 +87,6 @@ use syntax::parse::token::{special_idents};
 use syntax::print::pprust::stmt_to_str;
 use syntax::{ast, ast_util, codemap, ast_map};
 use syntax::abi::{X86, X86_64, Arm, Mips};
-use syntax::visit::Visitor;
 
 pub use middle::trans::context::task_llcx;
 
@@ -2163,14 +2162,6 @@ pub fn trans_enum_def(ccx: @mut CrateContext, enum_definition: &ast::enum_def,
     }
 }
 
-pub struct TransItemVisitor;
-
-impl Visitor<@mut CrateContext> for TransItemVisitor {
-    fn visit_item(&mut self, i: @ast::item, ccx: @mut CrateContext) {
-        trans_item(ccx, i);
-    }
-}
-
 pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
     let _icx = push_ctxt("trans_item");
     let path = match ccx.tcx.items.get_copy(&item.id) {
@@ -2202,10 +2193,15 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
                      item.id,
                      item.attrs);
         } else {
-            // Be sure to travel more than just one layer deep to catch nested
-            // items in blocks and such.
-            let mut v = TransItemVisitor;
-            v.visit_block(body, ccx);
+            for stmt in body.stmts.iter() {
+                match stmt.node {
+                  ast::stmt_decl(@codemap::spanned { node: ast::decl_item(i),
+                                                 _ }, _) => {
+                    trans_item(ccx, i);
+                  }
+                  _ => ()
+                }
+            }
         }
       }
       ast::item_impl(ref generics, _, _, ref ms) => {

branches/try2/src/librustc/middle/trans/meth.rs

@@ -37,7 +37,6 @@ use std::vec;
 use syntax::ast_map::{path, path_mod, path_name};
 use syntax::ast_util;
 use syntax::{ast, ast_map};
-use syntax::visit;
 
 /**
 The main "translation" pass for methods.  Generates code
@@ -57,15 +56,7 @@ pub fn trans_impl(ccx: @mut CrateContext,
     debug!("trans_impl(path=%s, name=%s, id=%?)",
            path.repr(tcx), name.repr(tcx), id);
 
-    // Both here and below with generic methods, be sure to recurse and look for
-    // items that we need to translate.
-    if !generics.ty_params.is_empty() {
-        let mut v = TransItemVisitor;
-        for method in methods.iter() {
-            visit::walk_method_helper(&mut v, *method, ccx);
-        }
-        return;
-    }
+    if !generics.ty_params.is_empty() { return; }
     let sub_path = vec::append_one(path, path_name(name));
     for method in methods.iter() {
         if method.generics.ty_params.len() == 0u {
@@ -78,9 +69,6 @@ pub fn trans_impl(ccx: @mut CrateContext,
                          *method,
                          None,
                          llfn);
-        } else {
-            let mut v = TransItemVisitor;
-            visit::walk_method_helper(&mut v, *method, ccx);
         }
     }
 }

branches/try2/src/librustc/middle/ty.rs

@@ -4572,7 +4572,7 @@ pub fn visitor_object_ty(tcx: ctxt,
                  trait_ref.def_id,
                  trait_ref.substs.clone(),
                  RegionTraitStore(region),
-                 ast::m_mutbl,
+                 ast::m_imm,
                  EmptyBuiltinBounds())))
 }
 

branches/try2/src/libstd/logging.rs

@@ -41,10 +41,16 @@ pub fn console_off() {
 #[lang="log_type"]
 #[allow(missing_doc)]
 pub fn log_type<T>(_level: u32, object: &T) {
-    use sys;
+    use io;
+    use repr;
+    use str;
+
+    let bytes = do io::with_bytes_writer |writer| {
+        repr::write_repr(writer, object);
+    };
 
     // XXX: Bad allocation
-    let msg = sys::log_str(object);
+    let msg = str::from_bytes(bytes);
     newsched_log_str(msg);
 }
 

branches/try2/src/libstd/num/f32.rs

@@ -1142,10 +1142,6 @@ mod tests {
         assert_eq!(infinity.abs_sub(&1f32), infinity);
         assert_eq!(0f32.abs_sub(&neg_infinity), infinity);
         assert_eq!(0f32.abs_sub(&infinity), 0f32);
-    }
-
-    #[test] #[ignore(cfg(windows))] // FIXME #8663
-    fn test_abs_sub_nowin() {
         assert!(NaN.abs_sub(&-1f32).is_NaN());
         assert!(1f32.abs_sub(&NaN).is_NaN());
     }
@@ -1271,10 +1267,7 @@ mod tests {
 
         assert_eq!(0f32.frexp(), (0f32, 0));
         assert_eq!((-0f32).frexp(), (-0f32, 0));
-    }
 
-    #[test] #[ignore(cfg(windows))] // FIXME #8755
-    fn test_frexp_nowin() {
         let inf: f32 = Float::infinity();
         let neg_inf: f32 = Float::neg_infinity();
         let nan: f32 = Float::NaN();

branches/try2/src/libstd/num/f64.rs

@@ -1192,10 +1192,6 @@ mod tests {
         assert_eq!(infinity.abs_sub(&1f64), infinity);
         assert_eq!(0f64.abs_sub(&neg_infinity), infinity);
         assert_eq!(0f64.abs_sub(&infinity), 0f64);
-    }
-
-    #[test] #[ignore(cfg(windows))] // FIXME #8663
-    fn test_abs_sub_nowin() {
         assert!(NaN.abs_sub(&-1f64).is_NaN());
         assert!(1f64.abs_sub(&NaN).is_NaN());
     }
@@ -1320,10 +1316,7 @@ mod tests {
 
         assert_eq!(0f64.frexp(), (0f64, 0));
         assert_eq!((-0f64).frexp(), (-0f64, 0));
-    }
 
-    #[test] #[ignore(cfg(windows))] // FIXME #8755
-    fn test_frexp_nowin() {
         let inf: f64 = Float::infinity();
         let neg_inf: f64 = Float::neg_infinity();
         let nan: f64 = Float::NaN();

branches/try2/src/libstd/num/float.rs

@@ -1163,10 +1163,6 @@ mod tests {
         assert_eq!(infinity.abs_sub(&1f), infinity);
         assert_eq!(0f.abs_sub(&neg_infinity), infinity);
         assert_eq!(0f.abs_sub(&infinity), 0f);
-    }
-
-    #[test] #[ignore(cfg(windows))] // FIXME #8663
-    fn test_abs_sub_nowin() {
         assert!(NaN.abs_sub(&-1f).is_NaN());
         assert!(1f.abs_sub(&NaN).is_NaN());
     }
@@ -1292,10 +1288,7 @@ mod tests {
 
         assert_eq!(0f.frexp(), (0f, 0));
         assert_eq!((-0f).frexp(), (-0f, 0));
-    }
 
-    #[test] #[ignore(cfg(windows))] // FIXME #8755
-    fn test_frexp_nowin() {
         let inf: float = Float::infinity();
         let neg_inf: float = Float::neg_infinity();
         let nan: float = Float::NaN();