---

yaml
---
r: 145014
b: refs/heads/try2
c: 3d14e82
h: refs/heads/master
v: v3

Author: Jakub

[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: 323e8f07ff4d5b8e2e38fe94a13c55070ce66384
+refs/heads/try2: 3d14e82be752959fb010a786ef4c9ef417bd64db
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/rt.mk

@@ -75,6 +75,7 @@ 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/try2/src/librustc/middle/stack_check.rs

@@ -80,18 +80,6 @@ fn stack_check_item(v: StackCheckVisitor,
                 visit::walk_method_helper(&mut v, method, new_cx);
             }
         }
-        ast::item_trait(_, _, ref methods) => {
-            for method in methods.iter() {
-                match *method {
-                    ast::provided(@ref method) => {
-                        let safe_stack = fixed_stack_segment(method.attrs);
-                        let new_cx = Context {safe_stack: safe_stack, ..in_cx};
-                        visit::walk_method_helper(&mut v, method, new_cx);
-                    }
-                    ast::required(*) => ()
-                }
-            }
-        }
         _ => {
             visit::walk_item(&mut v, item, in_cx);
         }

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

@@ -4267,7 +4267,6 @@ pub fn is_binopable(cx: ctxt, ty: t, op: ast::BinOp) -> bool {
     static tycat_int: int = 3;
     static tycat_float: int = 4;
     static tycat_bot: int = 5;
-    static tycat_raw_ptr: int = 6;
 
     static opcat_add: int = 0;
     static opcat_sub: int = 1;
@@ -4311,7 +4310,6 @@ pub fn is_binopable(cx: ctxt, ty: t, op: ast::BinOp) -> bool {
           ty_int(_) | ty_uint(_) | ty_infer(IntVar(_)) => tycat_int,
           ty_float(_) | ty_infer(FloatVar(_)) => tycat_float,
           ty_bot => tycat_bot,
-          ty_ptr(_) => tycat_raw_ptr,
           _ => tycat_other
         }
     }
@@ -4326,8 +4324,7 @@ pub fn is_binopable(cx: ctxt, ty: t, op: ast::BinOp) -> bool {
     /*char*/    [f, f, f, f,     t,   t,  f,   f],
     /*int*/     [t, t, t, t,     t,   t,  t,   f],
     /*float*/   [t, t, t, f,     t,   t,  f,   f],
-    /*bot*/     [t, t, t, t,     f,   f,  t,   t],
-    /*raw ptr*/ [f, f, f, f,     t,   t,  f,   f]];
+    /*bot*/     [t, t, t, t,     f,   f,  t,   t]];
 
     return tbl[tycat(cx, ty)][opcat(op)];
 }

branches/try2/src/librustpkg/package_id.rs

