---

yaml
---
r: 152035
b: refs/heads/try2
c: 3f8cc16
h: refs/heads/master
i:
  152033: b834904
  152031: f7b19a1
v: v3

Author: emberian

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

branches/try2/mk/docs.mk

@@ -29,8 +29,8 @@
 DOCS := index intro tutorial guide-ffi guide-macros guide-lifetimes \
 	guide-tasks guide-container guide-pointers guide-testing \
 	guide-runtime complement-bugreport complement-cheatsheet \
-	complement-lang-faq complement-design-faq complement-project-faq rust \
-    rustdoc guide-unsafe
+	complement-lang-faq complement-project-faq rust rustdoc \
+	guide-unsafe
 
 PDF_DOCS := tutorial rust
 

branches/try2/mk/platform.mk

@@ -97,6 +97,13 @@ endef
 $(foreach cvar,CC CXX CPP CFLAGS CXXFLAGS CPPFLAGS,\
   $(eval $(call SET_FROM_CFG,$(cvar))))
 
+ifeq ($(CFG_USING_CLANG),1)
+  # The -Qunused-arguments sidesteps spurious warnings from clang
+  CFLAGS += -Qunused-arguments
+  CXXFLAGS += -Qunused-arguments
+  CPPFLAGS += -Qunused-arguments
+endif
+
 CFG_RLIB_GLOB=lib$(1)-*.rlib
 
 # x86_64-unknown-linux-gnu configuration
@@ -509,21 +516,6 @@ CFG_LDPATH_x86_64-unknown-freebsd :=
 CFG_RUN_x86_64-unknown-freebsd=$(2)
 CFG_RUN_TARG_x86_64-unknown-freebsd=$(call CFG_RUN_x86_64-unknown-freebsd,,$(2))
 
-
-# The -Qunused-arguments sidesteps spurious warnings from clang
-define FILTER_FLAGS
-  ifeq ($$(CFG_USING_CLANG),1)
-    ifneq ($(findstring clang,$$(shell $(CC_$(1)) -v)),)
-      CFG_GCCISH_CFLAGS_$(1) += -Qunused-arguments
-      CFG_GCCISH_CXXFLAGS_$(1) += -Qunused-arguments
-    endif
-  endif
-endef
-
-$(foreach target,$(CFG_TARGET),\
-  $(eval $(call FILTER_FLAGS,$(target))))
-
-
 ifeq ($(CFG_CCACHE_CPP2),1)
   CCACHE_CPP2=1
   export CCACHE_CPP

branches/try2/src/compiletest/common.rs

