Preprocess by input reference

Author: grandizzy

crates/compilers/src/compile/project.rs

@@ -132,10 +132,10 @@ pub trait Preprocessor<C: Compiler>: Debug {
     fn preprocess(
         &self,
         compiler: &C,
-        input: C::Input,
+        input: &mut C::Input,
         paths: &ProjectPathsConfig<C::Language>,
         mocks: &mut HashSet<PathBuf>,
-    ) -> Result<C::Input>;
+    ) -> Result<()>;
 }
 
 #[derive(Debug)]
@@ -515,8 +515,12 @@ impl<L: Language, S: CompilerSettings> CompilerSources<'_, L, S> {
                 input.strip_prefix(project.paths.root.as_path());
 
                 if let Some(preprocessor) = preprocessor.as_ref() {
-                    input =
-                        preprocessor.preprocess(&project.compiler, input, &project.paths, mocks)?;
+                    preprocessor.preprocess(
+                        &project.compiler,
+                        &mut input,
+                        &project.paths,
+                        mocks,
+                    )?;
                 }
 
                 jobs.push((input, profile, actually_dirty));

crates/compilers/src/preprocessor/mod.rs

@@ -61,15 +61,15 @@ impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
     fn preprocess(
         &self,
         _solc: &SolcCompiler,
-        mut input: SolcVersionedInput,
+        input: &mut SolcVersionedInput,
         paths: &ProjectPathsConfig<SolcLanguage>,
         mocks: &mut HashSet<PathBuf>,
-    ) -> Result<SolcVersionedInput> {
+    ) -> Result<()> {
         let sources = &mut input.input.sources;
         // Skip if we are not preprocessing any tests or scripts. Avoids unnecessary AST parsing.
         if sources.iter().all(|(path, _)| !is_test_or_script(path, paths)) {
             trace!("no tests or sources to preprocess");
-            return Ok(input);
+            return Ok(());
         }
 
         let sess = Session::builder().with_buffer_emitter(Default::default()).build();
@@ -123,30 +123,25 @@ impl Preprocessor<SolcCompiler> for TestOptimizerPreprocessor {
             return Err(SolcError::Message(err.to_string()));
         }
 
-        Ok(input)
+        Ok(())
     }
 }
 
 impl Preprocessor<MultiCompiler> for TestOptimizerPreprocessor {
     fn preprocess(
         &self,
         compiler: &MultiCompiler,
-        input: <MultiCompiler as Compiler>::Input,
+        input: &mut <MultiCompiler as Compiler>::Input,
         paths: &ProjectPathsConfig<MultiCompilerLanguage>,
         mocks: &mut HashSet<PathBuf>,
-    ) -> Result<<MultiCompiler as Compiler>::Input> {
-        match input {
-            MultiCompilerInput::Solc(input) => {
-                if let Some(solc) = &compiler.solc {
-                    let paths = paths.clone().with_language::<SolcLanguage>();
-                    let input = self.preprocess(solc, input, &paths, mocks)?;
-                    Ok(MultiCompilerInput::Solc(input))
-                } else {
-                    Ok(MultiCompilerInput::Solc(input))
-                }
-            }
-            MultiCompilerInput::Vyper(input) => Ok(MultiCompilerInput::Vyper(input)),
-        }
+    ) -> Result<()> {
+        // Preprocess only Solc compilers.
+        let MultiCompilerInput::Solc(input) = input else { return Ok(()) };
+
+        let Some(solc) = &compiler.solc else { return Ok(()) };
+
+        let paths = paths.clone().with_language::<SolcLanguage>();
+        self.preprocess(solc, input, &paths, mocks)
     }
 }