@@ -99,35 +99,7 @@ impl PkgId {
     /// True if the ID has multiple components
     pub fn is_complex(&self) -> bool {
         self.short_name != self.path.to_str()
-    }
-
-    pub fn prefixes_iter(&self) -> Prefixes {
-        Prefixes {
-            components: self.path.components().to_owned(),
-            remaining: ~[]
-        }
-    }
-
-}
-
-struct Prefixes {
-    priv components: ~[~str],
-    priv remaining: ~[~str]
-}
-
-impl Iterator<(Path, Path)> for Prefixes {
-    #[inline]
-    fn next(&mut self) -> Option<(Path, Path)> {
-        if self.components.len() <= 1 {
-            None
-        }
-        else {
-            let last = self.components.pop();
-            self.remaining.push(last);
-            // converting to str and then back is a little unfortunate
-            Some((Path(self.components.to_str()), Path(self.remaining.to_str())))
-        }
-    }
+     }
 }
 
 impl ToStr for PkgId {
@@ -147,4 +119,3 @@ pub fn hash(data: ~str) -> ~str {
     write(hasher, data);
     hasher.result_str()
 }
-

branches/try2/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;
@@ -77,33 +77,6 @@ impl PkgSrc {
         let dir: Path = match path {
             Some(d) => (*d).clone(),
             None => {
-                // See if any of the prefixes of this package ID form a valid package ID
-                // That is, is this a package ID that points into the middle of a workspace?
-                for (prefix, suffix) in id.prefixes_iter() {
-                    let package_id = PkgId::new(prefix.to_str());
-                    let path = workspace.push("src").push_rel(&package_id.path);
-                    debug!("in loop: checking if %s is a directory", path.to_str());
-                    if os::path_is_dir(&path) {
-                        let ps = PkgSrc::new(workspace.clone(),
-                                             use_rust_path_hack,
-                                             PkgId::new(prefix.to_str()));
-                        debug!("pkgsrc: Returning [%s|%s|%s]", workspace.to_str(),
-                               ps.start_dir.push_rel(&suffix).to_str(), ps.id.to_str());
-
-                        return PkgSrc {
-                            workspace: workspace,
-                            start_dir: ps.start_dir.push_rel(&suffix),
-                            id: ps.id,
-                            libs: ~[],
-                            mains: ~[],
-                            tests: ~[],
-                            benchs: ~[]
-                        }
-
-                    };
-                }
-
-                // Ok, no prefixes work, so try fetching from git
                 let mut ok_d = None;
                 for w in to_try.iter() {
                     debug!("Calling fetch_git on %s", w.to_str());
@@ -120,17 +93,16 @@ impl PkgSrc {
                         if use_rust_path_hack {
                             match find_dir_using_rust_path_hack(&id) {
                                 Some(d) => d,
-                                None => {
-                                    cond.raise((id.clone(),
-                                        ~"supplied path for package dir does not \
-                                        exist, and couldn't interpret it as a URL fragment"))
-                                }
+                                None => cond.raise((id.clone(),
+                                    ~"supplied path for package dir does not \
+                                     exist, and couldn't interpret it as a URL fragment"))
                             }
                         }
                         else {
                             cond.raise((id.clone(),
-                                ~"supplied path for package dir does not \
-                                exist, and couldn't interpret it as a URL fragment"))
+                                        ~"supplied path for package dir does not \
+                                        exist, and couldn't interpret it as a URL fragment"))
+
                         }
                     }
                 }
@@ -143,9 +115,6 @@ impl PkgSrc {
                                         non-directory"));
         }
 
-        debug!("pkgsrc: Returning {%s|%s|%s}", workspace.to_str(),
-               dir.to_str(), id.to_str());
-
         PkgSrc {
             workspace: workspace,
             start_dir: dir,
@@ -197,12 +166,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 {

branches/try2/src/librustpkg/path_util.rs

@@ -43,22 +43,22 @@ pub static U_RWX: i32 = (S_IRUSR | S_IWUSR | S_IXUSR) as i32;
 /// succeeded.
 pub fn make_dir_rwx(p: &Path) -> bool { os::make_dir(p, U_RWX) }
 
+pub fn make_dir_rwx_recursive(p: &Path) -> bool { os::mkdir_recursive(p, U_RWX) }
+
 // n.b. The next three functions ignore the package version right
 // now. Should fix that.
 
 /// True if there's a directory in <workspace> with
 /// pkgid's short name
 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> {
-    if !os::path_is_dir(workspace) {
-        return None;
-    }
-
     let src_dir = workspace_to_src_dir(workspace);
 
     let mut found = None;
@@ -143,17 +143,9 @@ pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option<Pat
 }
 
 /// Does the actual searching stuff
-pub fn installed_library_in_workspace(pkg_path: &Path, workspace: &Path) -> Option<Path> {
+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
-    match pkg_path.filename() {
-        None => None,
-        Some(short_name) => library_in_workspace(pkg_path,
-                                                 short_name,
-                                                 Install,
-                                                 workspace,
-                                                 "lib",
-                                                 &NoVersion)
-    }
+    library_in_workspace(&Path(short_name), short_name, Install, workspace, "lib", &NoVersion)
 }
 
 /// `workspace` is used to figure out the directory to search.
@@ -399,12 +391,3 @@ pub fn find_dir_using_rust_path_hack(p: &PkgId) -> Option<Path> {
     }
     None
 }
-
-/// True if the user set RUST_PATH to something non-empty --
-/// as opposed to the default paths that rustpkg adds automatically
-pub fn user_set_rust_path() -> bool {
-    match os::getenv("RUST_PATH") {
-        None | Some(~"") => false,
-        Some(_)         => true
-    }
-}

branches/try2/src/librustpkg/rustpkg.rs

@@ -33,7 +33,7 @@ use rustc::metadata::filesearch::rust_path;
 use extra::{getopts};
 use syntax::{ast, diagnostic};
 use util::*;
-use messages::{error, warn, note};
+use messages::*;
 use path_util::build_pkg_id_in_workspace;
 use path_util::{U_RWX, in_rust_path};
 use path_util::{built_executable_in_workspace, built_library_in_workspace, default_workspace};
@@ -181,10 +181,7 @@ pub trait CtxMethods {
     /// second is a list of declared and discovered inputs
     fn install(&self, src: PkgSrc) -> (~[Path], ~[(~str, ~str)]);
     /// Returns a list of installed files
-    fn install_no_build(&self,
-                        source_workspace: &Path,
-                        target_workspace: &Path,
-                        id: &PkgId) -> ~[Path];
+    fn install_no_build(&self, workspace: &Path, id: &PkgId) -> ~[Path];
     fn prefer(&self, _id: &str, _vers: Option<~str>);
     fn test(&self);
     fn uninstall(&self, _id: &str, _vers: Option<~str>);
@@ -467,40 +464,28 @@ impl CtxMethods for BuildContext {
                 // install to the first workspace in the RUST_PATH if there's
                 // a non-default RUST_PATH. This code installs to the same
                 // workspace the package was built in.
-                let actual_workspace = if path_util::user_set_rust_path() {
-                    default_workspace()
-                }
-                else {
-                    Path(destination_workspace)
-                };
-                debug!("install: destination workspace = %s, id = %s, installing to %s",
-                       destination_workspace, id_str, actual_workspace.to_str());
-                let result = subself.install_no_build(&Path(destination_workspace),
-                                                      &actual_workspace,
-                                                      &sub_id);
+                debug!("install: destination workspace = %s, id = %s",
+                       destination_workspace, id_str);
+                let result = subself.install_no_build(&Path(destination_workspace), &sub_id);
                 debug!("install: id = %s, about to call discover_outputs, %?",
                        id_str, result.to_str());
 
                 discover_outputs(exec, result.clone());
                 sub_files.write(|r| { *r = result.clone(); });
                 sub_inputs.write(|r| { *r = *r + exec.lookup_discovered_inputs() });
-                note(fmt!("Installed package %s to %s", id_str, actual_workspace.to_str()));
             }
         };
         (installed_files.unwrap(), inputs.unwrap())
     }
 
-    fn install_no_build(&self,
-                        source_workspace: &Path,
-                        target_workspace: &Path,
-                        id: &PkgId) -> ~[Path] {
+    fn install_no_build(&self, workspace: &Path, id: &PkgId) -> ~[Path] {
         use conditions::copy_failed::cond;
 
         // Now copy stuff into the install dirs
-        let maybe_executable = built_executable_in_workspace(id, source_workspace);
-        let maybe_library = built_library_in_workspace(id, source_workspace);
-        let target_exec = target_executable_in_workspace(id, target_workspace);
-        let target_lib = maybe_library.map(|_p| target_library_in_workspace(id, target_workspace));
+        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));
 
         debug!("target_exec = %s target_lib = %? \
                 maybe_executable = %? maybe_library = %?",

branches/try2/src/librustpkg/search.rs

@@ -15,11 +15,10 @@ use version::Version;
 /// return Some(p) (returns the first one of there are multiple matches.) Return
 /// None if there's no such path.
 /// FIXME #8711: This ignores the desired version.
-pub fn find_installed_library_in_rust_path(pkg_path: &Path, _version: &Version) -> Option<Path> {
+pub fn find_installed_library_in_rust_path(short_name: &str, _version: &Version) -> Option<Path> {
     let rp = rust_path();
-    debug!("find_installed_library_in_rust_path: looking for path %s", pkg_path.to_str());
     for p in rp.iter() {
-        match installed_library_in_workspace(pkg_path, p) {
+        match installed_library_in_workspace(short_name, p) {
             Some(path) => return Some(path),
             None => ()
         }