feat: add ignored_error_codes_from option to Project and ProjectBuilder (#361)

- Related to foundry-rs/foundry#9516
- Blocking foundry-rs/foundry#13841

Author: ndavd

crates/compilers/src/compile/output/mod.rs

@@ -76,6 +76,8 @@ pub struct ProjectCompileOutput<
     pub(crate) cached_artifacts: Artifacts<T::Artifact>,
     /// errors that should be omitted
     pub(crate) ignored_error_codes: Vec<u64>,
+    /// errors that should be omitted from each path prefix
+    pub(crate) ignored_error_codes_from: Vec<(PathBuf, Vec<u64>)>,
     /// paths that should be omitted
     pub(crate) ignored_file_paths: Vec<PathBuf>,
     /// set minimum level of severity that is treated as an error
@@ -487,14 +489,19 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>>
     pub fn has_compiler_errors(&self) -> bool {
         self.compiler_output.has_error(
             &self.ignored_error_codes,
+            &self.ignored_error_codes_from,
             &self.ignored_file_paths,
             &self.compiler_severity_filter,
         )
     }
 
     /// Returns whether any warnings were emitted by the compiler.
     pub fn has_compiler_warnings(&self) -> bool {
-        self.compiler_output.has_warning(&self.ignored_error_codes, &self.ignored_file_paths)
+        self.compiler_output.has_warning(
+            &self.ignored_error_codes,
+            &self.ignored_error_codes_from,
+            &self.ignored_file_paths,
+        )
     }
 
     /// Panics if any errors were emitted by the compiler.
@@ -521,6 +528,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> fmt
             self.compiler_output
                 .diagnostics(
                     &self.ignored_error_codes,
+                    &self.ignored_error_codes_from,
                     &self.ignored_file_paths,
                     self.compiler_severity_filter,
                 )
@@ -565,12 +573,14 @@ impl<C: Compiler> AggregatedCompilerOutput<C> {
     pub fn diagnostics<'a>(
         &'a self,
         ignored_error_codes: &'a [u64],
+        ignored_error_codes_from: &'a [(PathBuf, Vec<u64>)],
         ignored_file_paths: &'a [PathBuf],
         compiler_severity_filter: Severity,
     ) -> OutputDiagnostics<'a, C> {
         OutputDiagnostics {
             compiler_output: self,
             ignored_error_codes,
+            ignored_error_codes_from,
             ignored_file_paths,
             compiler_severity_filter,
         }
@@ -831,6 +841,7 @@ impl<C: Compiler> AggregatedCompilerOutput<C> {
     pub fn has_error(
         &self,
         ignored_error_codes: &[u64],
+        ignored_error_codes_from: &[(PathBuf, Vec<u64>)],
         ignored_file_paths: &[PathBuf],
         compiler_severity_filter: &Severity,
     ) -> bool {
@@ -843,7 +854,11 @@ impl<C: Compiler> AggregatedCompilerOutput<C> {
             if compiler_severity_filter.ge(&err.severity()) {
                 if compiler_severity_filter.is_warning() {
                     // skip ignored error codes and file path from warnings
-                    return self.has_warning(ignored_error_codes, ignored_file_paths);
+                    return self.has_warning(
+                        ignored_error_codes,
+                        ignored_error_codes_from,
+                        ignored_file_paths,
+                    );
                 }
                 return true;
             }
@@ -853,15 +868,26 @@ impl<C: Compiler> AggregatedCompilerOutput<C> {
 
     /// Checks if there are any compiler warnings that are not ignored by the specified error codes
     /// and file paths.
-    pub fn has_warning(&self, ignored_error_codes: &[u64], ignored_file_paths: &[PathBuf]) -> bool {
-        self.errors
-            .iter()
-            .any(|error| !self.should_ignore(ignored_error_codes, ignored_file_paths, error))
+    pub fn has_warning(
+        &self,
+        ignored_error_codes: &[u64],
+        ignored_error_codes_from: &[(PathBuf, Vec<u64>)],
+        ignored_file_paths: &[PathBuf],
+    ) -> bool {
+        self.errors.iter().any(|error| {
+            !self.should_ignore(
+                ignored_error_codes,
+                ignored_error_codes_from,
+                ignored_file_paths,
+                error,
+            )
+        })
     }
 
     pub fn should_ignore(
         &self,
         ignored_error_codes: &[u64],
+        ignored_error_codes_from: &[(PathBuf, Vec<u64>)],
         ignored_file_paths: &[PathBuf],
         error: &C::CompilationError,
     ) -> bool {
@@ -877,6 +903,9 @@ impl<C: Compiler> AggregatedCompilerOutput<C> {
                 let path = Path::new(&loc.file);
                 ignore |=
                     ignored_file_paths.iter().any(|ignored_path| path.starts_with(ignored_path));
+                ignore |= ignored_error_codes_from
+                    .iter()
+                    .any(|(prefix, codes)| path.starts_with(prefix) && codes.contains(&code));
 
                 // we ignore spdx and contract size warnings in test
                 // files. if we are looking at one of these warnings
@@ -909,6 +938,8 @@ pub struct OutputDiagnostics<'a, C: Compiler> {
     compiler_output: &'a AggregatedCompilerOutput<C>,
     /// the error codes to ignore
     ignored_error_codes: &'a [u64],
+    /// the error codes to ignore from each path prefix
+    ignored_error_codes_from: &'a [(PathBuf, Vec<u64>)],
     /// the file paths to ignore
     ignored_file_paths: &'a [PathBuf],
     /// set minimum level of severity that is treated as an error
@@ -920,14 +951,19 @@ impl<C: Compiler> OutputDiagnostics<'_, C> {
     pub fn has_error(&self) -> bool {
         self.compiler_output.has_error(
             self.ignored_error_codes,
+            self.ignored_error_codes_from,
             self.ignored_file_paths,
             &self.compiler_severity_filter,
         )
     }
 
     /// Returns true if there is at least one warning
     pub fn has_warning(&self) -> bool {
-        self.compiler_output.has_warning(self.ignored_error_codes, self.ignored_file_paths)
+        self.compiler_output.has_warning(
+            self.ignored_error_codes,
+            self.ignored_error_codes_from,
+            self.ignored_file_paths,
+        )
     }
 }
 
@@ -945,6 +981,7 @@ impl<C: Compiler> fmt::Display for OutputDiagnostics<'_, C> {
         for err in &self.compiler_output.errors {
             if !self.compiler_output.should_ignore(
                 self.ignored_error_codes,
+                self.ignored_error_codes_from,
                 self.ignored_file_paths,
                 err,
             ) {

crates/compilers/src/compile/project.rs

@@ -319,6 +319,7 @@ impl<'a, T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
             )
         } else if output.has_error(
             &project.ignored_error_codes,
+            &project.ignored_error_codes_from,
             &project.ignored_file_paths,
             &project.compiler_severity_filter,
         ) {
@@ -374,10 +375,15 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
         let ArtifactsState { output, cache, compiled_artifacts } = self;
         let project = cache.project();
         let ignored_error_codes = project.ignored_error_codes.clone();
+        let ignored_error_codes_from = project.ignored_error_codes_from.clone();
         let ignored_file_paths = project.ignored_file_paths.clone();
         let compiler_severity_filter = project.compiler_severity_filter;
-        let has_error =
-            output.has_error(&ignored_error_codes, &ignored_file_paths, &compiler_severity_filter);
+        let has_error = output.has_error(
+            &ignored_error_codes,
+            &ignored_error_codes_from,
+            &ignored_file_paths,
+            &compiler_severity_filter,
+        );
         let skip_write_to_disk = project.no_artifacts || has_error;
         trace!(has_error, project.no_artifacts, skip_write_to_disk, cache_path=?project.cache_path(),"prepare writing cache file");
 
@@ -401,6 +407,7 @@ impl<T: ArtifactOutput<CompilerContract = C::CompilerContract>, C: Compiler>
             compiled_artifacts,
             cached_artifacts,
             ignored_error_codes,
+            ignored_error_codes_from,
             ignored_file_paths,
             compiler_severity_filter,
             builds,

crates/compilers/src/lib.rs

@@ -106,6 +106,9 @@ pub struct Project<
     pub artifacts: T,
     /// Errors/Warnings which match these error codes are not going to be logged
     pub ignored_error_codes: Vec<u64>,
+    /// Errors/Warnings which match these error codes from these path prefixes are not going to be
+    /// logged
+    pub ignored_error_codes_from: Vec<(PathBuf, Vec<u64>)>,
     /// Errors/Warnings which match these file paths are not going to be logged
     pub ignored_file_paths: Vec<PathBuf>,
     /// The minimum severity level that is treated as a compiler error
@@ -463,6 +466,8 @@ pub struct ProjectBuilder<
     artifacts: T,
     /// Which error codes to ignore
     pub ignored_error_codes: Vec<u64>,
+    /// Which error codes to ignore for files matching each path prefix
+    pub ignored_error_codes_from: Vec<(PathBuf, Vec<u64>)>,
     /// Which file paths to ignore
     pub ignored_file_paths: Vec<PathBuf>,
     /// The minimum severity level that is treated as a compiler error
@@ -484,6 +489,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
             slash_paths: true,
             artifacts,
             ignored_error_codes: Vec::new(),
+            ignored_error_codes_from: Vec::new(),
             ignored_file_paths: Vec::new(),
             compiler_severity_filter: Severity::Error,
             solc_jobs: None,
@@ -520,6 +526,15 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
         self
     }
 
+    #[must_use]
+    pub fn ignore_error_codes_from(
+        mut self,
+        pairs: impl IntoIterator<Item = (PathBuf, Vec<u64>)>,
+    ) -> Self {
+        self.ignored_error_codes_from.extend(pairs);
+        self
+    }
+
     pub fn ignore_paths(mut self, paths: Vec<PathBuf>) -> Self {
         self.ignored_file_paths = paths;
         self
@@ -643,6 +658,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
             cached,
             no_artifacts,
             ignored_error_codes,
+            ignored_error_codes_from,
             compiler_severity_filter,
             solc_jobs,
             offline,
@@ -665,6 +681,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
             slash_paths,
             artifacts,
             ignored_error_codes,
+            ignored_error_codes_from,
             ignored_file_paths,
             compiler_severity_filter,
             solc_jobs,
@@ -681,6 +698,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
             no_artifacts,
             artifacts,
             ignored_error_codes,
+            ignored_error_codes_from,
             ignored_file_paths,
             compiler_severity_filter,
             solc_jobs,
@@ -708,6 +726,7 @@ impl<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>> Pro
             no_artifacts,
             artifacts,
             ignored_error_codes,
+            ignored_error_codes_from,
             ignored_file_paths,
             compiler_severity_filter,
             solc_jobs: solc_jobs

crates/compilers/tests/project.rs

@@ -2205,7 +2205,7 @@ fn test_severity_warnings() {
     tmp.add_source("A", content).unwrap();
 
     let out = tmp.compile().unwrap();
-    assert!(out.output().has_error(&[], &[], &Severity::Warning));
+    assert!(out.output().has_error(&[], &[], &[], &Severity::Warning));
 
     let content = r"
     // SPDX-License-Identifier: MIT OR Apache-2.0
@@ -2215,7 +2215,7 @@ fn test_severity_warnings() {
     tmp.add_source("A", content).unwrap();
 
     let out = tmp.compile().unwrap();
-    assert!(!out.output().has_error(&[], &[], &Severity::Warning));
+    assert!(!out.output().has_error(&[], &[], &[], &Severity::Warning));
 
     let content = r"
     // SPDX-License-Identifier: MIT OR Apache-2.0
@@ -2229,7 +2229,7 @@ fn test_severity_warnings() {
     tmp.add_source("A", content).unwrap();
 
     let out = tmp.compile().unwrap();
-    assert!(out.output().has_error(&[], &[], &Severity::Warning));
+    assert!(out.output().has_error(&[], &[], &[], &Severity::Warning));
 }
 
 #[test]
@@ -2840,6 +2840,7 @@ fn compile_project_with_options(
     severity_filter: Option<foundry_compilers_artifacts::Severity>,
     ignore_paths: Option<Vec<PathBuf>>,
     ignore_error_code: Option<u64>,
+    ignore_error_codes_from: Option<Vec<(PathBuf, Vec<u64>)>>,
 ) -> ProjectCompileOutput<MultiCompiler> {
     let mut builder =
         Project::builder().no_artifacts().paths(gen_test_data_licensing_warning()).ephemeral();
@@ -2853,14 +2854,17 @@ fn compile_project_with_options(
     if let Some(severity) = severity_filter {
         builder = builder.set_compiler_severity_filter(severity);
     }
+    if let Some(pairs) = ignore_error_codes_from {
+        builder = builder.ignore_error_codes_from(pairs);
+    }
 
     let project = builder.build(Default::default()).unwrap();
     project.compile().unwrap()
 }
 
 #[test]
 fn test_compiler_ignored_file_paths() {
-    let compiled = compile_project_with_options(None, None, None);
+    let compiled = compile_project_with_options(None, None, None, None);
     // no ignored paths set, so the warning should be present
     assert!(compiled.has_compiler_warnings());
     compiled.assert_success();
@@ -2871,28 +2875,66 @@ fn test_compiler_ignored_file_paths() {
         Some(foundry_compilers_artifacts::Severity::Warning),
         Some(vec![testdata]),
         None,
+        None,
     );
 
     // ignored paths set, so the warning shouldnt be present
     assert!(!compiled.has_compiler_warnings());
     compiled.assert_success();
 }
 
+#[test]
+fn test_compiler_ignored_error_codes_from() {
+    let missing_license_error_code = 1878;
+
+    // no ignored_error_codes_from set, warning should be present
+    let compiled = compile_project_with_options(None, None, None, None);
+    assert!(compiled.has_compiler_warnings());
+
+    let testdata =
+        canonicalize(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../test-data")).unwrap();
+
+    // matching prefix and wrong error code, warning should be present
+    let compiled =
+        compile_project_with_options(None, None, None, Some(vec![(testdata.clone(), vec![9999])]));
+    assert!(compiled.has_compiler_warnings());
+
+    // non-matching prefix and correct error code, warning should be present
+    let compiled = compile_project_with_options(
+        None,
+        None,
+        None,
+        Some(vec![(PathBuf::from("nonexistent"), vec![missing_license_error_code])]),
+    );
+    assert!(compiled.has_compiler_warnings());
+
+    // matching prefix and matching error code, warning shouldn't be present
+    let compiled = compile_project_with_options(
+        None,
+        None,
+        None,
+        Some(vec![(testdata, vec![missing_license_error_code])]),
+    );
+    assert!(!compiled.has_compiler_warnings());
+    compiled.assert_success();
+}
+
 #[test]
 fn test_compiler_severity_filter_and_ignored_error_codes() {
     let missing_license_error_code = 1878;
 
-    let compiled = compile_project_with_options(None, None, None);
+    let compiled = compile_project_with_options(None, None, None, None);
     assert!(compiled.has_compiler_warnings());
 
-    let compiled = compile_project_with_options(None, None, Some(missing_license_error_code));
+    let compiled = compile_project_with_options(None, None, Some(missing_license_error_code), None);
     assert!(!compiled.has_compiler_warnings());
     compiled.assert_success();
 
     let compiled = compile_project_with_options(
         Some(foundry_compilers_artifacts::Severity::Warning),
         None,
         Some(missing_license_error_code),
+        None,
     );
     assert!(!compiled.has_compiler_warnings());
     compiled.assert_success();