wip

Signed-off-by: Cyrill Leutwiler <[email protected]>

Author: xermicus

Cargo.lock

@@ -71,6 +71,7 @@ tar = "0.4"
 toml = "0.8"
 assert_cmd = "2.0"
 assert_fs = "1.1"
+normpath = "1.3"
 
 # polkadot-sdk and friends
 codec = { version = "3.7.5", default-features = false, package = "parity-scale-codec" }

Cargo.toml

@@ -30,6 +30,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 sha3 = { workspace = true }
 which = { workspace = true }
+normpath = { workspace = true }
 
 revive-common = { workspace = true }
 revive-llvm-context = { workspace = true }

crates/resolc/Cargo.toml

@@ -5,6 +5,7 @@ use std::collections::BTreeSet;
 use std::fs::File;
 use std::io::Write;
 use std::path::Path;
+use std::path::PathBuf;
 
 use revive_solc_json_interface::CombinedJsonContract;
 use revive_solc_json_interface::SolcStandardJsonOutputContract;
@@ -14,10 +15,8 @@ use serde::Serialize;
 /// The Solidity contract build.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct Contract {
-    /// The contract path.
-    pub path: String,
-    /// The auxiliary identifier. Used to identify Yul objects.
-    pub identifier: String,
+    /// The contract identifier.
+    pub identifier: revive_common::ContractIdentifier,
     /// The LLVM module build.
     pub build: revive_llvm_context::PolkaVMBuild,
     /// The metadata JSON.
