---

yaml
---
r: 80750
b: refs/heads/try
c: 24fdb1d
h: refs/heads/master
v: v3

Author: catamorphism

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 1ac37d50c0096f13604c7ca249517b76ff1f1802
+refs/heads/try: 24fdb1d102eaa062a8a6213ec28803885192a694
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rustpkg.md

@@ -52,13 +52,11 @@ A valid workspace must contain each of the following subdirectories:
      rustpkg will install libraries for bar to `foo/lib/x86_64-apple-darwin/`.
      The libraries will have names of the form `foo/lib/x86_64-apple-darwin/libbar-[hash].dylib`,
      where [hash] is a hash of the package ID.
-* 'bin/': `rustpkg install` installs executable binaries into a target-specific subdirectory of this directory.
+* 'bin/': `rustpkg install` installs executable binaries into this directory.
 
-     For example, on a 64-bit machine running Mac OS X,
-     if `foo` is a workspace, containing the package `bar`,
-     rustpkg will install executables for `bar` to
-     `foo/bin/x86_64-apple-darwin/`.
-     The executables will have names of the form `foo/bin/x86_64-apple-darwin/bar`.
+     For example, rustpkg will install executables for `bar` to
+     `foo/bin`.
+     The executables will have names of the form `foo/bin/bar`.
 * 'build/': `rustpkg build` stores temporary build artifacts in a target-specific subdirectory of this directory.
 
      For example, on a 64-bit machine running Mac OS X,
@@ -85,6 +83,12 @@ rustpkg also interprets any dependencies on such a package ID literally
 Thus, `github.com/mozilla/rust#5c4cd30f80` is also a valid package ID,
 since git can deduce that 5c4cd30f80 refers to a revision of the desired repository.
 
+A package identifier can name a subdirectory of another package.
+For example, if `foo` is a workspace, and `foo/src/bar/lib.rs` exists,
+as well as `foo/src/bar/extras/baz/lib.rs`,
+then both `bar` and `bar/extras/baz` are valid package identifiers
+in the workspace `foo`.
+
 ## Source files
 
 rustpkg searches for four different fixed filenames in order to determine the crates to build:
@@ -140,9 +144,11 @@ but not in their `lib` or `bin` directories.
 
 ## install
 
-`rustpkg install foo` builds the libraries and/or executables that are targets for `foo`,
-and then installs them either into `foo`'s `lib` and `bin` directories,
-or into the `lib` and `bin` subdirectories of the first entry in `RUST_PATH`.
+`rustpkg install foo` builds the libraries and/or executables that are targets for `foo`.
+If `RUST_PATH` is declared as an environment variable, then rustpkg installs the
+libraries and executables into the `lib` and `bin` subdirectories
+of the first entry in `RUST_PATH`.
+Otherwise, it installs them into `foo`'s `lib` and `bin` directories.
 
 ## test
 

branches/try/mk/rt.mk

@@ -75,7 +75,6 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/rust_rng.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
-              rt/rust_crate_map.cpp \
               rt/isaac/randport.cpp \
               rt/miniz.cpp \
               rt/memory_region.cpp \

branches/try/src/libextra/fileinput.rs

