interpreter construction is reviewed

Author: rizsotto

bear/src/environment.rs

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
+use std::collections::HashSet;
+
 pub const KEY_DESTINATION: &str = "INTERCEPT_COLLECTOR_ADDRESS";
 
 // man page for `ld.so` (Linux dynamic linker/loader)
@@ -46,42 +48,80 @@ pub const KEY_CARGO__RUSTC_WRAPPER: &str = "RUSTC_WRAPPER";
 
 pub const KEY_CARGO__RUSTFLAGS: &str = "RUSTFLAGS";
 
+static MAKE_PROGRAM_KEYS: std::sync::LazyLock<HashSet<&'static str>> =
+    std::sync::LazyLock::new(|| {
+        [
+            KEY_MAKE__C_COMPILER,
+            KEY_MAKE__CXX_COMPILER,
+            KEY_MAKE__C_PREPROCESSOR,
+            KEY_MAKE__FORTRAN_COMPILER,
+            KEY_MAKE__ARCHIVE,
+            KEY_MAKE__ASSEMBLER,
+            KEY_MAKE__MODULA_COMPILER,
+            KEY_MAKE__PASCAL_COMPILER,
+            KEY_MAKE__LEX,
+            KEY_MAKE__YACC,
+            KEY_MAKE__LINT,
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    });
+
+static MAKE_FLAGS_KEYS: std::sync::LazyLock<HashSet<&'static str>> =
+    std::sync::LazyLock::new(|| {
+        [
+            KEY_MAKE__AR_FLAGS,
+            KEY_MAKE__AS_FLAGS,
+            KEY_MAKE__C_FLAGS,
+            KEY_MAKE__CXX_FLAGS,
+            KEY_MAKE__C_PREPROCESSOR_FLAGS,
+            KEY_MAKE__FORTRAN_FLAGS,
+            KEY_MAKE__LINKER_FLAGS,
+            KEY_MAKE__LINKER_LIBS,
+            KEY_MAKE__LEX_FLAGS,
+            KEY_MAKE__YACC_FLAGS,
+            KEY_MAKE__PASCAL_FLAGS,
+            KEY_MAKE__LINT_FLAGS,
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    });
+
+static CARGO_PROGRAM_KEYS: std::sync::LazyLock<HashSet<&'static str>> =
+    std::sync::LazyLock::new(|| {
+        [KEY_CARGO__CARGO, KEY_CARGO__RUSTC, KEY_CARGO__RUSTC_WRAPPER]
+            .iter()
+            .cloned()
+            .collect()
+    });
+
+static CARGO_FLAGS_KEYS: std::sync::LazyLock<HashSet<&'static str>> =
+    std::sync::LazyLock::new(|| [KEY_CARGO__RUSTFLAGS].iter().cloned().collect());
+
+static GCC_INCLUDE_KEYS: std::sync::LazyLock<HashSet<&'static str>> =
+    std::sync::LazyLock::new(|| {
+        [
+            KEY_GCC__C_INCLUDE_1,
+            KEY_GCC__C_INCLUDE_2,
+            KEY_GCC__C_INCLUDE_3,
+            KEY_GCC__OBJC_INCLUDE,
+        ]
+        .iter()
+        .cloned()
+        .collect()
+    });
+
 pub fn relevant_env(key: &str) -> bool {
-    matches!(
-        key,
-        KEY_DESTINATION
-            | KEY_OS__PRELOAD_PATH
-            | KEY_OS__PATH
-            | KEY_GCC__C_INCLUDE_1
-            | KEY_GCC__C_INCLUDE_2
-            | KEY_GCC__C_INCLUDE_3
-            | KEY_GCC__OBJC_INCLUDE
-            | KEY_MAKE__C_COMPILER
-            | KEY_MAKE__CXX_COMPILER
-            | KEY_MAKE__C_PREPROCESSOR
-            | KEY_MAKE__FORTRAN_COMPILER
-            | KEY_MAKE__ARCHIVE
-            | KEY_MAKE__ASSEMBLER
-            | KEY_MAKE__MODULA_COMPILER
-            | KEY_MAKE__PASCAL_COMPILER
-            | KEY_MAKE__LEX
-            | KEY_MAKE__YACC
-            | KEY_MAKE__LINT
-            | KEY_MAKE__AR_FLAGS
-            | KEY_MAKE__AS_FLAGS
-            | KEY_MAKE__C_FLAGS
-            | KEY_MAKE__CXX_FLAGS
-            | KEY_MAKE__C_PREPROCESSOR_FLAGS
-            | KEY_MAKE__FORTRAN_FLAGS
-            | KEY_MAKE__LINKER_FLAGS
-            | KEY_MAKE__LINKER_LIBS
-            | KEY_MAKE__LEX_FLAGS
-            | KEY_MAKE__YACC_FLAGS
-            | KEY_MAKE__PASCAL_FLAGS
-            | KEY_MAKE__LINT_FLAGS
-            | KEY_CARGO__CARGO
-            | KEY_CARGO__RUSTC
-            | KEY_CARGO__RUSTC_WRAPPER
-            | KEY_CARGO__RUSTFLAGS
-    )
+    matches!(key, KEY_DESTINATION | KEY_OS__PRELOAD_PATH | KEY_OS__PATH)
+        || MAKE_PROGRAM_KEYS.contains(key)
+        || MAKE_FLAGS_KEYS.contains(key)
+        || CARGO_PROGRAM_KEYS.contains(key)
+        || CARGO_FLAGS_KEYS.contains(key)
+        || GCC_INCLUDE_KEYS.contains(key)
+}
+
+pub fn program_env(key: &str) -> bool {
+    MAKE_PROGRAM_KEYS.contains(key) || CARGO_PROGRAM_KEYS.contains(key)
 }

bear/src/modes/mod.rs

@@ -299,13 +299,7 @@ mod impls {
             // Transform and log the events to semantics.
             let semantics = events
                 .into_iter()
-                .inspect(|event| {
-                    log::debug!("Processing event: {event:?}");
-                })
-                .flat_map(|event| self.interpreter.recognize(&event.execution))
-                .inspect(|semantic| {
-                    log::debug!("Recognized semantic: {semantic:?}");
-                });
+                .flat_map(|event| self.interpreter.recognize(&event.execution));
 
             // Consume the entries and write them to the output file.
             self.writer.write(semantics)?;

bear/src/semantic/interpreters/filter.rs

@@ -11,30 +11,26 @@ use std::path::PathBuf;
 use thiserror::Error;
 
 /// A wrapper interpreter that applies filtering to recognized compiler commands.
-pub struct FilteringInterpreter<T: Interpreter> {
+pub(super) struct FilteringInterpreter<T: Interpreter> {
     inner: T,
-    filter: Filter,
+    filter: Option<Filter>,
 }
 
 impl<T: Interpreter> FilteringInterpreter<T> {
-    /// Creates a new filtering interpreter that wraps another interpreter.
-    fn new(inner: T, filter: Filter) -> Self {
-        Self { inner, filter }
-    }
-
     /// Creates a filtering interpreter from configuration.
-    pub fn from_config(
-        inner: T,
-        compilers: &[config::Compiler],
-        sources: &config::SourceFilter,
-    ) -> Result<Self, InterpreterConfigError> {
-        let filter = Filter::try_from((compilers, sources))?;
-        Ok(Self::new(inner, filter))
+    pub fn from_filter(inner: T, filter: Filter) -> Self {
+        Self {
+            inner,
+            filter: Some(filter),
+        }
     }
 
     /// Creates a pass-through filtering interpreter (no filtering applied).
     pub fn pass_through(inner: T) -> Self {
-        Self::new(inner, Filter::Skip)
+        Self {
+            inner,
+            filter: None,
+        }
     }
 }
 
@@ -43,53 +39,45 @@ impl<T: Interpreter> Interpreter for FilteringInterpreter<T> {
         // First, let the inner interpreter recognize the command
         let command = self.inner.recognize(execution)?;
 
-        match command {
-            Command::Compiler(compiler_cmd) => {
-                // Apply filtering to the compiler command
-                match self.filter.filter_command(&compiler_cmd) {
-                    Ok(()) => Some(Command::Compiler(compiler_cmd)),
-                    Err(reason) => Some(Command::Filtered(reason)),
+        if let Some(filter) = &self.filter {
+            // If a filter is set, apply it to the recognized command
+            match command {
+                Command::Compiler(compiler_cmd) => {
+                    // Apply filtering to the compiler command
+                    match filter.filter_command(&compiler_cmd) {
+                        Ok(_) => Some(Command::Compiler(compiler_cmd)),
+                        Err(reason) => Some(Command::Filtered(reason)),
+                    }
                 }
+                // Pass through other command types unchanged
+                other => Some(other),
             }
-            // Pass through other command types unchanged
-            other => Some(other),
+        } else {
+            // If no filter is set, return the command as is
+            Some(command)
         }
     }
 }
 
 #[derive(Debug)]
-enum Filter {
-    /// Apply filtering according to the configuration
-    Filter {
-        compiler_filters: HashMap<PathBuf, config::IgnoreOrConsider>,
-        source_filters: Vec<config::DirectoryFilter>,
-    },
-    /// Skip filtering (pass through unchanged)
-    Skip,
+pub(super) struct Filter {
+    compiler_filters: HashMap<PathBuf, config::IgnoreOrConsider>,
+    source_filters: Vec<config::DirectoryFilter>,
 }
 
 impl Filter {
     fn filter_command(&self, cmd: &CompilerCommand) -> Result<(), String> {
-        match self {
-            Filter::Skip => Ok(()),
-            Filter::Filter {
-                compiler_filters,
-                source_filters,
-            } => {
-                // Check if the compiler should be filtered
-                if let Some(reason) = self.should_filter_compiler(&cmd.executable, compiler_filters)
-                {
-                    return Err(reason);
-                }
-
-                // Check if any source files should be filtered
-                if let Some(reason) = self.should_filter_sources(cmd, source_filters) {
-                    return Err(reason);
-                }
+        // Check if the compiler should be filtered
+        if let Some(reason) = self.should_filter_compiler(&cmd.executable, &self.compiler_filters) {
+            return Err(reason);
+        }
 
-                Ok(())
-            }
+        // Check if any source files should be filtered
+        if let Some(reason) = self.should_filter_sources(cmd, &self.source_filters) {
+            return Err(reason);
         }
+
+        Ok(())
     }
 
     fn should_filter_compiler(
@@ -282,7 +270,7 @@ impl TryFrom<(&[config::Compiler], &config::SourceFilter)> for Filter {
         // Validate source configuration
         let source_filters = Self::validate_source_configuration(sources)?;
 
-        Ok(Self::Filter {
+        Ok(Self {
             compiler_filters,
             source_filters,
         })
@@ -355,8 +343,9 @@ mod tests {
             .times(1)
             .return_const(Some(Command::Compiler(mock_cmd)));
 
-        let sut =
-            FilteringInterpreter::from_config(mock_interpreter, &compilers, &sources).unwrap();
+        let filter =
+            Filter::try_from((compilers.as_slice(), &sources)).expect("Failed to create filter");
+        let sut = FilteringInterpreter::from_filter(mock_interpreter, filter);
 
         let execution = Execution::from_strings(
             "/usr/bin/gcc",
@@ -392,8 +381,9 @@ mod tests {
             .times(1)
             .return_const(Some(Command::Compiler(mock_cmd)));
 
-        let sut =
-            FilteringInterpreter::from_config(mock_interpreter, &compilers, &sources).unwrap();
+        let filter =
+            Filter::try_from((compilers.as_slice(), &sources)).expect("Failed to create filter");
+        let sut = FilteringInterpreter::from_filter(mock_interpreter, filter);
 
         let execution = Execution::from_strings(
             "/usr/bin/gcc",