rustpkg: Fail when crate inference fails; inject link attributes
1. Fail when there's no package script and no crates named main.rs, lib.rs, bench.rs, or test.rs. 2. Inject the crate link_meta "name" and "vers" attributes, so that the output file gets named correctly in the library case. 3. Normalize '-' to '_' in package names.
This commit is contained in:
Tim Chevalier
parent
c2f5a87cdd
commit
c01c3d9fc6
3 changed files with 142 additions and 85 deletions
|
|
@ -11,7 +11,8 @@
|
|||
// rustpkg utilities having to do with paths and directories
|
||||
|
||||
use core::path::*;
|
||||
use core::os;
|
||||
use core::{os, str};
|
||||
use core::option::*;
|
||||
use util::PkgId;
|
||||
|
||||
/// Returns the output directory to use.
|
||||
|
|
@ -50,6 +51,24 @@ pub fn default_dest_dir(pkg_dir: &Path) -> Path {
|
|||
}
|
||||
}
|
||||
|
||||
/// Replace all occurrences of '-' in the stem part of path with '_'
|
||||
/// This is because we treat rust-foo-bar-quux and rust_foo_bar_quux
|
||||
/// as the same name
|
||||
pub fn normalize(p: ~Path) -> ~Path {
|
||||
match p.filestem() {
|
||||
None => p,
|
||||
Some(st) => {
|
||||
let replaced = str::replace(st, "-", "_");
|
||||
if replaced != st {
|
||||
~p.with_filestem(replaced)
|
||||
}
|
||||
else {
|
||||
p
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use core::{os, rand};
|
||||
|
|
|
|||
|
|
@ -36,8 +36,9 @@ use rustc::metadata::filesearch;
|
|||
use std::net::url;
|
||||
use std::{getopts};
|
||||
use syntax::{ast, diagnostic};
|
||||
use util::{ExitCode, Pkg, PkgId};
|
||||
use path_util::dest_dir;
|
||||
use util::*;
|
||||
use path_util::{dest_dir, normalize};
|
||||
use rustc::driver::session::{lib_crate, bin_crate, unknown_crate, crate_type};
|
||||
|
||||
mod conditions;
|
||||
mod usage;
|
||||
|
|
@ -117,9 +118,12 @@ impl PkgScript {
|
|||
Ok(r) => {
|
||||
let root = r.pop().pop().pop().pop(); // :-\
|
||||
debug!("Root is %s, calling compile_rest", root.to_str());
|
||||
util::compile_crate_from_input(self.input, Some(self.build_dir),
|
||||
sess, Some(crate), os::args()[0]);
|
||||
let exe = self.build_dir.push(~"pkg" + util::exe_suffix());
|
||||
util::compile_crate_from_input(self.input, self.id,
|
||||
Some(self.build_dir),
|
||||
sess, Some(crate),
|
||||
exe, os::args()[0],
|
||||
driver::cu_everything);
|
||||
debug!("Running program: %s %s %s", exe.to_str(), root.to_str(), what);
|
||||
let status = run::run_program(exe.to_str(), ~[root.to_str(), what]);
|
||||
if status != 0 {
|
||||
|
|
@ -199,15 +203,15 @@ impl Ctx {
|
|||
// relative to the CWD. In the future, we should search
|
||||
// paths
|
||||
let cwd = os::getcwd().normalize();
|
||||
debug!("Current working directory = %?", cwd);
|
||||
debug!("Current working directory = %s", cwd.to_str());
|
||||
|
||||
// Find crates inside the workspace
|
||||
// Create the package source
|
||||
let mut src = PkgSrc::new(&cwd, &dst_dir, &pkgid);
|
||||
debug!("Package src = %?", src);
|
||||
src.find_crates();
|
||||
|
||||
// Is there custom build logic? If so, use it
|
||||
let pkg_src_dir = cwd.push_rel(&pkgid.path);
|
||||
let mut custom = false;;
|
||||
debug!("Package source directory = %s", pkg_src_dir.to_str());
|
||||
let cfgs = match src.package_script_option(&pkg_src_dir) {
|
||||
Some(package_script_path) => {
|
||||
|
|
@ -221,6 +225,7 @@ impl Ctx {
|
|||
if hook_result != 0 {
|
||||
fail!(fmt!("Error running custom build command"))
|
||||
}
|
||||
custom = true;
|
||||
// otherwise, the package script succeeded
|
||||
cfgs
|
||||
}
|
||||
|
|
@ -229,6 +234,13 @@ impl Ctx {
|
|||
~[]
|
||||
}
|
||||
};
|
||||
|
||||
// Find crates inside the workspace
|
||||
if !custom {
|
||||
src.find_crates();
|
||||
}
|
||||
|
||||
// Build it!
|
||||
src.build(&dst_dir, cfgs);
|
||||
}
|
||||
~"clean" => {
|
||||
|
|
@ -728,7 +740,6 @@ condition! {
|
|||
|
||||
impl PkgSrc {
|
||||
|
||||
|
||||
fn new(src_dir: &Path, dst_dir: &Path,
|
||||
id: &PkgId) -> PkgSrc {
|
||||
PkgSrc {
|
||||
|
|
@ -765,12 +776,6 @@ impl PkgSrc {
|
|||
dir
|
||||
}
|
||||
|
||||
|
||||
fn has_pkg_file(&self) -> bool {
|
||||
let dir = self.check_dir();
|
||||
dir.push("pkg.rs").exists()
|
||||
}
|
||||
|
||||
// If a file named "pkg.rs" in the current directory exists,
|
||||
// return the path for it. Otherwise, None
|
||||
fn package_script_option(&self, cwd: &Path) -> Option<Path> {
|
||||
|
|
@ -786,14 +791,16 @@ impl PkgSrc {
|
|||
/// True if the given path's stem is self's pkg ID's stem
|
||||
/// or if the pkg ID's stem is <rust-foo> and the given path's
|
||||
/// stem is foo
|
||||
/// Requires that dashes in p have already been normalized to
|
||||
/// underscores
|
||||
fn stem_matches(&self, p: &Path) -> bool {
|
||||
let self_id = self.id.path.filestem();
|
||||
let self_id = normalize(~self.id.path).filestem();
|
||||
if self_id == p.filestem() {
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
for self_id.each |pth| {
|
||||
if pth.starts_with("rust-")
|
||||
if pth.starts_with("rust_") // because p is already normalized
|
||||
&& match p.filestem() {
|
||||
Some(s) => str::eq_slice(s, pth.slice(5, pth.len())),
|
||||
None => false
|
||||
|
|
@ -814,17 +821,14 @@ impl PkgSrc {
|
|||
cs.push(Crate::new(&sub));
|
||||
}
|
||||
|
||||
/// Infers crates to build. Called only in the case where there
|
||||
/// is no custom build logic
|
||||
fn find_crates(&mut self) {
|
||||
use PkgSrc::push_crate;
|
||||
|
||||
let dir = self.check_dir();
|
||||
let prefix = dir.components.len();
|
||||
// This is ugly, but can go away once we get rid
|
||||
// of .rc files
|
||||
let mut saw_rs = false;
|
||||
let mut saw_rc = false;
|
||||
debug!("Matching against %?",
|
||||
self.id.path.filestem());
|
||||
debug!("Matching against %?", self.id.path.filestem());
|
||||
for os::walk_dir(&dir) |pth| {
|
||||
match pth.filename() {
|
||||
Some(~"lib.rs") => push_crate(&mut self.libs,
|
||||
|
|
@ -836,30 +840,10 @@ impl PkgSrc {
|
|||
Some(~"bench.rs") => push_crate(&mut self.benchs,
|
||||
prefix, pth),
|
||||
_ => {
|
||||
// If the file stem is the same as the
|
||||
// package ID, with an .rs or .rc extension,
|
||||
// consider it to be a crate
|
||||
let ext = pth.filetype();
|
||||
let matches = |p: &Path| {
|
||||
self.stem_matches(p) && (ext == Some(~".rc")
|
||||
|| ext == Some(~".rs"))
|
||||
};
|
||||
debug!("Checking %? which %s and ext = %? %? %?", pth.filestem(),
|
||||
if matches(pth) { "matches" } else { "does not match" },
|
||||
ext, saw_rs, saw_rc);
|
||||
if matches(pth) &&
|
||||
// Avoid pushing foo.rc *and* foo.rs
|
||||
!((ext == Some(~".rc") && saw_rs) ||
|
||||
(ext == Some(~".rs") && saw_rc)) {
|
||||
push_crate(&mut self.libs, // ????
|
||||
prefix, pth);
|
||||
if ext == Some(~".rc") {
|
||||
saw_rc = true;
|
||||
}
|
||||
else if ext == Some(~".rs") {
|
||||
saw_rs = true;
|
||||
}
|
||||
}
|
||||
util::note(~"Couldn't infer any crates to build.\n\
|
||||
Try naming a crate `main.rs`, `lib.rs`, \
|
||||
`test.rs`, or `bench.rs`.");
|
||||
fail!(~"Failed to infer crates to build");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -870,22 +854,22 @@ impl PkgSrc {
|
|||
self.benchs.len())
|
||||
}
|
||||
|
||||
fn build_crates(dst_dir: &Path,
|
||||
fn build_crates(&self, dst_dir: &Path,
|
||||
src_dir: &Path,
|
||||
crates: &[Crate],
|
||||
cfgs: ~[~str],
|
||||
test: bool) {
|
||||
test: bool, crate_type: crate_type) {
|
||||
|
||||
for crates.each |&crate| {
|
||||
let path = &src_dir.push_rel(&crate.file).normalize();
|
||||
util::note(fmt!("build_crates: compiling %s", path.to_str()));
|
||||
util::note(fmt!("build_crates: destination dir is %s", dst_dir.to_str()));
|
||||
|
||||
let result = util::compile_crate(None, path,
|
||||
let result = util::compile_crate(None, self.id, path,
|
||||
dst_dir,
|
||||
crate.flags,
|
||||
crate.cfgs + cfgs,
|
||||
false, test);
|
||||
false, test, crate_type);
|
||||
if !result {
|
||||
build_err::cond.raise(fmt!("build failure on %s",
|
||||
path.to_str()));
|
||||
|
|
@ -898,12 +882,12 @@ impl PkgSrc {
|
|||
fn build(&self, dst_dir: &Path, cfgs: ~[~str]) {
|
||||
let dir = self.check_dir();
|
||||
debug!("Building libs");
|
||||
PkgSrc::build_crates(dst_dir, &dir, self.libs, cfgs, false);
|
||||
self.build_crates(dst_dir, &dir, self.libs, cfgs, false, lib_crate);
|
||||
debug!("Building mains");
|
||||
PkgSrc::build_crates(dst_dir, &dir, self.mains, cfgs, false);
|
||||
self.build_crates(dst_dir, &dir, self.mains, cfgs, false, bin_crate);
|
||||
debug!("Building tests");
|
||||
PkgSrc::build_crates(dst_dir, &dir, self.tests, cfgs, true);
|
||||
self.build_crates(dst_dir, &dir, self.tests, cfgs, true, bin_crate);
|
||||
debug!("Building benches");
|
||||
PkgSrc::build_crates(dst_dir, &dir, self.benchs, cfgs, true);
|
||||
self.build_crates(dst_dir, &dir, self.benchs, cfgs, true, bin_crate);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,16 +12,20 @@ use core::*;
|
|||
use core::cmp::Ord;
|
||||
use core::hash::Streaming;
|
||||
use rustc::driver::{driver, session};
|
||||
use rustc::driver::session::{lib_crate, bin_crate, unknown_crate};
|
||||
use rustc::metadata::filesearch;
|
||||
use std::getopts::groups::getopts;
|
||||
use std::semver;
|
||||
use std::{json, term, getopts};
|
||||
use syntax::ast_util::*;
|
||||
use syntax::codemap::{dummy_sp};
|
||||
use syntax::codemap::{dummy_sp, spanned, dummy_spanned};
|
||||
use syntax::ext::base::{mk_ctxt, ext_ctxt};
|
||||
use syntax::ext::build;
|
||||
use syntax::{ast, attr, codemap, diagnostic, fold};
|
||||
use syntax::ast::{meta_name_value, meta_list, attribute, crate_};
|
||||
use syntax::attr::{mk_attr};
|
||||
use rustc::back::link::output_type_exe;
|
||||
use rustc::driver::session::{lib_crate, bin_crate, unknown_crate, crate_type};
|
||||
|
||||
pub type ExitCode = int; // For now
|
||||
|
||||
|
|
@ -112,7 +116,7 @@ pub impl PkgId {
|
|||
impl ToStr for PkgId {
|
||||
fn to_str(&self) -> ~str {
|
||||
// should probably use the filestem and not the whole path
|
||||
fmt!("%s-v%s", self.path.to_str(), self.version.to_str())
|
||||
fmt!("%s-%s", self.path.to_str(), self.version.to_str())
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -425,44 +429,51 @@ pub fn add_pkg(pkg: &Pkg) -> bool {
|
|||
|
||||
// FIXME (#4432): Use workcache to only compile when needed
|
||||
pub fn compile_input(sysroot: Option<Path>,
|
||||
pkg_id: PkgId,
|
||||
in_file: &Path,
|
||||
out_dir: &Path,
|
||||
flags: ~[~str],
|
||||
cfgs: ~[~str],
|
||||
opt: bool,
|
||||
test: bool) -> bool {
|
||||
test: bool,
|
||||
crate_type: session::crate_type) -> bool {
|
||||
|
||||
let short_name = pkg_id.to_str();
|
||||
|
||||
assert!(in_file.components.len() > 1);
|
||||
let input = driver::file_input(copy *in_file);
|
||||
debug!("compile_input: %s", in_file.to_str());
|
||||
debug!("compile_input: %s / %?", in_file.to_str(), crate_type);
|
||||
// tjc: by default, use the package ID name as the link name
|
||||
// not sure if we should support anything else
|
||||
let short_name = in_file.filestem().expect("Can't compile a directory!");
|
||||
debug!("short_name = %s", short_name.to_str());
|
||||
|
||||
// Right now we're always assuming that we're building a library.
|
||||
// What we should do is parse the crate and infer whether it's a library
|
||||
// from the absence or presence of a main fn
|
||||
let out_file = out_dir.push(os::dll_filename(short_name));
|
||||
let building_library = true;
|
||||
let binary = os::args()[0];
|
||||
let building_library = match crate_type {
|
||||
lib_crate | unknown_crate => true,
|
||||
_ => false
|
||||
};
|
||||
|
||||
let out_file = if building_library {
|
||||
out_dir.push(os::dll_filename(short_name))
|
||||
}
|
||||
else {
|
||||
out_dir.push(short_name + if test { ~"test" } else { ~"" }
|
||||
+ os::EXE_SUFFIX)
|
||||
};
|
||||
|
||||
debug!("compiling %s into %s",
|
||||
in_file.to_str(),
|
||||
out_file.to_str());
|
||||
|
||||
let binary = os::args()[0];
|
||||
|
||||
debug!("flags: %s", str::connect(flags, ~" "));
|
||||
debug!("cfgs: %s", str::connect(cfgs, ~" "));
|
||||
// Again, we assume we're building a library
|
||||
|
||||
let matches = getopts(~[~"-Z", ~"time-passes"]
|
||||
+ if building_library { ~[~"--lib"] } else { ~[] }
|
||||
+ if building_library { ~[~"--lib"] }
|
||||
else { ~[] }
|
||||
+ flags
|
||||
+ cfgs.flat_map(|&c| { ~[~"--cfg", c] }),
|
||||
driver::optgroups()).get();
|
||||
let options = @session::options {
|
||||
crate_type: if building_library { session::lib_crate }
|
||||
else { session::bin_crate },
|
||||
crate_type: crate_type,
|
||||
optimize: if opt { session::Aggressive } else { session::No },
|
||||
test: test,
|
||||
maybe_sysroot: sysroot,
|
||||
|
|
@ -485,7 +496,9 @@ pub fn compile_input(sysroot: Option<Path>,
|
|||
|
||||
debug!("calling compile_crate_from_input, out_dir = %s,
|
||||
building_library = %?", out_dir.to_str(), sess.building_library);
|
||||
compile_crate_from_input(input, Some(*out_dir), sess, None, binary);
|
||||
let _ = compile_crate_from_input(input, pkg_id, Some(*out_dir), sess, None,
|
||||
out_file, binary,
|
||||
driver::cu_everything);
|
||||
true
|
||||
}
|
||||
|
||||
|
|
@ -493,24 +506,45 @@ pub fn compile_input(sysroot: Option<Path>,
|
|||
// Should also rename this to something better
|
||||
// If crate_opt is present, then finish compilation. If it's None, then
|
||||
// call compile_upto and return the crate
|
||||
pub fn compile_crate_from_input(input: driver::input, build_dir_opt: Option<Path>,
|
||||
sess: session::Session, crate_opt: Option<@ast::crate>,
|
||||
binary: ~str) -> @ast::crate {
|
||||
// also, too many arguments
|
||||
pub fn compile_crate_from_input(input: driver::input,
|
||||
pkg_id: PkgId,
|
||||
build_dir_opt: Option<Path>,
|
||||
sess: session::Session,
|
||||
crate_opt: Option<@ast::crate>,
|
||||
out_file: Path,
|
||||
binary: ~str,
|
||||
what: driver::compile_upto) -> @ast::crate {
|
||||
debug!("Calling build_output_filenames with %?", build_dir_opt);
|
||||
let outputs = driver::build_output_filenames(input, &build_dir_opt, &None, sess);
|
||||
let outputs = driver::build_output_filenames(input, &build_dir_opt, &Some(out_file), sess);
|
||||
debug!("Outputs are %? and output type = %?", outputs, sess.opts.output_type);
|
||||
let cfg = driver::build_configuration(sess, binary, input);
|
||||
match crate_opt {
|
||||
Some(c) => {
|
||||
debug!("Calling compile_rest, outputs = %?", outputs);
|
||||
assert!(what == driver::cu_everything);
|
||||
driver::compile_rest(sess, cfg, driver::cu_everything, Some(outputs), Some(c));
|
||||
c
|
||||
}
|
||||
None => {
|
||||
debug!("Calling compile_upto, outputs = %?", outputs);
|
||||
let (crate, _) = driver::compile_upto(sess, cfg, input, driver::cu_parse,
|
||||
Some(outputs));
|
||||
crate
|
||||
let (crate, _) = driver::compile_upto(sess, cfg, input, driver::cu_parse, Some(outputs));
|
||||
|
||||
// Inject the inferred link_meta info if it's not already there
|
||||
// (assumes that name and vers are the only linkage metas)
|
||||
let mut crate_to_use = crate;
|
||||
if attr::find_linkage_metas(crate.node.attrs).is_empty() {
|
||||
crate_to_use = add_attrs(*crate, ~[mk_attr(@dummy_spanned(meta_list(@~"link",
|
||||
// change PkgId to have a <shortname> field?
|
||||
~[@dummy_spanned(meta_name_value(@~"name",
|
||||
mk_string_lit(@pkg_id.path.filestem().get()))),
|
||||
@dummy_spanned(meta_name_value(@~"vers",
|
||||
mk_string_lit(@pkg_id.version.to_str())))])))]);
|
||||
}
|
||||
|
||||
|
||||
driver::compile_rest(sess, cfg, what, Some(outputs), Some(crate_to_use));
|
||||
crate_to_use
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -525,17 +559,30 @@ pub fn exe_suffix() -> ~str { ~".exe" }
|
|||
pub fn exe_suffix() -> ~str { ~"" }
|
||||
|
||||
|
||||
/// Returns a copy of crate `c` with attributes `attrs` added to its
|
||||
/// attributes
|
||||
fn add_attrs(c: ast::crate, new_attrs: ~[attribute]) -> @ast::crate {
|
||||
@spanned {
|
||||
node: crate_ {
|
||||
attrs: c.node.attrs + new_attrs, ..c.node
|
||||
},
|
||||
span: c.span
|
||||
}
|
||||
}
|
||||
|
||||
// Called by build_crates
|
||||
// FIXME (#4432): Use workcache to only compile when needed
|
||||
pub fn compile_crate(sysroot: Option<Path>, crate: &Path, dir: &Path,
|
||||
pub fn compile_crate(sysroot: Option<Path>, pkg_id: PkgId,
|
||||
crate: &Path, dir: &Path,
|
||||
flags: ~[~str], cfgs: ~[~str], opt: bool,
|
||||
test: bool) -> bool {
|
||||
test: bool, crate_type: crate_type) -> bool {
|
||||
debug!("compile_crate: crate=%s, dir=%s", crate.to_str(), dir.to_str());
|
||||
debug!("compile_crate: flags =...");
|
||||
debug!("compile_crate: short_name = %s, flags =...", pkg_id.to_str());
|
||||
for flags.each |&fl| {
|
||||
debug!("+++ %s", fl);
|
||||
}
|
||||
compile_input(sysroot, crate, dir, flags, cfgs, opt, test)
|
||||
compile_input(sysroot, pkg_id,
|
||||
crate, dir, flags, cfgs, opt, test, crate_type)
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -563,6 +610,13 @@ pub fn link_exe(src: &Path, dest: &Path) -> bool {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn mk_string_lit(s: @~str) -> ast::lit {
|
||||
spanned {
|
||||
node: ast::lit_str(s),
|
||||
span: dummy_sp()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::{is_cmd, parse_name};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue