release resolc v0.1.0 (#332)

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>

.github/workflows/release-llvm.yml

@@ -94,7 +94,7 @@ jobs:
 
       - name: Install LLVM Builder
         run: |
-          cargo install --path crates/llvm-builder
+          cargo install --locked --force --path crates/llvm-builder
 
       - name: Clone LLVM
         run: |

.github/workflows/release.yml

@@ -143,7 +143,7 @@ jobs:
     runs-on: ubuntu-24.04
     needs: [check-version-changed]
     env:
-      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive-workflow-test/releases/download/${{ github.ref_name }}/resolc.wasm
+      RELEASE_RESOLC_WASM_URI: https://github.com/paritytech/revive/releases/download/${{ github.ref_name }}/resolc.wasm
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1

Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/*"]
 
 [workspace.package]
-version = "0.1.0-dev.16"
+version = "0.1.0"
 authors = [
     "Cyrill Leutwiler <cyrill@parity.io>",
     "Parity Technologies <admin@parity.io>",
@@ -14,56 +14,57 @@ repository = "https://github.com/paritytech/revive"
 rust-version = "1.85.0"
 
 [workspace.dependencies]
-revive-benchmarks = { version = "0.1.0-dev.16", path = "crates/benchmarks" }
+resolc  = { version = "0.1.0", path = "crates/resolc" }
-revive-builtins = { version = "0.1.0-dev.16", path = "crates/builtins" }
+revive-benchmarks = { version = "0.1.0", path = "crates/benchmarks" }
-revive-common = { version = "0.1.0-dev.16", path = "crates/common" }
+revive-builtins = { version = "0.1.0", path = "crates/builtins" }
-revive-differential = { version = "0.1.0-dev.16", path = "crates/differential" }
+revive-common = { version = "0.1.0", path = "crates/common" }
-revive-integration = { version = "0.1.0-dev.16", path = "crates/integration" }
+revive-differential = { version = "0.1.0", path = "crates/differential" }
-revive-linker = { version = "0.1.0-dev.16", path = "crates/linker" }
+revive-integration = { version = "0.1.0", path = "crates/integration" }
-lld-sys = { version = "0.1.0-dev.16", path = "crates/lld-sys" }
+revive-linker = { version = "0.1.0", path = "crates/linker" }
-revive-llvm-context = { version = "0.1.0-dev.16", path = "crates/llvm-context" }
+lld-sys = { version = "0.1.0", path = "crates/lld-sys" }
-revive-runtime-api = { version = "0.1.0-dev.16", path = "crates/runtime-api" }
+revive-llvm-context = { version = "0.1.0", path = "crates/llvm-context" }
-revive-runner = { version = "0.1.0-dev.16", path = "crates/runner" }
+revive-runtime-api = { version = "0.1.0", path = "crates/runtime-api" }
-revive-solc-json-interface = { version = "0.1.0-dev.16", path = "crates/solc-json-interface" }
+revive-runner = { version = "0.1.0", path = "crates/runner" }
-revive-solidity = { version = "0.1.0-dev.16", path = "crates/solidity" }
+revive-solc-json-interface = { version = "0.1.0", path = "crates/solc-json-interface" }
-revive-stdlib = { version = "0.1.0-dev.16", path = "crates/stdlib" }
+revive-stdlib = { version = "0.1.0", path = "crates/stdlib" }
-revive-build-utils = { version = "0.1.0-dev.16", path = "crates/build-utils" }
+revive-build-utils = { version = "0.1.0", path = "crates/build-utils" }
+revive-yul = { version = "0.1.0", path = "crates/yul" }
 
 hex = "0.4.3"
 cc = "1.2"
 libc = "0.2.172"
-tempfile = "3.17"
+tempfile = "3.20"
 anyhow = "1.0"
 semver = { version = "1.0", features = ["serde"] }
 itertools = "0.14"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0", features = ["arbitrary_precision"] }
-regex = "1.10"
+regex = "1.11"
-once_cell = "1.20"
+once_cell = "1.21"
 num = "0.4.3"
 sha1 = "0.10"
 sha3 = "0.10"
 thiserror = "2.0"
 which = "7.0"
 path-slash = "0.2"
-rayon = "1.8"
+rayon = "1.10"
 clap = { version = "4", default-features = false, features = ["derive"] }
-polkavm-common = "0.21.0"
+polkavm-common = "0.24.0"
-polkavm-linker = "0.21.0"
+polkavm-linker = "0.24.0"
-polkavm-disassembler = "0.21.0"
+polkavm-disassembler = "0.24.0"
-polkavm = "0.21.0"
+polkavm = "0.24.0"
-alloy-primitives = { version = "0.8.21", features = ["serde"] }
+alloy-primitives = { version = "1.1", features = ["serde"] }
-alloy-sol-types = "0.8.21"
+alloy-sol-types = "1.1"
-alloy-genesis = "0.11.1"
+alloy-genesis = "1.0"
-alloy-serde = "0.11.1"
+alloy-serde = "1.0"
-env_logger = { version = "0.11.6", default-features = false }
+env_logger = { version = "0.11.8", default-features = false }
-serde_stacker = "0.1.11"
+serde_stacker = "0.1.12"
-criterion = { version = "0.5.1", features = ["html_reports"] }
+criterion = { version = "0.6", features = ["html_reports"] }
-log = { version = "0.4.25" }
+log = { version = "0.4.27" }
-git2 = { version = "0.20.0", default-features = false }
+git2 = { version = "0.20.2", default-features = false }
 downloader = "0.2.8"
-flate2 = "1.0.35"
+flate2 = "1.1"
-fs_extra = "1.3.0"
+fs_extra = "1.3"
 num_cpus = "1"
 tar = "0.4"
 toml = "0.8"
@@ -71,7 +72,7 @@ assert_cmd = "2.0"
 assert_fs = "1.1"
 
 # polkadot-sdk and friends
-codec = { version = "3.6.12", default-features = false, package = "parity-scale-codec" }
+codec = { version = "3.7.5", default-features = false, package = "parity-scale-codec" }
 scale-info = { version = "2.11.6", default-features = false }
 polkadot-sdk = { version = "2503.0.1" }
 

Makefile

@@ -11,7 +11,7 @@
 	machete \
 	test \
 	test-integration \
-	test-solidity \
+	test-resolc \
 	test-workspace \
 	test-cli \
 	test-wasm \
@@ -24,24 +24,24 @@
 install: install-bin install-npm
 
 install-bin:
-	cargo install --locked --path crates/solidity
+	cargo install --force --locked --path crates/resolc
 
 install-npm:
 	npm install && npm fund
 
 install-wasm: install-npm
-	cargo build --target wasm32-unknown-emscripten -p revive-solidity --release --no-default-features
+	cargo build --target wasm32-unknown-emscripten -p resolc --release --no-default-features
 	npm run build:package
 
 install-llvm-builder:
-	cargo install --path crates/llvm-builder
+	cargo install --force --locked --path crates/llvm-builder
 
 install-llvm: install-llvm-builder
 	revive-llvm clone
 	revive-llvm build --llvm-projects lld --llvm-projects clang
 
 install-revive-runner:
-	cargo install --path crates/runner --no-default-features --locked
+	cargo install --locked --force --path crates/runner --no-default-features
 
 format:
 	cargo fmt --all --check
@@ -58,8 +58,8 @@ test: format clippy machete test-cli test-workspace install-revive-runner
 test-integration: install-bin
 	cargo test --package revive-integration
 
-test-solidity: install
+test-resolc: install
-	cargo test --package revive-solidity
+	cargo test --package resolc
 
 test-workspace: install
 	cargo test --workspace --exclude revive-llvm-builder
@@ -90,6 +90,6 @@ clean:
 	cargo clean ; \
 	revive-llvm clean ; \
 	rm -rf node_modules ; \
-	rm -rf crates/solidity/src/tests/cli-tests/artifacts ; \
+	rm -rf crates/resolc/src/tests/cli-tests/artifacts ; \
-	cargo uninstall revive-solidity ; \
+	cargo uninstall resolc ; \
 	cargo uninstall revive-llvm-builder ;

README.md

@@ -14,7 +14,39 @@ This is experimental software in active development and not ready just yet for p
 Discussion around the development is hosted on the [Polkadot Forum](https://forum.polkadot.network/t/contracts-update-solidity-on-polkavm/6949#a-new-solidity-compiler-1).
 
 ## Installation
-Please consult [the documentation](https://contracts.polkadot.io/revive_compiler/installation) for installation instructions.
+Building Solidity contracts for PolkaVM requires installing the following two compilers:
+- `resolc`: The revive Solidity compiler YUL frontend and PolkaVM code generator (provided by this repository).
+- `solc`: The [Ethereum Solidity reference compiler](https://github.com/ethereum/solidity/) implemenation.`resolc` uses `solc` during the compilation process, please refer to the [Ethereum Solidity documentation](https://docs.soliditylang.org/en/latest/installing-solidity.html) for installation instructions.
+
+### `resolc` binary releases
+`resolc` is distributed as a standalone binary (with `solc` as the only external dependency). Please download one of our [binary releases](https://github.com/paritytech/revive/releases) for your target platform and mind the platform specific instructions below.
+
+<details>
+  <summary>MacOS users</summary>
+
+> **MacOS** users need to clear the `downloaded` attribute from the binary and set the executable flag.
+> ```sh
+> xattr -rc resolc-universal-apple-darwin
+> chmod +x resolc-universal-apple-darwin
+> ```
+
+</details>
+
+<details>
+  <summary>Linux users</summary>
+
+> **Linux** users need to set the executable flag.
+> ```sh
+> chmod +x resolc-x86_64-unknown-linux-musl
+> ```
+
+</details>
+
+
+### `resolc` NPM package
+We distribute the revive compiler as [node.js module](https://www.npmjs.com/package/@parity/resolc) and [hardhat plugin](https://www.npmjs.com/package/@parity/hardhat-polkadot-resolc).
+
+Note: The `solc` dependency is bundled via NPM packaging and defaults to the latest supported version.
 
 ## Building from source
 
@@ -99,8 +131,6 @@ Ensure that your branch passes `make test` locally when submitting a pull reques
 ### Design overview
 See the [relevant section in our documentation](https://contracts.polkadot.io/revive_compiler/architecture) to learn more about how the compiler works. 
 
-[Frontend](https://github.com/matter-labs/era-compiler-solidity) and [code generator](https://github.com/matter-labs/era-compiler-llvm-context) are based of ZKSync `zksolc` (the project started as a fork of the era compiler).
-
 ### Tests
 
 Before running the tests, ensure that Geth (Go Ethereum) is installed on your system. Follow the installation guide here: [Installing Geth](https://geth.ethereum.org/docs/getting-started/installing-geth).
@@ -109,3 +139,8 @@ Once Geth is installed, you can run the tests using the following command:
 ```sh
 make test
 ```
+# Acknowledgements
+
+The revive compiler project, after some early experiments with EVM bytecode translations, decided to fork the `era-compiler` framework.
+[Frontend](https://github.com/matter-labs/era-compiler-solidity), [code generator](https://github.com/matter-labs/era-compiler-llvm-context) and some supporting libraries are based of ZKSync `zksolc`. I'd like to express my gratitude and thank the original authors for providing a useable code base under a generous license.
+

RELEASE.md

@@ -4,11 +4,11 @@ Prior to the first stable release we neither have formal release processes nor d
 
 To create a new pre-release:
 
-1. Create a release PR which updates the `-dev.X` versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly.
+1. Create a release PR which updates the versions in the workspace `Cargo.toml` and updates the `CHANGELOG.md` accordingly.
 2. If the CI passes, merge the release PR.
-3. Push a tag that has the same `-dev.X` version as in `Cargo.toml`
+3. Push a `vX.Y.Z` tag that has the same version as in `Cargo.toml`
 4. The release workflow will attempt to build and publish a new pre-release if the latest tag does match the cargo package version.
-5. Wait for the `Release` workflow to finish. It should create the pre-release with the same `-dev.X` name.
+5. Wait for the `Release` workflow to finish. It should create the pre-release with the same name.
 6. Check that pre-release was created on the [Releases page](https://github.com/paritytech/revive/releases) with all artifacts.
 7. After the release is published, another workflow should start automatically and update json files in https://github.com/paritytech/resolc-bin. Check the changes.
 8. Update the [contract-docs](https://github.com/paritytech/contract-docs/) accordingly

crates/integration/Cargo.toml

@@ -13,7 +13,7 @@ alloy-sol-types = { workspace = true }
 hex = { workspace = true }
 serde_json = { workspace = true }
 
-revive-solidity = { workspace = true }
+resolc = { workspace = true }
 revive-runner = { workspace = true }
 revive-llvm-context = { workspace = true }
 

crates/integration/src/cases.rs

@@ -1,8 +1,8 @@
 use alloy_primitives::{Address, Bytes, I256, U256};
 use alloy_sol_types::{sol, SolCall, SolConstructor};
 
+use resolc::test_utils::*;
 use revive_llvm_context::OptimizerSettings;
-use revive_solidity::test_utils::*;
 
 #[derive(Clone)]
 pub struct Contract {

crates/resolc/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "revive-solidity"
+name = "resolc"
 version.workspace = true
 license.workspace = true
 edition.workspace = true
@@ -18,26 +18,23 @@ path = "src/resolc/main.rs"
 doctest = false
 
 [dependencies]
-clap = { workspace = true }
-thiserror = { workspace = true }
 anyhow = { workspace = true }
-which = { workspace = true }
+clap = { workspace = true }
+hex = { workspace = true }
+inkwell = { workspace = true }
+once_cell = { workspace = true }
 path-slash = { workspace = true }
 rayon = { workspace = true, optional = true }
-
+semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-semver = { workspace = true }
-once_cell = { workspace = true }
-regex = { workspace = true }
-hex = { workspace = true }
-num = { workspace = true }
 sha3 = { workspace = true }
-inkwell = { workspace = true }
+which = { workspace = true }
 
 revive-common = { workspace = true }
 revive-llvm-context = { workspace = true }
 revive-solc-json-interface = { workspace = true, features = ["resolc"] }
+revive-yul = { workspace = true }
 
 [target.'cfg(target_env = "musl")'.dependencies]
 mimalloc = { version = "*", default-features = false }

crates/resolc/src/lib.rs

@@ -7,7 +7,6 @@ pub(crate) mod process;
 pub(crate) mod project;
 pub(crate) mod solc;
 pub(crate) mod version;
-pub(crate) mod yul;
 
 pub use self::build::contract::Contract as ContractBuild;
 pub use self::build::Build;

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

@@ -8,7 +8,7 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::parser::statement::object::Object;
+use revive_yul::parser::statement::object::Object;
 
 use self::llvm_ir::LLVMIR;
 use self::yul::Yul;

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

@@ -5,7 +5,7 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::parser::statement::object::Object;
+use revive_yul::parser::statement::object::Object;
 
 /// The contract Yul source code.
 #[derive(Debug, Serialize, Deserialize, Clone)]

crates/resolc/src/project/mod.rs

@@ -9,11 +9,14 @@ use std::path::Path;
 
 #[cfg(feature = "parallel")]
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
-use revive_solc_json_interface::SolcStandardJsonOutput;
 use serde::Deserialize;
 use serde::Serialize;
 use sha3::Digest;
 
+use revive_solc_json_interface::SolcStandardJsonOutput;
+use revive_yul::lexer::Lexer;
+use revive_yul::parser::statement::object::Object;
+
 use crate::build::contract::Contract as ContractBuild;
 use crate::build::Build;
 use crate::missing_libraries::MissingLibraries;
@@ -22,8 +25,6 @@ use crate::process::Process;
 use crate::project::contract::ir::IR;
 use crate::solc::version::Version as SolcVersion;
 use crate::solc::Compiler;
-use crate::yul::lexer::Lexer;
-use crate::yul::parser::statement::object::Object;
 
 use self::contract::Contract;
 

crates/resolc/src/resolc/main.rs

@@ -5,7 +5,7 @@ pub mod arguments;
 use std::io::Write;
 use std::str::FromStr;
 
-use revive_solidity::Process;
+use resolc::Process;
 
 use self::arguments::Arguments;
 
@@ -36,7 +36,7 @@ fn main_inner() -> anyhow::Result<()> {
             std::io::stdout(),
             "{} version {}",
             env!("CARGO_PKG_DESCRIPTION"),
-            revive_solidity::ResolcVersion::default().long
+            resolc::ResolcVersion::default().long
         )?;
         return Ok(());
     }
@@ -45,8 +45,8 @@ fn main_inner() -> anyhow::Result<()> {
         writeln!(
             std::io::stdout(),
             ">={},<={}",
-            revive_solidity::SolcFirstSupportedVersion,
+            resolc::SolcFirstSupportedVersion,
-            revive_solidity::SolcLastSupportedVersion,
+            resolc::SolcLastSupportedVersion,
         )?;
         return Ok(());
     }
@@ -71,20 +71,20 @@ fn main_inner() -> anyhow::Result<()> {
             let mut infile = std::fs::File::open(fname)?;
             #[cfg(target_os = "emscripten")]
             {
-                return revive_solidity::WorkerProcess::run(Some(&mut infile));
+                return resolc::WorkerProcess::run(Some(&mut infile));
             }
             #[cfg(not(target_os = "emscripten"))]
             {
-                return revive_solidity::NativeProcess::run(Some(&mut infile));
+                return resolc::NativeProcess::run(Some(&mut infile));
             }
         }
         #[cfg(target_os = "emscripten")]
         {
-            return revive_solidity::WorkerProcess::run(None);
+            return resolc::WorkerProcess::run(None);
         }
         #[cfg(not(target_os = "emscripten"))]
         {
-            return revive_solidity::NativeProcess::run(None);
+            return resolc::NativeProcess::run(None);
         }
     }
 
@@ -111,14 +111,16 @@ fn main_inner() -> anyhow::Result<()> {
     let mut solc = {
         #[cfg(target_os = "emscripten")]
         {
-            revive_solidity::SoljsonCompiler
+            resolc::SoljsonCompiler
         }
 
         #[cfg(not(target_os = "emscripten"))]
         {
-            revive_solidity::SolcCompiler::new(arguments.solc.unwrap_or_else(|| {
+            resolc::SolcCompiler::new(
-                revive_solidity::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()
+                arguments
-            }))?
+                    .solc
+                    .unwrap_or_else(|| resolc::SolcCompiler::DEFAULT_EXECUTABLE_NAME.to_owned()),
+            )?
         }
     };
 
@@ -158,7 +160,7 @@ fn main_inner() -> anyhow::Result<()> {
     }
 
     let build = if arguments.yul {
-        revive_solidity::yul(
+        resolc::yul(
             input_files.as_slice(),
             &mut solc,
             optimizer_settings,
@@ -168,7 +170,7 @@ fn main_inner() -> anyhow::Result<()> {
             memory_config,
         )
     } else if arguments.llvm_ir {
-        revive_solidity::llvm_ir(
+        resolc::llvm_ir(
             input_files.as_slice(),
             optimizer_settings,
             include_metadata_hash,
@@ -177,7 +179,7 @@ fn main_inner() -> anyhow::Result<()> {
             memory_config,
         )
     } else if arguments.standard_json {
-        revive_solidity::standard_json(
+        resolc::standard_json(
             &mut solc,
             arguments.detect_missing_libraries,
             arguments.base_path,
@@ -188,7 +190,7 @@ fn main_inner() -> anyhow::Result<()> {
         )?;
         return Ok(());
     } else if let Some(format) = arguments.combined_json {
-        revive_solidity::combined_json(
+        resolc::combined_json(
             format,
             input_files.as_slice(),
             arguments.libraries,
@@ -210,7 +212,7 @@ fn main_inner() -> anyhow::Result<()> {
         )?;
         return Ok(());
     } else {
-        revive_solidity::standard_output(
+        resolc::standard_output(
             input_files.as_slice(),
             arguments.libraries,
             &mut solc,

crates/runner/Cargo.toml

@@ -17,7 +17,7 @@ path = "src/main.rs"
 [features]
 std = ["polkadot-sdk/std"]
 default = ["solidity"]
-solidity = ["revive-solidity", "revive-differential", "revive-llvm-context"]
+solidity = ["resolc", "revive-differential", "revive-llvm-context"]
 
 [dependencies]
 env_logger = { workspace = true }
@@ -39,6 +39,6 @@ polkadot-sdk.features = [
     "pallet-timestamp"
 ]
 
-revive-solidity = { workspace = true, optional = true }
+resolc = { workspace = true, optional = true }
 revive-differential = { workspace = true, optional = true }
 revive-llvm-context = { workspace = true, optional = true }

crates/runner/src/lib.rs

@@ -44,7 +44,7 @@ pub use crate::specs::*;
 mod runtime;
 mod specs;
 
-#[cfg(not(feature = "revive-solidity"))]
+#[cfg(not(feature = "resolc"))]
 pub(crate) const NO_SOLIDITY_FRONTEND: &str =
     "revive-runner was built without the solidity frontend; please enable the 'solidity' feature!";
 
@@ -234,7 +234,7 @@ impl CallResult {
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub enum Code {
-    #[cfg(feature = "revive-solidity")]
+    #[cfg(feature = "resolc")]
     /// Compile a single solidity source and use the blob of `contract`
     Solidity {
         path: Option<std::path::PathBuf>,
@@ -270,7 +270,7 @@ impl From<Code> for pallet_revive::Code {
                 let Ok(source_code) = std::fs::read_to_string(&path) else {
                     panic!("Failed to reead source code from {}", path.display());
                 };
-                pallet_revive::Code::Upload(revive_solidity::test_utils::compile_blob_with_options(
+                pallet_revive::Code::Upload(resolc::test_utils::compile_blob_with_options(
                     &contract,
                     &source_code,
                     solc_optimizer.unwrap_or(true),

crates/runner/src/specs.rs

@@ -4,12 +4,12 @@ use serde::{Deserialize, Serialize};
 
 use crate::*;
 use alloy_primitives::keccak256;
-#[cfg(feature = "revive-solidity")]
+#[cfg(feature = "resolc")]
 use alloy_primitives::Address;
-#[cfg(feature = "revive-solidity")]
+#[cfg(feature = "resolc")]
+use resolc::test_utils::*;
+#[cfg(feature = "resolc")]
 use revive_differential::{Evm, EvmLog};
-#[cfg(feature = "revive-solidity")]
-use revive_solidity::test_utils::*;
 
 const SPEC_MARKER_BEGIN: &str = "/* runner.json";
 const SPEC_MARKER_END: &str = "*/";
@@ -256,7 +256,7 @@ impl Specs {
             };
 
             match code {
-                #[cfg(feature = "revive-solidity")]
+                #[cfg(feature = "resolc")]
                 Code::Bytes(bytes) if bytes.is_empty() => {
                     let contract_source = match std::fs::read_to_string(contract_path) {
                         Err(err) => panic!("unable to read {contract_path}: {err}"),
@@ -264,9 +264,9 @@ impl Specs {
                     };
                     *bytes = compile_blob(contract_name, &contract_source)
                 }
-                #[cfg(not(feature = "revive-solidity"))]
+                #[cfg(not(feature = "resolc"))]
                 Code::Bytes(_) => panic!("{NO_SOLIDITY_FRONTEND}"),
-                #[cfg(feature = "revive-solidity")]
+                #[cfg(feature = "resolc")]
                 Code::Solidity { path, .. } if path.is_none() => *path = Some(contract_path.into()),
                 _ => continue,
             }

crates/yul/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "revive-yul"
+description = "The revive YUL parser library."
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+inkwell = { workspace = true }
+num = { workspace = true }
+regex = { workspace = true }
+serde = { workspace = true }
+thiserror = { workspace = true }
+
+revive-common = { workspace = true }
+revive-llvm-context = { workspace = true }

crates/yul/src/error.rs

@@ -1,7 +1,7 @@
 //! The Yul IR error.
 
-use crate::yul::lexer::error::Error as LexerError;
+use crate::lexer::error::Error as LexerError;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
 
 /// The Yul IR error.
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]

crates/yul/src/lexer/error.rs

@@ -1,6 +1,6 @@
 //! The Yul IR lexer error.
 
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
 
 /// The Yul IR lexer error.
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]

