rust: ignored semantic is part of recognition

Author: rizsotto

rust/bear/src/output/mod.rs

@@ -46,7 +46,10 @@ impl OutputWriter {
     }
 
     /// Implements the main logic of the output writer.
-    pub fn run(&self, meanings: impl Iterator<Item = semantic::Meaning>) -> anyhow::Result<()> {
+    pub fn run(
+        &self,
+        meanings: impl Iterator<Item = semantic::CompilerCall>,
+    ) -> anyhow::Result<()> {
         let entries = meanings.flat_map(|value| {
             into_entries(value).unwrap_or_else(|error| {
                 log::error!(
@@ -127,38 +130,34 @@ impl OutputWriter {
     }
 }
 
-pub fn into_entries(value: semantic::Meaning) -> Result<Vec<Entry>, anyhow::Error> {
-    match value {
-        semantic::Meaning::Compiler {
-            compiler,
-            working_dir,
-            passes,
-        } => {
-            let entries = passes
-                .iter()
-                .flat_map(|pass| -> Result<Entry, anyhow::Error> {
-                    match pass {
-                        semantic::CompilerPass::Preprocess => {
-                            Err(anyhow!("preprocess pass should not show up in results"))
-                        }
-                        semantic::CompilerPass::Compile {
-                            source,
-                            output,
-                            flags,
-                        } => Ok(Entry {
-                            file: into_abspath(source.clone(), working_dir.as_path())?,
-                            directory: working_dir.clone(),
-                            output: into_abspath_opt(output.clone(), working_dir.as_path())?,
-                            arguments: into_arguments(&compiler, source, output, flags)?,
-                        }),
-                    }
-                })
-                .collect();
+pub fn into_entries(value: semantic::CompilerCall) -> Result<Vec<Entry>, anyhow::Error> {
+    let semantic::CompilerCall {
+        compiler,
+        working_dir,
+        passes,
+    } = value;
+    let entries = passes
+        .iter()
+        .flat_map(|pass| -> Result<Entry, anyhow::Error> {
+            match pass {
+                semantic::CompilerPass::Preprocess => {
+                    Err(anyhow!("preprocess pass should not show up in results"))
+                }
+                semantic::CompilerPass::Compile {
+                    source,
+                    output,
+                    flags,
+                } => Ok(Entry {
+                    file: into_abspath(source.clone(), working_dir.as_path())?,
+                    directory: working_dir.clone(),
+                    output: into_abspath_opt(output.clone(), working_dir.as_path())?,
+                    arguments: into_arguments(&compiler, source, output, flags)?,
+                }),
+            }
+        })
+        .collect();
 
-            Ok(entries)
-        }
-        _ => Ok(vec![]),
-    }
+    Ok(entries)
 }
 
 fn into_arguments(
@@ -210,10 +209,7 @@ mod test {
     fn test_non_compilations() -> Result<()> {
         let empty: Vec<Entry> = vec![];
 
-        let result: Vec<Entry> = into_entries(semantic::Meaning::Ignored)?;
-        assert_eq!(empty, result);
-
-        let input = semantic::Meaning::Compiler {
+        let input = semantic::CompilerCall {
             compiler: PathBuf::from("/usr/bin/cc"),
             working_dir: PathBuf::from("/home/user"),
             passes: vec![],
@@ -226,7 +222,7 @@ mod test {
 
     #[test]
     fn test_single_source_compilation() -> Result<()> {
-        let input = semantic::Meaning::Compiler {
+        let input = semantic::CompilerCall {
             compiler: PathBuf::from("clang"),
             working_dir: PathBuf::from("/home/user"),
             passes: vec![semantic::CompilerPass::Compile {
@@ -252,7 +248,7 @@ mod test {
 
     #[test]
     fn test_multiple_sources_compilation() -> Result<()> {
-        let input = semantic::Meaning::Compiler {
+        let input = semantic::CompilerCall {
             compiler: PathBuf::from("clang"),
             working_dir: PathBuf::from("/home/user"),
             passes: vec![

rust/bear/src/recognition.rs

@@ -51,12 +51,8 @@ impl TryFrom<&config::Main> for Recognition {
 impl Recognition {
     /// Simple call the semantic module to recognize the execution.
     /// Forward only the compiler calls, and log each recognition result.
-    pub fn apply(&self, execution: Execution) -> Option<semantic::Meaning> {
+    pub fn apply(&self, execution: Execution) -> Option<semantic::CompilerCall> {
         match self.interpreter.recognize(&execution) {
-            semantic::Recognition::Success(semantic::Meaning::Ignored) => {
-                log::debug!("execution recognized, but ignored: {:?}", execution);
-                None
-            }
             semantic::Recognition::Success(semantic) => {
                 log::debug!(
                     "execution recognized as compiler call, {:?} : {:?}",
@@ -65,6 +61,10 @@ impl Recognition {
                 );
                 Some(semantic)
             }
+            semantic::Recognition::Ignored => {
+                log::debug!("execution recognized, but ignored: {:?}", execution);
+                None
+            }
             semantic::Recognition::Error(reason) => {
                 log::debug!(
                     "execution recognized with failure, {:?} : {:?}",

rust/bear/src/semantic/interpreters/combinators.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use super::super::{Interpreter, Meaning, Recognition};
+use super::super::{CompilerCall, Interpreter, Recognition};
 use intercept::Execution;
 
 /// Represents a set of interpreters, where any of them can recognize the semantic.
@@ -19,7 +19,7 @@ impl Any {
 }
 
 impl Interpreter for Any {
-    fn recognize(&self, x: &Execution) -> Recognition<Meaning> {
+    fn recognize(&self, x: &Execution) -> Recognition<CompilerCall> {
         for tool in &self.interpreters {
             match tool.recognize(x) {
                 Recognition::Unknown => continue,
@@ -35,7 +35,7 @@ mod test {
     use std::collections::HashMap;
     use std::path::PathBuf;
 
-    use super::super::super::Meaning;
+    use super::super::super::CompilerCall;
     use super::*;
 
     #[test]
@@ -57,7 +57,7 @@ mod test {
     }
 
     #[test]
-    fn test_any_when_match() {
+    fn test_any_when_success() {
         let sut = Any {
             interpreters: vec![
                 Box::new(MockTool::NotRecognize),
@@ -74,6 +74,24 @@ mod test {
         }
     }
 
+    #[test]
+    fn test_any_when_ignored() {
+        let sut = Any {
+            interpreters: vec![
+                Box::new(MockTool::NotRecognize),
+                Box::new(MockTool::RecognizeIgnored),
+                Box::new(MockTool::Recognize),
+            ],
+        };
+
+        let input = any_execution();
+
+        match sut.recognize(&input) {
+            Recognition::Ignored => assert!(true),
+            _ => assert!(false),
+        }
+    }
+
     #[test]
     fn test_any_when_match_fails() {
         let sut = Any {
@@ -95,14 +113,16 @@ mod test {
 
     enum MockTool {
         Recognize,
+        RecognizeIgnored,
         RecognizeFailed,
         NotRecognize,
     }
 
     impl Interpreter for MockTool {
-        fn recognize(&self, _: &Execution) -> Recognition<Meaning> {
+        fn recognize(&self, _: &Execution) -> Recognition<CompilerCall> {
             match self {
-                MockTool::Recognize => Recognition::Success(Meaning::Ignored),
+                MockTool::Recognize => Recognition::Success(any_compiler_call()),
+                MockTool::RecognizeIgnored => Recognition::Ignored,
                 MockTool::RecognizeFailed => Recognition::Error(String::from("problem")),
                 MockTool::NotRecognize => Recognition::Unknown,
             }
@@ -117,4 +137,12 @@ mod test {
             environment: HashMap::new(),
         }
     }
+
+    fn any_compiler_call() -> CompilerCall {
+        CompilerCall {
+            compiler: PathBuf::new(),
+            working_dir: PathBuf::new(),
+            passes: vec![],
+        }
+    }
 }

rust/bear/src/semantic/interpreters/gcc.rs

@@ -4,7 +4,7 @@ use nom::branch::alt;
 use nom::multi::many1;
 use nom::sequence::preceded;
 
-use super::super::{Interpreter, Meaning, Recognition};
+use super::super::{CompilerCall, Interpreter, Recognition};
 use intercept::Execution;
 use internal::Argument;
 
@@ -17,7 +17,7 @@ impl Gcc {
 }
 
 impl Interpreter for Gcc {
-    fn recognize(&self, execution: &Execution) -> Recognition<Meaning> {
+    fn recognize(&self, execution: &Execution) -> Recognition<CompilerCall> {
         let mut parser = preceded(
             internal::compiler,
             many1(alt((internal::flag, internal::source))),
@@ -29,7 +29,7 @@ impl Interpreter for Gcc {
                 let flags = result.1;
                 let passes = Argument::passes(flags.as_slice());
 
-                Recognition::Success(Meaning::Compiler {
+                Recognition::Success(CompilerCall {
                     compiler: execution.executable.clone(),
                     working_dir: execution.working_dir.clone(),
                     passes,

rust/bear/src/semantic/interpreters/generic.rs

@@ -4,7 +4,7 @@ use std::collections::HashSet;
 use std::path::PathBuf;
 use std::vec;
 
-use super::super::{CompilerPass, Interpreter, Meaning, Recognition};
+use super::super::{CompilerCall, CompilerPass, Interpreter, Recognition};
 use super::matchers::source::looks_like_a_source_file;
 use intercept::Execution;
 
@@ -25,7 +25,7 @@ impl Interpreter for Generic {
     /// - the executable name,
     /// - one of the arguments is a source file,
     /// - the rest of the arguments are flags.
-    fn recognize(&self, x: &Execution) -> Recognition<Meaning> {
+    fn recognize(&self, x: &Execution) -> Recognition<CompilerCall> {
         if self.executables.contains(&x.executable) {
             let mut flags = vec![];
             let mut sources = vec![];
@@ -42,7 +42,7 @@ impl Interpreter for Generic {
             if sources.is_empty() {
                 Recognition::Error(String::from("source file is not found"))
             } else {
-                Recognition::Success(Meaning::Compiler {
+                Recognition::Success(CompilerCall {
                     compiler: x.executable.clone(),
                     working_dir: x.working_dir.clone(),
                     passes: sources
@@ -87,7 +87,7 @@ mod test {
             environment: HashMap::new(),
         };
 
-        let expected = Meaning::Compiler {
+        let expected = CompilerCall {
             compiler: PathBuf::from("/usr/bin/something"),
             working_dir: PathBuf::from("/home/user"),
             passes: vec![CompilerPass::Compile {

rust/bear/src/semantic/interpreters/ignore.rs

@@ -3,7 +3,7 @@
 use std::collections::HashSet;
 use std::path::PathBuf;
 
-use super::super::{Interpreter, Meaning, Recognition};
+use super::super::{CompilerCall, Interpreter, Recognition};
 use intercept::Execution;
 
 /// A tool to ignore a command execution by executable name.
@@ -25,9 +25,9 @@ impl IgnoreByPath {
 
 /// A tool to ignore a command execution by arguments.
 impl Interpreter for IgnoreByPath {
-    fn recognize(&self, execution: &Execution) -> Recognition<Meaning> {
+    fn recognize(&self, execution: &Execution) -> Recognition<CompilerCall> {
         if self.executables.contains(&execution.executable) {
-            Recognition::Success(Meaning::Ignored)
+            Recognition::Ignored
         } else {
             Recognition::Unknown
         }
@@ -162,10 +162,7 @@ mod test {
         };
         let sut = IgnoreByPath::new();
 
-        assert_eq!(
-            Recognition::Success(Meaning::Ignored),
-            sut.recognize(&input)
-        )
+        assert_eq!(Recognition::Ignored, sut.recognize(&input))
     }
 
     #[test]

rust/bear/src/semantic/interpreters/mod.rs

@@ -64,7 +64,7 @@ mod test {
     use std::collections::HashMap;
     use std::path::PathBuf;
 
-    use super::super::{Meaning, Recognition};
+    use super::super::{CompilerCall, Recognition};
     use super::*;
     use crate::{vec_of_pathbuf, vec_of_strings};
     use intercept::Execution;
@@ -75,7 +75,7 @@ mod test {
 
         let input = any_execution();
         match sut.recognize(&input) {
-            Recognition::Success(Meaning::Compiler { .. }) => assert!(true),
+            Recognition::Success(CompilerCall { .. }) => assert!(true),
             _ => assert!(false),
         }
     }
@@ -87,7 +87,7 @@ mod test {
 
         let input = any_execution();
         match sut.recognize(&input) {
-            Recognition::Success(Meaning::Ignored) => assert!(true),
+            Recognition::Ignored => assert!(true),
             _ => assert!(false),
         }
     }

rust/bear/src/semantic/mod.rs

@@ -17,15 +17,10 @@ use std::path::PathBuf;
 
 /// Represents an executed command semantic.
 #[derive(Debug, PartialEq)]
-pub enum Meaning {
-    /// This is a compiler call.
-    Compiler {
-        compiler: PathBuf,
-        working_dir: PathBuf,
-        passes: Vec<CompilerPass>,
-    },
-    /// This is something else we recognised, but not interested to fully specify.
-    Ignored,
+pub struct CompilerCall {
+    pub compiler: PathBuf,
+    pub working_dir: PathBuf,
+    pub passes: Vec<CompilerPass>,
 }
 
 /// Represents a compiler call pass.
@@ -49,7 +44,7 @@ pub enum CompilerPass {
 /// Or classify the recognition as ignored to not be further processed
 /// later on.
 pub trait Interpreter: Send {
-    fn recognize(&self, _: &Execution) -> Recognition<Meaning>;
+    fn recognize(&self, _: &Execution) -> Recognition<CompilerCall>;
 }
 
 /// Represents a semantic recognition result.
@@ -59,7 +54,12 @@ pub trait Interpreter: Send {
 /// to continue with the next interpreter.
 #[derive(Debug, PartialEq)]
 pub enum Recognition<T> {
+    /// The command was recognized and the semantic was identified.
     Success(T),
+    /// The command was recognized, but the semantic was ignored.
+    Ignored,
+    /// The command was recognized, but the semantic was broken.
     Error(String),
+    /// The command was not recognized.
     Unknown,
 }