Optimization: type-aware recv codegen, zero-copy views, #[abi] structs

crates/common/src/diagnostics.rs

@@ -187,6 +187,7 @@ pub enum DiagnosticPass {
     MsgLower,
     EventLower,
     ErrorLower,
+    AbiStructLower,
     ArithmeticAttr,
     PayableAttr,
 
@@ -215,6 +216,7 @@ impl DiagnosticPass {
             Self::MsgLower => 9,
             Self::EventLower => 10,
             Self::ErrorLower => 16,
+            Self::AbiStructLower => 17,
             Self::ArithmeticAttr => 12,
             Self::PayableAttr => 13,
             Self::InlineAttr => 14,

crates/fe/src/abi.rs

@@ -680,6 +680,20 @@ fn semantic_ty_to_abi_desc(db: &DriverDataBase, ty: TyId<'_>) -> Result<AbiTypeD
         return Ok(AbiTypeDesc::simple("bytes"));
     }
 
+    if let Some((elem_ty, len_ty)) = core_unbound_array_view_parts(db, ty) {
+        let elem_desc = semantic_ty_to_abi_desc(db, elem_ty)?;
+        let len = array_len_to_string(db, len_ty)?;
+        return Ok(elem_desc.array(&len));
+    }
+
+    if is_core_unbound_bytes_view_ty(db, ty) {
+        return Ok(AbiTypeDesc::simple("bytes"));
+    }
+
+    if is_core_unbound_string_view_ty(db, ty) {
+        return Ok(AbiTypeDesc::simple("string"));
+    }
+
     if ty.is_string(db) {
         return Ok(AbiTypeDesc::simple("string"));
     }
@@ -806,6 +820,37 @@ fn core_dyn_array_elem_ty<'db>(db: &'db DriverDataBase, ty: TyId<'db>) -> Option
     args.first().copied()
 }
 
+/// Recognise an unbound `core::abi::ArrayView<T, N>` (I defaulted to `()`)
+/// and return `(elem_ty, len_ty)`.
+fn core_unbound_array_view_parts<'db>(
+    db: &'db DriverDataBase,
+    ty: TyId<'db>,
+) -> Option<(TyId<'db>, TyId<'db>)> {
+    if let Some((_, inner)) = ty.as_capability(db) {
+        return core_unbound_array_view_parts(db, inner);
+    }
+
+    let (base, args) = ty.decompose_ty_app(db);
+    let TyData::TyBase(TyBase::Adt(adt)) = base.data(db) else {
+        return None;
+    };
+    let adt_ref = adt.adt_ref(db);
+    let name = adt_ref.name(db)?;
+    if name.data(db) != "ArrayView" {
+        return None;
+    }
+    if !base
+        .ingot(db)
+        .is_some_and(|ingot| ingot.kind(db) == IngotKind::Core)
+    {
+        return None;
+    }
+
+    let elem_ty = args.first().copied()?;
+    let len_ty = args.get(1).copied()?;
+    Some((elem_ty, len_ty))
+}
+
 fn is_core_bytes_ty(db: &DriverDataBase, ty: TyId<'_>) -> bool {
     if let Some((_, inner)) = ty.as_capability(db) {
         return is_core_bytes_ty(db, inner);
@@ -848,6 +893,50 @@ fn is_core_dyn_string_ty(db: &DriverDataBase, ty: TyId<'_>) -> bool {
         .is_some_and(|ingot| ingot.kind(db) == IngotKind::Core)
 }
 
+/// Recognise an unbound `core::abi::BytesView` (I defaulted to `()`).
+fn is_core_unbound_bytes_view_ty(db: &DriverDataBase, ty: TyId<'_>) -> bool {
+    if let Some((_, inner)) = ty.as_capability(db) {
+        return is_core_unbound_bytes_view_ty(db, inner);
+    }
+
+    let base = ty.base_ty(db);
+    let TyData::TyBase(TyBase::Adt(adt)) = base.data(db) else {
+        return false;
+    };
+    let adt_ref = adt.adt_ref(db);
+    let Some(name) = adt_ref.name(db) else {
+        return false;
+    };
+    if name.data(db) != "BytesView" {
+        return false;
+    }
+
+    base.ingot(db)
+        .is_some_and(|ingot| ingot.kind(db) == IngotKind::Core)
+}
+
+/// Recognise an unbound `core::abi::StringView` (I defaulted to `()`).
+fn is_core_unbound_string_view_ty(db: &DriverDataBase, ty: TyId<'_>) -> bool {
+    if let Some((_, inner)) = ty.as_capability(db) {
+        return is_core_unbound_string_view_ty(db, inner);
+    }
+
+    let base = ty.base_ty(db);
+    let TyData::TyBase(TyBase::Adt(adt)) = base.data(db) else {
+        return false;
+    };
+    let adt_ref = adt.adt_ref(db);
+    let Some(name) = adt_ref.name(db) else {
+        return false;
+    };
+    if name.data(db) != "StringView" {
+        return false;
+    }
+
+    base.ingot(db)
+        .is_some_and(|ingot| ingot.kind(db) == IngotKind::Core)
+}
+
 /// Recognise `std::abi::sol` SolCompat wrapper types like `Uint160` / `Int24`
 /// and return their Solidity ABI type string (e.g. `"uint160"`, `"int24"`).
 fn std_sol_compat_abi_type(

crates/fe/tests/fixtures/fe_test/abi_dynamic_payload_view.fe

@@ -0,0 +1,94 @@
+use std::abi::DynString
+use std::evm::{Evm, encode_abi_payload, mem}
+use core::abi::BytesView
+use std::evm::CallData
+
+/// Test that BytesView (unbound) works as a msg field type for zero-copy
+/// bytes decoding. The handler receives BytesView<()> and binds it to
+/// CallData for zero-copy access.
+///
+/// Uses the same ABI encoding as Bytes, but the receiver decodes without
+/// copying the bytes payload to memory.
+
+msg DynamicPayloadViewMsg {
+    #[selector = 0x02]
+    Check { first: BytesView, marker: u256, second: BytesView } -> u256,
+}
+
+pub contract DynamicPayloadViewReceiver {
+    recv DynamicPayloadViewMsg {
+        Check { first, marker, second } -> u256 {
+            assert(marker == 0xabcdef)
+            assert(first.len == 33)
+            assert(second.len == 1)
+            first.len + second.len
+        }
+    }
+}
+
+/// Test the contract by sending raw ABI-encoded calldata that matches
+/// the Bytes encoding (since BytesView uses the same wire format).
+/// We reuse the DynamicPayloadReceiver from the existing test to
+/// produce the calldata, then call our contract with it.
+
+msg OriginalMsg {
+    #[selector = 0x02]
+    Check { first: Bytes, marker: u256, second: Bytes } -> u256,
+}
+
+fn two_word_bytes() -> Bytes
+uses (evm: mut Evm)
+{
+    let payload_len: u256 = 33
+    let payload_size: u256 = 96
+    let data_ptr = mem::alloc(payload_size)
+
+    evm.mstore(addr: data_ptr, value: payload_len)
+    evm.mstore(
+        addr: data_ptr + 32,
+        value: 0x1111111111111111111111111111111111111111111111111111111111111111,
+    )
+    evm.mstore(
+        addr: data_ptr + 64,
+        value: 0x2200000000000000000000000000000000000000000000000000000000000000,
+    )
+
+    Bytes { data: data_ptr, len: payload_len, size: payload_size }
+}
+
+fn one_byte_bytes() -> Bytes
+uses (evm: mut Evm)
+{
+    let payload_len: u256 = 1
+    let payload_size: u256 = 64
+    let data_ptr = mem::alloc(payload_size)
+
+    evm.mstore(addr: data_ptr, value: payload_len)
+    evm.mstore(
+        addr: data_ptr + 32,
+        value: 0x3300000000000000000000000000000000000000000000000000000000000000,
+    )
+
+    Bytes { data: data_ptr, len: payload_len, size: payload_size }
+}
+
+#[test]
+fn test_msg_dynamic_payload_view_decoding() uses (evm: mut Evm) {
+    let receiver = evm.create2<DynamicPayloadViewReceiver>(value: 0, args: (), salt: 0)
+    assert(receiver.inner != 0)
+
+    // Send using OriginalMsg (which uses Bytes, encodable) to the receiver
+    // that decodes as BytesView. Same ABI wire format.
+    let result: u256 = evm.call(
+        addr: receiver,
+        gas: 1000000,
+        value: 0,
+        message: OriginalMsg::Check {
+            first: two_word_bytes(),
+            marker: 0xabcdef,
+            second: one_byte_bytes(),
+        },
+    )
+
+    assert(result == 34)
+}

crates/fe/tests/fixtures/fe_test/abi_struct_g1point.fe

@@ -0,0 +1,41 @@
+use std::abi::sol
+use std::evm::Evm
+
+#[abi]
+pub struct G1Point {
+    pub x: u256,
+    pub y: u256,
+}
+
+msg PointMsg {
+    #[selector = sol("add((uint256,uint256),(uint256,uint256))")]
+    Add { a: G1Point, b: G1Point } -> (u256, u256),
+}
+
+pub contract PointAdder {
+    init() {}
+    recv PointMsg {
+        Add { a, b } -> (u256, u256) {
+            (a.x + b.x, a.y + b.y)
+        }
+    }
+}
+
+#[test]
+fn test_abi_struct_roundtrip() uses (evm: mut Evm) {
+    let c = evm.create2<PointAdder>(value: 0, args: (), salt: 0)
+    assert(c.inner != 0)
+
+    let (rx, ry): (u256, u256) = evm.call(
+        addr: c,
+        gas: 1000000,
+        value: 0,
+        message: PointMsg::Add {
+            a: G1Point { x: 10, y: 20 },
+            b: G1Point { x: 30, y: 40 },
+        },
+    )
+
+    assert(rx == 40)
+    assert(ry == 60)
+}

crates/hir/src/analysis/analysis_pass.rs

@@ -1,7 +1,7 @@
 use crate::analysis::{HirAnalysisDb, diagnostics::DiagnosticVoucher};
 use crate::{
-    ArithmeticAttrError, ErrorDiagnostic, EventError, InlineAttrError, LoopUnrollAttrError,
-    ParserError, PayableError, SelectorError,
+    AbiStructError, ArithmeticAttrError, ErrorDiagnostic, EventError, InlineAttrError,
+    LoopUnrollAttrError, ParserError, PayableError, SelectorError,
     hir_def::{ModuleTree, TopLevelMod},
     lower::{parse_file_impl, scope_graph_impl},
 };
@@ -131,6 +131,22 @@ impl ModuleAnalysisPass for ErrorLowerPass {
     }
 }
 
+/// Analysis pass that collects abi struct lowering diagnostics from `#[abi]` struct desugaring.
+pub struct AbiStructLowerPass {}
+
+impl ModuleAnalysisPass for AbiStructLowerPass {
+    fn run_on_module<'db>(
+        &mut self,
+        db: &'db dyn HirAnalysisDb,
+        top_mod: TopLevelMod<'db>,
+    ) -> Vec<Box<dyn DiagnosticVoucher>> {
+        scope_graph_impl::accumulated::<AbiStructError>(db, top_mod)
+            .into_iter()
+            .map(|d| Box::new(d.clone()) as _)
+            .collect::<Vec<_>>()
+    }
+}
+
 /// Analysis pass that collects arithmetic attribute validation errors.
 pub struct ArithmeticAttrPass {}
 

crates/hir/src/analysis/diagnostics.rs

@@ -712,6 +712,49 @@ impl DiagnosticVoucher for crate::ErrorDiagnostic {
     }
 }
 
