---

yaml
---
r: 149439
b: refs/heads/try2
c: 7736985
h: refs/heads/master
i:
  149437: 9b5f28e
  149435: 901d783
  149431: a7acf9f
  149423: b71eacd
  149407: 07fea0b
  149375: 2679e90
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: 698042de238644341b798238bd5a61ea2f3c0f20
+refs/heads/try2: 7736985f78e43aa2e7f45c5ad19a520c97f45d8f
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/AUTHORS.txt

@@ -7,7 +7,6 @@ Adrien Tétar <[email protected]>
 Alan Andrade <[email protected]>
 Aleksander Balicki <[email protected]>
 Alex Crichton <[email protected]>
-Alex Lyon <[email protected]>
 Alex Rønne Petersen <[email protected]>
 Alexander Stavonin <[email protected]>
 Alexandros Tasos <[email protected]>

branches/try2/mk/crates.mk

@@ -50,21 +50,20 @@
 ################################################################################
 
 TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
-                 uuid serialize sync getopts collections num test time
+                 uuid serialize sync getopts collections num
 HOST_CRATES := syntax rustc rustdoc fourcc
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt native:compiler-rt
-DEPS_extra := std term sync serialize getopts collections time
+DEPS_extra := std term sync serialize getopts collections
 DEPS_green := std native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize collections
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
-              collections time extra
-DEPS_rustdoc := rustc native:sundown serialize sync getopts collections \
-                test time
+              collections extra
+DEPS_rustdoc := rustc native:sundown serialize sync getopts collections
 DEPS_flate := std native:miniz
 DEPS_arena := std collections
 DEPS_glob := std
@@ -77,10 +76,8 @@ DEPS_getopts := std
 DEPS_collections := std serialize
 DEPS_fourcc := syntax std
 DEPS_num := std extra
-DEPS_test := std extra collections getopts serialize term
-DEPS_time := std serialize
 
-TOOL_DEPS_compiletest := test green rustuv getopts
+TOOL_DEPS_compiletest := extra green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc green rustuv
 TOOL_DEPS_rustc := rustc green rustuv
 TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs

branches/try2/mk/tests.mk

@@ -537,6 +537,10 @@ TEST_SREQ$(1)_T_$(2)_H_$(3) = \
 # remove directive, if present, from CFG_RUSTC_FLAGS (issue #7898).
 CTEST_RUSTC_FLAGS := $$(subst --cfg ndebug,,$$(CFG_RUSTC_FLAGS))
 
+# There's no need our entire test suite to take up gigabytes of space on disk
+# including copies of libstd/libextra all over the place
+CTEST_RUSTC_FLAGS := $$(CTEST_RUSTC_FLAGS) -C prefer-dynamic
+
 # The tests can not be optimized while the rest of the compiler is optimized, so
 # filter out the optimization (if any) from rustc and then figure out if we need
 # to be optimized

branches/try2/src/compiletest/compiletest.rs

@@ -13,13 +13,16 @@
 #[allow(non_camel_case_types)];
 #[deny(warnings)];
 
-extern crate test;
+extern crate extra;
 extern crate getopts;
 
 use std::os;
 use std::io;
 use std::io::fs;
+
 use getopts::{optopt, optflag, reqopt};
+use extra::test;
+
 use common::config;
 use common::mode_run_pass;
 use common::mode_run_fail;

branches/try2/src/compiletest/header.rs

@@ -32,8 +32,6 @@ pub struct TestProps {
     force_host: bool,
     // Check stdout for error-pattern output as well as stderr
     check_stdout: bool,
-    // Don't force a --crate-type=dylib flag on the command line
-    no_prefer_dynamic: bool,
 }
 
 // Load any test directives embedded in the file
@@ -47,7 +45,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
     let mut check_lines = ~[];
     let mut force_host = false;
     let mut check_stdout = false;
