}
}
+/// A proposed target.
+///
+/// Proposed targets are later filtered into actual Units based on whether or
+/// not the target requires its features to be present.
+#[derive(Debug)]
+struct Proposal<'a> {
+ pkg: &'a Package,
+ target: &'a Target,
+ /// Indicates whether or not all required features *must* be present. If
+ /// false, and the features are not available, then it will be silently
+ /// skipped. Generally, targets specified by name (`--bin foo`) are
+ /// required, all others can be silently skipped if features are missing.
+ requires_features: bool,
+ mode: CompileMode,
+}
+
/// Generates all the base targets for the packages the user has requested to
/// compile. Dependencies for these targets are computed later in
/// `unit_dependencies`.
}
};
- // Create a list of proposed targets. The `bool` value indicates
- // whether or not all required features *must* be present. If false,
- // and the features are not available, then it will be silently
- // skipped. Generally, targets specified by name (`--bin foo`) are
- // required, all others can be silently skipped if features are
- // missing.
- let mut proposals: Vec<(&Package, &Target, bool, CompileMode)> = Vec::new();
+ // Create a list of proposed targets.
+ let mut proposals: Vec<Proposal> = Vec::new();
match *filter {
CompileFilter::Default {
} => {
for pkg in packages {
let default = filter_default_targets(pkg.targets(), build_config.mode);
- proposals.extend(default.into_iter().map(|target| {
- (
- *pkg,
- target,
- !required_features_filterable,
- build_config.mode,
- )
+ proposals.extend(default.into_iter().map(|target| Proposal {
+ pkg,
+ target,
+ requires_features: !required_features_filterable,
+ mode: build_config.mode,
}));
if build_config.mode == CompileMode::Test {
- // Include doctest for lib.
if let Some(t) = pkg
.targets()
.iter()
.find(|t| t.is_lib() && t.doctested() && t.doctestable())
{
- proposals.push((pkg, t, false, CompileMode::Doctest));
+ proposals.push(Proposal {
+ pkg,
+ target: t,
+ requires_features: false,
+ mode: CompileMode::Doctest,
+ });
}
}
}
pkg.name()
))?;
} else {
- libs.push((*pkg, target, false, build_config.mode));
+ libs.push(Proposal {
+ pkg,
+ target,
+ requires_features: false,
+ mode: build_config.mode,
+ });
}
}
}
}
proposals.extend(libs);
}
+
// If --tests was specified, add all targets that would be
// generated by `cargo test`.
let test_filter = match *tests {
// Only include targets that are libraries or have all required
// features available.
let mut features_map = HashMap::new();
- let mut units = Vec::new();
- for (pkg, target, required, mode) in proposals {
+ let mut units = HashSet::new();
+ for Proposal { pkg, target, requires_features, mode} in proposals {
let unavailable_features = match target.required_features() {
Some(rf) => {
let features = features_map
};
if target.is_lib() || unavailable_features.is_empty() {
let unit = new_unit(pkg, target, mode);
- units.push(unit);
- } else if required {
+ units.insert(unit);
+ } else if requires_features {
let required_features = target.required_features().unwrap();
let quoted_required_features: Vec<String> = required_features
.iter()
}
// else, silently skip target.
}
- Ok(units)
+ Ok(units.into_iter().collect())
}
fn resolve_all_features(
target_desc: &'static str,
is_expected_kind: fn(&Target) -> bool,
mode: CompileMode,
-) -> CargoResult<Vec<(&'a Package, &'a Target, bool, CompileMode)>> {
+) -> CargoResult<Vec<Proposal<'a>>> {
let mut result = Vec::new();
match *rule {
FilterRule::All => {
for pkg in packages {
for target in pkg.targets() {
if is_expected_kind(target) {
- result.push((*pkg, target, false, mode));
+ result.push(Proposal {
+ pkg,
+ target,
+ requires_features: false,
+ mode,
+ });
}
}
}
target_desc: &'static str,
is_expected_kind: fn(&Target) -> bool,
mode: CompileMode,
-) -> CargoResult<Vec<(&'a Package, &'a Target, bool, CompileMode)>> {
+) -> CargoResult<Vec<Proposal<'a>>> {
let mut result = Vec::new();
for pkg in packages {
for target in pkg.targets() {
if target.name() == target_name && is_expected_kind(target) {
- result.push((*pkg, target, true, mode));
+ result.push(Proposal {
+ pkg,
+ target,
+ requires_features: true,
+ mode,
+ });
}
}
}
pub compile_opts: ops::CompileOptions<'a>,
pub no_run: bool,
pub no_fail_fast: bool,
- pub only_doc: bool,
}
pub fn run_tests(
if options.no_run {
return Ok(None);
}
- let (test, mut errors) = if options.only_doc {
- assert!(options.compile_opts.filter.is_specific());
- run_doc_tests(options, test_args, &compilation)?
- } else {
- run_unit_tests(options, test_args, &compilation)?
- };
+ let (test, mut errors) = run_unit_tests(options, test_args, &compilation)?;
// If we have an error and want to fail fast, return
if !errors.is_empty() && !options.no_fail_fast {
return Ok(Some(CargoTestError::new(test, errors)));
}
- // If a specific test was requested or we're not running any tests at all,
- // don't run any doc tests.
- if options.compile_opts.filter.is_specific() {
- match errors.len() {
- 0 => return Ok(None),
- _ => return Ok(Some(CargoTestError::new(test, errors))),
- }
- }
-
let (doctest, docerrors) = run_doc_tests(options, test_args, &compilation)?;
let test = if docerrors.is_empty() { test } else { doctest };
errors.extend(docerrors);
projects / cargo.git / commitdiff