---

yaml
---
r: 65919
b: refs/heads/master
c: 7d1065e
h: refs/heads/master
i:
  65917: 5bc7eec
  65915: 0974675
  65911: b37ffe4
  65903: d8d977e
  65887: 62ec0fa
  65855: 5928e78
  65791: dfdf50b
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e3c4104d746d87fc0f747005908c0b1ec209b3e4
+refs/heads/master: 7d1065e913e6d50ddb1a157f81bb7752caeca329
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/librustc/middle/lang_items.rs

@@ -441,6 +441,5 @@ pub fn collect_language_items(crate: @crate,
     let mut collector = LanguageItemCollector(crate, session);
     collector.collect();
     let LanguageItemCollector { items, _ } = collector;
-    session.abort_if_errors();
     items
 }

trunk/src/librustpkg/messages.rs

@@ -69,7 +69,6 @@ impl PkgId {
             }
         };
 
-        debug!("local_path = %s, remote_path = %s", local_path.to_str(), remote_path.to_str());
         PkgId {
             local_path: local_path,
             remote_path: remote_path,
@@ -91,7 +90,11 @@ impl PkgId {
 
 impl ToStr for PkgId {
     fn to_str(&self) -> ~str {
+        let maybe_dash = match self.version {
+            NoVersion => "",
+            _         => "-"
+        };
         // should probably use the filestem and not the whole path
-        fmt!("%s-%s", self.local_path.to_str(), self.version.to_str())
+        fmt!("%s%s%s", self.local_path.to_str(), maybe_dash, self.version.to_str())
     }
 }

trunk/src/librustpkg/package_id.rs

@@ -15,9 +15,8 @@ use core::option::*;
 use core::{os, run, str, vec};
 use context::*;
 use crate::Crate;
-use messages::*;
 use path_util::pkgid_src_in_workspace;
-use util::compile_crate;
+use util::{compile_crate, note};
 use version::{ExactRevision, SemanticVersion, NoVersion};
 
 // An enumeration of the unpacked source of a package workspace.
@@ -96,7 +95,7 @@ impl PkgSrc {
         };
 
 
-        note(fmt!("Fetching package: git clone %s %s %?", url, local.to_str(), branch_args));
+        note(fmt!("git clone %s %s %?", url, local.to_str(), branch_args));
 
         if run::process_output("git",
                                ~[~"clone", copy url, local.to_str()] + branch_args).status != 0 {

trunk/src/librustpkg/package_source.rs

@@ -11,16 +11,12 @@
 // rustpkg utilities having to do with paths and directories
 
 use core::prelude::*;
-pub use package_path::{RemotePath, LocalPath, normalize};
+pub use package_path::{RemotePath, LocalPath};
 pub use package_id::PkgId;
 pub use target::{OutputType, Main, Lib, Test, Bench, Target, Build, Install};
-pub use version::{Version, NoVersion, split_version_general};
 use core::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 use core::os::mkdir_recursive;
 use core::os;
-use core::iterator::IteratorUtil;
-use messages::*;
-use package_id::*;
 
 /// Returns the value of RUST_PATH, as a list
 /// of Paths. In general this should be read from the
@@ -42,39 +38,8 @@ pub fn make_dir_rwx(p: &Path) -> bool { os::make_dir(p, u_rwx) }
 /// True if there's a directory in <workspace> with
 /// pkgid's short name
 pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
-    let src_dir = workspace.push("src");
-    for os::list_dir(&src_dir).each |&p| {
-        let p = Path(p);
-        debug!("=> p = %s", p.to_str());
-        if !os::path_is_dir(&src_dir.push_rel(&p)) {
-            loop;
-        }
-        debug!("p = %s, remote_path = %s", p.to_str(), pkgid.remote_path.to_str());
-
-        if p == *pkgid.remote_path {
-            return true;
-        }
-        else {
-            let pf = p.filename();
-            for pf.iter().advance |&pf| {
-                let f_ = copy pf;
-                let g = f_.to_str();
-                match split_version_general(g, '-') {
-                    Some((ref might_match, ref vers)) => {
-                        debug!("might_match = %s, vers = %s", *might_match,
-                               vers.to_str());
-                        if *might_match == pkgid.short_name
-                            && (*vers == pkgid.version || pkgid.version == NoVersion)
-                        {
-                            return true;
-                        }
-                    }
-                    None => ()
-                }
-            }
-        }
-    }
-    false
+    let pkgpath = workspace.push("src").push(pkgid.remote_path.to_str());
+    os::path_is_dir(&pkgpath)
 }
 
 /// Returns a list of possible directories
@@ -149,34 +114,31 @@ fn output_in_workspace(pkgid: &PkgId, workspace: &Path, what: OutputType) -> Opt
 /// Figure out what the library name for <pkgid> in <workspace>'s build
 /// directory is, and if the file exists, return it.
 pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Path> {
-    library_in_workspace(&pkgid.local_path, pkgid.short_name,
-                         Build, workspace, "build")
+                        // passing in local_path here sounds fishy
+    library_in_workspace(pkgid.local_path.to_str(), pkgid.short_name, Build,
+                         workspace, "build")
 }
 
 /// Does the actual searching stuff
 pub fn installed_library_in_workspace(short_name: &str, workspace: &Path) -> Option<Path> {
-    library_in_workspace(&normalize(RemotePath(Path(short_name))),
-                         short_name, Install, workspace, "lib")
+    library_in_workspace(short_name, short_name, Install, workspace, "lib")
 }
 
 
 /// This doesn't take a PkgId, so we can use it for `extern mod` inference, where we
 /// don't know the entire package ID.
-/// `workspace` is used to figure out the directory to search.
+/// `full_name` is used to figure out the directory to search.
 /// `short_name` is taken as the link name of the library.
-pub fn library_in_workspace(path: &LocalPath, short_name: &str, where: Target,
+fn library_in_workspace(full_name: &str, short_name: &str, where: Target,
                         workspace: &Path, prefix: &str) -> Option<Path> {
     debug!("library_in_workspace: checking whether a library named %s exists",
            short_name);
 
     // We don't know what the hash is, so we have to search through the directory
     // contents
 
-    debug!("short_name = %s where = %? workspace = %s \
-            prefix = %s", short_name, where, workspace.to_str(), prefix);
-
     let dir_to_search = match where {
-        Build => workspace.push(prefix).push_rel(&**path),
+        Build => workspace.push(prefix).push(full_name),
         Install => workspace.push(prefix)
     };
     debug!("Listing directory %s", dir_to_search.to_str());
@@ -231,11 +193,7 @@ pub fn library_in_workspace(path: &LocalPath, short_name: &str, where: Target,
     // Return the filename that matches, which we now know exists
     // (if result_filename != None)
     match result_filename {
-        None => {
-            warn(fmt!("library_in_workspace didn't find a library in %s for %s",
-                            dir_to_search.to_str(), short_name));
-            None
-        }
+        None => None,
         Some(result_filename) => {
             let absolute_path = dir_to_search.push_rel(&result_filename);
             debug!("result_filename = %s", absolute_path.to_str());
@@ -252,17 +210,17 @@ pub fn target_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
 }
 
 
-/// Returns the executable that would be installed for <pkgid>
-/// in <workspace>
+/// Returns the installed path for <built_library> in <workspace>
 /// As a side effect, creates the lib-dir if it doesn't exist
-pub fn target_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
+pub fn target_library_in_workspace(workspace: &Path,
+                                   built_library: &Path) -> Path {
     use conditions::bad_path::cond;
-    if !os::path_is_dir(workspace) {
-        cond.raise((copy *workspace,
-                    fmt!("Workspace supplied to target_library_in_workspace \
-                          is not a directory! %s", workspace.to_str())));
+    let result = workspace.push("lib");
+    if !os::path_exists(&result) && !mkdir_recursive(&result, u_rwx) {
+        cond.raise((copy result, ~"I couldn't create the library directory"));
     }
-    target_file_in_workspace(pkgid, workspace, Lib, Install)
+    result.push(built_library.filename().expect(fmt!("I don't know how to treat %s as a library",
+                                                   built_library.to_str())))
 }
 
 /// Returns the test executable that would be installed for <pkgid>
@@ -291,9 +249,7 @@ fn target_file_in_workspace(pkgid: &PkgId, workspace: &Path,
     };
     let result = workspace.push(subdir);
     if !os::path_exists(&result) && !mkdir_recursive(&result, u_rwx) {
-        cond.raise((copy result, fmt!("target_file_in_workspace couldn't \
-            create the %s dir (pkgid=%s, workspace=%s, what=%?, where=%?",
-            subdir, pkgid.to_str(), workspace.to_str(), what, where)));
+        cond.raise((copy result, fmt!("I couldn't create the %s dir", subdir)));
     }
     mk_output_path(what, where, pkgid, &result)
 }
@@ -319,8 +275,7 @@ pub fn build_pkg_id_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path {
 /// given whether we're building a library and whether we're building tests
 pub fn mk_output_path(what: OutputType, where: Target,
                       pkg_id: &PkgId, workspace: &Path) -> Path {
-    let short_name_with_version = fmt!("%s-%s", pkg_id.short_name,
-                                       pkg_id.version.to_str());
+    let short_name_with_version = pkg_id.short_name_with_version();
     // Not local_path.dir_path()! For package foo/bar/blat/, we want
     // the executable blat-0.5 to live under blat/
     let dir = match where {
@@ -336,7 +291,7 @@ pub fn mk_output_path(what: OutputType, where: Target,
         // this code is duplicated from elsewhere; fix this
         Lib => dir.push(os::dll_filename(short_name_with_version)),
         // executable names *aren't* versioned
-        _ => dir.push(fmt!("%s%s%s", pkg_id.short_name,
+        _ => dir.push(fmt!("%s%s%s", copy pkg_id.short_name,
                            match what {
                                Test => "test",
                                Bench => "bench",

trunk/src/librustpkg/path_util.rs

@@ -36,20 +36,18 @@ use rustc::metadata::filesearch;
 use extra::{getopts};
 use syntax::{ast, diagnostic};
 use util::*;
-use messages::*;
 use path_util::{build_pkg_id_in_workspace, first_pkgid_src_in_workspace};
-use path_util::{u_rwx, rust_path};
+use path_util::u_rwx;
 use path_util::{built_executable_in_workspace, built_library_in_workspace};
 use path_util::{target_executable_in_workspace, target_library_in_workspace};
-use workspace::{each_pkg_parent_workspace, pkg_parent_workspaces};
+use workspace::pkg_parent_workspaces;
 use context::Ctx;
 use package_id::PkgId;
 use package_source::PkgSrc;
 
 mod conditions;
 mod context;
 mod crate;
-mod messages;
 mod package_id;
 mod package_path;
 mod package_source;
@@ -191,7 +189,7 @@ impl Ctx {
                 // The package id is presumed to be the first command-line
                 // argument
                 let pkgid = PkgId::new(copy args[0]);
-                for each_pkg_parent_workspace(&pkgid) |workspace| {
+                for pkg_parent_workspaces(&pkgid) |workspace| {
                     self.build(workspace, &pkgid);
                 }
             }
@@ -223,19 +221,8 @@ impl Ctx {
                 // The package id is presumed to be the first command-line
                 // argument
                 let pkgid = PkgId::new(args[0]);
-                let workspaces = pkg_parent_workspaces(&pkgid);
-                if workspaces.is_empty() {
-                    let rp = rust_path();
-                    assert!(!rp.is_empty());
-                    let src = PkgSrc::new(&rp[0], &build_pkg_id_in_workspace(&pkgid, &rp[0]),
-                                          &pkgid);
-                    src.fetch_git();
-                    self.install(&rp[0], &pkgid);
-                }
-                else {
-                    for each_pkg_parent_workspace(&pkgid) |workspace| {
-                        self.install(workspace, &pkgid);
-                    }
+                for pkg_parent_workspaces(&pkgid) |workspace| {
+                    self.install(workspace, &pkgid);
                 }
             }
             "prefer" => {
@@ -272,8 +259,6 @@ impl Ctx {
     }
 
     fn build(&self, workspace: &Path, pkgid: &PkgId) {
-        debug!("build: workspace = %s pkgid = %s", workspace.to_str(),
-               pkgid.to_str());
         let src_dir   = first_pkgid_src_in_workspace(pkgid, workspace);
         let build_dir = build_pkg_id_in_workspace(pkgid, workspace);
         debug!("Destination dir = %s", build_dir.to_str());
@@ -325,14 +310,14 @@ impl Ctx {
         // Do something reasonable for now
 
         let dir = build_pkg_id_in_workspace(id, workspace);
-        note(fmt!("Cleaning package %s (removing directory %s)",
+        util::note(fmt!("Cleaning package %s (removing directory %s)",
                         id.to_str(), dir.to_str()));
         if os::path_exists(&dir) {
             os::remove_dir_recursive(&dir);
-            note(fmt!("Removed directory %s", dir.to_str()));
+            util::note(fmt!("Removed directory %s", dir.to_str()));
         }
 
-        note(fmt!("Cleaned package %s", id.to_str()));
+        util::note(fmt!("Cleaned package %s", id.to_str()));
     }
 
     fn info(&self) {
@@ -353,7 +338,7 @@ impl Ctx {
         let maybe_executable = built_executable_in_workspace(id, workspace);
         let maybe_library = built_library_in_workspace(id, workspace);
         let target_exec = target_executable_in_workspace(id, workspace);
-        let target_lib = maybe_library.map(|_p| target_library_in_workspace(id, workspace));
+        let target_lib = maybe_library.map(|p| target_library_in_workspace(workspace, p));
 
         debug!("target_exec = %s target_lib = %? \
                 maybe_executable = %? maybe_library = %?",
@@ -407,7 +392,7 @@ pub fn main() {
     let matches = &match getopts::getopts(args, opts) {
         result::Ok(m) => m,
         result::Err(f) => {
-            error(fmt!("%s", getopts::fail_str(f)));
+            util::error(fmt!("%s", getopts::fail_str(f)));
 
             return;
         }
@@ -443,12 +428,8 @@ pub fn main() {
         };
     }
 
-    let sroot = match filesearch::get_rustpkg_sysroot() {
-        Ok(r) => Some(@r.pop().pop()), Err(_) => None
-    };
-    debug!("Using sysroot: %?", sroot);
     Ctx {
-        sysroot_opt: sroot, // Currently, only tests override this
+        sysroot_opt: None, // Currently, only tests override this
         json: json,
         dep_cache: @mut HashMap::new()
     }.run(cmd, args);

trunk/src/librustpkg/rustpkg.rc

@@ -22,4 +22,4 @@ pub fn find_library_in_search_path(sroot_opt: Option<@Path>, short_name: &str) -
         }
         None => None
     }
-}
+}