refactor(slang): resolve member access via BuiltIn variants

Match on slang's resolved BuiltIn variants (TxOrigin, MsgSender, etc.)
instead of string-matching member names against namespace built-ins.

Author: hedgar2017

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

@@ -7,6 +7,7 @@ pub mod type_conversion;
 use melior::ir::BlockRef;
 use melior::ir::Value;
 use melior::ir::ValueLike;
+use slang_solidity::backend::built_ins::BuiltIn;
 use slang_solidity::backend::ir::ast::ArgumentsDeclaration;
 use slang_solidity::backend::ir::ast::ElementaryType;
 use slang_solidity::backend::ir::ast::Expression;
@@ -153,38 +154,36 @@ impl<'emitter, 'state, 'context, 'block> CallEmitter<'emitter, 'state, 'context,
 
     /// Emits a member access expression (e.g. `tx.origin`, `msg.sender`).
     ///
+    /// Resolves the member via slang's binder to a specific `BuiltIn` variant
+    /// rather than string-matching the member name.
+    ///
     /// # Errors
     ///
     /// Returns an error if the member access is not a recognized EVM intrinsic.
     pub fn emit_member_access(
         &self,
-        operand: &Expression,
-        member: &str,
+        member_identifier: &slang_solidity::backend::ir::ast::Identifier,
         block: BlockRef<'context, 'block>,
     ) -> anyhow::Result<(Value<'context, 'block>, BlockRef<'context, 'block>)> {
-        if let Expression::Identifier(identifier) = operand {
-            let object = identifier.name();
-            let intrinsic = match (object.as_str(), member) {
-                ("tx", "origin") => solx_mlir::Builder::SOL_ORIGIN,
-                ("tx", "gasprice") => solx_mlir::Builder::SOL_GASPRICE,
-                ("msg", "sender") => solx_mlir::Builder::SOL_CALLER,
-                ("msg", "value") => solx_mlir::Builder::SOL_CALLVALUE,
-                ("block", "timestamp") => solx_mlir::Builder::SOL_TIMESTAMP,
-                ("block", "number") => solx_mlir::Builder::SOL_BLOCKNUMBER,
-                ("block", "coinbase") => solx_mlir::Builder::SOL_COINBASE,
-                ("block", "chainid") => solx_mlir::Builder::SOL_CHAINID,
-                ("block", "basefee") => solx_mlir::Builder::SOL_BASEFEE,
-                ("block", "gaslimit") => solx_mlir::Builder::SOL_GASLIMIT,
-                _ => anyhow::bail!("unsupported member access: {object}.{member}"),
-            };
-            let value = self
-                .expression_emitter
-                .state
-                .builder
-                .emit_sol_intrinsic(intrinsic, &block);
-            return Ok((value, block));
-        }
-        anyhow::bail!("unsupported member access on non-identifier operand")
+        let intrinsic = match member_identifier.resolved_built_in() {
+            Some(BuiltIn::TxOrigin) => solx_mlir::Builder::SOL_ORIGIN,
+            Some(BuiltIn::TxGasPrice) => solx_mlir::Builder::SOL_GASPRICE,
+            Some(BuiltIn::MsgSender) => solx_mlir::Builder::SOL_CALLER,
+            Some(BuiltIn::MsgValue) => solx_mlir::Builder::SOL_CALLVALUE,
+            Some(BuiltIn::BlockTimestamp) => solx_mlir::Builder::SOL_TIMESTAMP,
+            Some(BuiltIn::BlockNumber) => solx_mlir::Builder::SOL_BLOCKNUMBER,
+            Some(BuiltIn::BlockCoinbase) => solx_mlir::Builder::SOL_COINBASE,
+            Some(BuiltIn::BlockChainid) => solx_mlir::Builder::SOL_CHAINID,
+            Some(BuiltIn::BlockBasefee) => solx_mlir::Builder::SOL_BASEFEE,
+            Some(BuiltIn::BlockGaslimit) => solx_mlir::Builder::SOL_GASLIMIT,
+            _ => anyhow::bail!("unsupported member access: {}", member_identifier.name()),
+        };
+        let value = self
+            .expression_emitter
+            .state
+            .builder
+            .emit_sol_intrinsic(intrinsic, &block);
+        Ok((value, block))
     }
 
     /// Emits a `require(condition)` built-in via `sol.require`.

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

@@ -253,10 +253,9 @@ impl<'state, 'context, 'block> ExpressionEmitter<'state, 'context, 'block> {
                 self::call::CallEmitter::new(self).emit_function_call(call, block)
             }
             Expression::MemberAccessExpression(access) => {
-                let operand = access.operand();
-                let member = access.member().name();
+                let member = access.member();
                 self::call::CallEmitter::new(self)
-                    .emit_member_access(&operand, &member, block)
+                    .emit_member_access(&member, block)
                     .map(|(value, block)| (Some(value), block))
             }
             Expression::TupleExpression(tuple) => {