The new Yul optimizer toolkit (#519)

This PR introduces powerful code size optimizations. This is achieved
with an additional IR layer in between Yul and LLVM IR. It works quite
well (see below for a comparison) because it captures optimization gains
that neither solc nor LLVM can realize.

The feature is gated behind `--newyork` or a corresponding standard JSON
input setting and **off by default**.

### How it works

We implemented an SSA IR modelled after or inspired by the [MLIR SCF
dialect](https://mlir.llvm.org/docs/Dialects/SCFDialect/). Yul is
translated into this IR and the IR implements mainly the following
optimizations:

- **Type narrowing**: narrows 256-bit values to I1..I160 where provable
(bidirectional + interprocedural), so LLVM emits native 32/64-bit ops
instead
    of software 256-bit arithmetic.
- **FMP range proof**: exposes the `mload(0x40) < heap_size` bound to
LLVM
IPSCCP, eliminating trailing overflow checks on FMP-derived offsets.
Single
    largest code-size contributor.
- **Heap analysis**: skips big-endian byte-swaps where native
little-endian
    layout is safe.
  - **mem_opt / keccak fusion+folding**, **compound outlining** (mapping
sload/sstore), **guard narrowing**, **inlining** tuned for PolkaVM, and
    **exact + fuzzy function dedup**.

### Results
The optimizations implemented with the newyork IR bring substantial code
size improvements.
  - Integration contracts: approximately **-20% to -50%** code size.
  - OpenZeppelin Wizard corpus: around **-47%** code size.

This table shows the code size improvements on various OpenZeppelin ERC
implementations, taken from their [contracts
wizard](https://wizard.openzeppelin.com/), with almost all features
enabled.

| Contract | Default: (bytes) | With `--newyork`: (bytes) | Reduction |
|---|---:|---:|---:|
| erc1155 | 59,206 | 30,649 | -48.2% |
| erc20 | 81,697 | 42,893 | -47.5% |
| erc721 | 92,052 | 49,423 | -46.3% |
| oz_gov | 141,861 | 81,159 | -42.8% |
| oz_rwa | 77,274 | 37,975 | -50.9% |
| oz_simple_erc20 | 29,950 | 16,554 | -44.7% |
| oz_stable | 82,117 | 39,032 | -52.5% |
| **Total** | **564,157** | **297,685** | **-47.2%** |

We believe this to be a reasonably representative dataset and conclude
that the newyork IR achieves drastic code size reductions on real world
dApp implementations.

### Methodology, security and runtime performance

Since the main contributors to these improvements are the FMP range
proofs and the type narrowing, we don't expect big runtime performance
regressions (it may even benefit runtime performance in some cases).

The PR also includes docs
(`book/src/developer_guide/newyork_{optimizer,ir}.md`) and many new
integration tests, including regression tests for known FMP soundness
traps.

The PR was authored collaboratively and reviewed extensively by the
`revive` maintainers, as well as Claude Opus, Claude Fable, Qwen,
Minimax and Deepseek LLMs, over a span of many months.

The `newyork` compiler pipeline introduces no new regressions over our
integration and differential test suites (containing over 30000 test
cases). This was achieved by careful manual reviews and many LLM bughunt
loops. Additionally, a final security review by Anthropic's Fable 5 LLM
found no remaining soundness issues. Nonetheless, like any brand new
software, please consider this an experimental feature upon release.

---------

Signed-off-by: xermicus <bigcyrill@hotmail.com>
Signed-off-by: xermicus <cyrill@parity.io>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: neo <me@90f9.org>
Co-authored-by: LJ <81748770+elle-j@users.noreply.github.com>

crates/common/src/extension.rs

@@ -12,6 +12,9 @@ pub static EXTENSION_ABI: &str = "abi";
 /// The Yul IR file extension.
 pub static EXTENSION_YUL: &str = "yul";
 
+/// The newyork IR debug dump file extension.
+pub static EXTENSION_NEWYORK: &str = "newyork";
+
 /// The EVM file extension.
 pub static EXTENSION_EVM: &str = "evm";
 

crates/common/src/lib.rs

@@ -10,6 +10,7 @@ pub(crate) mod extension;
 pub(crate) mod keccak256;
 pub(crate) mod metadata;
 pub(crate) mod object;
+pub(crate) mod solidity_selector;
 pub(crate) mod utils;
 
 pub use self::base::*;
@@ -21,5 +22,6 @@ pub use self::extension::*;
 pub use self::keccak256::*;
 pub use self::metadata::*;
 pub use self::object::*;
+pub use self::solidity_selector::*;
 pub use self::utils::*;
 pub use contract_identifier::*;

crates/common/src/solidity_selector.rs

@@ -0,0 +1,22 @@
+//! Solidity ABI selector words used when emitting reverts.
+//!
+//! Each constant is the 32-byte EVM memory word that stores the corresponding
+//! Solidity selector at memory offset 0. The 4-byte selector occupies the
+//! high-order bytes (memory addresses 0..4) and the remaining 28 bytes are
+//! zero. The hex strings are consumed verbatim by 256-bit integer constructors
+//! such as `Context::word_const_str_hex`, so the selector ends up in the most
+//! significant bits of the resulting `i256`.
+
+/// 32-byte EVM word holding the Solidity `Panic(uint256)` ABI selector.
+///
+/// `keccak256("Panic(uint256)")[..4] == 0x4e487b71`, placed in the high-order
+/// bytes of a 32-byte word followed by 28 zero bytes.
+pub const PANIC_UINT256_SELECTOR_WORD_HEX: &str =
+    "4e487b7100000000000000000000000000000000000000000000000000000000";
+
+/// 32-byte EVM word holding the Solidity `Error(string)` ABI selector.
+///
+/// `keccak256("Error(string)")[..4] == 0x08c379a0`, placed in the high-order
+/// bytes of a 32-byte word followed by 28 zero bytes.
+pub const ERROR_STRING_SELECTOR_WORD_HEX: &str =
+    "08c379a000000000000000000000000000000000000000000000000000000000";