+impl DiagnosticVoucher for crate::AbiStructError {
+    fn to_complete(&self, _db: &dyn SpannedHirAnalysisDb) -> CompleteDiagnostic {
+        use crate::AbiStructErrorKind;
+
+        let primary_span = Span::new(self.file, self.primary_range, SpanKind::Original);
+
+        let (code, message, label, notes) = match &self.kind {
+            AbiStructErrorKind::AbiAttrOnNonStruct { item_kind } => (
+                1,
+                format!("`#[abi]` is only valid on structs (found on {item_kind})"),
+                "`#[abi]` must be placed on a `struct` item".to_string(),
+                vec!["move `#[abi]` to a struct declaration".to_string()],
+            ),
+            AbiStructErrorKind::InvalidAbiAttrForm => (
+                2,
+                "invalid `#[abi]` attribute form".to_string(),
+                "expected `#[abi]` without arguments".to_string(),
+                vec!["remove arguments and use `#[abi]`".to_string()],
+            ),
+            AbiStructErrorKind::GenericAbiStruct => (
+                3,
+                "`#[abi]` structs must be non-generic".to_string(),
+                "generics are not supported on `#[abi]` structs".to_string(),
+                vec!["remove generic parameters from the abi struct".to_string()],
+            ),
+        };
+
+        let error_code = GlobalErrorCode::new(DiagnosticPass::AbiStructLower, code);
+
+        CompleteDiagnostic::new(
+            Severity::Error,
+            message,
+            vec![SubDiagnostic::new(
+                LabelStyle::Primary,
+                label,
+                Some(primary_span),
+            )],
+            notes,
+            error_code,
+        )
+    }
+}
+
 impl DiagnosticVoucher for crate::InlineAttrError {
     fn to_complete(&self, _db: &dyn SpannedHirAnalysisDb) -> CompleteDiagnostic {
         use crate::hir_def::InlineAttrErrorKind;
@@ -3045,6 +3088,18 @@ impl DiagnosticVoucher for BodyDiag<'_> {
                 }
             }
 