-    let mut no_prefer_dynamic = false;
     iter_header(testfile, |ln| {
         match parse_error_pattern(ln) {
           Some(ep) => error_patterns.push(ep),
@@ -70,10 +67,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
             check_stdout = parse_check_stdout(ln);
         }
 
-        if !no_prefer_dynamic {
-            no_prefer_dynamic = parse_no_prefer_dynamic(ln);
-        }
-
         match parse_aux_build(ln) {
             Some(ab) => { aux_builds.push(ab); }
             None => {}
@@ -106,7 +99,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
         check_lines: check_lines,
         force_host: force_host,
         check_stdout: check_stdout,
-        no_prefer_dynamic: no_prefer_dynamic,
     };
 }
 
@@ -175,10 +167,6 @@ fn parse_check_stdout(line: &str) -> bool {
     parse_name_directive(line, "check-stdout")
 }
 
-fn parse_no_prefer_dynamic(line: &str) -> bool {
-    parse_name_directive(line, "no-prefer-dynamic")
-}
-
 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

@@ -34,7 +34,7 @@ use std::str;
 use std::task;
 use std::vec;
 
-use test::MetricMap;
+use extra::test::MetricMap;
 
 pub fn run(config: config, testfile: ~str) {
 
@@ -258,12 +258,15 @@ actual:\n\
 }
 
 fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
-    let mut config = config {
-        target_rustcflags: cleanup_debug_info_options(&config.target_rustcflags),
-        host_rustcflags: cleanup_debug_info_options(&config.host_rustcflags),
-        .. config.clone()
-    };
 
+    // do not optimize debuginfo tests
+    let mut config = match config.target_rustcflags {
+        Some(ref flags) => config {
+            target_rustcflags: Some(flags.replace("-O", "")),
+            .. (*config).clone()
+        },
+        None => (*config).clone()
+    };
     let config = &mut config;
     let check_lines = &props.check_lines;
     let mut cmds = props.debugger_cmds.connect("\n");
@@ -433,20 +436,6 @@ fn run_debuginfo_test(config: &config, props: &TestProps, testfile: &Path) {
                                   check_lines[i]), &ProcRes);
         }
     }
