---

yaml
---
r: 144591
b: refs/heads/try2
c: 91d6c60
h: refs/heads/master
i:
  144589: 2e9f552
  144587: d3d9629
  144583: f932257
  144575: 2d1f308
v: v3

Author: erickt

[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: 8002a09bf915bd186e4e455b25265b4160bfd125
+refs/heads/try2: 91d6c60bed2c5d574ca524ab4812f731118cd22d
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/librustc/middle/kind.rs

@@ -129,7 +129,7 @@ fn check_impl_of_trait(cx: Context, it: @item, trait_ref: &trait_ref, self_type:
 
     // If this trait has builtin-kind supertraits, meet them.
     let self_ty: ty::t = ty::node_id_to_type(cx.tcx, it.id);
-    debug!("checking impl with self type %?", ty::get(self_ty).sty);
+    error!("checking impl with self type %?", ty::get(self_ty).sty);
     do check_builtin_bounds(cx, self_ty, trait_def.bounds) |missing| {
         cx.tcx.sess.span_err(self_type.span,
             fmt!("the type `%s', which does not fulfill `%s`, cannot implement this \

branches/try2/src/librustpkg/api.rs

@@ -20,12 +20,7 @@ use std::hashmap::*;
 /// Convenience functions intended for calling from pkg.rs
 
 fn default_ctxt(p: @Path) -> Ctx {
-    Ctx {
-        use_rust_path_hack: false,
-        sysroot_opt: Some(p),
-        json: false,
-        dep_cache: @mut HashMap::new()
-    }
+    Ctx { sysroot_opt: Some(p), json: false, dep_cache: @mut HashMap::new() }
 }
 
 pub fn build_lib(sysroot: @Path, root: Path, name: ~str, version: Version,

branches/try2/src/librustpkg/conditions.rs

@@ -36,11 +36,3 @@ condition! {
 condition! {
     no_rust_path: (~str) -> super::Path;
 }
-
-condition! {
-    not_a_workspace: (~str) -> super::Path;
-}
-
-condition! {
-    failed_to_create_temp_dir: (~str) -> super::Path;
-}

branches/try2/src/librustpkg/context.rs

@@ -15,11 +15,6 @@ use std::hashmap::HashMap;
 use std::os;
 
 pub struct Ctx {
-    // If use_rust_path_hack is true, rustpkg searches for sources
-    // in *package* directories that are in the RUST_PATH (for example,
-    // FOO/src/bar-0.1 instead of FOO). The flag doesn't affect where
-    // rustpkg stores build artifacts.
-    use_rust_path_hack: bool,
     // Sysroot -- if this is None, uses rustc filesearch's
     // idea of the default
     sysroot_opt: Option<@Path>,

branches/try2/src/librustpkg/package_source.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-extern mod extra;
-
 use target::*;
 use package_id::PkgId;
 use std::path::Path;
@@ -18,9 +16,8 @@ use context::*;
 use crate::Crate;
 use messages::*;
 use source_control::{git_clone, git_clone_general};
-use path_util::{pkgid_src_in_workspace, find_dir_using_rust_path_hack, default_workspace};
+use path_util::pkgid_src_in_workspace;
 use util::compile_crate;
-use workspace::is_workspace;
 
 // An enumeration of the unpacked source of a package workspace.
 // This contains a list of files found in the source workspace.
@@ -51,7 +48,7 @@ impl PkgSrc {
     }
 
 
-    fn check_dir(&self, cx: &Ctx) -> Path {
+    fn check_dir(&self) -> Path {
         use conditions::nonexistent_package::cond;
 
         debug!("Pushing onto root: %s | %s", self.id.path.to_str(), self.root.to_str());
@@ -62,21 +59,12 @@ impl PkgSrc {
 
         let dir = match path {
             Some(d) => (*d).clone(),
-            None => {
-                match self.fetch_git() {
-                    Some(d) => d,
-                    None => {
-                        match find_dir_using_rust_path_hack(cx, &self.id) {
-                            Some(d) => d,
-                            None => cond.raise((self.id.clone(),
-                               ~"supplied path for package dir does not \
-                                 exist, and couldn't interpret it as a URL fragment"))
-                        }
-                    }
-                }
+            None => match self.fetch_git() {
+                Some(d) => d,
+                None => cond.raise((self.id.clone(), ~"supplied path for package dir does not \
+                                      exist, and couldn't interpret it as a URL fragment"))
             }
         };
-        debug!("For package id %s, returning %s", self.id.to_str(), dir.to_str());
         if !os::path_is_dir(&dir) {
             cond.raise((self.id.clone(), ~"supplied path for package dir is a \
                                         non-directory"));
@@ -91,19 +79,11 @@ impl PkgSrc {
     /// refers to a git repo on the local version, also check it out.
     /// (right now we only support git)
     pub fn fetch_git(&self) -> Option<Path> {
-        use conditions::failed_to_create_temp_dir::cond;
-
-        // We use a temporary directory because if the git clone fails,
-        // it creates the target directory anyway and doesn't delete it
-
-        let scratch_dir = extra::tempfile::mkdtemp(&os::tmpdir(), "rustpkg");
-        let clone_target = match scratch_dir {
-            Some(d) => d.push("rustpkg_temp"),
-            None    => cond.raise(~"Failed to create temporary directory for fetching git sources")
-        };
 
         let mut local = self.root.push("src");
         local = local.push(self.id.to_str());
+        // Git can't clone into a non-empty directory
+        os::remove_dir_recursive(&local);
 
         debug!("Checking whether %s exists locally. Cwd = %s, does it? %?",
                self.id.path.to_str(),
@@ -113,28 +93,15 @@ impl PkgSrc {
         if os::path_exists(&self.id.path) {
             debug!("%s exists locally! Cloning it into %s",
                    self.id.path.to_str(), local.to_str());
-            // Ok to use local here; we know it will succeed
             git_clone(&self.id.path, &local, &self.id.version);
             return Some(local);
         }
 
-        if (self.id.path.clone()).components().len() < 2 {
-            // If a non-URL, don't bother trying to fetch
-            return None;
-        }
-
         let url = fmt!("https://%s", self.id.path.to_str());
         note(fmt!("Fetching package: git clone %s %s [version=%s]",
-                  url, clone_target.to_str(), self.id.version.to_str()));
-
-        if git_clone_general(url, &clone_target, &self.id.version) {
-            // since the operation succeeded, move clone_target to local
-            if !os::rename_file(&clone_target, &local) {
-                 None
-            }
-            else {
-                 Some(local)
-            }
+                  url, local.to_str(), self.id.version.to_str()));
+        if git_clone_general(url, &local, &self.id.version) {
+            Some(local)
         }
         else {
             None
@@ -171,10 +138,10 @@ impl PkgSrc {
 
     /// Infers crates to build. Called only in the case where there
     /// is no custom build logic
-    pub fn find_crates(&mut self, cx: &Ctx) {
+    pub fn find_crates(&mut self) {
         use conditions::missing_pkg_files::cond;
 
-        let dir = self.check_dir(cx);
+        let dir = self.check_dir();
         debug!("Called check_dir, I'm in %s", dir.to_str());
         let prefix = dir.components.len();
         debug!("Matching against %?", self.id.short_name);
@@ -216,7 +183,6 @@ impl PkgSrc {
     fn build_crates(&self,
                     ctx: &Ctx,
                     src_dir: &Path,
-                    destination_dir: &Path,
                     crates: &[Crate],
                     cfgs: &[~str],
                     what: OutputType) {
@@ -228,8 +194,8 @@ impl PkgSrc {
             let result = compile_crate(ctx,
                                        &self.id,
                                        path,
-                                       // compile_crate wants the destination workspace
-                                       destination_dir,
+                                       // compile_crate wants the workspace
+                                       &self.root,
                                        crate.flags,
                                        crate.cfgs + cfgs,
                                        false,
@@ -243,39 +209,15 @@ impl PkgSrc {
         }
     }
 
-    pub fn build(&self, ctx: &Ctx, cfgs: ~[~str]) -> Path {
-        use conditions::not_a_workspace::cond;
-
-        // Determine the destination workspace (which depends on whether
-        // we're using the rust_path_hack)
-        let destination_workspace = if is_workspace(&self.root) {
-            debug!("%s is indeed a workspace", self.root.to_str());
-            self.root.clone()
-        }
-        else {
-            // It would be nice to have only one place in the code that checks
-            // for the use_rust_path_hack flag...
-            if ctx.use_rust_path_hack {
-                let rs = default_workspace();
-                debug!("Using hack: %s", rs.to_str());
-                rs
-            }
-            else {
-                cond.raise(fmt!("Package root %s is not a workspace; pass in --rust_path_hack \
-                                if you want to treat it as a package source", self.root.to_str()))
-            }
-        };
-
-        let dir = self.check_dir(ctx);
-        debug!("Building libs in %s, destination = %s", dir.to_str(),
-            destination_workspace.to_str());
-        self.build_crates(ctx, &dir, &destination_workspace, self.libs, cfgs, Lib);
+    pub fn build(&self, ctx: &Ctx, cfgs: ~[~str]) {
+        let dir = self.check_dir();
+        debug!("Building libs in %s", dir.to_str());
+        self.build_crates(ctx, &dir, self.libs, cfgs, Lib);
         debug!("Building mains");
-        self.build_crates(ctx, &dir, &destination_workspace, self.mains, cfgs, Main);
+        self.build_crates(ctx, &dir, self.mains, cfgs, Main);
         debug!("Building tests");
-        self.build_crates(ctx, &dir, &destination_workspace, self.tests, cfgs, Test);
+        self.build_crates(ctx, &dir, self.tests, cfgs, Test);
         debug!("Building benches");
-        self.build_crates(ctx, &dir, &destination_workspace, self.benchs, cfgs, Bench);
-        destination_workspace
+        self.build_crates(ctx, &dir, self.benchs, cfgs, Bench);
     }
 }

branches/try2/src/librustpkg/path_util.rs

@@ -14,7 +14,6 @@ pub use package_id::PkgId;
 pub use target::{OutputType, Main, Lib, Test, Bench, Target, Build, Install};
 pub use version::{Version, NoVersion, split_version_general, try_parsing_version};
 pub use rustc::metadata::filesearch::rust_path;
-use context::Ctx;
 
 use std::libc::consts::os::posix88::{S_IRUSR, S_IWUSR, S_IXUSR};
 use std::os::mkdir_recursive;
@@ -52,23 +51,18 @@ pub fn make_dir_rwx(p: &Path) -> bool { os::make_dir(p, U_RWX) }
 pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
     debug!("Checking in src dir of %s for %s",
            workspace.to_str(), pkgid.to_str());
-    workspace_contains_package_id_(pkgid, workspace, |p| { p.push("src") }).is_some()
-}
 
-pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path,
-// Returns the directory it was actually found in
-             workspace_to_src_dir: &fn(&Path) -> Path) -> Option<Path> {
-    let src_dir = workspace_to_src_dir(workspace);
+    let src_dir = workspace.push("src");
 
-    let mut found = None;
+    let mut found = false;
     do os::walk_dir(&src_dir) |p| {
         debug!("=> p = %s", p.to_str());
 
-        if os::path_is_dir(p) {
+        let was_found = os::path_is_dir(p) && {
             debug!("p = %s, path = %s [%s]", p.to_str(), pkgid.path.to_str(),
                    src_dir.push_rel(&pkgid.path).to_str());
 
-            if *p == src_dir.push_rel(&pkgid.path) || {
+            *p == src_dir.push_rel(&pkgid.path) || {
                 let pf = p.filename();
                 do pf.iter().any |pf| {
                     let g = pf.to_str();
@@ -82,15 +76,16 @@ pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path,
                         }
                     }
                 }
-            } {
-                found = Some(p.clone());
             }
-
         };
+
+        if was_found {
+            found = true
+        }
         true
     };
 
-    debug!(if found.is_some() { fmt!("Found %s in %s", pkgid.to_str(), workspace.to_str()) }
+    debug!(if found { fmt!("Found %s in %s", pkgid.to_str(), workspace.to_str()) }
            else     { fmt!("Didn't find %s in %s", pkgid.to_str(), workspace.to_str()) });
     found
 }
@@ -128,7 +123,8 @@ pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<
         Some(result)
     }
     else {
-        debug!("built_executable_in_workspace: %s does not exist", result.to_str());
+        // This is not an error, but it's worth logging it
+        error!(fmt!("built_executable_in_workspace: %s does not exist", result.to_str()));
         None
     }
 }
@@ -168,7 +164,7 @@ pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Pat
 
 /// Does the actual searching stuff
 pub fn installed_library_in_workspace(short_name: &str, workspace: &Path) -> Option<Path> {
-    // This could break once we're handling multiple versions better -- I should add a test for it
+    // NOTE: this could break once we're handling multiple versions better... want a test for it
     library_in_workspace(&Path(short_name), short_name, Install, workspace, "lib", &NoVersion)
 }
 
@@ -250,8 +246,8 @@ pub fn library_in_workspace(path: &Path, short_name: &str, where: Target,
     } // for
 
     if result_filename.is_none() {
-        debug!("warning: library_in_workspace didn't find a library in %s for %s",
-                  dir_to_search.to_str(), short_name);
+        warn(fmt!("library_in_workspace didn't find a library in %s for %s",
+                  dir_to_search.to_str(), short_name));
     }
 
     // Return the filename that matches, which we now know exists
@@ -396,25 +392,3 @@ pub fn uninstall_package_from(workspace: &Path, pkgid: &PkgId) {
     }
 
 }
-
-fn dir_has_file(dir: &Path, file: &str) -> bool {
-    assert!(dir.is_absolute());
-    os::path_exists(&dir.push(file))
-}
-
-pub fn find_dir_using_rust_path_hack(cx: &Ctx, p: &PkgId) -> Option<Path> {
-    if !cx.use_rust_path_hack {
-        return None;
-    }
-    let rp = rust_path();
-    for dir in rp.iter() {
-        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())
-    }
-    None
-}