Make compiler IO completely generic.

Before this commit, the types that were used for the compiler input and
output were the resolc compiler types which was a leaky abstraction as
we have traits to abstract the compilers away but we expose their
internal types out to other crates.

This commit did the following:
1. Made the compiler IO types fully generic so that all of the logic for
   constructing the map of compiled contracts is all done by the
   compiler implementation and not by the consuming code.
2. Changed the input types used for Solc to be the forge standard JSON
   types for Solc instead of resolc.

crates/report/Cargo.toml

@@ -10,9 +10,9 @@ rust-version.workspace = true
 [dependencies]
 revive-dt-config = { workspace = true }
 revive-dt-format = { workspace = true }
+revive-dt-compiler = { workspace = true }
 
 anyhow = { workspace = true }
 tracing = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-revive-solc-json-interface = { workspace = true }

crates/report/src/analyzer.rs

@@ -1,5 +1,6 @@
 //! The report analyzer enriches the raw report data.
 
+use revive_dt_compiler::CompilerOutput;
 use serde::{Deserialize, Serialize};
 
 use crate::reporter::CompilationTask;
@@ -13,41 +14,27 @@ pub struct CompilerStatistics {
     pub mean_code_size: usize,
     /// The mean size of the optimized YUL IR.
     pub mean_yul_size: usize,
-    /// Is a proxy because the YUL also containes a lot of comments.
+    /// Is a proxy because the YUL also contains a lot of comments.
     pub yul_to_bytecode_size_ratio: f32,
 }
 
 impl CompilerStatistics {
     /// Cumulatively update the statistics with the next compiler task.
     pub fn sample(&mut self, compilation_task: &CompilationTask) {
-        let Some(output) = &compilation_task.json_output else {
-            return;
-        };
-
-        let Some(contracts) = &output.contracts else {
+        let Some(CompilerOutput { contracts }) = &compilation_task.json_output else {
             return;
         };
 
         for (_solidity, contracts) in contracts.iter() {
-            for (_name, contract) in contracts.iter() {
-                let Some(evm) = &contract.evm else {
-                    continue;
-                };
-                let Some(deploy_code) = &evm.deployed_bytecode else {
-                    continue;
-                };
-
+            for (_name, (bytecode, _)) in contracts.iter() {
                 // The EVM bytecode can be unlinked and thus is not necessarily a decodable hex
                 // string; for our statistics this is a good enough approximation.
-                let bytecode_size = deploy_code.object.len() / 2;
+                let bytecode_size = bytecode.len() / 2;
 
-                let yul_size = contract
-                    .ir_optimized
-                    .as_ref()
-                    .expect("if the contract has a deploy code it should also have the opimized IR")
-                    .len();
+                // TODO: for the time being we set the yul_size to be zero. We need to change this
+                // when we overhaul the reporting.
 
-                self.update_sizes(bytecode_size, yul_size);
+                self.update_sizes(bytecode_size, 0);
             }
         }
     }

crates/report/src/reporter.rs

@@ -12,11 +12,11 @@ use std::{
 };
 
 use anyhow::Context;
+use revive_dt_compiler::{CompilerInput, CompilerOutput};
 use serde::{Deserialize, Serialize};
 
 use revive_dt_config::{Arguments, TestingPlatform};
 use revive_dt_format::{corpus::Corpus, mode::SolcMode};
-use revive_solc_json_interface::{SolcStandardJsonInput, SolcStandardJsonOutput};
 
 use crate::analyzer::CompilerStatistics;
 
@@ -44,9 +44,9 @@ pub struct Report {
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct CompilationTask {
     /// The observed compiler input.
-    pub json_input: SolcStandardJsonInput,
+    pub json_input: CompilerInput,
     /// The observed compiler output.
-    pub json_output: Option<SolcStandardJsonOutput>,
+    pub json_output: Option<CompilerOutput>,
     /// The observed compiler mode.
     pub mode: SolcMode,
     /// The observed compiler version.
@@ -152,15 +152,7 @@ impl Report {
         for (platform, results) in self.compiler_results.iter() {
             for result in results {
                 // ignore if there were no errors
-                if result.compilation_task.error.is_none()
-                    && result
-                        .compilation_task
-                        .json_output
-                        .as_ref()
-                        .and_then(|output| output.errors.as_ref())
-                        .map(|errors| errors.is_empty())
-                        .unwrap_or(true)
-                {
+                if result.compilation_task.error.is_none() {
                     continue;
                 }