@@ -417,20 +417,23 @@ mod test {
 
     use super::{FileInput, make_path_option_vec, input_vec, input_vec_state};
 
-    use std::io;
+    use std::rt::io;
+    use std::rt::io::Writer;
+    use std::rt::io::file;
     use std::uint;
     use std::vec;
 
     fn make_file(path : &Path, contents: &[~str]) {
-        let file = io::file_writer(path, [io::Create, io::Truncate]).unwrap();
+        let mut file = file::open(path, io::CreateOrTruncate, io::Write).unwrap();
 
         for str in contents.iter() {
-            file.write_str(*str);
-            file.write_char('\n');
+            file.write(str.as_bytes());
+            file.write(['\n' as u8]);
         }
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_make_path_option_vec() {
         let strs = [~"some/path",
                     ~"some/other/path"];
@@ -445,6 +448,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_fileinput_read_byte() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -475,6 +479,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_fileinput_read() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -495,6 +500,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec() {
         let mut all_lines = ~[];
         let filenames = make_path_option_vec(vec::from_fn(
@@ -518,6 +524,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec_state() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -540,6 +547,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_empty_files() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -564,18 +572,21 @@ mod test {
     }
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_no_trailing_newline() {
         let f1 =
             Some(Path("tmp/lib-fileinput-test-no-trailing-newline-1.tmp"));
         let f2 =
             Some(Path("tmp/lib-fileinput-test-no-trailing-newline-2.tmp"));
 
-        let wr = io::file_writer(f1.get_ref(),
-                                 [io::Create, io::Truncate]).unwrap();
-        wr.write_str("1\n2");
-        let wr = io::file_writer(f2.get_ref(),
-                                 [io::Create, io::Truncate]).unwrap();
-        wr.write_str("3\n4");
+        {
+            let mut wr = file::open(f1.get_ref(), io::CreateOrTruncate,
+                                    io::Write).unwrap();
+            wr.write("1\n2".as_bytes());
+            let mut wr = file::open(f2.get_ref(), io::CreateOrTruncate,
+                                    io::Write).unwrap();
+            wr.write("3\n4".as_bytes());
+        }
 
         let mut lines = ~[];
         do input_vec(~[f1, f2]) |line| {
@@ -587,6 +598,7 @@ mod test {
 
 
     #[test]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_next_file() {
         let filenames = make_path_option_vec(vec::from_fn(
             3,
@@ -618,6 +630,7 @@ mod test {
 
     #[test]
     #[should_fail]
+    #[ignore(cfg(windows))] // FIXME(#8810): rt::io::file and windows don't agree
     fn test_input_vec_missing_file() {
         do input_vec(make_path_option_vec([~"this/file/doesnt/exist"], true)) |line| {
             println(line);

branches/try/src/librustc/metadata/filesearch.rs

@@ -77,15 +77,15 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
             if !found {
                 let rustpath = rust_path();
                 for path in rustpath.iter() {
-                    debug!("is %s in visited_dirs? %?",
-                            path.push("lib").to_str(),
-                            visited_dirs.contains(&path.push("lib").to_str()));
+                    let tlib_path = make_rustpkg_target_lib_path(path, self.target_triple);
+                    debug!("is %s in visited_dirs? %?", tlib_path.to_str(),
+                            visited_dirs.contains(&tlib_path.to_str()));
 
-                    if !visited_dirs.contains(&path.push("lib").to_str()) {
-                        visited_dirs.insert(path.push("lib").to_str());
+                    if !visited_dirs.contains(&tlib_path.to_str()) {
+                        visited_dirs.insert(tlib_path.to_str());
                         // Don't keep searching the RUST_PATH if one match turns up --
                         // if we did, we'd get a "multiple matching crates" error
-                        match f(&path.push("lib")) {
+                        match f(&tlib_path) {
                            FileMatches => {
                                break;
                            }
@@ -145,6 +145,11 @@ fn make_target_lib_path(sysroot: &Path,
     sysroot.push_rel(&relative_target_lib_path(target_triple))
 }
 
+fn make_rustpkg_target_lib_path(dir: &Path,
+                        target_triple: &str) -> Path {
+    dir.push_rel(&Path(libdir()).push(target_triple.to_owned()))
+}
+
 fn get_or_default_sysroot() -> Path {
     match os::self_exe_path() {
       option::Some(ref p) => (*p).pop(),

branches/try/src/librustc/middle/trans/build.rs

@@ -655,9 +655,9 @@ pub fn FastCall(cx: @mut Block, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef {
 }
 
 pub fn CallWithConv(cx: @mut Block, Fn: ValueRef, Args: &[ValueRef],
-                    Conv: CallConv, sret: bool) -> ValueRef {
+                    Conv: CallConv) -> ValueRef {
     if cx.unreachable { return _UndefReturn(cx, Fn); }
-    B(cx).call_with_conv(Fn, Args, Conv, sret)
+    B(cx).call_with_conv(Fn, Args, Conv)
 }
 
 pub fn AtomicFence(cx: @mut Block, order: AtomicOrdering) {

branches/try/src/librustc/middle/trans/builder.rs

@@ -13,7 +13,6 @@ use lib::llvm::llvm;
 use lib::llvm::{CallConv, AtomicBinOp, AtomicOrdering, AsmDialect};
 use lib::llvm::{Opcode, IntPredicate, RealPredicate, False};
 use lib::llvm::{ValueRef, BasicBlockRef, BuilderRef, ModuleRef};
-use lib::llvm::{StructRetAttribute};
 use middle::trans::base;
 use middle::trans::common::*;
 use middle::trans::machine::llalign_of_min;
@@ -779,9 +778,14 @@ impl Builder {
 
     pub fn call(&self, llfn: ValueRef, args: &[ValueRef]) -> ValueRef {
         self.count_insn("call");
+
+        debug!("Call(llfn=%s, args=%?)",
+               self.ccx.tn.val_to_str(llfn),
+               args.map(|arg| self.ccx.tn.val_to_str(*arg)));
+
         do args.as_imm_buf |ptr, len| {
             unsafe {
-                llvm::LLVMBuildCall(self.llbuilder, llfn, ptr, len as c_uint, noname())
+            llvm::LLVMBuildCall(self.llbuilder, llfn, ptr, len as c_uint, noname())
             }
         }
     }
@@ -797,16 +801,12 @@ impl Builder {
     }
 
     pub fn call_with_conv(&self, llfn: ValueRef, args: &[ValueRef],
-                         conv: CallConv, sret: bool) -> ValueRef {
+                        conv: CallConv) -> ValueRef {
         self.count_insn("callwithconv");
         unsafe {
             let v = llvm::LLVMBuildCall(self.llbuilder, llfn, vec::raw::to_ptr(args),
                                         args.len() as c_uint, noname());
             lib::llvm::SetInstructionCallConv(v, conv);
-            if sret {
-                let return_slot = 1;
-                llvm::LLVMAddInstrAttribute(v, return_slot, StructRetAttribute as c_uint);
-            }
             v
         }
     }

branches/try/src/librustc/middle/trans/foreign.rs

@@ -266,7 +266,7 @@ pub fn trans_native_call(bcx: @mut Block,
         }
     };
 
-    let llforeign_retval = CallWithConv(bcx, llfn, llargs_foreign, cc, fn_type.sret);
+    let llforeign_retval = CallWithConv(bcx, llfn, llargs_foreign, cc);
 
     // If the function we just called does not use an outpointer,
     // store the result into the rust outpointer. Cast the outpointer

branches/try/src/librustpkg/package_source.rs

@@ -18,7 +18,7 @@ use context::*;
 use crate::Crate;
 use messages::*;
 use source_control::{git_clone, git_clone_general};
-use path_util::{find_dir_using_rust_path_hack, default_workspace};
+use path_util::{find_dir_using_rust_path_hack, default_workspace, make_dir_rwx_recursive};
 use util::compile_crate;
 use workspace::is_workspace;
 use workcache_support;
@@ -197,12 +197,14 @@ impl PkgSrc {
                   url, clone_target.to_str(), pkgid.version.to_str());
 
         if git_clone_general(url, &clone_target, &pkgid.version) {
-            // since the operation succeeded, move clone_target to local
-            if !os::rename_file(&clone_target, local) {
-                 None
+            // Since the operation succeeded, move clone_target to local.
+            // First, create all ancestor directories.
+            if make_dir_rwx_recursive(&local.pop())
+                && os::rename_file(&clone_target, local) {
+                 Some(local.clone())
             }
             else {
-                 Some(local.clone())
+                 None
             }
         }
         else {