resolc crate (#328)

- Factor the YUL crate out of `revive-solidity`.
- `revive-solidity` is in reality not a Solidity implementation but the
revive solidity compiler driver (`resolc`). By renaming we not only get
this straight but also a binary with the same name as the crate which
should be less confusing.

---------

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: |

Cargo.lock

@@ -8358,6 +8358,31 @@ dependencies = [
  "windows-registry",
 ]
 
+[[package]]
+name = "resolc"
+version = "0.1.0-dev.16"
+dependencies = [
+ "anyhow",
+ "clap",
+ "git2",
+ "hex",
+ "inkwell",
+ "libc",
+ "mimalloc",
+ "once_cell",
+ "path-slash",
+ "rayon",
+ "revive-common",
+ "revive-llvm-context",
+ "revive-solc-json-interface",
+ "revive-yul",
+ "semver 1.0.26",
+ "serde",
+ "serde_json",
+ "sha3",
+ "which",
+]
+
 [[package]]
 name = "revive-benchmarks"
 version = "0.1.0-dev.16"
@@ -8412,9 +8437,9 @@ dependencies = [
  "alloy-sol-types",
  "hex",
  "rayon",
+ "resolc",
  "revive-llvm-context",
  "revive-runner",
- "revive-solidity",
  "serde",
  "serde_json",
  "sha1",
@@ -8487,9 +8512,9 @@ dependencies = [
  "hex",
  "parity-scale-codec",
  "polkadot-sdk 2503.0.1",
+ "resolc",
  "revive-differential",
  "revive-llvm-context",
- "revive-solidity",
  "scale-info",
  "serde",
  "serde_json",
@@ -8517,33 +8542,6 @@ dependencies = [
  "serde_json",
 ]
 
-[[package]]
-name = "revive-solidity"
-version = "0.1.0-dev.16"
-dependencies = [
- "anyhow",
- "clap",
- "git2",
- "hex",
- "inkwell",
- "libc",
- "mimalloc",
- "num",
- "once_cell",
- "path-slash",
- "rayon",
- "regex",
- "revive-common",
- "revive-llvm-context",
- "revive-solc-json-interface",
- "semver 1.0.26",
- "serde",
- "serde_json",
- "sha3",
- "thiserror 2.0.12",
- "which",
-]
-
 [[package]]
 name = "revive-stdlib"
 version = "0.1.0-dev.16"
@@ -8552,6 +8550,20 @@ dependencies = [
  "revive-build-utils",
 ]
 
+[[package]]
+name = "revive-yul"
+version = "0.1.0-dev.16"
+dependencies = [
+ "anyhow",
+ "inkwell",
+ "num",
+ "regex",
+ "revive-common",
+ "revive-llvm-context",
+ "serde",
+ "thiserror 2.0.12",
+]
+
 [[package]]
 name = "rfc6979"
 version = "0.4.0"

Cargo.toml

@@ -14,6 +14,7 @@ repository = "https://github.com/paritytech/revive"
 rust-version = "1.85.0"
 
 [workspace.dependencies]
+resolc  = { version = "0.1.0-dev.16", path = "crates/resolc" }
 revive-benchmarks = { version = "0.1.0-dev.16", path = "crates/benchmarks" }
 revive-builtins = { version = "0.1.0-dev.16", path = "crates/builtins" }
 revive-common = { version = "0.1.0-dev.16", path = "crates/common" }
@@ -25,9 +26,9 @@ revive-llvm-context = { version = "0.1.0-dev.16", path = "crates/llvm-context" }
 revive-runtime-api = { version = "0.1.0-dev.16", path = "crates/runtime-api" }
 revive-runner = { version = "0.1.0-dev.16", path = "crates/runner" }
 revive-solc-json-interface = { version = "0.1.0-dev.16", path = "crates/solc-json-interface" }
-revive-solidity = { version = "0.1.0-dev.16", path = "crates/solidity" }
 revive-stdlib = { version = "0.1.0-dev.16", path = "crates/stdlib" }
 revive-build-utils = { version = "0.1.0-dev.16", path = "crates/build-utils" }
+revive-yul = { version = "0.1.0-dev.16", path = "crates/yul" }
 
 hex = "0.4.3"
 cc = "1.2"

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 ;

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 {

package.json

@@ -2,14 +2,14 @@
   "name": "root",
   "private": true,
   "scripts": {
-    "test:cli": "npm run test -w crates/solidity/src/tests/cli-tests",
+    "test:cli": "npm run test -w crates/resolc/src/tests/cli-tests",
     "test:wasm": "npm run test:node -w js/emscripten",
     "build:package": "npm run build:package -w js/emscripten",
     "lint": "npx eslint 'js/**/*.{cjs,mjs,ts}' && npx prettier --check '**/*.{mjs,cjs,ts}'",
     "lint:fix": "npx prettier --write '**/*.{mjs,cjs,ts}'"
   },
   "workspaces": [
-    "crates/solidity/src/tests/cli-tests",
+    "crates/resolc/src/tests/cli-tests",
     "js/emscripten",
     "js/resolc"
   ],