---

yaml
---
r: 144595
b: refs/heads/try2
c: 8d12673
h: refs/heads/master
i:
  144593: 24f261e
  144591: 758366f
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: 29449e355a68d2b878af1cdb65b97454e645206f
+refs/heads/try2: 8d12673c825c2785e375e12295a7bdc24a625114
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/doc/rust.md

@@ -209,7 +209,7 @@ break
 do
 else enum extern
 false fn for
-if impl in
+if impl
 let loop
 match mod mut
 priv pub

branches/try2/mk/tests.mk

@@ -476,15 +476,15 @@ RFAIL_RC := $(wildcard $(S)src/test/run-fail/*.rc)
 RFAIL_RS := $(wildcard $(S)src/test/run-fail/*.rs)
 CFAIL_RC := $(wildcard $(S)src/test/compile-fail/*.rc)
 CFAIL_RS := $(wildcard $(S)src/test/compile-fail/*.rs)
-BENCH_RS := $(wildcard $(S)src/test/bench/*.rs)
+BENCH_RS := $(wildcard $(S)src/test/bench/rt/*.rs $(S)src/test/bench/shootout/*.rs $(S)src/test/bench/std/*.rs $(S)src/test/bench/*.rs)
 PRETTY_RS := $(wildcard $(S)src/test/pretty/*.rs)
 DEBUGINFO_RS := $(wildcard $(S)src/test/debug-info/*.rs)
 CODEGEN_RS := $(wildcard $(S)src/test/codegen/*.rs)
 CODEGEN_CC := $(wildcard $(S)src/test/codegen/*.cc)
 
 # perf tests are the same as bench tests only they run under
 # a performance monitor.
-PERF_RS := $(wildcard $(S)src/test/bench/*.rs)
+PERF_RS := $(BENCH_RS)
 
 RPASS_TESTS := $(RPASS_RC) $(RPASS_RS)
 RPASS_FULL_TESTS := $(RPASS_FULL_RC) $(RPASS_FULL_RS)
@@ -516,7 +516,7 @@ CTEST_BUILD_BASE_cfail = compile-fail
 CTEST_MODE_cfail = compile-fail
 CTEST_RUNTOOL_cfail = $(CTEST_RUNTOOL)
 
-CTEST_SRC_BASE_bench = bench
+CTEST_SRC_BASE_bench = bench bench/rt bench/shootout bench/std
 CTEST_BUILD_BASE_bench = bench
 CTEST_MODE_bench = run-pass
 CTEST_RUNTOOL_bench = $(CTEST_RUNTOOL)
@@ -610,7 +610,8 @@ define DEF_RUN_COMPILETEST
 
 CTEST_ARGS$(1)-T-$(2)-H-$(3)-$(4) := \
         $$(CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3))	\
-        --src-base $$(S)src/test/$$(CTEST_SRC_BASE_$(4))/ \
+        $(foreach base,$$(CTEST_SRC_BASE_$(4)), \
+        --src-base $$(S)src/test/$$(base))/ \
         --build-base $(3)/test/$$(CTEST_BUILD_BASE_$(4))/ \
         --ratchet-metrics $(call TEST_RATCHET_FILE,$(1),$(2),$(3),$(4)) \
         --mode $$(CTEST_MODE_$(4)) \

branches/try2/src/compiletest/common.rs

@@ -36,7 +36,7 @@ pub struct config {
     llvm_bin_path: Option<Path>,
 
     // The directory containing the tests to run
-    src_base: Path,
+    src_base: ~[Path],
 
     // The directory where programs should be built
     build_base: Path,

branches/try2/src/compiletest/compiletest.rs

@@ -19,7 +19,7 @@ use std::os;
 use std::f64;
 
 use extra::getopts;
-use extra::getopts::groups::{optopt, optflag, reqopt};
+use extra::getopts::groups::{optopt, optflag, reqopt, optmulti};
 use extra::test;
 
 use common::config;
@@ -49,19 +49,19 @@ pub fn main() {
 pub fn parse_config(args: ~[~str]) -> config {
 
     let groups : ~[getopts::groups::OptGroup] =
-        ~[reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
-          reqopt("", "run-lib-path", "path to target shared libraries", "PATH"),
-          reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"),
-          optopt("", "clang-path", "path to  executable for codegen tests", "PATH"),
-          optopt("", "llvm-bin-path", "path to directory holding llvm binaries", "DIR"),
-          reqopt("", "src-base", "directory to scan for test files", "PATH"),
-          reqopt("", "build-base", "directory to deposit test outputs", "PATH"),
-          reqopt("", "aux-base", "directory to find auxiliary test files", "PATH"),
-          reqopt("", "stage-id", "the target-stage identifier", "stageN-TARGET"),
-          reqopt("", "mode", "which sort of compile tests to run",
-                 "(compile-fail|run-fail|run-pass|pretty|debug-info)"),
-          optflag("", "ignored", "run tests marked as ignored / xfailed"),
-          optopt("", "runtool", "supervisor program to run tests under \
+        ~[reqopt   ("", "compile-lib-path", "path to host shared libraries", "PATH"),
+          reqopt   ("", "run-lib-path", "path to target shared libraries", "PATH"),
+          reqopt   ("", "rustc-path", "path to rustc to use for compiling", "PATH"),
+          optopt   ("", "clang-path", "path to  executable for codegen tests", "PATH"),
+          optopt   ("", "llvm-bin-path", "path to directory holding llvm binaries", "DIR"),
+          optmulti ("", "src-base", "directory to scan for test files", "PATH"),
+          reqopt   ("", "build-base", "directory to deposit test outputs", "PATH"),
+          reqopt   ("", "aux-base", "directory to find auxiliary test files", "PATH"),
+          reqopt   ("", "stage-id", "the target-stage identifier", "stageN-TARGET"),
+          reqopt   ("", "mode", "which sort of compile tests to run",
+                    " (compile-fail|run-fail|run-pass|pretty|debug-info)"),
+          optflag  ("", "ignored", "run tests marked as ignored / xfailed"),
+          optopt   ("", "runtool", "supervisor program to run tests under \
                                  (eg. emulator, valgrind)", "PROGRAM"),
           optopt("", "rustcflags", "flags to pass to rustc", "FLAGS"),
           optflag("", "verbose", "run tests verbosely, showing all output"),
@@ -105,13 +105,15 @@ pub fn parse_config(args: ~[~str]) -> config {
         Path(getopts::opt_str(m, nm))
     }
 
+    let src_base = getopts::opt_strs(matches, "src-base");
+
     config {
         compile_lib_path: getopts::opt_str(matches, "compile-lib-path"),
         run_lib_path: getopts::opt_str(matches, "run-lib-path"),
         rustc_path: opt_path(matches, "rustc-path"),
         clang_path: getopts::opt_maybe_str(matches, "clang-path").map_move(|s| Path(s)),
         llvm_bin_path: getopts::opt_maybe_str(matches, "llvm-bin-path").map_move(|s| Path(s)),
-        src_base: opt_path(matches, "src-base"),
+        src_base: src_base.iter().map(|x| Path(x.clone())).collect(),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: getopts::opt_str(matches, "stage-id"),
@@ -245,7 +247,7 @@ pub fn make_tests(config: &config) -> ~[test::TestDescAndFn] {
     debug!("making tests from %s",
            config.src_base.to_str());
     let mut tests = ~[];
-    let dirs = os::list_dir_path(&config.src_base);
+    let dirs = config.src_base.iter().flat_map(|x| os::list_dir_path(x).move_iter()).to_owned_vec();
     for file in dirs.iter() {
         let file = file.clone();
         debug!("inspecting file %s", file.to_str());

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

@@ -5,7 +5,6 @@
 ;; Url: https://github.com/mozilla/rust
 
 (eval-when-compile (require 'cl))
-(eval-when-compile (require 'misc))
 
 ;; Syntax definitions and helpers
 (defvar rust-mode-syntax-table
@@ -58,39 +57,19 @@
               ;; A closing brace is 1 level unindended
               ((looking-at "}") (* rust-indent-offset (- level 1)))
 
-              ; Doc comments in /** style with leading * indent to line up the *s
-              ((and (nth 4 (syntax-ppss)) (looking-at "*"))
-               (+ 1 (* rust-indent-offset level)))
-
               ;; If we're in any other token-tree / sexp, then:
               ;;  - [ or ( means line up with the opening token
               ;;  - { 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 (other than whitespace and line
-              ;;    comments) , and wasn't an attribute.  But if we have 
-              ;;    something after the open brace and ending with a comma,
-              ;;    treat it as fields and align them.  PHEW.
+              ;;    semi, comma or brace, and wasn't an attribute. PHEW.
               ((> level 0)
                (let ((pt (point)))
                  (rust-rewind-irrelevant)
                  (backward-up-list)
-                 (cond 
-                  ((and
-                      (looking-at "[[(]")
-                      ; We don't want to indent out to the open bracket if the
-                      ; open bracket ends the line
-                      (save-excursion 
-                        (forward-char)
-                        (not (looking-at "[[:space:]]*\\(?://.*\\)?$"))))
-                   (+ 1 (current-column)))
-                  ;; Check for fields on the same line as the open curly brace:
-                  ((looking-at "{[[:blank:]]*[^}\n]*,[[:space:]]*$")
+                 (if (looking-at "[[(]")
+                     (+ 1 (current-column))
                    (progn
-                    (forward-char)
-                    (forward-to-word 1)
-                    (current-column)))
-                  (t (progn
                      (goto-char pt)
                      (back-to-indentation)
                      (if (looking-at "\\<else\\>")
@@ -100,12 +79,12 @@
                          (beginning-of-line)
                          (rust-rewind-irrelevant)
                          (end-of-line)
-                         (if (looking-back "[,;{}(][[:space:]]*\\(?://.*\\)?")
+                         (if (looking-back "[{};,]")
                              (* rust-indent-offset level)
                            (back-to-indentation)
                            (if (looking-at "#")
                                (* rust-indent-offset level)
-                             (* rust-indent-offset (+ 1 level)))))))))))
+                             (* rust-indent-offset (+ 1 level))))))))))
 
               ;; Otherwise we're in a column-zero definition
               (t 0))))))

branches/try2/src/libextra/dlist.rs

@@ -594,7 +594,7 @@ impl<A: Eq> Eq for DList<A> {
     }
 
     fn ne(&self, other: &DList<A>) -> bool {
-        self.len() != other.len() ||
+        self.len() != other.len() &&
             iterator::order::ne(self.iter(), other.iter())
     }
 }
@@ -978,10 +978,6 @@ mod tests {
         assert!(n != m);
         m.push_back(1);
         assert_eq!(&n, &m);
-
-        let n = list_from([2,3,4]);
-        let m = list_from([1,2,3]);
-        assert!(n != m);
     }
 
     #[test]

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/back/link.rs

@@ -216,7 +216,7 @@ pub mod write {
     use lib;
 
     use std::c_str::ToCStr;
-    use std::libc::c_uint;
+    use std::libc::{c_uint, c_int};
     use std::path::Path;
     use std::run;
     use std::str;
@@ -257,17 +257,7 @@ pub mod write {
                 }
             }
 
-            // Copy what clan does by turning on loop vectorization at O2 and
-            // slp vectorization at O3
-            let vectorize_loop = !sess.no_vectorize_loops() &&
-                                 (sess.opts.optimize == session::Default ||
-                                  sess.opts.optimize == session::Aggressive);
-            let vectorize_slp = !sess.no_vectorize_slp() &&
-                                sess.opts.optimize == session::Aggressive;
-            llvm::LLVMRustSetLLVMOptions(sess.print_llvm_passes(),
-                                         vectorize_loop,
-                                         vectorize_slp,
-                                         sess.time_llvm_passes());
+            configure_llvm(sess);
 
             let OptLevel = match sess.opts.optimize {
               session::No => lib::llvm::CodeGenLevelNone,
@@ -293,12 +283,9 @@ pub mod write {
             // Create the two optimizing pass managers. These mirror what clang
             // does, and are by populated by LLVM's default PassManagerBuilder.
             // Each manager has a different set of passes, but they also share
-            // some common passes. Each one is initialized with the analyis
-            // passes the target requires, and then further passes are added.
+            // some common passes.
             let fpm = llvm::LLVMCreateFunctionPassManagerForModule(llmod);
             let mpm = llvm::LLVMCreatePassManager();
-            llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
-            llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
 
             // If we're verifying or linting, add them to the function pass
             // manager.
@@ -308,32 +295,11 @@ pub mod write {
             if !sess.no_verify() { assert!(addpass("verify")); }
             if sess.lint_llvm()  { assert!(addpass("lint"));   }
 
-            // Create the PassManagerBuilder for LLVM. We configure it with
-            // reasonable defaults and prepare it to actually populate the pass
-            // manager.
-            let builder = llvm::LLVMPassManagerBuilderCreate();
-            match sess.opts.optimize {
-                session::No => {
-                    // Don't add lifetime intrinsics add O0
-                    llvm::LLVMRustAddAlwaysInlinePass(builder, false);
-                }
-                // numeric values copied from clang
-                session::Less => {
-                    llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
-                                                                        225);
-                }
-                session::Default | session::Aggressive => {
-                    llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
-                                                                        275);
-                }
+            if !sess.no_prepopulate_passes() {
+                llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
+                llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
+                populate_llvm_passess(fpm, mpm, llmod, OptLevel);
             }
-            llvm::LLVMPassManagerBuilderSetOptLevel(builder, OptLevel as c_uint);
-            llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod);
-
-            // Use the builder to populate the function/module pass managers.
-            llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
-            llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
-            llvm::LLVMPassManagerBuilderDispose(builder);
 
             for pass in sess.opts.custom_passes.iter() {
                 do pass.with_c_str |s| {
@@ -424,6 +390,74 @@ pub mod write {
             sess.abort_if_errors();
         }
     }
+
+    unsafe fn configure_llvm(sess: Session) {
+        // Copy what clan does by turning on loop vectorization at O2 and
+        // slp vectorization at O3
+        let vectorize_loop = !sess.no_vectorize_loops() &&
+                             (sess.opts.optimize == session::Default ||
+                              sess.opts.optimize == session::Aggressive);
+        let vectorize_slp = !sess.no_vectorize_slp() &&
+                            sess.opts.optimize == session::Aggressive;
+
+        let mut llvm_c_strs = ~[];
+        let mut llvm_args = ~[];
+        let add = |arg: &str| {
+            let s = arg.to_c_str();
+            llvm_args.push(s.with_ref(|p| p));
+            llvm_c_strs.push(s);
+        };
+        add("rustc"); // fake program name
+        add("-arm-enable-ehabi");
+        add("-arm-enable-ehabi-descriptors");
+        if vectorize_loop { add("-vectorize-loops"); }
+        if vectorize_slp  { add("-vectorize-slp");   }
+        if sess.time_llvm_passes() { add("-time-passes"); }
+        if sess.print_llvm_passes() { add("-debug-pass=Structure"); }
+
+        for arg in sess.opts.llvm_args.iter() {
+            add(*arg);
+        }
+
+        do llvm_args.as_imm_buf |p, len| {
+            llvm::LLVMRustSetLLVMOptions(len as c_int, p);
+        }
+    }
+
+    unsafe fn populate_llvm_passess(fpm: lib::llvm::PassManagerRef,
+                                    mpm: lib::llvm::PassManagerRef,
+                                    llmod: ModuleRef,
+                                    opt: lib::llvm::CodeGenOptLevel) {
+        // Create the PassManagerBuilder for LLVM. We configure it with
+        // reasonable defaults and prepare it to actually populate the pass
+        // manager.
+        let builder = llvm::LLVMPassManagerBuilderCreate();
+        match opt {
+            lib::llvm::CodeGenLevelNone => {
+                // Don't add lifetime intrinsics add O0
+                llvm::LLVMRustAddAlwaysInlinePass(builder, false);
+            }
+            lib::llvm::CodeGenLevelLess => {
+                llvm::LLVMRustAddAlwaysInlinePass(builder, true);
+            }
+            // numeric values copied from clang
+            lib::llvm::CodeGenLevelDefault => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
+                                                                    225);
+            }
+            lib::llvm::CodeGenLevelAggressive => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder,
+                                                                    275);
+            }
+        }
+        llvm::LLVMPassManagerBuilderSetOptLevel(builder, opt as c_uint);
+        llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod);
+
+        // Use the builder to populate the function/module pass managers.
+        llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(builder, fpm);
+        llvm::LLVMPassManagerBuilderPopulateModulePassManager(builder, mpm);
+        llvm::LLVMPassManagerBuilderDispose(builder);
+    }
 }