diff --git a/src/etc/combine-tests.py b/src/etc/combine-tests.py index aaba80aa446..e87187abbcb 100755 --- a/src/etc/combine-tests.py +++ b/src/etc/combine-tests.py @@ -45,7 +45,7 @@ c.write( """ // AUTO-GENERATED FILE: DO NOT EDIT #[crate_id=\"run_pass_stage2#0.1\"]; -#[pkgid=\"run_pass_stage2#0.1\"]; +#[crate_id=\"run_pass_stage2#0.1\"]; #[feature(globs, macro_rules, struct_variant, managed_boxes)]; #[allow(warnings)]; """ diff --git a/src/librustpkg/api.rs b/src/librustpkg/api.rs index 8e4216562c0..0730a6fc3a2 100644 --- a/src/librustpkg/api.rs +++ b/src/librustpkg/api.rs @@ -10,7 +10,7 @@ use context::*; use crate::*; -use package_id::*; +use crate_id::*; use package_source::*; use path_util::{platform_library_name, target_build_dir}; use target::*; @@ -92,7 +92,7 @@ pub fn build_lib_with_cfgs(sysroot: Path, root: Path, name: ~str, build_in_destination: false, destination_workspace: root.clone(), start_dir: root.join_many(["src", name.as_slice()]), - id: PkgId{ version: version, ..PkgId::new(name)}, + id: CrateId{ version: version, ..CrateId::new(name)}, // n.b. This assumes the package only has one crate libs: ~[mk_crate(lib)], mains: ~[], @@ -115,7 +115,7 @@ pub fn build_exe_with_cfgs(sysroot: Path, root: Path, name: ~str, build_in_destination: false, destination_workspace: root.clone(), start_dir: root.join_many(["src", name.as_slice()]), - id: PkgId{ version: version, ..PkgId::new(name)}, + id: CrateId{ version: version, ..CrateId::new(name)}, libs: ~[], // n.b. This assumes the package only has one crate mains: ~[mk_crate(main)], @@ -132,8 +132,8 @@ pub fn install_pkg(cx: &BuildContext, version: Version, // For now, these inputs are assumed to be inputs to each of the crates more_inputs: ~[(~str, Path)]) { // pairs of Kind and Path - let pkgid = PkgId{ version: version, ..PkgId::new(name)}; - cx.install(PkgSrc::new(workspace.clone(), workspace, false, pkgid), + let crateid = CrateId{ version: version, ..CrateId::new(name)}; + cx.install(PkgSrc::new(workspace.clone(), workspace, false, crateid), &WhatToBuild{ build_type: Inferred, inputs_to_discover: more_inputs, sources: Everything }); @@ -157,10 +157,10 @@ pub fn build_library_in_workspace(exec: &mut workcache::Exec, let out_name = workspace_build_dir.join_many([package_name.to_str(), platform_library_name(output)]); // make paths absolute - let pkgid = PkgId::new(package_name); + let crateid = CrateId::new(package_name); let absolute_paths = paths.map(|s| { let whatever = workspace.join_many([~"src", - pkgid.to_str(), + crateid.to_str(), s.to_owned()]); whatever.as_str().unwrap().to_owned() }); @@ -190,8 +190,8 @@ pub fn my_workspace(context: &Context, package_name: &str) -> Path { use bad_pkg_id = conditions::bad_pkg_id::cond; // (this assumes no particular version is requested) - let pkgid = PkgId::new(package_name); - let workspaces = pkg_parent_workspaces(context, &pkgid); + let crateid = CrateId::new(package_name); + let workspaces = pkg_parent_workspaces(context, &crateid); if workspaces.is_empty() { bad_pkg_id.raise((Path::new(package_name), package_name.to_owned())); } diff --git a/src/librustpkg/conditions.rs b/src/librustpkg/conditions.rs index 023bba15f97..6c38d63a518 100644 --- a/src/librustpkg/conditions.rs +++ b/src/librustpkg/conditions.rs @@ -10,7 +10,7 @@ // Useful conditions -pub use package_id::PkgId; +pub use crate_id::CrateId; pub use std::io::FileStat; pub use std::io::process::ProcessExit; pub use std::path::Path; @@ -20,15 +20,15 @@ } condition! { - pub nonexistent_package: (PkgId, ~str) -> Path; + pub nonexistent_package: (CrateId, ~str) -> Path; } condition! { - pub missing_pkg_files: (PkgId) -> (); + pub missing_pkg_files: (CrateId) -> (); } condition! { - pub bad_pkg_id: (Path, ~str) -> PkgId; + pub bad_pkg_id: (Path, ~str) -> CrateId; } condition! { diff --git a/src/librustpkg/package_id.rs b/src/librustpkg/crate_id.rs similarity index 93% rename from src/librustpkg/package_id.rs rename to src/librustpkg/crate_id.rs index 04ac30e3732..7ff8417f23c 100644 --- a/src/librustpkg/package_id.rs +++ b/src/librustpkg/crate_id.rs @@ -17,7 +17,7 @@ /// 'github.com/graydon/test'; path must be a relative /// path with >=1 component. #[deriving(Clone)] -pub struct PkgId { +pub struct CrateId { /// This is a path, on the local filesystem, referring to where the /// files for this package live. For example: /// github.com/mozilla/quux-whatever (it's assumed that if we're @@ -35,14 +35,14 @@ pub struct PkgId { version: Version } -impl Eq for PkgId { - fn eq(&self, other: &PkgId) -> bool { +impl Eq for CrateId { + fn eq(&self, other: &CrateId) -> bool { self.path == other.path && self.version == other.version } } -impl PkgId { - pub fn new(s: &str) -> PkgId { +impl CrateId { + pub fn new(s: &str) -> CrateId { use conditions::bad_pkg_id::cond; let mut given_version = None; @@ -60,10 +60,10 @@ pub fn new(s: &str) -> PkgId { let path = Path::new(s); if !path.is_relative() { - return cond.raise((path, ~"absolute pkgid")); + return cond.raise((path, ~"absolute crate_id")); } if path.filename().is_none() { - return cond.raise((path, ~"0-length pkgid")); + return cond.raise((path, ~"0-length crate_id")); } let short_name = path.filestem_str().expect(format!("Strange path! {}", s)); @@ -78,7 +78,7 @@ pub fn new(s: &str) -> PkgId { } }; - PkgId { + CrateId { path: path.clone(), short_name: short_name.to_owned(), version: version @@ -142,7 +142,7 @@ fn next(&mut self) -> Option<(Path, Path)> { } } -impl ToStr for PkgId { +impl ToStr for CrateId { fn to_str(&self) -> ~str { // should probably use the filestem and not the whole path format!("{}-{}", self.path.as_str().unwrap(), self.version.to_str()) diff --git a/src/librustpkg/installed_packages.rs b/src/librustpkg/installed_packages.rs index 48c25a53682..67ba5d2b8e8 100644 --- a/src/librustpkg/installed_packages.rs +++ b/src/librustpkg/installed_packages.rs @@ -16,7 +16,7 @@ use std::io; use std::io::fs; -pub fn list_installed_packages(f: |&PkgId| -> bool) -> bool { +pub fn list_installed_packages(f: |&CrateId| -> bool) -> bool { let workspaces = rust_path(); for p in workspaces.iter() { let binfiles = { @@ -28,7 +28,7 @@ pub fn list_installed_packages(f: |&PkgId| -> bool) -> bool { match exec.filestem_str() { None => (), Some(exec_path) => { - if !f(&PkgId::new(exec_path)) { + if !f(&CrateId::new(exec_path)) { return false; } } @@ -50,7 +50,7 @@ pub fn list_installed_packages(f: |&PkgId| -> bool) -> bool { let rel_path = rel_p.join(basename); rel_path.display().with_str(|s| { debug!("Rel name: {}", s); - f(&PkgId::new(s)); + f(&CrateId::new(s)); }); } None => () @@ -78,7 +78,7 @@ pub fn has_library(p: &Path) -> Option<~str> { None } -pub fn package_is_installed(p: &PkgId) -> bool { +pub fn package_is_installed(p: &CrateId) -> bool { let mut is_installed = false; list_installed_packages(|installed| { if installed == p { diff --git a/src/librustpkg/lib.rs b/src/librustpkg/lib.rs index 6bb6add407a..2b54a6d6f1c 100644 --- a/src/librustpkg/lib.rs +++ b/src/librustpkg/lib.rs @@ -45,7 +45,7 @@ use context::{Context, BuildContext, RustcFlags, Trans, Link, Nothing, Pretty, Analysis, Assemble, LLVMAssemble, LLVMCompileBitcode}; -use package_id::PkgId; +use crate_id::CrateId; use package_source::PkgSrc; use target::{WhatToBuild, Everything, is_lib, is_main, is_test, is_bench}; use target::{Main, Tests, MaybeCustom, Inferred, JustOne}; @@ -59,7 +59,7 @@ pub mod exit_codes; mod installed_packages; mod messages; -pub mod package_id; +pub mod crate_id; pub mod package_source; mod path_util; mod source_control; @@ -78,7 +78,7 @@ /// an explicit package script. struct PkgScript<'a> { /// Uniquely identifies this package - id: &'a PkgId, + id: &'a CrateId, /// File path for the package script input: Path, /// The session to use *only* for compiling the custom @@ -99,7 +99,7 @@ impl<'a> PkgScript<'a> { fn parse<'a>(sysroot: Path, script: Path, workspace: &Path, - id: &'a PkgId) -> PkgScript<'a> { + id: &'a CrateId) -> PkgScript<'a> { // Get the executable name that was invoked let binary = os::args()[0].to_managed(); // Build the rustc session data structures to pass @@ -208,10 +208,10 @@ pub trait CtxMethods { fn run(&self, cmd: &str, args: ~[~str]); fn do_cmd(&self, _cmd: &str, _pkgname: &str); /// Returns a pair of the selected package ID, and the destination workspace - fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(PkgId, Path)>; + fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(CrateId, Path)>; /// Returns the destination workspace fn build(&self, pkg_src: &mut PkgSrc, what: &WhatToBuild); - fn clean(&self, workspace: &Path, id: &PkgId); + fn clean(&self, workspace: &Path, id: &CrateId); fn info(&self); /// Returns a pair. First component is a list of installed paths, /// second is a list of declared and discovered inputs @@ -221,24 +221,24 @@ fn install_no_build(&self, build_workspace: &Path, build_inputs: &[Path], target_workspace: &Path, - id: &PkgId) -> ~[~str]; + id: &CrateId) -> ~[~str]; fn prefer(&self, _id: &str, _vers: Option<~str>); - fn test(&self, id: &PkgId, workspace: &Path); + fn test(&self, id: &CrateId, workspace: &Path); fn uninstall(&self, _id: &str, _vers: Option<~str>); fn unprefer(&self, _id: &str, _vers: Option<~str>); fn init(&self); } impl CtxMethods for BuildContext { - fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(PkgId, Path)> { + fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(CrateId, Path)> { let cwd = os::getcwd(); if args.len() < 1 { match cwd_to_workspace() { None if dir_has_crate_file(&cwd) => { // FIXME (#9639): This needs to handle non-utf8 paths - let pkgid = PkgId::new(cwd.filename_str().unwrap()); - let mut pkg_src = PkgSrc::new(cwd, default_workspace(), true, pkgid); + let crateid = CrateId::new(cwd.filename_str().unwrap()); + let mut pkg_src = PkgSrc::new(cwd, default_workspace(), true, crateid); self.build(&mut pkg_src, what); match pkg_src { PkgSrc { destination_workspace: ws, @@ -248,8 +248,8 @@ fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(PkgId, Path)> } } None => { usage::build(); None } - Some((ws, pkgid)) => { - let mut pkg_src = PkgSrc::new(ws.clone(), ws, false, pkgid); + Some((ws, crateid)) => { + let mut pkg_src = PkgSrc::new(ws.clone(), ws, false, crateid); self.build(&mut pkg_src, what); match pkg_src { PkgSrc { destination_workspace: ws, @@ -262,23 +262,23 @@ fn build_args(&self, args: ~[~str], what: &WhatToBuild) -> Option<(PkgId, Path)> } else { // The package id is presumed to be the first command-line // argument - let pkgid = PkgId::new(args[0].clone()); + let crateid = CrateId::new(args[0].clone()); let mut dest_ws = default_workspace(); - each_pkg_parent_workspace(&self.context, &pkgid, |workspace| { + each_pkg_parent_workspace(&self.context, &crateid, |workspace| { debug!("found pkg {} in workspace {}, trying to build", - pkgid.to_str(), workspace.display()); + crateid.to_str(), workspace.display()); dest_ws = determine_destination(os::getcwd(), self.context.use_rust_path_hack, workspace); let mut pkg_src = PkgSrc::new(workspace.clone(), dest_ws.clone(), - false, pkgid.clone()); + false, crateid.clone()); self.build(&mut pkg_src, what); true }); // n.b. If this builds multiple packages, it only returns the workspace for // the last one. The whole building-multiple-packages-with-the-same-ID is weird // anyway and there are no tests for it, so maybe take it out - Some((pkgid, dest_ws)) + Some((crateid, dest_ws)) } } fn run(&self, cmd: &str, args: ~[~str]) { @@ -293,15 +293,15 @@ fn run(&self, cmd: &str, args: ~[~str]) { None => { usage::clean(); return } // tjc: Maybe clean should clean all the packages in the // current workspace, though? - Some((ws, pkgid)) => self.clean(&ws, &pkgid) + Some((ws, crateid)) => self.clean(&ws, &crateid) } } else { // The package id is presumed to be the first command-line // argument - let pkgid = PkgId::new(args[0].clone()); - self.clean(&cwd, &pkgid); // tjc: should use workspace, not cwd + let crateid = CrateId::new(args[0].clone()); + self.clean(&cwd, &crateid); // tjc: should use workspace, not cwd } } "do" => { @@ -320,15 +320,15 @@ fn run(&self, cmd: &str, args: ~[~str]) { None if dir_has_crate_file(&cwd) => { // FIXME (#9639): This needs to handle non-utf8 paths - let inferred_pkgid = - PkgId::new(cwd.filename_str().unwrap()); + let inferred_crateid = + CrateId::new(cwd.filename_str().unwrap()); self.install(PkgSrc::new(cwd, default_workspace(), - true, inferred_pkgid), + true, inferred_crateid), &WhatToBuild::new(MaybeCustom, Everything)); } None => { usage::install(); return; } - Some((ws, pkgid)) => { - let pkg_src = PkgSrc::new(ws.clone(), ws.clone(), false, pkgid); + Some((ws, crateid)) => { + let pkg_src = PkgSrc::new(ws.clone(), ws.clone(), false, crateid); self.install(pkg_src, &WhatToBuild::new(MaybeCustom, Everything)); } @@ -337,13 +337,13 @@ fn run(&self, cmd: &str, args: ~[~str]) { else { // The package id is presumed to be the first command-line // argument - let pkgid = PkgId::new(args[0]); - let workspaces = pkg_parent_workspaces(&self.context, &pkgid); + let crateid = CrateId::new(args[0]); + let workspaces = pkg_parent_workspaces(&self.context, &crateid); debug!("package ID = {}, found it in {:?} workspaces", - pkgid.to_str(), workspaces.len()); + crateid.to_str(), workspaces.len()); if workspaces.is_empty() { let d = default_workspace(); - let src = PkgSrc::new(d.clone(), d, false, pkgid.clone()); + let src = PkgSrc::new(d.clone(), d, false, crateid.clone()); self.install(src, &WhatToBuild::new(MaybeCustom, Everything)); } else { @@ -354,7 +354,7 @@ fn run(&self, cmd: &str, args: ~[~str]) { let src = PkgSrc::new(workspace.clone(), dest, self.context.use_rust_path_hack, - pkgid.clone()); + crateid.clone()); self.install(src, &WhatToBuild::new(MaybeCustom, Everything)); }; } @@ -400,8 +400,8 @@ fn run(&self, cmd: &str, args: ~[~str]) { return usage::uninstall(); } - let pkgid = PkgId::new(args[0]); - if !installed_packages::package_is_installed(&pkgid) { + let crateid = CrateId::new(args[0]); + if !installed_packages::package_is_installed(&crateid) { warn(format!("Package {} doesn't seem to be installed! \ Doing nothing.", args[0])); return; @@ -409,10 +409,10 @@ fn run(&self, cmd: &str, args: ~[~str]) { else { let rp = rust_path(); assert!(!rp.is_empty()); - each_pkg_parent_workspace(&self.context, &pkgid, |workspace| { - path_util::uninstall_package_from(workspace, &pkgid); + each_pkg_parent_workspace(&self.context, &crateid, |workspace| { + path_util::uninstall_package_from(workspace, &crateid); note(format!("Uninstalled package {} (was installed in {})", - pkgid.to_str(), workspace.display())); + crateid.to_str(), workspace.display())); true }); } @@ -437,34 +437,34 @@ fn build(&self, pkg_src: &mut PkgSrc, what_to_build: &WhatToBuild) { use conditions::git_checkout_failed::cond; let workspace = pkg_src.source_workspace.clone(); - let pkgid = pkg_src.id.clone(); + let crateid = pkg_src.id.clone(); debug!("build: workspace = {} (in Rust path? {:?} is git dir? {:?} \ - pkgid = {} pkgsrc start_dir = {}", workspace.display(), - in_rust_path(&workspace), is_git_dir(&workspace.join(&pkgid.path)), - pkgid.to_str(), pkg_src.start_dir.display()); + crateid = {} pkgsrc start_dir = {}", workspace.display(), + in_rust_path(&workspace), is_git_dir(&workspace.join(&crateid.path)), + crateid.to_str(), pkg_src.start_dir.display()); debug!("build: what to build = {:?}", what_to_build); // If workspace isn't in the RUST_PATH, and it's a git repo, // then clone it into the first entry in RUST_PATH, and repeat - if !in_rust_path(&workspace) && is_git_dir(&workspace.join(&pkgid.path)) { + if !in_rust_path(&workspace) && is_git_dir(&workspace.join(&crateid.path)) { let mut out_dir = default_workspace().join("src"); - out_dir.push(&pkgid.path); - let git_result = source_control::safe_git_clone(&workspace.join(&pkgid.path), - &pkgid.version, + out_dir.push(&crateid.path); + let git_result = source_control::safe_git_clone(&workspace.join(&crateid.path), + &crateid.version, &out_dir); match git_result { CheckedOutSources => make_read_only(&out_dir), // FIXME (#9639): This needs to handle non-utf8 paths - _ => cond.raise((pkgid.path.as_str().unwrap().to_owned(), out_dir.clone())) + _ => cond.raise((crateid.path.as_str().unwrap().to_owned(), out_dir.clone())) }; let default_ws = default_workspace(); debug!("Calling build recursively with {:?} and {:?}", default_ws.display(), - pkgid.to_str()); + crateid.to_str()); return self.build(&mut PkgSrc::new(default_ws.clone(), default_ws, false, - pkgid.clone()), what_to_build); + crateid.clone()), what_to_build); } // Is there custom build logic? If so, use it @@ -482,7 +482,7 @@ fn build(&self, pkg_src: &mut PkgSrc, what_to_build: &WhatToBuild) { let subsysroot = sysroot.clone(); let psp = package_script_path.clone(); let ws = workspace.clone(); - let pid = pkgid.clone(); + let pid = crateid.clone(); prep.exec(proc(exec) { let mut pscript = PkgScript::parse(subsysroot.clone(), psp.clone(), @@ -550,7 +550,7 @@ fn build(&self, pkg_src: &mut PkgSrc, what_to_build: &WhatToBuild) { } } - fn clean(&self, workspace: &Path, id: &PkgId) { + fn clean(&self, workspace: &Path, id: &CrateId) { // Could also support a custom build hook in the pkg // script for cleaning files rustpkg doesn't know about. // Do something reasonable for now @@ -616,7 +616,7 @@ fn install_no_build(&self, build_workspace: &Path, build_inputs: &[Path], target_workspace: &Path, - id: &PkgId) -> ~[~str] { + id: &CrateId) -> ~[~str] { debug!("install_no_build: assuming {} comes from {} with target {}", id.to_str(), build_workspace.display(), target_workspace.display()); @@ -705,8 +705,8 @@ fn prefer(&self, _id: &str, _vers: Option<~str>) { fail!("prefer not yet implemented"); } - fn test(&self, pkgid: &PkgId, workspace: &Path) { - match built_test_in_workspace(pkgid, workspace) { + fn test(&self, crateid: &CrateId, workspace: &Path) { + match built_test_in_workspace(crateid, workspace) { Some(test_exec) => { debug!("test: test_exec = {}", test_exec.display()); // FIXME (#9639): This needs to handle non-utf8 paths @@ -723,7 +723,7 @@ fn test(&self, pkgid: &PkgId, workspace: &Path) { None => { error(format!("Internal error: test executable for package ID {} in workspace {} \ wasn't built! Please report this as a bug.", - pkgid.to_str(), workspace.display())); + crateid.to_str(), workspace.display())); } } } diff --git a/src/librustpkg/package_source.rs b/src/librustpkg/package_source.rs index 4865003cb5e..651d64aa9d3 100644 --- a/src/librustpkg/package_source.rs +++ b/src/librustpkg/package_source.rs @@ -11,7 +11,7 @@ extern mod extra; use target::*; -use package_id::PkgId; +use crate_id::CrateId; use std::io; use std::io::fs; use std::os; @@ -49,7 +49,7 @@ pub struct PkgSrc { // Directory to start looking in for packages -- normally // this is workspace/src/id but it may be just workspace start_dir: Path, - id: PkgId, + id: CrateId, libs: ~[Crate], mains: ~[Crate], tests: ~[Crate], @@ -77,7 +77,7 @@ impl PkgSrc { pub fn new(mut source_workspace: Path, destination_workspace: Path, use_rust_path_hack: bool, - id: PkgId) -> PkgSrc { + id: CrateId) -> PkgSrc { use conditions::nonexistent_package::cond; debug!("Checking package source for package ID {}, \ @@ -133,14 +133,14 @@ pub fn new(mut source_workspace: Path, // 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() { - let package_id = PkgId::new(prefix.as_str().unwrap()); - let path = build_dir.join(&package_id.path); + let crate_id = CrateId::new(prefix.as_str().unwrap()); + let path = build_dir.join(&crate_id.path); debug!("in loop: checking if {} is a directory", path.display()); if path.is_dir() { let ps = PkgSrc::new(source_workspace, destination_workspace, use_rust_path_hack, - package_id); + crate_id); match ps { PkgSrc { source_workspace: source, @@ -264,36 +264,36 @@ pub fn new(mut source_workspace: Path, /// if this was successful, None otherwise. Similarly, if the package id /// refers to a git repo on the local version, also check it out. /// (right now we only support git) - pub fn fetch_git(local: &Path, pkgid: &PkgId) -> Option { + pub fn fetch_git(local: &Path, crateid: &CrateId) -> Option { use conditions::git_checkout_failed::cond; let cwd = os::getcwd(); debug!("Checking whether {} (path = {}) exists locally. Cwd = {}, does it? {:?}", - pkgid.to_str(), pkgid.path.display(), + crateid.to_str(), crateid.path.display(), cwd.display(), - pkgid.path.exists()); + crateid.path.exists()); - match safe_git_clone(&pkgid.path, &pkgid.version, local) { + match safe_git_clone(&crateid.path, &crateid.version, local) { CheckedOutSources => { make_read_only(local); Some(local.clone()) } DirToUse(clone_target) => { - if pkgid.path.components().nth(1).is_none() { + if crateid.path.components().nth(1).is_none() { // If a non-URL, don't bother trying to fetch return None; } // FIXME (#9639): This needs to handle non-utf8 paths - let url = format!("https://{}", pkgid.path.as_str().unwrap()); + let url = format!("https://{}", crateid.path.as_str().unwrap()); debug!("Fetching package: git clone {} {} [version={}]", - url, clone_target.display(), pkgid.version.to_str()); + url, clone_target.display(), crateid.version.to_str()); let mut failed = false; cond.trap(|_| { failed = true; - }).inside(|| git_clone_url(url, &clone_target, &pkgid.version)); + }).inside(|| git_clone_url(url, &clone_target, &crateid.version)); if failed { return None; diff --git a/src/librustpkg/path_util.rs b/src/librustpkg/path_util.rs index 0d927fc36ae..1b8a988ab2c 100644 --- a/src/librustpkg/path_util.rs +++ b/src/librustpkg/path_util.rs @@ -12,7 +12,7 @@ #[allow(dead_code)]; -pub use package_id::PkgId; +pub use crate_id::CrateId; 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; @@ -59,12 +59,12 @@ pub fn make_dir_rwx_recursive(p: &Path) -> bool { // now. Should fix that. /// True if there's a directory in with -/// pkgid's short name -pub fn workspace_contains_package_id(pkgid: &PkgId, workspace: &Path) -> bool { - workspace_contains_package_id_(pkgid, workspace, |p| p.join("src")).is_some() +/// crateid's short name +pub fn workspace_contains_crate_id(crateid: &CrateId, workspace: &Path) -> bool { + workspace_contains_crate_id_(crateid, workspace, |p| p.join("src")).is_some() } -pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path, +pub fn workspace_contains_crate_id_(crateid: &CrateId, workspace: &Path, // Returns the directory it was actually found in workspace_to_src_dir: |&Path| -> Path) -> Option { if !workspace.is_dir() { @@ -77,14 +77,14 @@ pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path, let mut found = None; for p in fs::walk_dir(&src_dir) { if p.is_dir() { - if p == src_dir.join(&pkgid.path) || { + if p == src_dir.join(&crateid.path) || { let pf = p.filename_str(); pf.iter().any(|&g| { match split_version_general(g, '-') { None => false, Some((ref might_match, ref vers)) => { - *might_match == pkgid.short_name - && (pkgid.version == *vers || pkgid.version == NoVersion) + *might_match == crateid.short_name + && (crateid.version == *vers || crateid.version == NoVersion) } } }) @@ -96,9 +96,9 @@ pub fn workspace_contains_package_id_(pkgid: &PkgId, workspace: &Path, } if found.is_some() { - debug!("Found {} in {}", pkgid.to_str(), workspace.display()); + debug!("Found {} in {}", crateid.to_str(), workspace.display()); } else { - debug!("Didn't find {} in {}", pkgid.to_str(), workspace.display()); + debug!("Didn't find {} in {}", crateid.to_str(), workspace.display()); } found } @@ -126,11 +126,11 @@ fn target_bin_dir(workspace: &Path) -> Path { workspace.join("bin") } -/// Figure out what the executable name for in 's build +/// Figure out what the executable name for in 's build /// directory is, and if the file exists, return it. -pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option { +pub fn built_executable_in_workspace(crateid: &CrateId, workspace: &Path) -> Option { let mut result = target_build_dir(workspace); - result = mk_output_path(Main, Build, pkgid, result); + result = mk_output_path(Main, Build, crateid, result); debug!("built_executable_in_workspace: checking whether {} exists", result.display()); if result.exists() { @@ -142,22 +142,22 @@ pub fn built_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option< } } -/// Figure out what the test name for in 's build +/// Figure out what the test name for in 's build /// directory is, and if the file exists, return it. -pub fn built_test_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option { - output_in_workspace(pkgid, workspace, Test) +pub fn built_test_in_workspace(crateid: &CrateId, workspace: &Path) -> Option { + output_in_workspace(crateid, workspace, Test) } -/// Figure out what the test name for in 's build +/// Figure out what the test name for in 's build /// directory is, and if the file exists, return it. -pub fn built_bench_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option { - output_in_workspace(pkgid, workspace, Bench) +pub fn built_bench_in_workspace(crateid: &CrateId, workspace: &Path) -> Option { + output_in_workspace(crateid, workspace, Bench) } -fn output_in_workspace(pkgid: &PkgId, workspace: &Path, what: OutputType) -> Option { +fn output_in_workspace(crateid: &CrateId, workspace: &Path, what: OutputType) -> Option { let mut result = target_build_dir(workspace); // should use a target-specific subdirectory - result = mk_output_path(what, Build, pkgid, result); + result = mk_output_path(what, Build, crateid, result); debug!("output_in_workspace: checking whether {} exists", result.display()); if result.exists() { @@ -169,10 +169,11 @@ fn output_in_workspace(pkgid: &PkgId, workspace: &Path, what: OutputType) -> Opt } } -/// Figure out what the library name for in 's build +/// Figure out what the library name for in 's build /// directory is, and if the file exists, return it. -pub fn built_library_in_workspace(pkgid: &PkgId, workspace: &Path) -> Option { - library_in_workspace(&pkgid.path, pkgid.short_name, Build, workspace, "build", &pkgid.version) +pub fn built_library_in_workspace(crateid: &CrateId, workspace: &Path) -> Option { + library_in_workspace(&crateid.path, crateid.short_name, Build, workspace, "build", + &crateid.version) } /// Does the actual searching stuff @@ -292,45 +293,45 @@ fn library_in(short_name: &str, version: &Version, dir_to_search: &Path) -> Opti abs_path } -/// Returns the executable that would be installed for +/// Returns the executable that would be installed for /// in /// As a side effect, creates the bin-dir if it doesn't exist -pub fn target_executable_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path { - target_file_in_workspace(pkgid, workspace, Main, Install) +pub fn target_executable_in_workspace(crateid: &CrateId, workspace: &Path) -> Path { + target_file_in_workspace(crateid, workspace, Main, Install) } -/// Returns the executable that would be installed for +/// Returns the executable that would be installed for /// in /// 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(crateid: &CrateId, workspace: &Path) -> Path { use conditions::bad_path::cond; if !workspace.is_dir() { cond.raise(((*workspace).clone(), format!("Workspace supplied to target_library_in_workspace \ is not a directory! {}", workspace.display()))); } - target_file_in_workspace(pkgid, workspace, Lib, Install) + target_file_in_workspace(crateid, workspace, Lib, Install) } -/// Returns the test executable that would be installed for +/// Returns the test executable that would be installed for /// in /// note that we *don't* install test executables, so this is just for unit testing -pub fn target_test_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path { - target_file_in_workspace(pkgid, workspace, Test, Install) +pub fn target_test_in_workspace(crateid: &CrateId, workspace: &Path) -> Path { + target_file_in_workspace(crateid, workspace, Test, Install) } -/// Returns the bench executable that would be installed for +/// Returns the bench executable that would be installed for /// in /// note that we *don't* install bench executables, so this is just for unit testing -pub fn target_bench_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path { - target_file_in_workspace(pkgid, workspace, Bench, Install) +pub fn target_bench_in_workspace(crateid: &CrateId, workspace: &Path) -> Path { + target_file_in_workspace(crateid, workspace, Bench, Install) } -/// Returns the path that pkgid `pkgid` would have if placed `where` +/// Returns the path that crateid `crateid` would have if placed `where` /// in `workspace` -fn target_file_in_workspace(pkgid: &PkgId, workspace: &Path, +fn target_file_in_workspace(crateid: &CrateId, workspace: &Path, what: OutputType, where: Target) -> Path { use conditions::bad_path::cond; @@ -340,25 +341,25 @@ fn target_file_in_workspace(pkgid: &PkgId, workspace: &Path, // Artifacts in the build directory live in a package-ID-specific subdirectory, // but installed ones don't. let result = match (where, what) { - (Build, _) => target_build_dir(workspace).join(&pkgid.path), + (Build, _) => target_build_dir(workspace).join(&crateid.path), (Install, Lib) => target_lib_dir(workspace), (Install, _) => target_bin_dir(workspace) }; if io::result(|| fs::mkdir_recursive(&result, io::UserRWX)).is_err() { cond.raise((result.clone(), format!("target_file_in_workspace couldn't \ - create the {} dir (pkgid={}, workspace={}, what={:?}, where={:?}", - subdir, pkgid.to_str(), workspace.display(), what, where))); + create the {} dir (crateid={}, workspace={}, what={:?}, where={:?}", + subdir, crateid.to_str(), workspace.display(), what, where))); } - mk_output_path(what, where, pkgid, result) + mk_output_path(what, where, crateid, result) } -/// Return the directory for 's build artifacts in . +/// Return the directory for 's build artifacts in . /// Creates it if it doesn't exist. -pub fn build_pkg_id_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path { +pub fn build_pkg_id_in_workspace(crateid: &CrateId, workspace: &Path) -> Path { let mut result = target_build_dir(workspace); - result.push(&pkgid.path); + result.push(&crateid.path); debug!("Creating build dir {} for package id {}", result.display(), - pkgid.to_str()); + crateid.to_str()); fs::mkdir_recursive(&result, io::UserRWX); return result; } @@ -366,7 +367,7 @@ pub fn build_pkg_id_in_workspace(pkgid: &PkgId, workspace: &Path) -> Path { /// Return the output file for a given directory name, /// 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 { + pkg_id: &CrateId, workspace: Path) -> Path { let short_name_with_version = format!("{}-{}", pkg_id.short_name, pkg_id.version.to_str()); // Not local_path.dir_path()! For package foo/bar/blat/, we want @@ -399,22 +400,22 @@ pub fn mk_output_path(what: OutputType, where: Target, output_path } -/// Removes files for the package `pkgid`, assuming it's installed in workspace `workspace` -pub fn uninstall_package_from(workspace: &Path, pkgid: &PkgId) { +/// Removes files for the package `crateid`, assuming it's installed in workspace `workspace` +pub fn uninstall_package_from(workspace: &Path, crateid: &CrateId) { let mut did_something = false; - let installed_bin = target_executable_in_workspace(pkgid, workspace); + let installed_bin = target_executable_in_workspace(crateid, workspace); if installed_bin.exists() { fs::unlink(&installed_bin); did_something = true; } - let installed_lib = target_library_in_workspace(pkgid, workspace); + let installed_lib = target_library_in_workspace(crateid, workspace); if installed_lib.exists() { fs::unlink(&installed_lib); did_something = true; } if !did_something { warn(format!("Warning: there don't seem to be any files for {} installed in {}", - pkgid.to_str(), workspace.display())); + crateid.to_str(), workspace.display())); } } @@ -429,7 +430,7 @@ fn dir_has_file(dir: &Path, file: &str) -> bool { dir.join(file).exists() } -pub fn find_dir_using_rust_path_hack(p: &PkgId) -> Option { +pub fn find_dir_using_rust_path_hack(p: &CrateId) -> Option { let rp = rust_path(); for dir in rp.iter() { // Require that the parent directory match the package ID diff --git a/src/librustpkg/tests.rs b/src/librustpkg/tests.rs index 21f18eda140..7f6342dba5c 100644 --- a/src/librustpkg/tests.rs +++ b/src/librustpkg/tests.rs @@ -24,7 +24,7 @@ use extra::getopts::groups::getopts; use std::run::ProcessOutput; use installed_packages::list_installed_packages; -use package_id::{PkgId}; +use crate_id::{CrateId}; use version::{ExactRevision, NoVersion, Version, Tagged}; use path_util::{target_executable_in_workspace, target_test_in_workspace, target_bench_in_workspace, make_dir_rwx, @@ -59,25 +59,25 @@ fn fake_ctxt(sysroot: Path, workspace: &Path) -> BuildContext { } } -fn fake_pkg() -> PkgId { +fn fake_pkg() -> CrateId { let sn = ~"bogus"; - PkgId { + CrateId { path: Path::new(sn.as_slice()), short_name: sn, version: NoVersion } } -fn git_repo_pkg() -> PkgId { - PkgId { +fn git_repo_pkg() -> CrateId { + CrateId { path: Path::new("mockgithub.com/catamorphism/test-pkg"), short_name: ~"test-pkg", version: NoVersion } } -fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId { - PkgId { +fn git_repo_pkg_with_tag(a_tag: ~str) -> CrateId { + CrateId { path: Path::new("mockgithub.com/catamorphism/test-pkg"), short_name: ~"test-pkg", version: Tagged(a_tag) @@ -302,15 +302,16 @@ fn command_line_test_with_env(args: &[~str], cwd: &Path, env: Option<~[(~str, ~s } } -fn create_local_package(pkgid: &PkgId) -> TempDir { - let (workspace, parent_dir) = mk_temp_workspace(&pkgid.path, &pkgid.version); - debug!("Created empty package dir for {}, returning {}", pkgid.to_str(), parent_dir.display()); +fn create_local_package(crateid: &CrateId) -> TempDir { + let (workspace, parent_dir) = mk_temp_workspace(&crateid.path, &crateid.version); + debug!("Created empty package dir for {}, returning {}", crateid.to_str(), + parent_dir.display()); workspace } -fn create_local_package_in(pkgid: &PkgId, pkgdir: &Path) -> Path { +fn create_local_package_in(crateid: &CrateId, pkgdir: &Path) -> Path { - let package_dir = pkgdir.join_many([~"src", pkgid.to_str()]); + let package_dir = pkgdir.join_many([~"src", crateid.to_str()]); // Create main, lib, test, and bench files fs::mkdir_recursive(&package_dir, io::UserRWX); @@ -329,29 +330,29 @@ fn create_local_package_in(pkgid: &PkgId, pkgdir: &Path) -> Path { package_dir } -fn create_local_package_with_test(pkgid: &PkgId) -> TempDir { - debug!("Dry run -- would create package {:?} with test", pkgid); - create_local_package(pkgid) // Already has tests??? +fn create_local_package_with_test(crateid: &CrateId) -> TempDir { + debug!("Dry run -- would create package {:?} with test", crateid); + create_local_package(crateid) // Already has tests??? } -fn create_local_package_with_dep(pkgid: &PkgId, subord_pkgid: &PkgId) -> TempDir { - let package_dir = create_local_package(pkgid); - create_local_package_in(subord_pkgid, package_dir.path()); - // Write a main.rs file into pkgid that references subord_pkgid - writeFile(&package_dir.path().join_many([~"src", pkgid.to_str(), ~"main.rs"]), +fn create_local_package_with_dep(crateid: &CrateId, subord_crateid: &CrateId) -> TempDir { + let package_dir = create_local_package(crateid); + create_local_package_in(subord_crateid, package_dir.path()); + // Write a main.rs file into crateid that references subord_crateid + writeFile(&package_dir.path().join_many([~"src", crateid.to_str(), ~"main.rs"]), format!("extern mod {};\nfn main() \\{\\}", - subord_pkgid.short_name)); - // Write a lib.rs file into subord_pkgid that has something in it - writeFile(&package_dir.path().join_many([~"src", subord_pkgid.to_str(), ~"lib.rs"]), + subord_crateid.short_name)); + // Write a lib.rs file into subord_crateid that has something in it + writeFile(&package_dir.path().join_many([~"src", subord_crateid.to_str(), ~"lib.rs"]), "pub fn f() {}"); package_dir } -fn create_local_package_with_custom_build_hook(pkgid: &PkgId, +fn create_local_package_with_custom_build_hook(crateid: &CrateId, custom_build_hook: &str) -> TempDir { debug!("Dry run -- would create package {} with custom build hook {}", - pkgid.to_str(), custom_build_hook); - create_local_package(pkgid) + crateid.to_str(), custom_build_hook); + create_local_package(crateid) // actually write the pkg.rs with the custom build hook } @@ -376,18 +377,18 @@ fn assert_executable_exists(repo: &Path, short_name: &str) { fn executable_exists(repo: &Path, short_name: &str) -> bool { debug!("executable_exists: repo = {}, short_name = {}", repo.display(), short_name); - let exec = target_executable_in_workspace(&PkgId::new(short_name), repo); + let exec = target_executable_in_workspace(&CrateId::new(short_name), repo); exec.exists() && is_rwx(&exec) } fn test_executable_exists(repo: &Path, short_name: &str) -> bool { debug!("test_executable_exists: repo = {}, short_name = {}", repo.display(), short_name); - let exec = built_test_in_workspace(&PkgId::new(short_name), repo); + let exec = built_test_in_workspace(&CrateId::new(short_name), repo); exec.map_default(false, |exec| exec.exists() && is_rwx(&exec)) } -fn remove_executable_file(p: &PkgId, workspace: &Path) { - let exec = target_executable_in_workspace(&PkgId::new(p.short_name), workspace); +fn remove_executable_file(p: &CrateId, workspace: &Path) { + let exec = target_executable_in_workspace(&CrateId::new(p.short_name), workspace); if exec.exists() { fs::unlink(&exec); } @@ -400,15 +401,15 @@ fn assert_built_executable_exists(repo: &Path, short_name: &str) { fn built_executable_exists(repo: &Path, short_name: &str) -> bool { debug!("assert_built_executable_exists: repo = {}, short_name = {}", repo.display(), short_name); - let exec = built_executable_in_workspace(&PkgId::new(short_name), repo); + let exec = built_executable_in_workspace(&CrateId::new(short_name), repo); exec.is_some() && { let execname = exec.get_ref(); execname.exists() && is_rwx(execname) } } -fn remove_built_executable_file(p: &PkgId, workspace: &Path) { - let exec = built_executable_in_workspace(&PkgId::new(p.short_name), workspace); +fn remove_built_executable_file(p: &CrateId, workspace: &Path) { + let exec = built_executable_in_workspace(&CrateId::new(p.short_name), workspace); match exec { Some(r) => fs::unlink(&r), None => () @@ -443,7 +444,7 @@ fn assert_built_library_exists(repo: &Path, short_name: &str) { fn built_library_exists(repo: &Path, short_name: &str) -> bool { debug!("assert_built_library_exists: repo = {}, short_name = {}", repo.display(), short_name); - let lib = built_library_in_workspace(&PkgId::new(short_name), repo); + let lib = built_library_in_workspace(&CrateId::new(short_name), repo); lib.is_some() && { let libname = lib.get_ref(); libname.exists() && is_rwx(libname) @@ -493,9 +494,9 @@ fn output_file_name(workspace: &Path, short_name: ~str) -> Path { } #[cfg(target_os = "linux")] -fn touch_source_file(workspace: &Path, pkgid: &PkgId) { +fn touch_source_file(workspace: &Path, crateid: &CrateId) { use conditions::bad_path::cond; - let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]); + let pkg_src_dir = workspace.join_many([~"src", crateid.to_str()]); let contents = fs::readdir(&pkg_src_dir); for p in contents.iter() { if p.extension_str() == Some("rs") { @@ -513,9 +514,9 @@ fn touch_source_file(workspace: &Path, pkgid: &PkgId) { } #[cfg(not(target_os = "linux"))] -fn touch_source_file(workspace: &Path, pkgid: &PkgId) { +fn touch_source_file(workspace: &Path, crateid: &CrateId) { use conditions::bad_path::cond; - let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]); + let pkg_src_dir = workspace.join_many([~"src", crateid.to_str()]); let contents = fs::readdir(&pkg_src_dir); for p in contents.iter() { if p.extension_str() == Some("rs") { @@ -532,9 +533,9 @@ fn touch_source_file(workspace: &Path, pkgid: &PkgId) { } /// Add a comment at the end -fn frob_source_file(workspace: &Path, pkgid: &PkgId, filename: &str) { +fn frob_source_file(workspace: &Path, crateid: &CrateId, filename: &str) { use conditions::bad_path::cond; - let pkg_src_dir = workspace.join_many([~"src", pkgid.to_str()]); + let pkg_src_dir = workspace.join_many([~"src", crateid.to_str()]); let mut maybe_p = None; let maybe_file = pkg_src_dir.join(filename); debug!("Trying to frob {} -- {}", pkg_src_dir.display(), filename); @@ -618,7 +619,7 @@ fn test_install_valid() { #[ignore] fn test_install_invalid() { let sysroot = test_sysroot(); - let pkgid = fake_pkg(); + let crateid = fake_pkg(); let temp_workspace = TempDir::new("test").expect("couldn't create temp dir"); let temp_workspace = temp_workspace.path().clone(); let ctxt = fake_ctxt(sysroot, &temp_workspace); @@ -628,7 +629,7 @@ fn test_install_invalid() { let pkg_src = PkgSrc::new(temp_workspace.clone(), temp_workspace.clone(), false, - pkgid.clone()); + crateid.clone()); ctxt.install(pkg_src, &WhatToBuild::new(MaybeCustom, Everything)); }; assert!(result.unwrap_err() @@ -637,7 +638,7 @@ fn test_install_invalid() { #[test] fn test_install_valid_external() { - let temp_pkg_id = PkgId::new("foo"); + let temp_pkg_id = CrateId::new("foo"); let (tempdir, _) = mk_temp_workspace(&temp_pkg_id.path, &temp_pkg_id.version); let temp_workspace = tempdir.path(); @@ -724,7 +725,7 @@ fn test_install_git() { } #[test] -fn test_package_ids_must_be_relative_path_like() { +fn test_crate_ids_must_be_relative_path_like() { use conditions::bad_pkg_id::cond; /* @@ -738,30 +739,30 @@ fn test_package_ids_must_be_relative_path_like() { */ - let whatever = PkgId::new("foo"); + let whatever = CrateId::new("foo"); assert_eq!(~"foo-0.0", whatever.to_str()); assert!("github.com/catamorphism/test-pkg-0.0" == - PkgId::new("github.com/catamorphism/test-pkg").to_str()); + CrateId::new("github.com/catamorphism/test-pkg").to_str()); cond.trap(|(p, e)| { assert!(p.filename().is_none()) - assert!("0-length pkgid" == e); + assert!("0-length crate_id" == e); whatever.clone() }).inside(|| { - let x = PkgId::new(""); + let x = CrateId::new(""); assert_eq!(~"foo-0.0", x.to_str()); }); cond.trap(|(p, e)| { let abs = os::make_absolute(&Path::new("foo/bar/quux")); assert_eq!(p, abs); - assert!("absolute pkgid" == e); + assert!("absolute crate_id" == e); whatever.clone() }).inside(|| { let zp = os::make_absolute(&Path::new("foo/bar/quux")); // FIXME (#9639): This needs to handle non-utf8 paths - let z = PkgId::new(zp.as_str().unwrap()); + let z = CrateId::new(zp.as_str().unwrap()); assert_eq!(~"foo-0.0", z.to_str()); }) } @@ -785,7 +786,7 @@ fn test_package_version() { add_git_tag(&repo_subdir, ~"0.4"); // It won't pick up the 0.4 version because the dir isn't in the RUST_PATH, but... - let temp_pkg_id = PkgId::new("mockgithub.com/catamorphism/test_pkg_version"); + let temp_pkg_id = CrateId::new("mockgithub.com/catamorphism/test_pkg_version"); // This should look at the prefix, clone into a workspace, then build. command_line_test([~"install", ~"mockgithub.com/catamorphism/test_pkg_version"], repo); @@ -837,7 +838,7 @@ fn test_package_request_version() { } None => false }); - let temp_pkg_id = PkgId::new("mockgithub.com/catamorphism/test_pkg_version#0.3"); + let temp_pkg_id = CrateId::new("mockgithub.com/catamorphism/test_pkg_version#0.3"); assert!(target_executable_in_workspace(&temp_pkg_id, &repo.join(".rust")) == repo.join_many([".rust", "bin", "test_pkg_version"])); @@ -880,7 +881,7 @@ fn rustpkg_library_target() { #[test] fn rustpkg_local_pkg() { - let dir = create_local_package(&PkgId::new("foo")); + let dir = create_local_package(&CrateId::new("foo")); command_line_test([~"install", ~"foo"], dir.path()); assert_executable_exists(dir.path(), "foo"); } @@ -888,7 +889,7 @@ fn rustpkg_local_pkg() { #[test] #[ignore(reason="busted")] fn package_script_with_default_build() { - let dir = create_local_package(&PkgId::new("fancy-lib")); + let dir = create_local_package(&CrateId::new("fancy-lib")); let dir = dir.path(); debug!("dir = {}", dir.display()); let mut source = test_sysroot().dir_path(); @@ -945,7 +946,7 @@ fn rustpkg_clean_no_arg() { command_line_test([~"build"], &package_dir); assert_built_executable_exists(&tmp, "foo"); command_line_test([~"clean"], &package_dir); - let res = built_executable_in_workspace(&PkgId::new("foo"), &tmp); + let res = built_executable_in_workspace(&CrateId::new("foo"), &tmp); assert!(!res.as_ref().map_default(false, |m| m.exists())); } @@ -1003,11 +1004,11 @@ fn rust_path_parse() { fn test_list() { let dir = TempDir::new("test_list").expect("test_list failed"); let dir = dir.path(); - let foo = PkgId::new("foo"); + let foo = CrateId::new("foo"); create_local_package_in(&foo, dir); - let bar = PkgId::new("bar"); + let bar = CrateId::new("bar"); create_local_package_in(&bar, dir); - let quux = PkgId::new("quux"); + let quux = CrateId::new("quux"); create_local_package_in(&quux, dir); // list doesn't output very much right now... @@ -1033,9 +1034,9 @@ fn test_list() { fn install_remove() { let dir = TempDir::new("install_remove").expect("install_remove"); let dir = dir.path(); - let foo = PkgId::new("foo"); - let bar = PkgId::new("bar"); - let quux = PkgId::new("quux"); + let foo = CrateId::new("foo"); + let bar = CrateId::new("bar"); + let quux = CrateId::new("quux"); create_local_package_in(&foo, dir); create_local_package_in(&bar, dir); create_local_package_in(&quux, dir); @@ -1062,13 +1063,13 @@ fn install_check_duplicates() { // check invariant that there are no dups in the pkg database let dir = TempDir::new("install_remove").expect("install_remove"); let dir = dir.path(); - let foo = PkgId::new("foo"); + let foo = CrateId::new("foo"); create_local_package_in(&foo, dir); command_line_test([~"install", ~"foo"], dir); command_line_test([~"install", ~"foo"], dir); let mut contents = ~[]; - let check_dups = |p: &PkgId| { + let check_dups = |p: &CrateId| { if contents.contains(p) { fail!("package {} appears in `list` output more than once", p.path.display()); } @@ -1082,7 +1083,7 @@ fn install_check_duplicates() { #[test] fn no_rebuilding() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); command_line_test([~"build", ~"foo"], workspace); @@ -1103,7 +1104,7 @@ fn no_rebuilding() { #[test] #[ignore] fn no_recopying() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); command_line_test([~"install", ~"foo"], workspace); @@ -1122,8 +1123,8 @@ fn no_recopying() { #[test] fn no_rebuilding_dep() { - let p_id = PkgId::new("foo"); - let dep_id = PkgId::new("bar"); + let p_id = CrateId::new("foo"); + let dep_id = CrateId::new("bar"); let workspace = create_local_package_with_dep(&p_id, &dep_id); let workspace = workspace.path(); command_line_test([~"build", ~"foo"], workspace); @@ -1141,8 +1142,8 @@ fn no_rebuilding_dep() { #[test] fn do_rebuild_dep_dates_change() { - let p_id = PkgId::new("foo"); - let dep_id = PkgId::new("bar"); + let p_id = CrateId::new("foo"); + let dep_id = CrateId::new("bar"); let workspace = create_local_package_with_dep(&p_id, &dep_id); let workspace = workspace.path(); command_line_test([~"build", ~"foo"], workspace); @@ -1161,8 +1162,8 @@ fn do_rebuild_dep_dates_change() { #[test] fn do_rebuild_dep_only_contents_change() { - let p_id = PkgId::new("foo"); - let dep_id = PkgId::new("bar"); + let p_id = CrateId::new("foo"); + let dep_id = CrateId::new("bar"); let workspace = create_local_package_with_dep(&p_id, &dep_id); let workspace = workspace.path(); command_line_test([~"build", ~"foo"], workspace); @@ -1182,8 +1183,8 @@ fn do_rebuild_dep_only_contents_change() { #[test] fn test_versions() { - let workspace = create_local_package(&PkgId::new("foo#0.1")); - let _other_workspace = create_local_package(&PkgId::new("foo#0.2")); + let workspace = create_local_package(&CrateId::new("foo#0.1")); + let _other_workspace = create_local_package(&CrateId::new("foo#0.2")); command_line_test([~"install", ~"foo#0.1"], workspace.path()); let output = command_line_test_output([~"list"]); // make sure output includes versions @@ -1193,7 +1194,7 @@ fn test_versions() { #[test] #[ignore(reason = "do not yet implemented")] fn test_build_hooks() { - let workspace = create_local_package_with_custom_build_hook(&PkgId::new("foo"), + let workspace = create_local_package_with_custom_build_hook(&CrateId::new("foo"), "frob"); command_line_test([~"do", ~"foo", ~"frob"], workspace.path()); } @@ -1203,14 +1204,14 @@ fn test_build_hooks() { #[ignore(reason = "info not yet implemented")] fn test_info() { let expected_info = ~"package foo"; // fill in - let workspace = create_local_package(&PkgId::new("foo")); + let workspace = create_local_package(&CrateId::new("foo")); let output = command_line_test([~"info", ~"foo"], workspace.path()); assert_eq!(str::from_utf8_owned(output.output), expected_info); } #[test] fn test_uninstall() { - let workspace = create_local_package(&PkgId::new("foo")); + let workspace = create_local_package(&CrateId::new("foo")); command_line_test([~"uninstall", ~"foo"], workspace.path()); let output = command_line_test([~"list"], workspace.path()); assert!(!str::from_utf8(output.output).contains("foo")); @@ -1346,7 +1347,7 @@ fn test_extern_mod_simpler() { #[test] fn test_import_rustpkg() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); writeFile(&workspace.join_many(["src", "foo-0.0", "pkg.rs"]), @@ -1359,7 +1360,7 @@ fn test_import_rustpkg() { #[test] fn test_macro_pkg_script() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); writeFile(&workspace.join_many(["src", "foo-0.0", "pkg.rs"]), @@ -1386,7 +1387,7 @@ fn multiple_workspaces() { // FIXME (#9639): This needs to handle non-utf8 paths let env = Some(~[(~"RUST_PATH", format!("{}:{}", a_loc.as_str().unwrap(), b_loc.as_str().unwrap()))]); - let c_loc = create_local_package_with_dep(&PkgId::new("bar"), &PkgId::new("foo")); + let c_loc = create_local_package_with_dep(&CrateId::new("bar"), &CrateId::new("foo")); command_line_test_with_env([~"install", ~"bar"], c_loc.path(), env); } @@ -1399,7 +1400,7 @@ fn rust_path_hack_test(hack_flag: bool) { make sure built files for foo are in B make sure nothing gets built into A or A/../build[lib,bin] */ - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); @@ -1524,8 +1525,8 @@ fn rust_path_hack_build_no_arg() { #[test] fn rust_path_hack_build_with_dependency() { - let foo_id = PkgId::new("foo"); - let dep_id = PkgId::new("dep"); + let foo_id = CrateId::new("foo"); + let dep_id = CrateId::new("dep"); // Tests that when --rust-path-hack is in effect, dependencies get built // into the destination workspace and not the source directory let work_dir = create_local_package(&foo_id); @@ -1573,7 +1574,7 @@ fn rust_path_install_target() { #[test] fn sysroot_flag() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); // no-op sysroot setting; I'm not sure how else to test this @@ -1589,7 +1590,7 @@ fn sysroot_flag() { #[test] fn compile_flag_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1606,7 +1607,7 @@ fn compile_flag_build() { #[test] fn compile_flag_fail() { // --no-link shouldn't be accepted for install - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1622,7 +1623,7 @@ fn compile_flag_fail() { #[test] fn notrans_flag_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let flags_to_test = [~"--no-trans", ~"--parse-only", @@ -1647,7 +1648,7 @@ fn notrans_flag_build() { #[test] fn notrans_flag_fail() { // --no-trans shouldn't be accepted for install - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let flags_to_test = [~"--no-trans", ~"--parse-only", @@ -1668,7 +1669,7 @@ fn notrans_flag_fail() { #[test] fn dash_S() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1685,7 +1686,7 @@ fn dash_S() { #[test] fn dash_S_fail() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1702,7 +1703,7 @@ fn dash_S_fail() { #[test] fn test_cfg_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); // If the cfg flag gets messed up, this won't compile @@ -1721,7 +1722,7 @@ fn test_cfg_build() { #[test] fn test_cfg_fail() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); writeFile(&workspace.join_many(["src", "foo-0.0", "main.rs"]), @@ -1740,7 +1741,7 @@ fn test_cfg_fail() { #[test] fn test_emit_llvm_S_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1758,7 +1759,7 @@ fn test_emit_llvm_S_build() { #[test] fn test_emit_llvm_S_fail() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1778,7 +1779,7 @@ fn test_emit_llvm_S_fail() { #[test] fn test_emit_llvm_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1797,7 +1798,7 @@ fn test_emit_llvm_build() { #[test] fn test_emit_llvm_fail() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1818,7 +1819,7 @@ fn test_emit_llvm_fail() { #[test] fn test_linker_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let matches = getopts([], optgroups()); @@ -1863,7 +1864,7 @@ fn test_build_install_flags_fail() { #[test] fn test_optimized_build() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1877,7 +1878,7 @@ fn test_optimized_build() { } #[test] -fn pkgid_pointing_to_subdir() { +fn crateid_pointing_to_subdir() { // The actual repo is mockgithub.com/mozilla/some_repo // rustpkg should recognize that and treat the part after some_repo/ as a subdir let workspace = TempDir::new("parent_repo").expect("Couldn't create temp dir"); @@ -1913,9 +1914,9 @@ fn pkgid_pointing_to_subdir() { #[test] fn test_recursive_deps() { - let a_id = PkgId::new("a"); - let b_id = PkgId::new("b"); - let c_id = PkgId::new("c"); + let a_id = CrateId::new("a"); + let b_id = CrateId::new("b"); + let c_id = CrateId::new("c"); let b_workspace = create_local_package_with_dep(&b_id, &c_id); let b_workspace = b_workspace.path(); writeFile(&b_workspace.join_many(["src", "c-0.0", "lib.rs"]), @@ -1939,7 +1940,7 @@ fn test_recursive_deps() { #[test] fn test_install_to_rust_path() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let second_workspace = create_local_package(&p_id); let second_workspace = second_workspace.path(); let first_workspace = mk_empty_workspace(&Path::new("p"), &NoVersion, "dest"); @@ -1963,7 +1964,7 @@ fn test_install_to_rust_path() { #[test] fn test_target_specific_build_dir() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1979,7 +1980,7 @@ fn test_target_specific_build_dir() { #[test] fn test_target_specific_install_dir() { - let p_id = PkgId::new("foo"); + let p_id = CrateId::new("foo"); let workspace = create_local_package(&p_id); let workspace = workspace.path(); let test_sys = test_sysroot(); @@ -1998,7 +1999,7 @@ fn test_target_specific_install_dir() { #[test] #[ignore(reason = "See #7240")] fn test_dependencies_terminate() { - let b_id = PkgId::new("b"); + let b_id = CrateId::new("b"); let workspace = create_local_package(&b_id); let workspace = workspace.path(); let b_dir = workspace.join_many(["src", "b-0.0"]); @@ -2011,7 +2012,7 @@ fn test_dependencies_terminate() { #[test] fn install_after_build() { - let b_id = PkgId::new("b"); + let b_id = CrateId::new("b"); let workspace = create_local_package(&b_id); let workspace = workspace.path(); command_line_test([~"build", ~"b"], workspace); @@ -2022,7 +2023,7 @@ fn install_after_build() { #[test] fn reinstall() { - let b = PkgId::new("b"); + let b = CrateId::new("b"); let workspace = create_local_package(&b); let workspace = workspace.path(); // 1. Install, then remove executable file, then install again, @@ -2061,8 +2062,8 @@ fn correct_package_name_with_rust_path_hack() { */ // 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_id = CrateId::new("foo"); + let bar_id = CrateId::new("bar"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); let dest_workspace = mk_empty_workspace(&Path::new("bar"), &NoVersion, "dest_workspace"); @@ -2091,7 +2092,7 @@ fn correct_package_name_with_rust_path_hack() { #[test] fn test_rustpkg_test_creates_exec() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); writeFile(&foo_workspace.join_many(["src", "foo-0.0", "test.rs"]), @@ -2102,7 +2103,7 @@ fn test_rustpkg_test_creates_exec() { #[test] fn test_rustpkg_test_output() { - let workspace = create_local_package_with_test(&PkgId::new("foo")); + let workspace = create_local_package_with_test(&CrateId::new("foo")); let output = command_line_test([~"test", ~"foo"], workspace.path()); let output_str = str::from_utf8(output.output); // The first two assertions are separate because test output may @@ -2114,7 +2115,7 @@ fn test_rustpkg_test_output() { #[test] fn test_rustpkg_test_failure_exit_status() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); writeFile(&foo_workspace.join_many(["src", "foo-0.0", "test.rs"]), @@ -2128,7 +2129,7 @@ fn test_rustpkg_test_failure_exit_status() { #[test] fn test_rustpkg_test_cfg() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); writeFile(&foo_workspace.join_many(["src", "foo-0.0", "test.rs"]), @@ -2141,7 +2142,7 @@ fn test_rustpkg_test_cfg() { #[test] fn test_rebuild_when_needed() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); let test_crate = foo_workspace.join_many(["src", "foo-0.0", "test.rs"]); @@ -2162,7 +2163,7 @@ fn test_rebuild_when_needed() { #[test] #[ignore] // FIXME (#10257): This doesn't work as is since a read only file can't execute fn test_no_rebuilding() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); let test_crate = foo_workspace.join_many(["src", "foo-0.0", "test.rs"]); @@ -2196,7 +2197,7 @@ fn test_installed_read_only() { writeFile(&repo_subdir.join("lib.rs"), "pub fn f() { let _x = (); }"); add_git_tag(&repo_subdir, ~"0.1"); // this has the effect of committing the files - // update pkgid to what will be auto-detected + // update crateid to what will be auto-detected temp_pkg_id.version = ExactRevision(~"0.1"); // FIXME (#9639): This needs to handle non-utf8 paths @@ -2281,7 +2282,7 @@ fn test_installed_local_changes() { #[test] fn test_7402() { - let dir = create_local_package(&PkgId::new("foo")); + let dir = create_local_package(&CrateId::new("foo")); let dest_workspace = TempDir::new("more_rust").expect("test_7402"); let dest_workspace = dest_workspace.path(); // FIXME (#9639): This needs to handle non-utf8 paths @@ -2295,7 +2296,7 @@ fn test_7402() { #[test] fn test_compile_error() { - let foo_id = PkgId::new("foo"); + let foo_id = CrateId::new("foo"); let foo_workspace = create_local_package(&foo_id); let foo_workspace = foo_workspace.path(); let main_crate = foo_workspace.join_many(["src", "foo-0.0", "main.rs"]); @@ -2329,7 +2330,7 @@ fn test_c_dependency_ok() { // registers a hook to build it if it's not fresh // After running `build`, test that the C library built - let dir = create_local_package(&PkgId::new("cdep")); + let dir = create_local_package(&CrateId::new("cdep")); let dir = dir.path(); writeFile(&dir.join_many(["src", "cdep-0.0", "main.rs"]), "#[link_args = \"-lfoo\"]\nextern { fn f(); } \ @@ -2352,7 +2353,7 @@ fn test_c_dependency_ok() { #[test] #[ignore(reason="busted")] fn test_c_dependency_no_rebuilding() { - let dir = create_local_package(&PkgId::new("cdep")); + let dir = create_local_package(&CrateId::new("cdep")); let dir = dir.path(); writeFile(&dir.join_many(["src", "cdep-0.0", "main.rs"]), "#[link_args = \"-lfoo\"]\nextern { fn f(); } \ @@ -2386,7 +2387,7 @@ fn test_c_dependency_no_rebuilding() { #[test] #[ignore(reason="busted")] fn test_c_dependency_yes_rebuilding() { - let dir = create_local_package(&PkgId::new("cdep")); + let dir = create_local_package(&CrateId::new("cdep")); let dir = dir.path(); writeFile(&dir.join_many(["src", "cdep-0.0", "main.rs"]), "#[link_args = \"-lfoo\"]\nextern { fn f(); } \ @@ -2407,7 +2408,7 @@ fn test_c_dependency_yes_rebuilding() { assert!(c_library_path.exists()); // Now, make the Rust library read-only so rebuilding will fail - match built_library_in_workspace(&PkgId::new("cdep"), dir) { + match built_library_in_workspace(&CrateId::new("cdep"), dir) { Some(ref pth) => assert!(chmod_read_only(pth)), None => assert_built_library_exists(dir, "cdep") } @@ -2425,7 +2426,7 @@ fn test_c_dependency_yes_rebuilding() { fn correct_error_dependency() { // Supposing a package we're trying to install via a dependency doesn't // exist, we should throw a condition, and not ICE - let workspace_dir = create_local_package(&PkgId::new("badpkg")); + let workspace_dir = create_local_package(&CrateId::new("badpkg")); let dir = workspace_dir.path(); let main_rs = dir.join_many(["src", "badpkg-0.0", "main.rs"]); diff --git a/src/librustpkg/util.rs b/src/librustpkg/util.rs index eb7dbe4e4a8..2bb252c362c 100644 --- a/src/librustpkg/util.rs +++ b/src/librustpkg/util.rs @@ -29,7 +29,7 @@ use rustc::back::link::output_type_exe; use rustc::back::link; use context::{in_target, StopBefore, Link, Assemble, BuildContext}; -use package_id::PkgId; +use crate_id::CrateId; use package_source::PkgSrc; use workspace::pkg_parent_workspaces; use path_util::{system_library, target_build_dir}; @@ -52,7 +52,7 @@ pub type ExitCode = int; // For now pub struct Pkg { - id: PkgId, + id: CrateId, bins: ~[~str], libs: ~[~str], } @@ -170,7 +170,7 @@ pub fn ready_crate(sess: session::Session, pub fn compile_input(context: &BuildContext, exec: &mut workcache::Exec, - pkg_id: &PkgId, + pkg_id: &CrateId, in_file: &Path, workspace: &Path, deps: &mut DepMap, @@ -303,17 +303,17 @@ pub fn compile_input(context: &BuildContext, addl_lib_search_paths.get().insert(p); }); - // Inject the pkgid attribute so we get the right package name and version + // Inject the crate_id attribute so we get the right package name and version if !attr::contains_name(crate.attrs, "crate_id") { // FIXME (#9639): This needs to handle non-utf8 paths - let pkgid_attr = + let crateid_attr = attr::mk_name_value_item_str(@"crate_id", format!("{}\\#{}", pkg_id.path.as_str().unwrap(), pkg_id.version.to_str()).to_managed()); - debug!("pkgid attr: {:?}", pkgid_attr); - crate.attrs.push(attr::mk_attr(pkgid_attr)); + debug!("crateid attr: {:?}", crateid_attr); + crate.attrs.push(attr::mk_attr(crateid_attr)); } debug!("calling compile_crate_from_input, workspace = {}, @@ -428,7 +428,7 @@ pub fn exe_suffix() -> ~str { ~"" } // Called by build_crates pub fn compile_crate(ctxt: &BuildContext, exec: &mut workcache::Exec, - pkg_id: &PkgId, + pkg_id: &CrateId, crate: &Path, workspace: &Path, deps: &mut DepMap, @@ -446,7 +446,7 @@ pub fn compile_crate(ctxt: &BuildContext, struct ViewItemVisitor<'a> { context: &'a BuildContext, - parent: &'a PkgId, + parent: &'a CrateId, parent_crate: &'a Path, sess: session::Session, exec: &'a mut workcache::Exec, @@ -491,7 +491,7 @@ fn visit_view_item(&mut self, vi: &ast::view_item, env: ()) { debug!("Trying to install library {}, rebuilding it", lib_name.to_str()); // Try to install it - let pkg_id = PkgId::new(lib_name); + let pkg_id = CrateId::new(lib_name); // Find all the workspaces in the RUST_PATH that contain this package. let workspaces = pkg_parent_workspaces(&self.context.context, &pkg_id); @@ -607,7 +607,7 @@ fn visit_view_item(&mut self, vi: &ast::view_item, env: ()) { /// try to install their targets, failing if any target /// can't be found. pub fn find_and_install_dependencies(context: &BuildContext, - parent: &PkgId, + parent: &CrateId, parent_crate: &Path, sess: session::Session, exec: &mut workcache::Exec, diff --git a/src/librustpkg/workspace.rs b/src/librustpkg/workspace.rs index 95fc6677272..d6e617d2d50 100644 --- a/src/librustpkg/workspace.rs +++ b/src/librustpkg/workspace.rs @@ -13,23 +13,23 @@ use std::os; use std::path::Path; use context::Context; -use path_util::{workspace_contains_package_id, find_dir_using_rust_path_hack, default_workspace}; +use path_util::{workspace_contains_crate_id, find_dir_using_rust_path_hack, default_workspace}; use path_util::rust_path; use util::option_to_vec; -use package_id::PkgId; +use crate_id::CrateId; pub fn each_pkg_parent_workspace(cx: &Context, - pkgid: &PkgId, + crateid: &CrateId, action: |&Path| -> bool) -> bool { // Using the RUST_PATH, find workspaces that contain // this package ID - let workspaces = pkg_parent_workspaces(cx, pkgid); + let workspaces = pkg_parent_workspaces(cx, crateid); if workspaces.is_empty() { // tjc: make this a condition fail!("Package {} not found in any of \ the following workspaces: {}", - pkgid.path.display(), + crateid.path.display(), rust_path().map(|p| p.display().to_str()).to_str()); } for ws in workspaces.iter() { @@ -42,12 +42,12 @@ pub fn each_pkg_parent_workspace(cx: &Context, /// Given a package ID, return a vector of all of the workspaces in /// the RUST_PATH that contain it -pub fn pkg_parent_workspaces(cx: &Context, pkgid: &PkgId) -> ~[Path] { +pub fn pkg_parent_workspaces(cx: &Context, crateid: &CrateId) -> ~[Path] { let rs: ~[Path] = rust_path().move_iter() - .filter(|ws| workspace_contains_package_id(pkgid, ws)) + .filter(|ws| workspace_contains_crate_id(crateid, ws)) .collect(); if cx.use_rust_path_hack { - rs + option_to_vec(find_dir_using_rust_path_hack(pkgid)) + rs + option_to_vec(find_dir_using_rust_path_hack(crateid)) } else { rs @@ -56,7 +56,7 @@ pub fn pkg_parent_workspaces(cx: &Context, pkgid: &PkgId) -> ~[Path] { /// Construct a workspace and package-ID name based on the current directory. /// This gets used when rustpkg gets invoked without a package-ID argument. -pub fn cwd_to_workspace() -> Option<(Path, PkgId)> { +pub fn cwd_to_workspace() -> Option<(Path, CrateId)> { let cwd = os::getcwd(); for path in rust_path().move_iter() { let srcpath = path.join("src"); @@ -64,7 +64,7 @@ pub fn cwd_to_workspace() -> Option<(Path, PkgId)> { let rel = cwd.path_relative_from(&srcpath); let rel_s = rel.as_ref().and_then(|p|p.as_str()); if rel_s.is_some() { - return Some((path, PkgId::new(rel_s.unwrap()))); + return Some((path, CrateId::new(rel_s.unwrap()))); } } } diff --git a/src/test/compile-fail/issue-7573.rs b/src/test/compile-fail/issue-7573.rs index 4ab0ac6386e..3b8eda8f783 100644 --- a/src/test/compile-fail/issue-7573.rs +++ b/src/test/compile-fail/issue-7573.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub struct PkgId { +pub struct CrateId { local_path: ~str, junk: ~str } -impl PkgId { - fn new(s: &str) -> PkgId { - PkgId { +impl CrateId { + fn new(s: &str) -> CrateId { + CrateId { local_path: s.to_owned(), junk: ~"wutevs" } @@ -23,8 +23,8 @@ fn new(s: &str) -> PkgId { } pub fn remove_package_from_database() { - let mut lines_to_use: ~[&PkgId] = ~[]; //~ ERROR cannot infer an appropriate lifetime - let push_id = |installed_id: &PkgId| { + let mut lines_to_use: ~[&CrateId] = ~[]; //~ ERROR cannot infer an appropriate lifetime + let push_id = |installed_id: &CrateId| { lines_to_use.push(installed_id); }; list_database(push_id); @@ -35,11 +35,11 @@ pub fn remove_package_from_database() { } -pub fn list_database(f: |&PkgId|) { +pub fn list_database(f: |&CrateId|) { let stuff = ["foo", "bar"]; for l in stuff.iter() { - f(&PkgId::new(*l)); + f(&CrateId::new(*l)); } }