---

yaml
---
r: 144437
b: refs/heads/try2
c: 87d9d37
h: refs/heads/master
i:
  144435: 411183c
v: v3

Author: emberian

[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: 1ac7d809af161abc7fb73d76bae4fd0fb2a4826d
+refs/heads/try2: 87d9d37c07c96ed2fe816e9cda6e3d1e14cda2fc
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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

@@ -13,15 +13,13 @@ use std::option;
 use std::os;
 use std::hashmap::HashSet;
 
-pub enum FileMatch { FileMatches, FileDoesntMatch }
-
 // A module for searching for libraries
 // FIXME (#2658): I'm not happy how this module turned out. Should
 // probably just be folded into cstore.
 
 /// Functions with type `pick` take a parent directory as well as
 /// a file found in that directory.
-pub type pick<'self> = &'self fn(path: &Path) -> FileMatch;
+pub type pick<'self, T> = &'self fn(path: &Path) -> Option<T>;
 
 pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
     if path.file_path() == file {
@@ -33,7 +31,7 @@ pub fn pick_file(file: Path, path: &Path) -> Option<Path> {
 
 pub trait FileSearch {
     fn sysroot(&self) -> @Path;
-    fn for_each_lib_search_path(&self, f: &fn(&Path) -> FileMatch);
+    fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) -> bool;
     fn get_target_lib_path(&self) -> Path;
     fn get_target_lib_file_path(&self, file: &Path) -> Path;
 }
@@ -49,51 +47,34 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
     }
     impl FileSearch for FileSearchImpl {
         fn sysroot(&self) -> @Path { self.sysroot }
-        fn for_each_lib_search_path(&self, f: &fn(&Path) -> FileMatch) {
+        fn for_each_lib_search_path(&self, f: &fn(&Path) -> bool) -> bool {
             let mut visited_dirs = HashSet::new();
-            let mut found = false;
 
             debug!("filesearch: searching additional lib search paths [%?]",
                    self.addl_lib_search_paths.len());
             for path in self.addl_lib_search_paths.iter() {
-                match f(path) {
-                    FileMatches => found = true,
-                    FileDoesntMatch => ()
-                }
+                f(path);
                 visited_dirs.insert(path.to_str());
             }
 
             debug!("filesearch: searching target lib path");
             let tlib_path = make_target_lib_path(self.sysroot,
                                         self.target_triple);
             if !visited_dirs.contains(&tlib_path.to_str()) {
-                match f(&tlib_path) {
-                    FileMatches => found = true,
-                    FileDoesntMatch => ()
+                if !f(&tlib_path) {
+                    return false;
                 }
             }
             visited_dirs.insert(tlib_path.to_str());
             // Try RUST_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 rustpath = rust_path();
+            for path in rustpath.iter() {
                     if !visited_dirs.contains(&path.push("lib").to_str()) {
+                        f(&path.push("lib"));
                         visited_dirs.insert(path.push("lib").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")) {
-                           FileMatches => {
-                               break;
-                           }
-                           FileDoesntMatch => ()
-                        }
                     }
-                }
             }
+            true
         }
         fn get_target_lib_path(&self) -> Path {
             make_target_lib_path(self.sysroot, self.target_triple)
@@ -112,26 +93,28 @@ pub fn mk_filesearch(maybe_sysroot: &Option<@Path>,
     } as @FileSearch
 }
 
-pub fn search(filesearch: @FileSearch, pick: pick) {
+pub fn search<T>(filesearch: @FileSearch, pick: pick<T>) -> Option<T> {
+    let mut rslt = None;
     do filesearch.for_each_lib_search_path() |lib_search_path| {
         debug!("searching %s", lib_search_path.to_str());
         let r = os::list_dir_path(lib_search_path);
-        let mut rslt = FileDoesntMatch;
         for path in r.iter() {
             debug!("testing %s", path.to_str());
             let maybe_picked = pick(path);
             match maybe_picked {
-                FileMatches => {
+                Some(_) => {
                     debug!("picked %s", path.to_str());
-                    rslt = FileMatches;
+                    rslt = maybe_picked;
+                    break;
                 }
-                FileDoesntMatch => {
+                None => {
                     debug!("rejected %s", path.to_str());
                 }
             }
         }
-        rslt
+        rslt.is_none()
     };
+    return rslt;
 }
 
 pub fn relative_target_lib_path(target_triple: &str) -> Path {

branches/try2/src/librustc/metadata/loader.rs

@@ -14,7 +14,7 @@
 use lib::llvm::{False, llvm, mk_object_file, mk_section_iter};
 use metadata::decoder;
 use metadata::encoder;
-use metadata::filesearch::{FileSearch, FileMatch, FileMatches, FileDoesntMatch};
+use metadata::filesearch::FileSearch;
 use metadata::filesearch;
 use syntax::codemap::span;
 use syntax::diagnostic::span_handler;
@@ -92,10 +92,10 @@ fn find_library_crate_aux(
     // want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
     let prefix = fmt!("%s%s-", prefix, crate_name);
     let mut matches = ~[];
-    filesearch::search(filesearch, |path| -> FileMatch {
+    filesearch::search(filesearch, |path| -> Option<()> {
       let path_str = path.filename();
       match path_str {
-          None => FileDoesntMatch,
+          None => None,
           Some(path_str) =>
               if path_str.starts_with(prefix) && path_str.ends_with(suffix) {
                   debug!("%s is a candidate", path.to_str());
@@ -104,20 +104,20 @@ fn find_library_crate_aux(
                           if !crate_matches(cvec, cx.metas, cx.hash) {
                               debug!("skipping %s, metadata doesn't match",
                                   path.to_str());
-                              FileDoesntMatch
+                              None
                           } else {
                               debug!("found %s with matching metadata", path.to_str());
                               matches.push((path.to_str(), cvec));
-                              FileMatches
+                              None
                           },
                       _ => {
                           debug!("could not load metadata for %s", path.to_str());
-                          FileDoesntMatch
+                          None
                       }
                   }
                }
                else {
-                   FileDoesntMatch
+                   None
                }
       }
     });

branches/try2/src/librustc/middle/trans/base.rs

@@ -2370,12 +2370,7 @@ pub fn create_entry_wrapper(ccx: @mut CrateContext,
             decl_cdecl_fn(ccx.llmod, "amain", llfty)
         } else {
             let main_name = match ccx.sess.targ_cfg.os {
-                session::os_win32 => {
-                    match ccx.sess.targ_cfg.arch {
-                        X86 => ~"WinMain@16",
-                        _ => ~"WinMain",
-                    }
-                },
+                session::os_win32 => ~"WinMain@16",
                 _ => ~"main",
             };
             decl_cdecl_fn(ccx.llmod, main_name, llfty)

branches/try2/src/librustpkg/path_util.rs

@@ -49,9 +49,6 @@ 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 {
-    debug!("Checking in src dir of %s for %s",
-           workspace.to_str(), pkgid.to_str());
-
     let src_dir = workspace.push("src");
 
     let mut found = false;
@@ -84,9 +81,6 @@ pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool {
         }
         true
     };
-
-    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
 }
 

branches/try2/src/librustpkg/rustpkg.rs

@@ -250,8 +250,6 @@ impl CtxMethods for Ctx {
                     // argument
                     let pkgid = PkgId::new(args[0]);
                     let workspaces = pkg_parent_workspaces(&pkgid);
-                    debug!("package ID = %s, found it in %? workspaces",
-                           pkgid.to_str(), workspaces.len());
                     if workspaces.is_empty() {
                         let rp = rust_path();
                         assert!(!rp.is_empty());

branches/try2/src/librustpkg/search.rs

@@ -8,8 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use path_util::{installed_library_in_workspace, rust_path};
-use version::Version;
+use path_util::installed_library_in_workspace;
 
 /// If a library with path `p` matching pkg_id's name exists under sroot_opt,
 /// return Some(p). Return None if there's no such path or if sroot_opt is None.
@@ -20,18 +19,3 @@ pub fn find_library_in_search_path(sroot_opt: Option<@Path>, short_name: &str) -
         installed_library_in_workspace(short_name, sroot)
     }
 }
-
-/// If some workspace `p` in the RUST_PATH contains a package matching short_name,
-/// 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(short_name: &str, _version: &Version) -> Option<Path> {
-    let rp = rust_path();
-    for p in rp.iter() {
-        match installed_library_in_workspace(short_name, p) {
-            Some(path) => return Some(path),
-            None => ()
-        }
-    }
-    None
-}

branches/try2/src/librustpkg/tests.rs

@@ -686,7 +686,7 @@ fn package_script_with_default_build() {
         push("testsuite").push("pass").push("src").push("fancy-lib").push("pkg.rs");
     debug!("package_script_with_default_build: %s", source.to_str());
     if !os::copy_file(&source,
-                      &dir.push("src").push("fancy-lib-0.1").push("pkg.rs")) {
+                      & dir.push("src").push("fancy-lib-0.1").push("pkg.rs")) {
         fail!("Couldn't copy file");
     }
     command_line_test([~"install", ~"fancy-lib"], &dir);
@@ -890,28 +890,20 @@ fn no_rebuilding_dep() {
     assert!(bar_date < foo_date);
 }
 
-// n.b. The following two tests are ignored; they worked "accidentally" before,
-// when the behavior was "always rebuild libraries" (now it's "never rebuild
-// libraries if they already exist"). They can be un-ignored once #7075 is done.
 #[test]
-#[ignore(reason = "Workcache not yet implemented -- see #7075")]
 fn do_rebuild_dep_dates_change() {
     let p_id = PkgId::new("foo");
     let dep_id = PkgId::new("bar");
     let workspace = create_local_package_with_dep(&p_id, &dep_id);
     command_line_test([~"build", ~"foo"], &workspace);
-    let bar_lib_name = lib_output_file_name(&workspace, "build", "bar");
-    let bar_date = datestamp(&bar_lib_name);
-    debug!("Datestamp on %s is %?", bar_lib_name.to_str(), bar_date);
+    let bar_date = datestamp(&lib_output_file_name(&workspace, "build", "bar"));
     touch_source_file(&workspace, &dep_id);
     command_line_test([~"build", ~"foo"], &workspace);
-    let new_bar_date = datestamp(&bar_lib_name);
-    debug!("Datestamp on %s is %?", bar_lib_name.to_str(), new_bar_date);
+    let new_bar_date = datestamp(&lib_output_file_name(&workspace, "build", "bar"));
     assert!(new_bar_date > bar_date);
 }
 
 #[test]
-#[ignore(reason = "Workcache not yet implemented -- see #7075")]
 fn do_rebuild_dep_only_contents_change() {
     let p_id = PkgId::new("foo");
     let dep_id = PkgId::new("bar");
@@ -1068,23 +1060,6 @@ fn test_macro_pkg_script() {
         os::EXE_SUFFIX))));
 }
 
-#[test]
-fn multiple_workspaces() {
-// Make a package foo; build/install in directory A
-// Copy the exact same package into directory B and install it
-// Set the RUST_PATH to A:B
-// Make a third package that uses foo, make sure we can build/install it
-    let a_loc = mk_temp_workspace(&Path("foo"), &NoVersion).pop().pop();
-    let b_loc = mk_temp_workspace(&Path("foo"), &NoVersion).pop().pop();
-    debug!("Trying to install foo in %s", a_loc.to_str());
-    command_line_test([~"install", ~"foo"], &a_loc);
-    debug!("Trying to install foo in %s", b_loc.to_str());
-    command_line_test([~"install", ~"foo"], &b_loc);
-    let env = Some(~[(~"RUST_PATH", fmt!("%s:%s", a_loc.to_str(), b_loc.to_str()))]);
-    let c_loc = create_local_package_with_dep(&PkgId::new("bar"), &PkgId::new("foo"));
-    command_line_test_with_env([~"install", ~"bar"], &c_loc, env);
-}
-
 /// Returns true if p exists and is executable
 fn is_executable(p: &Path) -> bool {
     use std::libc::consts::os::posix88::{S_IXUSR};

branches/try2/src/librustpkg/util.rs

@@ -20,10 +20,9 @@ use rustc::back::link::output_type_exe;
 use rustc::driver::session::{lib_crate, bin_crate};
 use context::{Ctx, in_target};
 use package_id::PkgId;
-use search::{find_library_in_search_path, find_installed_library_in_rust_path};
+use search::find_library_in_search_path;
 use path_util::{target_library_in_workspace, U_RWX};
 pub use target::{OutputType, Main, Lib, Bench, Test};
-use version::NoVersion;
 
 // It would be nice to have the list of commands in just one place -- for example,
 // you could update the match in rustpkg.rc but forget to update this list. I think
@@ -361,32 +360,18 @@ pub fn find_and_install_dependencies(ctxt: &Ctx,
                         debug!("It exists: %s", installed_path.to_str());
                     }
                     None => {
-                        // FIXME #8711: need to parse version out of path_opt
-                        match find_installed_library_in_rust_path(lib_name, &NoVersion) {
-                            Some(installed_path) => {
-                               debug!("Found library %s, not rebuilding it",
-                                      installed_path.to_str());
-                               // Once workcache is implemented, we'll actually check
-                               // whether or not the library at installed_path is fresh
-                               save(installed_path.pop());
-                            }
-                            None => {
-                               debug!("Trying to install library %s, rebuilding it",
-                                      lib_name.to_str());
-                               // Try to install it
-                               let pkg_id = PkgId::new(lib_name);
-                               my_ctxt.install(&my_workspace, &pkg_id);
-                               // Also, add an additional search path
-                               debug!("let installed_path...")
-                               let installed_path = target_library_in_workspace(&pkg_id,
+                        // Try to install it
+                        let pkg_id = PkgId::new(lib_name);
+                        my_ctxt.install(&my_workspace, &pkg_id);
+                        // Also, add an additional search path
+                        debug!("let installed_path...")
+                        let installed_path = target_library_in_workspace(&pkg_id,
                                                                          &my_workspace).pop();
-                               debug!("Great, I installed %s, and it's in %s",
-                                   lib_name, installed_path.to_str());
-                               save(installed_path);
-                           }
+                        debug!("Great, I installed %s, and it's in %s",
+                               lib_name, installed_path.to_str());
+                        save(installed_path);
                     }
                 }
-              }
             }
             // Ignore `use`s
             _ => ()

branches/try2/src/librustpkg/version.rs

@@ -213,9 +213,11 @@ fn is_url_like(p: &Path) -> bool {
 pub fn split_version<'a>(s: &'a str) -> Option<(&'a str, Version)> {
     // Check for extra '#' characters separately
     if s.split_iter('#').len() > 2 {
-        return None;
+        None
+    }
+    else {
+        split_version_general(s, '#')
     }
-    split_version_general(s, '#')
 }
 
 pub fn split_version_general<'a>(s: &'a str, sep: char) -> Option<(&'a str, Version)> {

branches/try2/src/libstd/default.rs

@@ -0,0 +1,17 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! The Default trait
+
+/// A trait that types which have a useful default value should implement.
+pub trait Default {
+    /// Return the "default value" for a type.
+    fn default() -> Self;
+}