crates/yul/src/lexer/mod.rs

@@ -42,6 +42,7 @@ impl Lexer {
     }
 
     /// Advances the lexer, returning the next lexeme.
+    #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Result<Token, Error> {
         if let Some(peeked) = self.peeked.take() {
             return Ok(peeked);

crates/yul/src/lexer/tests.rs

@@ -1,9 +1,9 @@
 //! The Yul IR lexer tests.
 
-use crate::yul::lexer::error::Error;
+use crate::lexer::error::Error;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
 
 #[test]
 fn default() {

crates/yul/src/lexer/token/lexeme/comment/mod.rs

@@ -3,7 +3,7 @@
 pub mod multi_line;
 pub mod single_line;
 
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 use self::multi_line::Comment as MultiLineComment;
 use self::single_line::Comment as SingleLineComment;

crates/yul/src/lexer/token/lexeme/comment/multi_line.rs

@@ -1,8 +1,8 @@
 //! The multi-line comment lexeme.
 
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The multi-line comment lexeme.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/comment/single_line.rs

@@ -1,8 +1,8 @@
 //! The single-line comment lexeme.
 
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The single-line comment lexeme.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/identifier.rs

@@ -1,9 +1,9 @@
 //! The identifier lexeme.
 
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The identifier lexeme.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/keyword.rs

@@ -1,10 +1,10 @@
 //! The keyword lexeme.
 
-use crate::yul::lexer::token::lexeme::literal::boolean::Boolean as BooleanLiteral;
+use crate::lexer::token::lexeme::literal::boolean::Boolean as BooleanLiteral;
-use crate::yul::lexer::token::lexeme::literal::Literal;
+use crate::lexer::token::lexeme::literal::Literal;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The keyword lexeme.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/literal/boolean.rs

@@ -3,7 +3,7 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
 
 /// The boolean literal lexeme.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/literal/integer.rs

@@ -3,10 +3,10 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::lexeme::Literal;
+use crate::lexer::token::lexeme::Literal;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The integer literal lexeme.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/literal/string.rs

@@ -3,10 +3,10 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::lexeme::Literal;
+use crate::lexer::token::lexeme::Literal;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The string literal lexeme.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]

crates/yul/src/lexer/token/lexeme/symbol.rs

@@ -1,8 +1,8 @@
 //! The symbol lexeme.
 
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
 
 /// The symbol lexeme.
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/yul/src/parser/error.rs

@@ -2,7 +2,7 @@
 
 use std::collections::BTreeSet;
 
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
 
 /// The Yul IR parser error.
 #[derive(Debug, thiserror::Error, PartialEq, Eq)]

crates/yul/src/parser/identifier.rs

@@ -3,13 +3,13 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::r#type::Type;
+use crate::parser::r#type::Type;
 
 /// The YUL source code identifier.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -50,7 +50,7 @@ impl Identifier {
 
         let mut expected_comma = false;
         loop {
-            let token = crate::yul::parser::take_or_next(initial.take(), lexer)?;
+            let token = crate::parser::take_or_next(initial.take(), lexer)?;
 
             match token {
                 Token {
@@ -81,7 +81,7 @@ impl Identifier {
 
         let mut expected_comma = false;
         loop {
-            let token = crate::yul::parser::take_or_next(initial.take(), lexer)?;
+            let token = crate::parser::take_or_next(initial.take(), lexer)?;
 
             match token {
                 Token {

crates/yul/src/parser/mod.rs

@@ -5,9 +5,9 @@ pub mod identifier;
 pub mod statement;
 pub mod r#type;
 
-use crate::yul::lexer::error::Error as LexerError;
+use crate::lexer::error::Error as LexerError;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
 
 /// Returns the `token` value if it is `Some(_)`, otherwise takes the next token from the `stream`.
 pub fn take_or_next(mut token: Option<Token>, lexer: &mut Lexer) -> Result<Token, LexerError> {

crates/yul/src/parser/statement/assignment.rs

@@ -6,15 +6,15 @@ use inkwell::types::BasicType;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::identifier::Identifier;
+use crate::parser::identifier::Identifier;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 /// The Yul assignment expression statement.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -30,7 +30,7 @@ pub struct Assignment {
 impl Assignment {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, identifier) = match token {
             Token {
@@ -75,7 +75,7 @@ impl Assignment {
                     Some(Token::new(location, Lexeme::Identifier(identifier), length)),
                 )?;
 
-                match crate::yul::parser::take_or_next(next, lexer)? {
+                match crate::parser::take_or_next(next, lexer)? {
                     Token {
                         lexeme: Lexeme::Symbol(Symbol::Assignment),
                         ..

crates/yul/src/parser/statement/block.rs

@@ -7,16 +7,16 @@ use serde::Serialize;
 
 use inkwell::debug_info::AsDIScope;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::assignment::Assignment;
+use crate::parser::statement::assignment::Assignment;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
-use crate::yul::parser::statement::Statement;
+use crate::parser::statement::Statement;
 
 /// The Yul source code block.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -30,7 +30,7 @@ pub struct Block {
 impl Block {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let mut statements = Vec::new();
 
@@ -53,7 +53,7 @@ impl Block {
         let mut remaining = None;
 
         loop {
-            match crate::yul::parser::take_or_next(remaining.take(), lexer)? {
+            match crate::parser::take_or_next(remaining.take(), lexer)? {
                 token @ Token {
                     lexeme: Lexeme::Keyword(_),
                     ..
@@ -221,10 +221,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_bracket_curly_left() {

crates/yul/src/parser/statement/code.rs

@@ -5,14 +5,14 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
 
 /// The YUL code entity, which is the first block of the object.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -26,7 +26,7 @@ pub struct Code {
 impl Code {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let location = match token {
             Token {
@@ -68,10 +68,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_code() {

crates/yul/src/parser/statement/expression/function_call/mod.rs

@@ -9,16 +9,16 @@ use inkwell::values::BasicValue;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::literal::Literal as LexicalLiteral;
+use crate::lexer::token::lexeme::literal::Literal as LexicalLiteral;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::expression::literal::Literal;
+use crate::parser::statement::expression::literal::Literal;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 use self::name::Name;
 
@@ -36,7 +36,7 @@ pub struct FunctionCall {
 impl FunctionCall {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, name) = match token {
             Token {

crates/yul/src/parser/statement/expression/function_call/verbatim.rs

@@ -1,6 +1,6 @@
 //! Translates the verbatim simulations.
 
-use crate::yul::parser::statement::expression::function_call::FunctionCall;
+use crate::parser::statement::expression::function_call::FunctionCall;
 
 /// Translates the verbatim simulations.
 pub fn verbatim<'ctx, D>(

crates/yul/src/parser/statement/expression/literal.rs

@@ -7,17 +7,17 @@ use num::Zero;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::literal::boolean::Boolean as BooleanLiteral;
+use crate::lexer::token::lexeme::literal::boolean::Boolean as BooleanLiteral;
-use crate::yul::lexer::token::lexeme::literal::integer::Integer as IntegerLiteral;
+use crate::lexer::token::lexeme::literal::integer::Integer as IntegerLiteral;
-use crate::yul::lexer::token::lexeme::literal::Literal as LexicalLiteral;
+use crate::lexer::token::lexeme::literal::Literal as LexicalLiteral;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::r#type::Type;
+use crate::parser::r#type::Type;
 
 /// Represents a literal in YUL without differentiating its type.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -33,7 +33,7 @@ pub struct Literal {
 impl Literal {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, literal) = match token {
             Token {

crates/yul/src/parser/statement/expression/mod.rs

@@ -8,14 +8,14 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::identifier::Identifier;
+use crate::parser::identifier::Identifier;
 
 use self::function_call::FunctionCall;
 use self::literal::Literal;
@@ -34,7 +34,7 @@ pub enum Expression {
 impl Expression {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, identifier) = match token {
             Token {

crates/yul/src/parser/statement/for_loop.rs

@@ -5,12 +5,12 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 /// The Yul for-loop statement.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -30,7 +30,7 @@ pub struct ForLoop {
 impl ForLoop {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
         let location = token.location;
 
         let initializer = Block::parse(lexer, Some(token))?;

crates/yul/src/parser/statement/function_definition.rs

@@ -8,16 +8,16 @@ use inkwell::types::BasicType;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::identifier::Identifier;
+use crate::parser::identifier::Identifier;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
-use crate::yul::parser::statement::expression::function_call::name::Name as FunctionName;
+use crate::parser::statement::expression::function_call::name::Name as FunctionName;
 
 /// The function definition statement.
 /// All functions are translated in two steps:
@@ -48,7 +48,7 @@ impl FunctionDefinition {
 
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, identifier) = match token {
             Token {
@@ -94,7 +94,7 @@ impl FunctionDefinition {
         }
 
         let (arguments, next) = Identifier::parse_typed_list(lexer, None)?;
-        match crate::yul::parser::take_or_next(next, lexer)? {
+        match crate::parser::take_or_next(next, lexer)? {
             Token {
                 lexeme: Lexeme::Symbol(Symbol::ParenthesisRight),
                 ..
@@ -328,10 +328,10 @@ where
 mod tests {
     use std::collections::BTreeSet;
 
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_identifier() {

crates/yul/src/parser/statement/if_conditional.rs

@@ -5,12 +5,12 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 /// The Yul if-conditional statement.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -26,7 +26,7 @@ pub struct IfConditional {
 impl IfConditional {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
         let location = token.location;
 
         let condition = Expression::parse(lexer, Some(token))?;

crates/yul/src/parser/statement/mod.rs

@@ -16,13 +16,13 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
 
 use self::assignment::Assignment;
 use self::block::Block;
@@ -72,7 +72,7 @@ impl Statement {
         lexer: &mut Lexer,
         initial: Option<Token>,
     ) -> Result<(Self, Option<Token>), Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         match token {
             token @ Token {

crates/yul/src/parser/statement/object.rs

@@ -7,16 +7,16 @@ use inkwell::debug_info::AsDIScope;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::literal::Literal;
+use crate::lexer::token::lexeme::literal::Literal;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::code::Code;
+use crate::parser::statement::code::Code;
 
 /// The upper-level YUL object, representing the deploy code.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -38,7 +38,7 @@ pub struct Object {
 impl Object {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let location = match token {
             Token {
@@ -299,10 +299,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_object() {

crates/yul/src/parser/statement/switch/case.rs

@@ -5,14 +5,14 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
-use crate::yul::parser::statement::expression::literal::Literal;
+use crate::parser::statement::expression::literal::Literal;
 
 /// The Yul switch statement case.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -28,7 +28,7 @@ pub struct Case {
 impl Case {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         let (location, literal) = match token {
             token @ Token {
@@ -63,10 +63,10 @@ impl Case {
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_literal() {

crates/yul/src/parser/statement/switch/mod.rs

@@ -7,15 +7,15 @@ use std::collections::HashSet;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::statement::block::Block;
+use crate::parser::statement::block::Block;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 use self::case::Case;
 
@@ -45,7 +45,7 @@ pub enum State {
 impl Switch {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let mut token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let mut token = crate::parser::take_or_next(initial, lexer)?;
         let location = token.location;
         let mut state = State::CaseOrDefaultKeyword;
 
@@ -177,10 +177,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_invalid_token_case() {

crates/yul/src/parser/statement/variable_declaration.rs

@@ -7,16 +7,16 @@ use inkwell::values::BasicValue;
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::symbol::Symbol;
+use crate::lexer::token::lexeme::symbol::Symbol;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::location::Location;
+use crate::lexer::token::location::Location;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
-use crate::yul::parser::identifier::Identifier;
+use crate::parser::identifier::Identifier;
-use crate::yul::parser::statement::expression::function_call::name::Name as FunctionName;
+use crate::parser::statement::expression::function_call::name::Name as FunctionName;
-use crate::yul::parser::statement::expression::Expression;
+use crate::parser::statement::expression::Expression;
 
 /// The Yul variable declaration statement.
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -35,7 +35,7 @@ impl VariableDeclaration {
         lexer: &mut Lexer,
         initial: Option<Token>,
     ) -> Result<(Self, Option<Token>), Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
         let location = token.location;
 
         let (bindings, next) = Identifier::parse_typed_list(lexer, Some(token))?;
@@ -52,7 +52,7 @@ impl VariableDeclaration {
             }
         }
 
-        match crate::yul::parser::take_or_next(next, lexer)? {
+        match crate::parser::take_or_next(next, lexer)? {
             Token {
                 lexeme: Lexeme::Symbol(Symbol::Assignment),
                 ..
@@ -220,10 +220,10 @@ where
 
 #[cfg(test)]
 mod tests {
-    use crate::yul::lexer::token::location::Location;
+    use crate::lexer::token::location::Location;
-    use crate::yul::lexer::Lexer;
+    use crate::lexer::Lexer;
-    use crate::yul::parser::error::Error;
+    use crate::parser::error::Error;
-    use crate::yul::parser::statement::object::Object;
+    use crate::parser::statement::object::Object;
 
     #[test]
     fn error_reserved_identifier() {

crates/yul/src/parser/type.rs

@@ -3,12 +3,12 @@
 use serde::Deserialize;
 use serde::Serialize;
 
-use crate::yul::error::Error;
+use crate::error::Error;
-use crate::yul::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::keyword::Keyword;
-use crate::yul::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::lexeme::Lexeme;
-use crate::yul::lexer::token::Token;
+use crate::lexer::token::Token;
-use crate::yul::lexer::Lexer;
+use crate::lexer::Lexer;
-use crate::yul::parser::error::Error as ParserError;
+use crate::parser::error::Error as ParserError;
 
 /// The YUL source code type.
 /// The type is not currently in use, so all values have the `uint256` type by default.
@@ -33,7 +33,7 @@ impl Default for Type {
 impl Type {
     /// The element parser.
     pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
-        let token = crate::yul::parser::take_or_next(initial, lexer)?;
+        let token = crate::parser::take_or_next(initial, lexer)?;
 
         match token {
             Token {