feat(slang): lower additional EVM intrinsics

Wire up `block.blobbasefee`, `block.difficulty`, `block.prevrandao`,
`address.balance`, and `address.codehash` member accesses to their Sol
dialect ops. The address-base intrinsics evaluate the operand
expression and emit `sol.balance` / `sol.code_hash` with the resulting
address value.

Author: hedgar2017

solx-slang/src/ast/contract/function/expression/call/mod.rs

@@ -11,15 +11,21 @@ use slang_solidity::backend::built_ins::BuiltIn;
 use slang_solidity::backend::ir::ast::ArgumentsDeclaration;
 use slang_solidity::backend::ir::ast::Expression;
 use slang_solidity::backend::ir::ast::FunctionCallExpression;
+use slang_solidity::backend::ir::ast::MemberAccessExpression;
+use solx_mlir::ods::sol::BalanceOperation;
 use solx_mlir::ods::sol::BaseFeeOperation;
+use solx_mlir::ods::sol::BlobBaseFeeOperation;
 use solx_mlir::ods::sol::BlockNumberOperation;
 use solx_mlir::ods::sol::CallValueOperation;
 use solx_mlir::ods::sol::CallerOperation;
 use solx_mlir::ods::sol::ChainIdOperation;
+use solx_mlir::ods::sol::CodeHashOperation;
 use solx_mlir::ods::sol::CoinbaseOperation;
+use solx_mlir::ods::sol::DifficultyOperation;
 use solx_mlir::ods::sol::GasLimitOperation;
 use solx_mlir::ods::sol::GasPriceOperation;
 use solx_mlir::ods::sol::OriginOperation;
+use solx_mlir::ods::sol::PrevRandaoOperation;
 use solx_mlir::ods::sol::TimestampOperation;
 
 use crate::ast::contract::function::expression::ExpressionEmitter;
@@ -172,15 +178,51 @@ impl<'emitter, 'state, 'context, 'block> CallEmitter<'emitter, 'state, 'context,
     /// Returns an error if the member access is not a recognized EVM intrinsic.
     pub fn emit_member_access(
         &self,
-        member_identifier: &slang_solidity::backend::ir::ast::Identifier,
+        access: &MemberAccessExpression,
         block: BlockRef<'context, 'block>,
     ) -> anyhow::Result<(Value<'context, 'block>, BlockRef<'context, 'block>)> {
+        let member_identifier = access.member();
         let builder = &self.expression_emitter.state.builder;
         let context = builder.context;
         let location = builder.unknown_location;
         let address_type = builder.types.sol_address;
         let ui256_type = builder.types.ui256;
-        let operation = match member_identifier.resolved_built_in() {
+        let resolved_built_in = member_identifier.resolved_built_in();
+        if let Some(BuiltIn::AddressBalance) = resolved_built_in {
+            let operand = access.operand();
+            let (address_value, current_block) =
+                self.expression_emitter.emit_value(&operand, block)?;
+            let value = current_block
+                .append_operation(
+                    BalanceOperation::builder(context, location)
+                        .cont_addr(address_value)
+                        .out(ui256_type)
+                        .build()
+                        .into(),
+                )
+                .result(0)
+                .expect("sol.balance always produces one result")
+                .into();
+            return Ok((value, current_block));
+        }
+        if let Some(BuiltIn::AddressCodehash) = resolved_built_in {
+            let operand = access.operand();
+            let (address_value, current_block) =
+                self.expression_emitter.emit_value(&operand, block)?;
+            let value = current_block
+                .append_operation(
+                    CodeHashOperation::builder(context, location)
+                        .cont_addr(address_value)
+                        .out(ui256_type)
+                        .build()
+                        .into(),
+                )
+                .result(0)
+                .expect("sol.code_hash always produces one result")
+                .into();
+            return Ok((value, current_block));
+        }
+        let operation = match resolved_built_in {
             Some(BuiltIn::TxOrigin) => OriginOperation::builder(context, location)
                 .addr(address_type)
                 .build()
@@ -221,6 +263,18 @@ impl<'emitter, 'state, 'context, 'block> CallEmitter<'emitter, 'state, 'context,
                 .val(ui256_type)
                 .build()
                 .into(),
+            Some(BuiltIn::BlockBlobbasefee) => BlobBaseFeeOperation::builder(context, location)
+                .val(ui256_type)
+                .build()
+                .into(),
+            Some(BuiltIn::BlockDifficulty) => DifficultyOperation::builder(context, location)
+                .val(ui256_type)
+                .build()
+                .into(),
+            Some(BuiltIn::BlockPrevrandao) => PrevRandaoOperation::builder(context, location)
+                .val(ui256_type)
+                .build()
+                .into(),
             _ => anyhow::bail!("unsupported member access: {}", member_identifier.name()),
         };
         let value = block

solx-slang/src/ast/contract/function/expression/mod.rs

@@ -289,12 +289,9 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
             Expression::FunctionCallExpression(call) => {
                 self::call::CallEmitter::new(self).emit_function_call(call, block)
             }
-            Expression::MemberAccessExpression(access) => {
-                let member = access.member();
-                self::call::CallEmitter::new(self)
-                    .emit_member_access(&member, block)
-                    .map(|(value, block)| (Some(value), block))
-            }
+            Expression::MemberAccessExpression(access) => self::call::CallEmitter::new(self)
+                .emit_member_access(access, block)
+                .map(|(value, block)| (Some(value), block)),
             Expression::TupleExpression(tuple) => {
                 let items = tuple.items();
                 // TODO: support multi-value tuples (e.g. tuple deconstruction)