@@ -56,10 +56,10 @@ impl fmt::Show for Mode {
 #[deriving(Clone)]
 pub struct Config {
     // The library paths required for running the compiler
-    pub compile_lib_path: String,
+    pub compile_lib_path: StrBuf,
 
     // The library paths required for running compiled programs
-    pub run_lib_path: String,
+    pub run_lib_path: StrBuf,
 
     // The rustc executable
     pub rustc_path: Path,
@@ -80,7 +80,7 @@ pub struct Config {
     pub aux_base: Path,
 
     // The name of the stage being built (stage1, etc)
-    pub stage_id: String,
+    pub stage_id: StrBuf,
 
     // The test mode, compile-fail, run-fail, run-pass
     pub mode: Mode,
@@ -113,37 +113,37 @@ pub struct Config {
 
     // A command line to prefix program execution with,
     // for running under valgrind
-    pub runtool: Option<String>,
+    pub runtool: Option<StrBuf>,
 
     // Flags to pass to the compiler when building for the host
-    pub host_rustcflags: Option<String>,
+    pub host_rustcflags: Option<StrBuf>,
 
     // Flags to pass to the compiler when building for the target
-    pub target_rustcflags: Option<String>,
+    pub target_rustcflags: Option<StrBuf>,
 
     // Run tests using the JIT
     pub jit: bool,
 
     // Target system to be tested
-    pub target: String,
+    pub target: StrBuf,
 
     // Host triple for the compiler being invoked
-    pub host: String,
+    pub host: StrBuf,
 
     // Path to the android tools
     pub android_cross_path: Path,
 
     // Extra parameter to run adb on arm-linux-androideabi
-    pub adb_path: String,
+    pub adb_path: StrBuf,
 
     // Extra parameter to run test sute on arm-linux-androideabi
-    pub adb_test_dir: String,
+    pub adb_test_dir: StrBuf,
 
     // status whether android device available or not
     pub adb_device_status: bool,
 
     // the path containing LLDB's Python module
-    pub lldb_python_dir: Option<String>,
+    pub lldb_python_dir: Option<StrBuf>,
 
     // Explain what's going on
     pub verbose: bool

branches/try2/src/compiletest/compiletest.rs

@@ -56,7 +56,7 @@ pub fn main() {
     run_tests(&config);
 }
 
-pub fn parse_config(args: Vec<String> ) -> Config {
+pub fn parse_config(args: Vec<StrBuf> ) -> Config {
 
     let groups : Vec<getopts::OptGroup> =
         vec!(reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"),
@@ -225,14 +225,14 @@ pub fn log_config(config: &Config) {
     logv(c, format_strbuf!("\n"));
 }
 
-pub fn opt_str<'a>(maybestr: &'a Option<String>) -> &'a str {
+pub fn opt_str<'a>(maybestr: &'a Option<StrBuf>) -> &'a str {
     match *maybestr {
         None => "(none)",
         Some(ref s) => s.as_slice(),
     }
 }
 
-pub fn opt_str2(maybestr: Option<String>) -> String {
+pub fn opt_str2(maybestr: Option<StrBuf>) -> StrBuf {
     match maybestr {
         None => "(none)".to_strbuf(),
         Some(s) => s,
@@ -352,7 +352,7 @@ pub fn make_test(config: &Config, testfile: &Path, f: || -> test::TestFn)
 pub fn make_test_name(config: &Config, testfile: &Path) -> test::TestName {
 
     // Try to elide redundant long paths
-    fn shorten(path: &Path) -> String {
+    fn shorten(path: &Path) -> StrBuf {
         let filename = path.filename_str();
         let p = path.dir_path();
         let dir = p.filename_str();

branches/try2/src/compiletest/errors.rs

@@ -13,8 +13,8 @@ use regex::Regex;
 
 pub struct ExpectedError {
     pub line: uint,
-    pub kind: String,
-    pub msg: String,
+    pub kind: StrBuf,
+    pub msg: StrBuf,
 }
 
 pub static EXPECTED_PATTERN : &'static str = r"//~(?P<adjusts>\^*)\s*(?P<kind>\S*)\s*(?P<msg>.*)";

branches/try2/src/compiletest/header.rs

@@ -14,20 +14,20 @@ use util;
 
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
-    pub error_patterns: Vec<String> ,
+    pub error_patterns: Vec<StrBuf> ,
     // Extra flags to pass to the compiler
-    pub compile_flags: Option<String>,
+    pub compile_flags: Option<StrBuf>,
     // Extra flags to pass when the compiled code is run (such as --bench)
-    pub run_flags: Option<String>,
+    pub run_flags: Option<StrBuf>,
     // If present, the name of a file that this test should match when
     // pretty-printed
     pub pp_exact: Option<Path>,
     // Modules from aux directory that should be compiled
-    pub aux_builds: Vec<String> ,
+    pub aux_builds: Vec<StrBuf> ,
     // Environment settings to use during execution
-    pub exec_env: Vec<(String,String)> ,
+    pub exec_env: Vec<(StrBuf,StrBuf)> ,
     // Lines to check if they appear in the expected debugger output
-    pub check_lines: Vec<String> ,
+    pub check_lines: Vec<StrBuf> ,
     // Flag to force a crate to be built with the host architecture
     pub force_host: bool,
     // Check stdout for error-pattern output as well as stderr
@@ -119,10 +119,10 @@ pub fn load_props(testfile: &Path) -> TestProps {
 }
 
 pub fn is_test_ignored(config: &Config, testfile: &Path) -> bool {
-    fn ignore_target(config: &Config) -> String {
+    fn ignore_target(config: &Config) -> StrBuf {
         format_strbuf!("ignore-{}", util::get_os(config.target.as_slice()))
     }
-    fn ignore_stage(config: &Config) -> String {
+    fn ignore_stage(config: &Config) -> StrBuf {
         format_strbuf!("ignore-{}",
                        config.stage_id.as_slice().split('-').next().unwrap())
     }
@@ -169,23 +169,23 @@ fn iter_header(testfile: &Path, it: |&str| -> bool) -> bool {
     return true;
 }
 
-fn parse_error_pattern(line: &str) -> Option<String> {
+fn parse_error_pattern(line: &str) -> Option<StrBuf> {
     parse_name_value_directive(line, "error-pattern".to_strbuf())
 }
 
-fn parse_aux_build(line: &str) -> Option<String> {
+fn parse_aux_build(line: &str) -> Option<StrBuf> {
     parse_name_value_directive(line, "aux-build".to_strbuf())
 }
 
-fn parse_compile_flags(line: &str) -> Option<String> {
+fn parse_compile_flags(line: &str) -> Option<StrBuf> {
     parse_name_value_directive(line, "compile-flags".to_strbuf())
 }
 
-fn parse_run_flags(line: &str) -> Option<String> {
+fn parse_run_flags(line: &str) -> Option<StrBuf> {
     parse_name_value_directive(line, "run-flags".to_strbuf())
 }
 
-fn parse_check_line(line: &str) -> Option<String> {
+fn parse_check_line(line: &str) -> Option<StrBuf> {
     parse_name_value_directive(line, "check".to_strbuf())
 }
 
@@ -205,10 +205,10 @@ fn parse_no_pretty_expanded(line: &str) -> bool {
     parse_name_directive(line, "no-pretty-expanded")
 }
 
-fn parse_exec_env(line: &str) -> Option<(String, String)> {
+fn parse_exec_env(line: &str) -> Option<(StrBuf, StrBuf)> {
     parse_name_value_directive(line, "exec-env".to_strbuf()).map(|nv| {
         // nv is either FOO or FOO=BAR
-        let mut strs: Vec<String> = nv.as_slice()
+        let mut strs: Vec<StrBuf> = nv.as_slice()
                                       .splitn('=', 1)
                                       .map(|s| s.to_strbuf())
                                       .collect();
@@ -241,8 +241,8 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
     line.contains(directive)
 }
 
-pub fn parse_name_value_directive(line: &str, directive: String)
-                                  -> Option<String> {
+pub fn parse_name_value_directive(line: &str, directive: StrBuf)
+                                  -> Option<StrBuf> {
     let keycolon = format_strbuf!("{}:", directive);
     match line.find_str(keycolon.as_slice()) {
         Some(colon) => {

branches/try2/src/compiletest/procsrv.rs

@@ -13,7 +13,7 @@ use std::str;
 use std::io::process::{ProcessExit, Command, Process, ProcessOutput};
 use std::unstable::dynamic_lib::DynamicLibrary;
 
-fn target_env(lib_path: &str, prog: &str) -> Vec<(String, String)> {
+fn target_env(lib_path: &str, prog: &str) -> Vec<(StrBuf, StrBuf)> {
     let prog = if cfg!(windows) {prog.slice_to(prog.len() - 4)} else {prog};
     let mut aux_path = prog.to_strbuf();
     aux_path.push_str(".libaux");
@@ -26,7 +26,7 @@ fn target_env(lib_path: &str, prog: &str) -> Vec<(String, String)> {
 
     // Remove the previous dylib search path var
     let var = DynamicLibrary::envvar();
-    let mut env: Vec<(String,String)> =
+    let mut env: Vec<(StrBuf,StrBuf)> =
         os::env().move_iter().map(|(a,b)|(a.to_strbuf(), b.to_strbuf())).collect();
     match env.iter().position(|&(ref k, _)| k.as_slice() == var) {
         Some(i) => { env.remove(i); }
@@ -40,13 +40,13 @@ fn target_env(lib_path: &str, prog: &str) -> Vec<(String, String)> {
     return env;
 }
 
-pub struct Result {pub status: ProcessExit, pub out: String, pub err: String}
+pub struct Result {pub status: ProcessExit, pub out: StrBuf, pub err: StrBuf}
 
 pub fn run(lib_path: &str,
            prog: &str,
-           args: &[String],
-           env: Vec<(String, String)> ,
-           input: Option<String>) -> Option<Result> {
+           args: &[StrBuf],
+           env: Vec<(StrBuf, StrBuf)> ,
+           input: Option<StrBuf>) -> Option<Result> {
 
     let env = env.clone().append(target_env(lib_path, prog).as_slice());
     match Command::new(prog).args(args).env(env.as_slice()).spawn() {
@@ -69,9 +69,9 @@ pub fn run(lib_path: &str,
 
 pub fn run_background(lib_path: &str,
            prog: &str,
-           args: &[String],
-           env: Vec<(String, String)> ,
-           input: Option<String>) -> Option<Process> {
+           args: &[StrBuf],
+           env: Vec<(StrBuf, StrBuf)> ,
+           input: Option<StrBuf>) -> Option<Process> {
 
     let env = env.clone().append(target_env(lib_path, prog).as_slice());
     match Command::new(prog).args(args).env(env.as_slice()).spawn() {