+            Self::WhereConstPredicateFailed { primary } => CompleteDiagnostic {
+                severity,
+                message: "where clause const predicate failed".to_string(),
+                sub_diagnostics: vec![SubDiagnostic {
+                    style: LabelStyle::Primary,
+                    message: "const predicate evaluated to `false`".to_string(),
+                    span: primary.resolve(db),
+                }],
+                notes: Vec::new(),
+                error_code,
+            },
+
             Self::InvalidCast {
                 primary,
                 from,

crates/hir/src/analysis/mod.rs

@@ -6,8 +6,8 @@ pub mod place;
 pub mod semantic;
 
 use self::analysis_pass::{
-    AnalysisPassManager, ArithmeticAttrPass, ErrorLowerPass, EventLowerPass, InlineAttrPass,
-    LoopUnrollAttrPass, MsgLowerPass, ParsingPass, PayableAttrPass,
+    AbiStructLowerPass, AnalysisPassManager, ArithmeticAttrPass, ErrorLowerPass, EventLowerPass,
+    InlineAttrPass, LoopUnrollAttrPass, MsgLowerPass, ParsingPass, PayableAttrPass,
 };
 use self::name_resolution::ImportAnalysisPass;
 use self::ty::{
@@ -33,6 +33,7 @@ pub fn initialize_analysis_pass() -> AnalysisPassManager {
     pass_manager.add_module_pass("MsgLower", Box::new(MsgLowerPass {}));
     pass_manager.add_module_pass("EventLower", Box::new(EventLowerPass {}));
     pass_manager.add_module_pass("ErrorLower", Box::new(ErrorLowerPass {}));
+    pass_manager.add_module_pass("AbiStructLower", Box::new(AbiStructLowerPass {}));
     pass_manager.add_module_pass("InlineAttr", Box::new(InlineAttrPass {}));
     pass_manager.add_module_pass("LoopUnrollAttr", Box::new(LoopUnrollAttrPass {}));
     pass_manager.add_module_pass("MsgSelector", Box::new(MsgSelectorAnalysisPass {}));