-
-    fn cleanup_debug_info_options(options: &Option<~str>) -> Option<~str> {
-        if options.is_none() {
-            return None;
-        }
-
-        // Remove options that are either unwanted (-O) or may lead to duplicates due to RUSTFLAGS.
-        let options_to_remove = [~"-O", ~"-g", ~"--debuginfo"];
-        let new_options = split_maybe_args(options).move_iter()
-                                                   .filter(|x| !options_to_remove.contains(x))
-                                                   .to_owned_vec()
-                                                   .connect(" ");
-        Some(new_options)
-    }
 }
 
 fn check_error_patterns(props: &TestProps,
@@ -715,13 +704,9 @@ 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 crate_type = if aux_props.no_prefer_dynamic {
-            ~[]
-        } else {
-            ~[~"--crate-type=dylib"]
-        };
         let aux_args =
-            make_compile_args(config, &aux_props, crate_type + extra_link_args,
+            make_compile_args(config, &aux_props, ~[~"--crate-type=dylib"]
+                                                  + extra_link_args,
                               |a,b| {
                                   let f = make_lib_name(a, b, testfile);
                                   ThisDirectory(f.dir_path())
@@ -785,10 +770,6 @@ fn make_compile_args(config: &config,
                      ~"-L", config.build_base.as_str().unwrap().to_owned(),
                      ~"--target=" + target]
         + extras;
-    if !props.no_prefer_dynamic {
-        args.push(~"-C");
-        args.push(~"prefer-dynamic");
-    }
     let path = match xform_file {
         ThisFile(path) => { args.push(~"-o"); path }
         ThisDirectory(path) => { args.push(~"--out-dir"); path }

branches/try2/src/doc/complement-cheatsheet.md

@@ -22,14 +22,13 @@ let y: int = x.unwrap();
 
 **Int to string, in non-base-10**
 
-Use the `format!` syntax extension.
+Use [`ToStrRadix`](http://static.rust-lang.org/doc/master/std/num/trait.ToStrRadix.html).
 
 ~~~
+use std::num::ToStrRadix;
+
 let x: int = 42;
-let y: ~str = format!("{:t}", x);   // binary
-let y: ~str = format!("{:o}", x);   // octal
-let y: ~str = format!("{:x}", x);   // lowercase hexadecimal
-let y: ~str = format!("{:X}", x);   // uppercase hexidecimal
+let y: ~str = x.to_str_radix(16);
 ~~~
 
 **String to int, in non-base-10**

branches/try2/src/doc/guide-macros.md

@@ -11,17 +11,17 @@ which both pattern-match on their input and both return early in one case,
 doing nothing otherwise:
 
 ~~~~
-# enum T { SpecialA(uint), SpecialB(uint) };
+# enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 match input_1 {
-    SpecialA(x) => { return x; }
+    special_a(x) => { return x; }
     _ => {}
 }
 // ...
 match input_2 {
-    SpecialB(x) => { return x; }
+    special_b(x) => { return x; }
     _ => {}
 }
 # return 0u;
@@ -37,22 +37,22 @@ lightweight custom syntax extensions, themselves defined using the
 the pattern in the above code:
 
 ~~~~
-# enum T { SpecialA(uint), SpecialB(uint) };
+# enum t { special_a(uint), special_b(uint) };
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
-    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 SpecialE)`
+    ($inp:expr $sp:ident) => ( // invoke it like `(input_5 special_e)`
         match $inp {
             $sp(x) => { return x; }
             _ => {}
         }
     );
 )
 // ...
-early_return!(input_1 SpecialA);
+early_return!(input_1 special_a);
 // ...
-early_return!(input_2 SpecialB);
+early_return!(input_2 special_b);
 # return 0;
 # }
 ~~~~
@@ -155,10 +155,10 @@ separator token (a comma-separated list could be written `$(...),*`), and `+`
 instead of `*` to mean "at least one".
 
 ~~~~
-# enum T { SpecialA(uint),SpecialB(uint),SpecialC(uint),SpecialD(uint)};
+# enum t { special_a(uint),special_b(uint),special_c(uint),special_d(uint)};
 # fn f() -> uint {
-# let input_1 = SpecialA(0);
-# let input_2 = SpecialA(0);
+# let input_1 = special_a(0);
+# let input_2 = special_a(0);
 macro_rules! early_return(
     ($inp:expr, [ $($sp:ident)|+ ]) => (
         match $inp {
@@ -170,9 +170,9 @@ macro_rules! early_return(
     );
 )
 // ...
-early_return!(input_1, [SpecialA|SpecialC|SpecialD]);
+early_return!(input_1, [special_a|special_c|special_d]);
 // ...
-early_return!(input_2, [SpecialB]);
+early_return!(input_2, [special_b]);
 # return 0;
 # }
 ~~~~
@@ -215,14 +215,14 @@ solves the problem.
 Now consider code like the following:
 
 ~~~~
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
 match x {
-    Good1(g1, val) => {
+    good_1(g1, val) => {
         match g1.body {
-            Good2(result) => {
+            good_2(result) => {
                 // complicated stuff goes here
                 return result + val;
             },
@@ -261,13 +261,13 @@ macro_rules! biased_match (
     )
 )
 
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
-biased_match!((x)       ~ (Good1(g1, val)) else { return 0 };
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
+biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
               binds g1, val )
-biased_match!((g1.body) ~ (Good2(result) )
+biased_match!((g1.body) ~ (good_2(result) )
                   else { fail!("Didn't get good_2") };
               binds result )
 // complicated stuff goes here
@@ -365,13 +365,13 @@ macro_rules! biased_match (
 )
 
 
-# enum T1 { Good1(T2, uint), Bad1};
-# struct T2 { body: T3 }
-# enum T3 { Good2(uint), Bad2};
-# fn f(x: T1) -> uint {
+# enum t1 { good_1(t2, uint), bad_1 };
+# struct t2 { body: t3 }
+# enum t3 { good_2(uint), bad_2};
+# fn f(x: t1) -> uint {
 biased_match!(
-    (x)       ~ (Good1(g1, val)) else { return 0 };
-    (g1.body) ~ (Good2(result) ) else { fail!("Didn't get Good2") };
+    (x)       ~ (good_1(g1, val)) else { return 0 };
+    (g1.body) ~ (good_2(result) ) else { fail!("Didn't get good_2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;