@@ -35,16 +34,14 @@ pub struct Contract {
 impl Contract {
     /// A shortcut constructor.
     pub fn new(
-        path: String,
-        identifier: String,
+        identifier: revive_common::ContractIdentifier,
         build: revive_llvm_context::PolkaVMBuild,
         metadata_json: serde_json::Value,
         missing_libraries: BTreeSet<String>,
         factory_dependencies: BTreeSet<String>,
         object_format: revive_common::ObjectFormat,
     ) -> Self {
         Self {
-            path,
             identifier,
             build,
             metadata_json,
@@ -63,14 +60,15 @@ impl Contract {
         output_binary: bool,
         overwrite: bool,
     ) -> anyhow::Result<()> {
-        let file_name = Self::short_path(self.path.as_str());
+        let file_path = PathBuf::from(self.identifier.path);
+        let file_name = file_path
+            .file_name()
+            .expect("Always exists")
+            .to_str()
+            .expect("Always valid");
 
         if output_assembly {
-            let file_name = format!(
-                "{}.{}",
-                file_name,
-                revive_common::EXTENSION_POLKAVM_ASSEMBLY
-            );
+            let file_name = format!("{file_name}.{}", revive_common::EXTENSION_POLKAVM_ASSEMBLY);
             let mut file_path = path.to_owned();
             file_path.push(file_name);
 
@@ -79,21 +77,17 @@ impl Contract {
                     "Refusing to overwrite an existing file {file_path:?} (use --overwrite to force)."
                 );
             } else {
-                let assembly_text = self.build.assembly_text;
-
                 File::create(&file_path)
+                    .map_err(|error| anyhow::anyhow!("File {file_path:?} creating error: {error}"))?
+                    .write_all(self.build.assembly_text.as_bytes())
                     .map_err(|error| {
-                        anyhow::anyhow!("File {:?} creating error: {}", file_path, error)
-                    })?
-                    .write_all(assembly_text.as_bytes())
-                    .map_err(|error| {
-                        anyhow::anyhow!("File {:?} writing error: {}", file_path, error)
+                        anyhow::anyhow!("File {file_path:?} writing error: {error}")
                     })?;
             }
         }
 
         if output_binary {
-            let file_name = format!("{}.{}", file_name, revive_common::EXTENSION_POLKAVM_BINARY);
+            let file_name = format!("{file_name}.{}", revive_common::EXTENSION_POLKAVM_BINARY);
             let mut file_path = path.to_owned();
             file_path.push(file_name);
 
@@ -103,12 +97,10 @@ impl Contract {
                 );
             } else {
                 File::create(&file_path)
-                    .map_err(|error| {
-                        anyhow::anyhow!("File {:?} creating error: {}", file_path, error)
-                    })?
+                    .map_err(|error| anyhow::anyhow!("File {file_path:?} creating error: {error}"))?
                     .write_all(self.build.bytecode.as_slice())
                     .map_err(|error| {
-                        anyhow::anyhow!("File {:?} writing error: {}", file_path, error)
+                        anyhow::anyhow!("File {file_path:?} writing error: {error}")
                     })?;
             }
         }

crates/resolc/src/build/contract.rs

@@ -5,16 +5,19 @@ pub mod contract;
 use std::collections::BTreeMap;
 use std::io::Write;
 use std::path::Path;
+use std::path::PathBuf;
+
+use normpath::PathExt;
 
 use revive_solc_json_interface::combined_json::CombinedJson;
+use revive_solc_json_interface::CombinedJsonContract;
 use revive_solc_json_interface::SolcStandardJsonOutput;
+use revive_solc_json_interface::SolcStandardJsonOutputContract;
 use revive_solc_json_interface::SolcStandardJsonOutputError;
 use revive_solc_json_interface::SolcStandardJsonOutputErrorHandler;
 
+use crate::build::contract::Contract;
 use crate::solc::version::Version as SolcVersion;
-use crate::ResolcVersion;
-
-use self::contract::Contract;
 
 /// The Solidity project PVM build.
 #[derive(Debug, Default)]
@@ -82,20 +85,23 @@ impl Build {
     }
 
     /// Writes all contracts assembly and bytecode to the combined JSON.
-    pub fn write_to_combined_json(self, combined_json: &mut CombinedJson) -> anyhow::Result<()> {
+    pub fn write_to_combined_json(
+        mut self,
+        combined_json: &mut CombinedJson,
+    ) -> anyhow::Result<()> {
         self.take_and_write_warnings();
         self.exit_on_error();
 
         for result in self.results.into_values() {
             let build = result.expect("Exits on an error above");
-            let name = build.name.clone();
+            let identifier = build.identifier.clone();
 
             let combined_json_contract =
                 match combined_json
                     .contracts
                     .iter_mut()
                     .find_map(|(json_path, contract)| {
-                        if Self::normalize_full_path(name.full_path.as_str())
+                        if Self::normalize_full_path(identifier.full_path.as_str())
                             .ends_with(Self::normalize_full_path(json_path).as_str())
                         {
                             Some(contract)
@@ -106,12 +112,12 @@ impl Build {
                     Some(contract) => contract,
                     None => {
                         combined_json.contracts.insert(
-                            name.full_path.clone(),
-                            era_solc::CombinedJsonContract::default(),
+                            identifier.full_path.clone(),
+                            CombinedJsonContract::default(),
                         );
                         combined_json
                             .contracts
-                            .get_mut(name.full_path.as_str())
+                            .get_mut(identifier.full_path.as_str())
                             .expect("Always exists")
                     }
                 };
@@ -124,31 +130,73 @@ impl Build {
 
     /// Writes all contracts assembly and bytecode to the standard JSON.
     pub fn write_to_standard_json(
-        mut self,
+        self,
         standard_json: &mut SolcStandardJsonOutput,
         solc_version: &SolcVersion,
     ) -> anyhow::Result<()> {
-        let contracts = match standard_json.contracts.as_mut() {
-            Some(contracts) => contracts,
-            None => return Ok(()),
-        };
-
-        for (path, contracts) in contracts.iter_mut() {
-            for (name, contract) in contracts.iter_mut() {
-                let full_name = format!("{path}:{name}");
-
-                if let Some(contract_data) = self.contracts.remove(full_name.as_str()) {
-                    contract_data.write_to_standard_json(contract)?;
+        let mut errors = Vec::with_capacity(self.results.len());
+        for result in self.results.into_values() {
+            let build = match result {
+                Ok(build) => build,
+                Err(error) => {
+                    errors.push(error);
+                    continue;
+                }
+            };
+            let identifier = build.identifier.clone();
+
+            match standard_json
+                .contracts
+                .get_mut(identifier.path.as_str())
+                .and_then(|contracts| {
+                    contracts.get_mut(
+                        identifier
+                            .name
+                            .as_deref()
+                            .unwrap_or(identifier.path.as_str()),
+                    )
+                }) {
+                Some(contract) => {
+                    build.write_to_standard_json(contract)?;
+                }
+                None => {
+                    let contracts = standard_json
+                        .contracts
+                        .entry(identifier.path.clone())
+                        .or_default();
+                    let mut contract = SolcStandardJsonOutputContract::default();
+                    build.write_to_standard_json(&mut contract)?;
+                    contracts.insert(identifier.name.unwrap_or(identifier.path), contract);
                 }
             }
         }
 
+        standard_json.errors.extend(errors);
         standard_json.version = Some(solc_version.default.to_string());
         standard_json.long_version = Some(solc_version.long.to_owned());
-        standard_json.revive_version = Some(ResolcVersion::default().long);
 
         Ok(())
     }
+
+    /// Normalizes the full contract path.
+    ///
+    /// # Panics
+    /// If the path does not contain a colon.
+    fn normalize_full_path(path: &str) -> String {
+        let mut iterator = path.split(':');
+        let path = iterator.next().expect("Always exists");
+        let name = iterator.next().expect("Always exists");
+
+        let mut full_path = PathBuf::from(path)
+            .normalize()
+            .expect("Path normalization error")
+            .as_os_str()
+            .to_string_lossy()
+            .into_owned();
+        full_path.push(':');
+        full_path.push_str(name);
+        full_path
+    }
 }
 
 impl revive_solc_json_interface::SolcStandardJsonOutputErrorHandler for Build {

crates/resolc/src/build/mod.rs

@@ -33,18 +33,6 @@ impl Process for NativeProcess {
             anyhow::anyhow!("{:?} subprocess spawning error: {:?}", executable, error)
         })?;
 
-        #[cfg(debug_assertions)]
-        input
-            .debug_config
-            .dump_stage_output(&input.contract.path, Some("stage"), &input_json)
-            .map_err(|error| {
-                anyhow::anyhow!(
-                    "{:?} failed to log the recursive process output: {:?}",
-                    executable,
-                    error,
-                )
-            })?;
-
         process
             .stdin
             .as_ref()

crates/resolc/src/process/native_process.rs

@@ -2,27 +2,39 @@
 
 use std::collections::BTreeSet;
 
+use revive_yul::lexer::Lexer;
 use serde::Deserialize;
 use serde::Serialize;
 
 use revive_yul::parser::statement::object::Object;
 
-/// The contract Yul source code.
+/// he contract Yul source code.
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Yul {
-    /// The Yul source code.
-    pub source_code: String,
     /// The Yul AST object.
     pub object: Object,
 }
 
 impl Yul {
-    /// A shortcut constructor.
-    pub fn new(source_code: String, object: Object) -> Self {
-        Self {
-            source_code,
-            object,
+    /// Transforms the `solc` standard JSON output contract into a Yul object.
+    pub fn try_from_source(
+        path: &str,
+        source_code: &str,
+        debug_config: Option<&revive_llvm_context::DebugConfig>,
+    ) -> anyhow::Result<Option<Self>> {
+        if source_code.is_empty() {
+            return Ok(None);
+        };
+
+        if let Some(debug_config) = debug_config {
+            debug_config.dump_yul(path, source_code)?;
         }
+
+        let mut lexer = Lexer::new(source_code.to_owned());
+        let object = Object::parse(&mut lexer, None)
+            .map_err(|error| anyhow::anyhow!("Yul parsing: {error:?}"))?;
+
+        Ok(Some(Self { object }))
     }
 
     /// Get the list of missing deployable libraries.

crates/resolc/src/project/contract/ir/yul.rs

@@ -25,7 +25,7 @@ use self::metadata::Metadata;
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Contract {
     /// The absolute file path.
-    pub path: String,
+    pub identifier: revive_common::ContractIdentifier,
     /// The IR source code data.
     pub ir: IR,
     /// The metadata JSON.
@@ -35,7 +35,7 @@ pub struct Contract {
 impl Contract {
     /// A shortcut constructor.
     pub fn new(
-        path: String,
+        identifier: revive_common::ContractIdentifier,
         source_hash: [u8; revive_common::BYTE_LENGTH_WORD],
         source_version: SolcVersion,
         ir: IR,
@@ -49,7 +49,7 @@ impl Contract {
         });
 
         Self {
-            path,
+            identifier,
             ir,
             metadata_json,
         }
@@ -156,8 +156,7 @@ impl Contract {
         let build = context.build(self.path.as_str(), metadata_hash)?;
 
         Ok(ContractBuild::new(
-            self.path,
-            identifier,
+            self.identifier,
             build,
             metadata_json,
             missing_libraries,