Add standard-json as inspect output field (#10537)

* Add standard-json as inspect output field option

* Address PR feedback

Author: 2xic

crates/forge/src/cmd/inspect.rs

@@ -2,18 +2,21 @@ use alloy_json_abi::{EventParam, InternalType, JsonAbi, Param};
 use alloy_primitives::{hex, keccak256};
 use clap::Parser;
 use comfy_table::{modifiers::UTF8_ROUND_CORNERS, Cell, Table};
-use eyre::Result;
+use eyre::{eyre, Result};
 use foundry_cli::opts::{BuildOpts, CompilerOpts};
 use foundry_common::{
     compile::{PathOrContractInfo, ProjectCompiler},
     find_matching_contract_artifact, find_target_path, shell,
 };
-use foundry_compilers::artifacts::{
-    output_selection::{
-        BytecodeOutputSelection, ContractOutputSelection, DeployedBytecodeOutputSelection,
-        EvmOutputSelection, EwasmOutputSelection,
+use foundry_compilers::{
+    artifacts::{
+        output_selection::{
+            BytecodeOutputSelection, ContractOutputSelection, DeployedBytecodeOutputSelection,
+            EvmOutputSelection, EwasmOutputSelection,
+        },
+        StorageLayout,
     },
-    StorageLayout,
+    solc::SolcLanguage,
 };
 use regex::Regex;
 use serde_json::{Map, Value};
@@ -47,8 +50,8 @@ impl InspectArgs {
 
         // Map field to ContractOutputSelection
         let mut cos = build.compiler.extra_output;
-        if !field.is_default() && !cos.iter().any(|selected| field == *selected) {
-            cos.push(field.into());
+        if !field.can_skip_field() && !cos.iter().any(|selected| field == *selected) {
+            cos.push(field.try_into()?);
         }
 
         // Run Optimized?
@@ -58,6 +61,9 @@ impl InspectArgs {
             build.compiler.optimize
         };
 
+        // Get the solc version if specified
+        let solc_version = build.use_solc.clone();
+
         // Build modified Args
         let modified_build_args = BuildOpts {
             compiler: CompilerOpts { extra_output: cos, optimize: optimized, ..build.compiler },
@@ -129,6 +135,18 @@ impl InspectArgs {
                 let out = artifact.abi.as_ref().map_or(Map::new(), parse_events);
                 print_errors_events(&out, false)?;
             }
+            ContractArtifactField::StandardJson => {
+                let standard_json = if let Some(version) = solc_version {
+                    let version = version.parse()?;
+                    let mut standard_json =
+                        project.standard_json_input(&target_path)?.normalize_evm_version(&version);
+                    standard_json.settings.sanitize(&version, SolcLanguage::Solidity);
+                    standard_json
+                } else {
+                    project.standard_json_input(&target_path)?
+                };
+                print_json(&standard_json)?;
+            }
         };
 
         Ok(())
@@ -353,6 +371,7 @@ pub enum ContractArtifactField {
     Ewasm,
     Errors,
     Events,
+    StandardJson,
 }
 
 macro_rules! impl_value_enum {
@@ -440,31 +459,39 @@ impl_value_enum! {
         Ewasm             => "ewasm" | "e-wasm",
         Errors            => "errors" | "er",
         Events            => "events" | "ev",
+        StandardJson      => "standardJson" | "standard-json" | "standard_json",
     }
 }
 
-impl From<ContractArtifactField> for ContractOutputSelection {
-    fn from(field: ContractArtifactField) -> Self {
+impl TryFrom<ContractArtifactField> for ContractOutputSelection {
+    type Error = eyre::Error;
+
+    fn try_from(field: ContractArtifactField) -> Result<Self, Self::Error> {
         type Caf = ContractArtifactField;
         match field {
-            Caf::Abi => Self::Abi,
-            Caf::Bytecode => Self::Evm(EvmOutputSelection::ByteCode(BytecodeOutputSelection::All)),
-            Caf::DeployedBytecode => Self::Evm(EvmOutputSelection::DeployedByteCode(
+            Caf::Abi => Ok(Self::Abi),
+            Caf::Bytecode => {
+                Ok(Self::Evm(EvmOutputSelection::ByteCode(BytecodeOutputSelection::All)))
+            }
+            Caf::DeployedBytecode => Ok(Self::Evm(EvmOutputSelection::DeployedByteCode(
                 DeployedBytecodeOutputSelection::All,
-            )),
-            Caf::Assembly | Caf::AssemblyOptimized => Self::Evm(EvmOutputSelection::Assembly),
-            Caf::LegacyAssembly => Self::Evm(EvmOutputSelection::LegacyAssembly),
-            Caf::MethodIdentifiers => Self::Evm(EvmOutputSelection::MethodIdentifiers),
-            Caf::GasEstimates => Self::Evm(EvmOutputSelection::GasEstimates),
-            Caf::StorageLayout => Self::StorageLayout,
-            Caf::DevDoc => Self::DevDoc,
-            Caf::Ir => Self::Ir,
-            Caf::IrOptimized => Self::IrOptimized,
-            Caf::Metadata => Self::Metadata,
-            Caf::UserDoc => Self::UserDoc,
-            Caf::Ewasm => Self::Ewasm(EwasmOutputSelection::All),
-            Caf::Errors => Self::Abi,
-            Caf::Events => Self::Abi,
+            ))),
+            Caf::Assembly | Caf::AssemblyOptimized => Ok(Self::Evm(EvmOutputSelection::Assembly)),
+            Caf::LegacyAssembly => Ok(Self::Evm(EvmOutputSelection::LegacyAssembly)),
+            Caf::MethodIdentifiers => Ok(Self::Evm(EvmOutputSelection::MethodIdentifiers)),
+            Caf::GasEstimates => Ok(Self::Evm(EvmOutputSelection::GasEstimates)),
+            Caf::StorageLayout => Ok(Self::StorageLayout),
+            Caf::DevDoc => Ok(Self::DevDoc),
+            Caf::Ir => Ok(Self::Ir),
+            Caf::IrOptimized => Ok(Self::IrOptimized),
+            Caf::Metadata => Ok(Self::Metadata),
+            Caf::UserDoc => Ok(Self::UserDoc),
+            Caf::Ewasm => Ok(Self::Ewasm(EwasmOutputSelection::All)),
+            Caf::Errors => Ok(Self::Abi),
+            Caf::Events => Ok(Self::Abi),
+            Caf::StandardJson => {
+                Err(eyre!("StandardJson is not supported for ContractOutputSelection"))
+            }
         }
     }
 }
@@ -501,9 +528,9 @@ impl fmt::Display for ContractArtifactField {
 }
 
 impl ContractArtifactField {
-    /// Returns true if this field is generated by default.
-    pub const fn is_default(&self) -> bool {
-        matches!(self, Self::Bytecode | Self::DeployedBytecode)
+    /// Returns true if this field does not need to be passed to the compiler.
+    pub const fn can_skip_field(&self) -> bool {
+        matches!(self, Self::Bytecode | Self::DeployedBytecode | Self::StandardJson)
     }
 }
 
@@ -556,14 +583,22 @@ mod tests {
     #[test]
     fn contract_output_selection() {
         for &field in ContractArtifactField::ALL {
-            let selection: ContractOutputSelection = field.into();
-            assert_eq!(field, selection);
-
-            let s = field.as_str();
-            assert_eq!(s, field.to_string());
-            assert_eq!(s.parse::<ContractArtifactField>().unwrap(), field);
-            for alias in field.aliases() {
-                assert_eq!(alias.parse::<ContractArtifactField>().unwrap(), field);
+            if field == ContractArtifactField::StandardJson {
+                let selection: Result<ContractOutputSelection, _> = field.try_into();
+                assert!(selection
+                    .unwrap_err()
+                    .to_string()
+                    .eq("StandardJson is not supported for ContractOutputSelection"));
+            } else {
+                let selection: ContractOutputSelection = field.try_into().unwrap();
+                assert_eq!(field, selection);
+
+                let s = field.as_str();
+                assert_eq!(s, field.to_string());
+                assert_eq!(s.parse::<ContractArtifactField>().unwrap(), field);
+                for alias in field.aliases() {
+                    assert_eq!(alias.parse::<ContractArtifactField>().unwrap(), field);
+                }
             }
         }
     }

crates/forge/tests/cli/cmd.rs

@@ -3632,6 +3632,53 @@ forgetest!(inspect_custom_counter_method_identifiers, |prj, cmd| {
 ╰----------------------------+------------╯
 
 
+"#]]);
+});
+
+forgetest_init!(can_inspect_standard_json, |prj, cmd| {
+    cmd.args(["inspect", "src/Counter.sol:Counter", "standard-json"]).assert_success().stdout_eq(str![[r#"
+{
+  "language": "Solidity",
+  "sources": {
+    "src/Counter.sol": {
+      "content": "// SPDX-License-Identifier: UNLICENSED/npragma solidity ^0.8.13;/n/ncontract Counter {/n    uint256 public number;/n/n    function setNumber(uint256 newNumber) public {/n        number = newNumber;/n    }/n/n    function increment() public {/n        number++;/n    }/n}/n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "forge-std/=lib/forge-std/src/"
+    ],
+    "optimizer": {
+      "enabled": false,
+      "runs": 200
+    },
+    "metadata": {
+      "useLiteralContent": false,
+      "bytecodeHash": "ipfs",
+      "appendCBOR": true
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "abi",
+          "evm.bytecode.object",
+          "evm.bytecode.sourceMap",
+          "evm.bytecode.linkReferences",
+          "evm.deployedBytecode.object",
+          "evm.deployedBytecode.sourceMap",
+          "evm.deployedBytecode.linkReferences",
+          "evm.deployedBytecode.immutableReferences",
+          "evm.methodIdentifiers",
+          "metadata"
+        ]
+      }
+    },
+    "evmVersion": "cancun",
+    "viaIR": false,
+    "libraries": {}
+  }
+}
+
 "#]]);
 });