---

yaml
---
r: 95358
b: refs/heads/dist-snap
c: 7bad416
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 399a42575a3a5392277e4034812ce32c4f491929
+refs/heads/dist-snap: 7bad4167654ef846155bae7165fd0ffcc24fcbbe
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/lib/llvm.rs

@@ -15,7 +15,8 @@
 
 use std::c_str::ToCStr;
 use std::hashmap::HashMap;
-use std::libc::{c_uint, c_ushort};
+use std::libc::{c_uint, c_ushort, c_void, free};
+use std::str::raw::from_c_str;
 use std::option;
 
 use middle::trans::type_::Type;
@@ -1666,6 +1667,7 @@ pub mod llvm {
                                             -> ValueRef;
 
         pub fn LLVMDICompositeTypeSetTypeArray(CompositeType: ValueRef, TypeArray: ValueRef);
+        pub fn LLVMTypeToString(Type: TypeRef) -> *c_char;
 
         pub fn LLVMIsAArgument(value_ref: ValueRef) -> ValueRef;
 
@@ -1789,68 +1791,15 @@ impl TypeNames {
         self.named_types.find_equiv(&s).map(|x| Type::from_ref(*x))
     }
 
-    // We have a depth count, because we seem to make infinite types.
-    pub fn type_to_str_depth(&self, ty: Type, depth: int) -> ~str {
-        match self.find_name(&ty) {
-            option::Some(name) => return name.to_owned(),
-            None => ()
-        }
-
-        if depth == 0 {
-            return ~"###";
-        }
-
+    pub fn type_to_str(&self, ty: Type) -> ~str {
         unsafe {
-            let kind = ty.kind();
-
-            match kind {
-                Void => ~"Void",
-                Half => ~"Half",
-                Float => ~"Float",
-                Double => ~"Double",
-                X86_FP80 => ~"X86_FP80",
-                FP128 => ~"FP128",
-                PPC_FP128 => ~"PPC_FP128",
-                Label => ~"Label",
-                Vector => ~"Vector",
-                Metadata => ~"Metadata",
-                X86_MMX => ~"X86_MMAX",
-                Integer => {
-                    format!("i{}", llvm::LLVMGetIntTypeWidth(ty.to_ref()) as int)
-                }
-                Function => {
-                    let out_ty = ty.return_type();
-                    let args = ty.func_params();
-                    let args =
-                        args.map(|&ty| self.type_to_str_depth(ty, depth-1)).connect(", ");
-                    let out_ty = self.type_to_str_depth(out_ty, depth-1);
-                    format!("fn({}) -> {}", args, out_ty)
-                }
-                Struct => {
-                    let tys = ty.field_types();
-                    let tys = tys.map(|&ty| self.type_to_str_depth(ty, depth-1)).connect(", ");
-                    format!("\\{{}\\}", tys)
-                }
-                Array => {
-                    let el_ty = ty.element_type();
-                    let el_ty = self.type_to_str_depth(el_ty, depth-1);
-                    let len = ty.array_length();
-                    format!("[{} x {}]", el_ty, len)
-                }
-                Pointer => {
-                    let el_ty = ty.element_type();
-                    let el_ty = self.type_to_str_depth(el_ty, depth-1);
-                    format!("*{}", el_ty)
-                }
-                _ => fail2!("Unknown Type Kind ({})", kind as uint)
-            }
+            let s = llvm::LLVMTypeToString(ty.to_ref());
+            let ret = from_c_str(s);
+            free(s as *c_void);
+            ret
         }
     }
 
-    pub fn type_to_str(&self, ty: Type) -> ~str {
-        self.type_to_str_depth(ty, 30)
-    }
-
     pub fn types_to_str(&self, tys: &[Type]) -> ~str {
         let strs = tys.map(|t| self.type_to_str(*t));
         format!("[{}]", strs.connect(","))

branches/dist-snap/src/librustpkg/context.rs

@@ -210,11 +210,11 @@ impl RustcFlags {
 }
 
 /// Returns true if any of the flags given are incompatible with the cmd
-pub fn flags_forbidden_for_cmd(flags: &RustcFlags,
+pub fn flags_ok_for_cmd(flags: &RustcFlags,
                         cfgs: &[~str],
                         cmd: &str, user_supplied_opt_level: bool) -> bool {
     let complain = |s| {
-        println!("The {} option can only be used with the `build` command:
+        println!("The {} option can only be used with the build command:
                   rustpkg [options..] build {} [package-ID]", s, s);
     };
 

branches/dist-snap/src/librustpkg/exit_codes.rs

@@ -9,6 +9,3 @@
 // except according to those terms.
 
 pub static COPY_FAILED_CODE: int = 65;
-pub static BAD_FLAG_CODE: int    = 67;
-pub static NONEXISTENT_PACKAGE_CODE: int = 68;
-

branches/dist-snap/src/librustpkg/rustpkg.rs

@@ -50,7 +50,7 @@ use package_source::PkgSrc;
 use target::{WhatToBuild, Everything, is_lib, is_main, is_test, is_bench, Tests};
 // use workcache_support::{discover_outputs, digest_only_date};
 use workcache_support::digest_only_date;
-use exit_codes::{COPY_FAILED_CODE, BAD_FLAG_CODE};
+use exit_codes::COPY_FAILED_CODE;
 
 pub mod api;
 mod conditions;
@@ -701,7 +701,7 @@ pub fn main_args(args: &[~str]) -> int {
             return 1;
         }
     };
-    let help = matches.opt_present("h") ||
+    let mut help = matches.opt_present("h") ||
                    matches.opt_present("help");
     let no_link = matches.opt_present("no-link");
     let no_trans = matches.opt_present("no-trans");
@@ -798,11 +798,8 @@ pub fn main_args(args: &[~str]) -> int {
             return 0;
         }
         Some(cmd) => {
-            let bad_option = context::flags_forbidden_for_cmd(&rustc_flags,
-                                                              cfgs,
-                                                              *cmd,
-                                                              user_supplied_opt_level);
-            if help || bad_option {
+            help |= context::flags_ok_for_cmd(&rustc_flags, cfgs, *cmd, user_supplied_opt_level);
+            if help {
                 match *cmd {
                     ~"build" => usage::build(),
                     ~"clean" => usage::clean(),
@@ -817,12 +814,7 @@ pub fn main_args(args: &[~str]) -> int {
                     ~"unprefer" => usage::unprefer(),
                     _ => usage::general()
                 };
-                if bad_option {
-                    return BAD_FLAG_CODE;
-                }
-                else {
-                    return 0;
-                }
+                return 0;
             } else {
                 cmd
             }

branches/dist-snap/src/librustpkg/tests.rs

@@ -36,7 +36,6 @@ use syntax::diagnostic;
 use target::*;
 use package_source::PkgSrc;
 use source_control::{CheckedOutSources, DirToUse, safe_git_clone};
-use exit_codes::{BAD_FLAG_CODE, COPY_FAILED_CODE};
 use util::datestamp;
 
 fn fake_ctxt(sysroot: Path, workspace: &Path) -> BuildContext {
@@ -245,26 +244,14 @@ fn rustpkg_exec() -> Path {
 fn command_line_test(args: &[~str], cwd: &Path) -> ProcessOutput {
     match command_line_test_with_env(args, cwd, None) {
         Success(r) => r,
-        Fail(error) => fail2!("Command line test failed with error {}", error)
+        _ => fail2!("Command line test failed")
     }
 }
 
 fn command_line_test_partial(args: &[~str], cwd: &Path) -> ProcessResult {
     command_line_test_with_env(args, cwd, None)
 }
 
-fn command_line_test_expect_fail(args: &[~str],
-                                 cwd: &Path,
-                                 env: Option<~[(~str, ~str)]>,
-                                 expected_exitcode: int) {
-    match command_line_test_with_env(args, cwd, env) {
-        Success(_) => fail2!("Should have failed with {}, but it succeeded", expected_exitcode),
-        Fail(error) if error == expected_exitcode => (), // ok
-        Fail(other) => fail2!("Expected to fail with {}, but failed with {} instead",
-                              expected_exitcode, other)
-    }
-}
-
 enum ProcessResult {
     Success(ProcessOutput),
     Fail(int) // exit code
@@ -1461,11 +1448,11 @@ fn compile_flag_fail() {
     let p_id = PkgId::new("foo");
     let workspace = create_local_package(&p_id);
     let workspace = workspace.path();
-    command_line_test_expect_fail([test_sysroot().to_str(),
+    command_line_test([test_sysroot().to_str(),
                        ~"install",
                        ~"--no-link",
                        ~"foo"],
-                      workspace, None, BAD_FLAG_CODE);
+                      workspace);
     assert!(!built_executable_exists(workspace, "foo"));
     assert!(!object_file_exists(workspace, "foo"));
 }
@@ -1501,11 +1488,14 @@ fn notrans_flag_fail() {
     let flags_to_test = [~"--no-trans", ~"--parse-only",
                          ~"--pretty", ~"-S"];
     for flag in flags_to_test.iter() {
-        command_line_test_expect_fail([test_sysroot().to_str(),
+        command_line_test([test_sysroot().to_str(),
                            ~"install",
                            flag.clone(),
                            ~"foo"],
-                          workspace, None, BAD_FLAG_CODE);
+                          workspace);
+        // Ideally we'd test that rustpkg actually fails, but
+        // since task failure doesn't set the exit code properly,
+        // we can't tell
         assert!(!built_executable_exists(workspace, "foo"));
         assert!(!object_file_exists(workspace, "foo"));
         assert!(!lib_exists(workspace, &Path("foo"), NoVersion));
@@ -1532,11 +1522,11 @@ fn dash_S_fail() {
     let p_id = PkgId::new("foo");
     let workspace = create_local_package(&p_id);
     let workspace = workspace.path();
-    command_line_test_expect_fail([test_sysroot().to_str(),
+    command_line_test([test_sysroot().to_str(),
                        ~"install",
                        ~"-S",
                        ~"foo"],
-                       workspace, None, BAD_FLAG_CODE);
+                      workspace);
     assert!(!built_executable_exists(workspace, "foo"));
     assert!(!object_file_exists(workspace, "foo"));
     assert!(!assembly_file_exists(workspace, "foo"));
@@ -1597,13 +1587,11 @@ fn test_emit_llvm_S_fail() {
     let p_id = PkgId::new("foo");
     let workspace = create_local_package(&p_id);
     let workspace = workspace.path();
-    command_line_test_expect_fail([test_sysroot().to_str(),
+    command_line_test([test_sysroot().to_str(),
                        ~"install",
                        ~"-S", ~"--emit-llvm",
                        ~"foo"],
-                       workspace,
-                       None,
-                       BAD_FLAG_CODE);
+                      workspace);
     assert!(!built_executable_exists(workspace, "foo"));
     assert!(!object_file_exists(workspace, "foo"));
     assert!(!llvm_assembly_file_exists(workspace, "foo"));
@@ -1632,13 +1620,11 @@ fn test_emit_llvm_fail() {
     let p_id = PkgId::new("foo");
     let workspace = create_local_package(&p_id);
     let workspace = workspace.path();
-    command_line_test_expect_fail([test_sysroot().to_str(),
+    command_line_test([test_sysroot().to_str(),
                        ~"install",
                        ~"--emit-llvm",
                        ~"foo"],
-                                  workspace,
-                                  None,
-                                  BAD_FLAG_CODE);
+                      workspace);
     assert!(!built_executable_exists(workspace, "foo"));
     assert!(!object_file_exists(workspace, "foo"));
     assert!(!llvm_bitcode_file_exists(workspace, "foo"));
@@ -1679,10 +1665,11 @@ fn test_build_install_flags_fail() {
                      ~[~"--target", host_triple()],
                      ~[~"--target-cpu", ~"generic"],
                      ~[~"-Z", ~"--time-passes"]];
-    let cwd = os::getcwd();
     for flag in forbidden.iter() {
-        command_line_test_expect_fail([test_sysroot().to_str(),
-                           ~"list"] + *flag, &cwd, None, BAD_FLAG_CODE);
+        let output = command_line_test_output([test_sysroot().to_str(),
+                           ~"list"] + *flag);
+        assert!(output.len() > 1);
+        assert!(output[1].find_str("can only be used with").is_some());
     }
 }
 
@@ -1699,7 +1686,6 @@ fn test_optimized_build() {
     assert!(built_executable_exists(workspace, "foo"));
 }
 
-#[test]
 fn pkgid_pointing_to_subdir() {
     // The actual repo is mocki.8713187.xyz/mozilla/some_repo
     // rustpkg should recognize that and treat the part after some_repo/ as a subdir
@@ -1731,7 +1717,6 @@ fn pkgid_pointing_to_subdir() {
     assert_executable_exists(workspace, "testpkg");
 }
 
-#[test]
 fn test_recursive_deps() {
     let a_id = PkgId::new("a");
     let b_id = PkgId::new("b");
@@ -1777,7 +1762,6 @@ fn test_install_to_rust_path() {
     assert!(!executable_exists(second_workspace, "foo"));
 }
 
-#[test]
 fn test_target_specific_build_dir() {
     let p_id = PkgId::new("foo");
     let workspace = create_local_package(&p_id);
@@ -1886,9 +1870,8 @@ fn correct_package_name_with_rust_path_hack() {
     let rust_path = Some(~[(~"RUST_PATH", format!("{}:{}", dest_workspace.to_str(),
                         foo_workspace.push_many(["src", "foo-0.1"]).to_str()))]);
     // bar doesn't exist, but we want to make sure rustpkg doesn't think foo is bar
-    command_line_test_expect_fail([~"install", ~"--rust-path-hack", ~"bar"],
-                                  // FIXME #3408: Should be NONEXISTENT_PACKAGE_CODE
-                               dest_workspace, rust_path, COPY_FAILED_CODE);
+    command_line_test_with_env([~"install", ~"--rust-path-hack", ~"bar"],
+                               dest_workspace, rust_path);
     assert!(!executable_exists(dest_workspace, "bar"));
     assert!(!lib_exists(dest_workspace, &bar_id.path.clone(), bar_id.version.clone()));
     assert!(!executable_exists(dest_workspace, "foo"));
@@ -2067,23 +2050,6 @@ fn test_7402() {
     assert_executable_exists(dest_workspace, "foo");
 }
 
-#[test]
-fn test_compile_error() {
-    let foo_id = PkgId::new("foo");
-    let foo_workspace = create_local_package(&foo_id);
-    let foo_workspace = foo_workspace.path();
-    let main_crate = foo_workspace.push_many(["src", "foo-0.1", "main.rs"]);
-    // Write something bogus
-    writeFile(&main_crate, "pub fn main() { if 42 != ~\"the answer\" { fail!(); } }");
-    let result = command_line_test_partial([~"build", ~"foo"], foo_workspace);
-    match result {
-        Success(*) => fail2!("Failed by succeeding!"), // should be a compile error
-        Fail(status) => {
-            debug2!("Failed with status {:?}... that's good, right?", status);
-        }
-    }
-}
-
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};

branches/dist-snap/src/rustllvm/RustWrapper.cpp

@@ -803,3 +803,10 @@ extern "C" void LLVMDICompositeTypeSetTypeArray(
 {
     unwrapDI<DICompositeType>(CompositeType).setTypeArray(unwrapDI<DIArray>(TypeArray));
 }
+
+extern "C" char *LLVMTypeToString(LLVMTypeRef Type) {
+    std::string s;
+    llvm::raw_string_ostream os(s);
+    unwrap<llvm::Type>(Type)->print(os);
+    return strdup(os.str().data());
+}

branches/dist-snap/src/rustllvm/rustllvm.def.in

@@ -628,3 +628,4 @@ LLVMRustSetNormalizedTarget
 LLVMRustAddAlwaysInlinePass
 LLVMAddReturnAttribute
 LLVMRemoveReturnAttribute
+LLVMTypeToString