save local packaged id + small fix

Author: zeegomo

src/results/mod.rs

@@ -238,7 +238,7 @@ impl ::std::str::FromStr for FailureReason {
     type Err = ::failure::Error;
 
     fn from_str(s: &str) -> ::failure::Fallible<FailureReason> {
-        if let Some(idx) = s.find('(') {
+        if let (Some(idx), true) = (s.find('('), s.ends_with(')')) {
             let prefix = &s[..idx];
             let contents = s[idx + 1..s.len() - 1].split(", ");
             match prefix {

src/runner/test.rs

@@ -5,12 +5,12 @@ use crate::results::{BrokenReason, EncodingType, FailureReason, TestResult, Writ
 use crate::runner::tasks::TaskCtx;
 use crate::runner::OverrideResult;
 use cargo_metadata::diagnostic::DiagnosticLevel;
-use cargo_metadata::Message;
+use cargo_metadata::{Message, Metadata, PackageId};
 use failure::Error;
 use remove_dir_all::remove_dir_all;
 use rustwide::cmd::{CommandError, ProcessLinesActions, SandboxBuilder};
 use rustwide::{Build, PrepareError};
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, HashSet};
 use std::convert::TryFrom;
 
 fn failure_reason(err: &Error) -> FailureReason {
@@ -61,10 +61,25 @@ pub(super) fn detect_broken<T>(res: Result<T, Error>) -> Result<T, Error> {
     }
 }
 
+fn get_local_packages(build_env: &Build) -> Fallible<HashSet<PackageId>> {
+    Ok(build_env
+        .cargo()
+        .args(&["metadata", "--no-deps", "--format-version=1"])
+        .log_output(false)
+        .run_capture()?
+        .stdout_lines()
+        .iter()
+        .filter_map(|line| serde_json::from_str::<Metadata>(line).ok())
+        .flat_map(|metadata| metadata.packages.into_iter().map(|pkg| pkg.id))
+        .collect::<HashSet<_>>())
+}
+
 fn run_cargo<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
     args: &[&str],
+    check_errors: bool,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<()> {
     let mut rustflags = format!("--cap-lints={}", ctx.experiment.cap_lints.to_str());
     if let Some(ref tc_rustflags) = ctx.toolchain.rustflags {
@@ -84,42 +99,46 @@ fn run_cargo<DB: WriteResults>(
 
     let mut detect_error = |line: &str, actions: &mut ProcessLinesActions| {
         // Avoid trying to deserialize non JSON output
-        if line.starts_with('{') {
-            let message = serde_json::from_str(line);
-            if let Ok(message) = message {
-                match message {
-                    Message::CompilerMessage(compiler_message) => {
-                        let inner_message = compiler_message.message;
-                        match (
-                            inner_message.level,
-                            Crate::try_from(&compiler_message.package_id),
-                        ) {
-                            // the only local crate in a well defined job is the crate currently being tested
-                            (DiagnosticLevel::Error, Ok(Crate::Local(_))) => {
-                                if let Some(code) = inner_message.code {
-                                    error_codes.insert(DiagnosticCode::from(code.code));
-                                }
-                            }
-                            (DiagnosticLevel::Ice, Ok(Crate::Local(_))) => did_ice = true,
-                            // If the error is in a crate that is not local then it's referred to a dependency
-                            // of the current crate
-                            (DiagnosticLevel::Error, Ok(krate)) => {
-                                deps.insert(krate);
-                            }
-                            (DiagnosticLevel::Ice, Ok(krate)) => {
-                                deps.insert(krate);
-                            }
+        if !line.starts_with('{') {
+            return;
+        }
 
-                            _ => (),
-                        }
+        let message = match serde_json::from_str(line) {
+            Ok(message) => message,
+            Err(_) => return,
+        };
 
-                        actions.replace_with_lines(
-                            inner_message.rendered.unwrap_or_default().split('\n'),
-                        );
+        match message {
+            Message::CompilerMessage(compiler_message) => {
+                let inner_message = compiler_message.message;
+                match (inner_message.level, &compiler_message.package_id) {
+                    // the only local crate in a well defined job is the crate currently being tested
+                    (DiagnosticLevel::Error, pkgid) if local_packages_id.contains(pkgid) => {
+                        if let Some(code) = inner_message.code {
+                            error_codes.insert(DiagnosticCode::from(code.code));
+                        }
+                    }
+                    (DiagnosticLevel::Ice, pkgid) if local_packages_id.contains(pkgid) => {
+                        did_ice = true
+                    }
+                    // If the error is in a crate that is not local then it's referred to a dependency
+                    // of the current crate
+                    (DiagnosticLevel::Error, pkgid) => {
+                        if let Ok(krate) = Crate::try_from(pkgid) {
+                            deps.insert(krate);
+                        }
                     }
-                    _ => actions.remove_line(),
+                    (DiagnosticLevel::Ice, pkgid) => {
+                        if let Ok(krate) = Crate::try_from(pkgid) {
+                            deps.insert(krate);
+                        }
+                    }
+                    _ => (),
                 }
+
+                actions.replace_with_lines(inner_message.rendered.unwrap_or_default().split('\n'));
             }
+            _ => actions.remove_line(),
         }
     };
 
@@ -128,8 +147,11 @@ fn run_cargo<DB: WriteResults>(
         .args(args)
         .env("CARGO_INCREMENTAL", "0")
         .env("RUST_BACKTRACE", "full")
-        .env(rustflags_env, rustflags)
-        .process_lines(&mut detect_error);
+        .env(rustflags_env, rustflags);
+
+    if check_errors {
+        command = command.process_lines(&mut detect_error);
+    }
 
     if ctx.quiet {
         command = command.no_output_timeout(None);
@@ -154,7 +176,7 @@ fn run_cargo<DB: WriteResults>(
 pub(super) fn run_test<DB: WriteResults>(
     action: &str,
     ctx: &TaskCtx<DB>,
-    test_fn: fn(&TaskCtx<DB>, &Build) -> Fallible<TestResult>,
+    test_fn: fn(&TaskCtx<DB>, &Build, &HashSet<PackageId>) -> Fallible<TestResult>,
 ) -> Fallible<()> {
     if let Some(res) = ctx
         .db
@@ -195,23 +217,34 @@ pub(super) fn run_test<DB: WriteResults>(
                     build = build.patch_with_git(&patch.name, &patch.repo, &patch.branch);
                 }
 
-                detect_broken(build.run(|build| test_fn(ctx, build)))
+                detect_broken(build.run(|build| {
+                    let local_packages_id = get_local_packages(build)?;
+                    test_fn(ctx, build, &local_packages_id)
+                }))
             },
         )?;
     }
     Ok(())
 }
 
-fn build<DB: WriteResults>(ctx: &TaskCtx<DB>, build_env: &Build) -> Fallible<()> {
+fn build<DB: WriteResults>(
+    ctx: &TaskCtx<DB>,
+    build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
+) -> Fallible<()> {
     run_cargo(
         ctx,
         build_env,
         &["build", "--frozen", "--message-format=json"],
+        true,
+        local_packages_id,
     )?;
     run_cargo(
         ctx,
         build_env,
         &["test", "--frozen", "--no-run", "--message-format=json"],
+        true,
+        local_packages_id,
     )?;
     Ok(())
 }
@@ -220,15 +253,18 @@ fn test<DB: WriteResults>(ctx: &TaskCtx<DB>, build_env: &Build) -> Fallible<()>
     run_cargo(
         ctx,
         build_env,
-        &["test", "--frozen", "--message-format=json"],
+        &["test", "--frozen"],
+        false,
+        &HashSet::new(),
     )
 }
 
 pub(super) fn test_build_and_test<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
-    let build_r = build(ctx, build_env);
+    let build_r = build(ctx, build_env, local_packages_id);
     let test_r = if build_r.is_ok() {
         Some(test(ctx, build_env))
     } else {
@@ -246,8 +282,9 @@ pub(super) fn test_build_and_test<DB: WriteResults>(
 pub(super) fn test_build_only<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
-    if let Err(err) = build(ctx, build_env) {
+    if let Err(err) = build(ctx, build_env, local_packages_id) {
         Ok(TestResult::BuildFail(failure_reason(&err)))
     } else {
         Ok(TestResult::TestSkipped)
@@ -257,11 +294,20 @@ pub(super) fn test_build_only<DB: WriteResults>(
 pub(super) fn test_check_only<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
     if let Err(err) = run_cargo(
         ctx,
         build_env,
-        &["check", "--frozen", "--all", "--all-targets"],
+        &[
+            "check",
+            "--frozen",
+            "--all",
+            "--all-targets",
+            "--message-format=json",
+        ],
+        true,
+        local_packages_id,
     ) {
         Ok(TestResult::BuildFail(failure_reason(&err)))
     } else {
@@ -272,11 +318,20 @@ pub(super) fn test_check_only<DB: WriteResults>(
 pub(super) fn test_clippy_only<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
     if let Err(err) = run_cargo(
         ctx,
         build_env,
-        &["clippy", "--frozen", "--all", "--all-targets"],
+        &[
+            "clippy",
+            "--frozen",
+            "--all",
+            "--all-targets",
+            "--message-format=json",
+        ],
+        true,
+        local_packages_id,
     ) {
         Ok(TestResult::BuildFail(failure_reason(&err)))
     } else {
@@ -287,11 +342,20 @@ pub(super) fn test_clippy_only<DB: WriteResults>(
 pub(super) fn test_rustdoc<DB: WriteResults>(
     ctx: &TaskCtx<DB>,
     build_env: &Build,
+    local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
     let res = run_cargo(
         ctx,
         build_env,
-        &["doc", "--frozen", "--no-deps", "--document-private-items"],
+        &[
+            "doc",
+            "--frozen",
+            "--no-deps",
+            "--document-private-items",
+            "--message-format=json",
+        ],
+        true,
+        local_packages_id,
     );
 
     // Make sure to remove the built documentation

src/runner/unstable_features.rs

@@ -2,6 +2,7 @@ use crate::prelude::*;
 use crate::results::TestResult;
 use crate::results::WriteResults;
 use crate::runner::tasks::TaskCtx;
+use cargo_metadata::PackageId;
 use rustwide::Build;
 use std::collections::HashSet;
 use std::path::Path;
@@ -10,6 +11,7 @@ use walkdir::{DirEntry, WalkDir};
 pub(super) fn find_unstable_features<DB: WriteResults>(
     _ctx: &TaskCtx<DB>,
     build: &Build,
+    _local_packages_id: &HashSet<PackageId>,
 ) -> Fallible<TestResult> {
     let mut features = HashSet::new();