---

yaml
---
r: 81889
b: refs/heads/master
c: 252c6db
h: refs/heads/master
i:
  81887: 58d2b2e
v: v3

Author: dcrewi

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eb2b25dd6d38157213742b048fad63fa4ceec691
+refs/heads/master: 252c6dbe857c3440c889928b451790a52106f5c6
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/configure

@@ -848,8 +848,6 @@ do
         # Disable term-info, linkage of which comes in multiple forms,
         # making our snapshots incompatible (#9334)
         LLVM_OPTS="$LLVM_OPTS --disable-terminfo"
-        # Try to have LLVM pull in as few dependencies as possible (#9397)
-        LLVM_OPTS="$LLVM_OPTS --disable-zlib --disable-libffi"
 
         case "$CFG_C_COMPILER" in
             ("ccache clang")

trunk/src/libextra/crypto/md5.rs

@@ -156,7 +156,7 @@ static C4: [u32, ..16] = [
 
 
 /// The MD5 Digest algorithm
-struct Md5 {
+pub struct Md5 {
     priv length_bytes: u64,
     priv buffer: FixedBuffer64,
     priv state: Md5State,

trunk/src/libextra/crypto/sha2.rs

@@ -230,7 +230,8 @@ impl Engine512 {
 }
 
 
-struct Sha512 {
+/// The SHA-512 hash algorithm
+pub struct Sha512 {
     priv engine: Engine512
 }
 
@@ -282,7 +283,8 @@ static H512: [u64, ..8] = [
 ];
 
 
-struct Sha384 {
+/// The SHA-384 hash algorithm
+pub struct Sha384 {
     priv engine: Engine512
 }
 
@@ -332,7 +334,8 @@ static H384: [u64, ..8] = [
 ];
 
 
-struct Sha512Trunc256 {
+/// The SHA-512 hash algorithm with digest truncated to 256 bits
+pub struct Sha512Trunc256 {
     priv engine: Engine512
 }
 
@@ -380,7 +383,8 @@ static H512_TRUNC_256: [u64, ..8] = [
 ];
 
 
-struct Sha512Trunc224 {
+/// The SHA-512 hash algorithm with digest truncated to 224 bits
+pub struct Sha512Trunc224 {
     priv engine: Engine512
 }
 
@@ -635,7 +639,8 @@ impl Engine256 {
 }
 
 
-struct Sha256 {
+/// The SHA-256 hash algorithm
+pub struct Sha256 {
     priv engine: Engine256
 }
 
@@ -687,7 +692,8 @@ static H256: [u32, ..8] = [
 ];
 
 
-struct Sha224 {
+/// The SHA-224 hash algorithm
+pub struct Sha224 {
     priv engine: Engine256
 }
 

trunk/src/librustpkg/package_source.rs

@@ -59,8 +59,7 @@ impl PkgSrc {
         use conditions::nonexistent_package::cond;
 
         debug!("Checking package source for package ID %s, \
-               workspace = %s use_rust_path_hack = %?",
-               id.to_str(), workspace.to_str(), use_rust_path_hack);
+               workspace = %s", id.to_str(), workspace.to_str());
 
         let mut to_try = ~[];
         if use_rust_path_hack {

trunk/src/librustpkg/path_util.rs

@@ -421,16 +421,11 @@ fn dir_has_file(dir: &Path, file: &str) -> bool {
 pub fn find_dir_using_rust_path_hack(p: &PkgId) -> Option<Path> {
     let rp = rust_path();
     for dir in rp.iter() {
-        // Require that the parent directory match the package ID
-        // Note that this only matches if the package ID being searched for
-        // has a name that's a single component
-        if dir.is_parent_of(&p.path) || dir.is_parent_of(&versionize(&p.path, &p.version)) {
-            debug!("In find_dir_using_rust_path_hack: checking dir %s", dir.to_str());
-            if dir_has_file(dir, "lib.rs") || dir_has_file(dir, "main.rs")
-                || dir_has_file(dir, "test.rs") || dir_has_file(dir, "bench.rs") {
-                debug!("Did find id %s in dir %s", p.to_str(), dir.to_str());
-                return Some(dir.clone());
-            }
+        debug!("In find_dir_using_rust_path_hack: checking dir %s", dir.to_str());
+        if dir_has_file(dir, "lib.rs") || dir_has_file(dir, "main.rs")
+            || dir_has_file(dir, "test.rs") || dir_has_file(dir, "bench.rs") {
+            debug!("Did find id %s in dir %s", p.to_str(), dir.to_str());
+            return Some(dir.clone());
         }
         debug!("Didn't find id %s in dir %s", p.to_str(), dir.to_str())
     }
@@ -445,11 +440,3 @@ pub fn user_set_rust_path() -> bool {
         Some(_)         => true
     }
 }
-
-/// Append the version string onto the end of the path's filename
-fn versionize(p: &Path, v: &Version) -> Path {
-    let q = p.file_path().to_str();
-    p.with_filename(fmt!("%s-%s", q, v.to_str()))
-}
-
-

trunk/src/librustpkg/tests.rs

@@ -1267,9 +1267,7 @@ fn test_rust_path_can_contain_package_dirs_without_flag() {
 #[test]
 fn rust_path_hack_cwd() {
    // Same as rust_path_hack_test, but the CWD is the dir to build out of
-   let cwd = mkdtemp(&os::tmpdir(), "foo").expect("rust_path_hack_cwd");
-   let cwd = cwd.push("foo");
-   assert!(os::mkdir_recursive(&cwd, U_RWX));
+   let cwd = mkdtemp(&os::tmpdir(), "pkg_files").expect("rust_path_hack_cwd");
    writeFile(&cwd.push("lib.rs"), "pub fn f() { }");
 
    let dest_workspace = mk_empty_workspace(&Path("bar"), &NoVersion, "dest_workspace");
@@ -1765,41 +1763,6 @@ fn reinstall() {
     assert_built_executable_exists(&workspace, b.short_name);
 }
 
-#[test]
-fn correct_package_name_with_rust_path_hack() {
-    /*
-    Set rust_path_hack flag
-
-    Try to install bar
-    Check that:
-    - no output gets produced in any workspace
-    - there's an error
-    */
-
-    // Set RUST_PATH to something containing only the sources for foo
-    let foo_id = PkgId::new("foo");
-    let bar_id = PkgId::new("bar");
-    let foo_workspace = create_local_package(&foo_id);
-    let dest_workspace = mk_empty_workspace(&Path("bar"), &NoVersion, "dest_workspace");
-
-    writeFile(&dest_workspace.push_many(["src", "bar-0.1", "main.rs"]),
-              "extern mod blat; fn main() { let _x = (); }");
-
-    let rust_path = Some(~[(~"RUST_PATH", fmt!("%s:%s", 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_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"));
-    assert!(!lib_exists(&dest_workspace, &foo_id.path.clone(), foo_id.version.clone()));
-    assert!(!executable_exists(&foo_workspace, "bar"));
-    assert!(!lib_exists(&foo_workspace, &bar_id.path.clone(), bar_id.version.clone()));
-    assert!(!executable_exists(&foo_workspace, "foo"));
-    assert!(!lib_exists(&foo_workspace, &foo_id.path.clone(), foo_id.version.clone()));
-}
-
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};

trunk/src/librustpkg/util.rs

@@ -439,30 +439,26 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
                         let pkg_id = PkgId::new(lib_name);
                         let workspaces = pkg_parent_workspaces(&self.context.context,
                                                                &pkg_id);
-                        let source_workspace = if workspaces.is_empty() {
-                            error(fmt!("Couldn't find package %s \
-                                       in any of the workspaces in the RUST_PATH (%s)",
-                                       lib_name,
-                                       rust_path().map(|s| s.to_str()).connect(":")));
+                        let dep_workspace = if workspaces.is_empty() {
+                            error(fmt!("Couldn't find package %s, which is needed by %s, \
+                                            in any of the workspaces in the RUST_PATH (%?)",
+                                            lib_name,
+                                            self.parent.to_str(),
+                                            rust_path()));
                             cond.raise((pkg_id.clone(), ~"Dependency not found"))
                         }
-                            else {
+                        else {
                             workspaces[0]
                         };
                         let (outputs_disc, inputs_disc) =
-                            self.context.install(PkgSrc::new(source_workspace.clone(),
-                            // Use the rust_path_hack to search for dependencies iff
-                            // we were already using it
-                            self.context.context.use_rust_path_hack,
+                            self.context.install(PkgSrc::new(dep_workspace.clone(),
+                                                             false,
                                                              pkg_id),
                                                  &JustOne(Path(
-                                    lib_crate_filename)));
+                                                    lib_crate_filename)));
                         debug!("Installed %s, returned %? dependencies and \
                                %? transitive dependencies",
                                lib_name, outputs_disc.len(), inputs_disc.len());
-                        // It must have installed *something*...
-                        assert!(!outputs_disc.is_empty());
-                        let target_workspace = outputs_disc[0].pop();
                         for dep in outputs_disc.iter() {
                             debug!("Discovering a binary input: %s", dep.to_str());
                             self.exec.discover_input("binary",
@@ -475,24 +471,31 @@ impl<'self> Visitor<()> for ViewItemVisitor<'self> {
                                                          *dep,
                                                          digest_file_with_date(&Path(*dep)));
                             }
-                                else if *what == ~"binary" {
+                            else if *what == ~"binary" {
                                 self.exec.discover_input(*what,
                                                          *dep,
                                                          digest_only_date(&Path(*dep)));
                             }
-                                else {
+                            else {
                                 fail!("Bad kind: %s", *what);
                             }
                         }
                         // Also, add an additional search path
-                        debug!("Installed %s into %s", lib_name, target_workspace.to_str());
-                        (self.save)(target_workspace);
+                        debug!("Adding additional search path: %s", lib_name);
+                        let installed_library =
+                            installed_library_in_workspace(&Path(lib_name), &dep_workspace)
+                                .expect(fmt!("rustpkg failed to install dependency %s",
+                                              lib_name));
+                        let install_dir = installed_library.pop();
+                        debug!("Installed %s into %s [%?]", lib_name, install_dir.to_str(),
+                               datestamp(&installed_library));
+                        (self.save)(install_dir);
                     }
-                }
-            }
+                }}
             // Ignore `use`s
             _ => ()
         }
+
         visit::walk_view_item(self, vi, env)
     }
 }

trunk/src/libstd/logging.rs

@@ -10,11 +10,11 @@
 
 //! Logging
 
-use fmt;
 use option::*;
 use os;
 use rt;
 use rt::logging::{Logger, StdErrLogger};
+use send_str::SendStrOwned;
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -37,17 +37,7 @@ pub fn console_off() {
     rt::logging::console_off();
 }
 
-#[cfg(stage0)]
-#[doc(hidden)]
-pub fn log(_level: u32, s: ~str) {
-    // this is a terrible approximation, but it gets the job done (for stage0 at
-    // least)
-    ::io::println(s);
-}
-
-#[allow(missing_doc)]
-#[cfg(not(stage0))]
-pub fn log(_level: u32, args: &fmt::Arguments) {
+fn newsched_log_str(msg: ~str) {
     use rt::task::Task;
     use rt::local::Local;
 
@@ -56,13 +46,20 @@ pub fn log(_level: u32, args: &fmt::Arguments) {
         match optional_task {
             Some(local) => {
                 // Use the available logger
-                (*local).logger.log(args);
+                (*local).logger.log(SendStrOwned(msg));
             }
             None => {
                 // There is no logger anywhere, just write to stderr
                 let mut logger = StdErrLogger;
-                logger.log(args);
+                logger.log(SendStrOwned(msg));
             }
         }
     }
 }
+
+// XXX: This will change soon to not require an allocation. This is an unstable
+//      api which should not be used outside of the macros in ext/expand.
+#[doc(hidden)]
+pub fn log(_level: u32, msg: ~str) {
+    newsched_log_str(msg);
+}

trunk/src/libstd/path.rs

@@ -233,21 +233,6 @@ pub trait GenericPath : Clone + Eq + ToStr {
         result
     }
 
-
-    /// Returns `true` iff `child` is a suffix of `parent`. See the test
-    /// case for examples.
-    fn is_parent_of(&self, child: &Self) -> bool {
-        if !self.is_absolute() || child.is_absolute()
-            || self.components().len() < child.components().len()
-            || self.components().is_empty() {
-            return false;
-        }
-        let child_components = child.components().len();
-        let parent_components = self.components().len();
-        let to_drop = self.components().len() - child_components;
-        self.components().slice(to_drop, parent_components) == child.components()
-    }
-
     fn components<'a>(&'a self) -> &'a [~str];
 }
 
@@ -1465,43 +1450,4 @@ mod tests {
 
     }
 
-
-    #[test]
-    fn test_is_parent_of() {
-        fn is_parent_of_pp(p: &PosixPath, q: &PosixPath) -> bool {
-            p.is_parent_of(q)
-        }
-
-        assert!(is_parent_of_pp(&PosixPath("/a/b/c/d/e"), &PosixPath("c/d/e")));
-        assert!(!is_parent_of_pp(&PosixPath("a/b/c/d/e"), &PosixPath("c/d/e")));
-        assert!(!is_parent_of_pp(&PosixPath("/a/b/c/d/e"), &PosixPath("/c/d/e")));
-        assert!(!is_parent_of_pp(&PosixPath(""), &PosixPath("")));
-        assert!(!is_parent_of_pp(&PosixPath(""), &PosixPath("a/b/c")));
-        assert!(is_parent_of_pp(&PosixPath("/a/b/c"), &PosixPath("")));
-        assert!(is_parent_of_pp(&PosixPath("/a/b/c"), &PosixPath("a/b/c")));
-        assert!(!is_parent_of_pp(&PosixPath("/a/b/c"), &PosixPath("d/e/f")));
-
-        fn is_parent_of_wp(p: &WindowsPath, q: &WindowsPath) -> bool {
-            p.is_parent_of(q)
-        }
-
-        let abcde = WindowsPath("C:\\a\\b\\c\\d\\e");
-        let rel_abcde = WindowsPath("a\\b\\c\\d\\e");
-        let cde   = WindowsPath("c\\d\\e");
-        let slashcde = WindowsPath("C:\\c\\d\\e");
-        let empty = WindowsPath("");
-        let abc = WindowsPath("C:\\a\\b\\c");
-        let rel_abc = WindowsPath("a\\b\\c");
-        let def = WindowsPath("d\\e\\f");
-
-        assert!(is_parent_of_wp(&abcde, &cde));
-        assert!(!is_parent_of_wp(&rel_abcde, &cde));
-        assert!(!is_parent_of_wp(&abcde, &slashcde));
-        assert!(!is_parent_of_wp(&empty, &empty));
-        assert!(!is_parent_of_wp(&empty, &rel_abc));
-        assert!(is_parent_of_wp(&abc, &empty));
-        assert!(is_parent_of_wp(&abc, &rel_abc));
-        assert!(!is_parent_of_wp(&abc, &def));
-    }
-
 }

trunk/src/libstd/prelude.rs

@@ -72,10 +72,10 @@ pub use from_str::FromStr;
 pub use to_bytes::IterBytes;
 pub use to_str::{ToStr, ToStrConsume};
 pub use tuple::{CopyableTuple, ImmutableTuple};
-pub use tuple::{Tuple1, ImmutableTuple1};
-pub use tuple::{Tuple2, Tuple3, Tuple4, Tuple5};
-pub use tuple::{Tuple6, Tuple7, Tuple8, Tuple9};
-pub use tuple::{Tuple10, Tuple11, Tuple12};
+pub use tuple::{CloneableTuple1, ImmutableTuple1};
+pub use tuple::{CloneableTuple2, CloneableTuple3, CloneableTuple4, CloneableTuple5};
+pub use tuple::{CloneableTuple6, CloneableTuple7, CloneableTuple8, CloneableTuple9};
+pub use tuple::{CloneableTuple10, CloneableTuple11, CloneableTuple12};
 pub use tuple::{ImmutableTuple2, ImmutableTuple3, ImmutableTuple4, ImmutableTuple5};
 pub use tuple::{ImmutableTuple6, ImmutableTuple7, ImmutableTuple8, ImmutableTuple9};
 pub use tuple::{ImmutableTuple10, ImmutableTuple11, ImmutableTuple12};