feat: stdlib improvements, trait dispatch on primitives, generics soundness

[brockelmore]

Summary

• Trait method calls on primitives: u256.unsafe_add(b) style calls now work via trait impl lookup with span-based error messages
• Generic Map with Index trait dispatch: Replaced hardcoded starts_with("Map") checks with proper Index trait impl lookup — any user-defined type implementing Index gets the same treatment
• Generics soundness fixes: resolve_generic_type_name() now returns None for ambiguous monomorphizations instead of silently picking the first; added type_sig_hint threading and resolve_generic_type_name_with_args() for precise resolution
• is_primitive_type() fix: Validates width ranges matching lexer rules (u/i 8-256 step 8, bytes 1-32) instead of matching any prefix
• Stdlib auto-imports: Map, ops, Option, Result auto-imported as globals
• Refactored calls.rs: Extracted helpers, removed StructParamInfo
• Clippy clean + nightly fmt

Adds a few stdlib traits:

// Index trait allows for operator overloading of indexing, i.e. my_map[a][b] or my_array[0]
// using a custom index and output.
trait Index<Idx, Output> {
    fn index(self, index: Idx) -> (Output);
}

trait UniqueSlot {
    // Derive a storage slot from this key and a base slot.
    // EVM convention: keccak256(abi.encode(key, base_slot))
    // Compiler provides implementations for primitive types.
    fn derive_slot(self, base_slot: u256) -> u256;
}

trait Sstore {
    fn sstore(self, base_slot: u256);
}

trait Sload {
    fn sload(base_slot: u256) -> Self;
}

Index allows for operator overloading of [] syntax. UniqueSlot is a way to customize slot calculation - takes a base slot provided by the compiler. Introduce Sstore + Sload traits which tell the compiler what to do for loading and storing to storage. Here is an example that is in the examples/tests/test_map_std.edge:

use std::ops::UniqueSlot;
use std::ops::Sstore;
use std::ops::Sload;

type CustomSStore = {
    ignored: u256,
    packed_a: u128,
    packed_b: u128
};

type CustomHash = {
    a: u128,
    b: u128
};

// Struct key with NO UniqueSlot impl — uses default keccak-chained derive_slot
type DefaultKey = {
    x: u256,
    y: u256
};

impl CustomHash: UniqueSlot {
    fn derive_slot(self, base_slot: u256) -> u256 {
        let packed_combo: u256 = (self.a << 128) | self.b;
        base_slot + packed_combo
    }
}

impl CustomSStore: Sstore {
    fn sstore(self, base_slot: u256) {
        let packed_combo: u256 = (self.packed_a << 128) | self.packed_b;
        packed_combo.sstore(base_slot);
    }
}

impl CustomSStore: Sload {
    fn sload(base_slot: u256) -> Self {
        let packed_combo = u256::sload(base_slot);
        let a = packed_combo >> 128;
        let b = packed_combo & ((1 << 128) - 1);
        CustomSStore { ignored: 0, packed_a: a, packed_b: b }
    }
}

contract TestMappings {
    let basic_map: &s Map<u256, u256>;
    let custom: &s CustomSStore;
    let custom_sstore_map: &s Map<u256, CustomSStore>;
    let double_custom_sstore_map: &s Map<CustomHash, CustomSStore>;
    let default_key_map: &s Map<DefaultKey, u256>;

    // Getters
    pub fn get_custom() -> CustomSStore {
        custom
    }

    pub fn get_basic(key: u256) -> u256 {
        basic_map.get(key)
    }

    pub fn get_basic_by_indexable(key: u256) -> u256 {
        basic_map[key]
    }

    pub fn get_custom(key: u256) -> u256 {
        let val: CustomSStore = custom_sstore_map.get(key);
        (val.packed_a << 128) | val.packed_b
    }

    pub fn get_custom_by_indexable(key: u256) -> u256 {
        let val: CustomSStore = custom_sstore_map[key];
        (val.packed_a << 128) | val.packed_b
    }

    // Setters
    pub mut fn set_custom(a: u128, b: u128) {
        custom = CustomSStore { ignored: 10000, packed_a: a, packed_b: b }
    }

    pub mut fn set_basic(key: u256, val: u256) -> u256 {
        basic_map.set(key, val);
    }

    pub mut fn set_basic_by_indexable(key: u256, val: u256) -> u256 {
        basic_map[key] = val;
    }

    pub mut fn set_custom(key: u256, val: CustomSStore) {
        custom_sstore_map.set(key, val);
    }

    pub mut fn set_custom_by_indexable(key: u256, val: CustomSStore) {
        custom_sstore_map[key] = val;
    }

    // Double custom: CustomHash key + CustomSStore value
    pub fn get_double_custom(a: u128, b: u128) -> u256 {
        let key = CustomHash { a: a, b: b };
        let val: CustomSStore = double_custom_sstore_map.get(key);
        (val.packed_a << 128) | val.packed_b
    }

    pub mut fn set_double_custom(a: u128, b: u128, val_a: u128, val_b: u128) {
        let key = CustomHash { a: a, b: b };
        let val = CustomSStore { ignored: 0, packed_a: val_a, packed_b: val_b };
        double_custom_sstore_map.set(key, val);
    }

    // Default derive_slot (no UniqueSlot impl on DefaultKey)
    pub fn get_default_key(x: u256, y: u256) -> u256 {
        let key = DefaultKey { x: x, y: y };
        default_key_map.get(key)
    }

    pub mut fn set_default_key(x: u256, y: u256, val: u256) {
        let key = DefaultKey { x: x, y: y };
        default_key_map.set(key, val);
    }
}

Notably: this removes map as a primitive and instead just represents it using the normal type system and gives users the flexibility to really get the most out of their contract.

[netlify]

✅ Deploy Preview for edgelang ready!

Name	Link
🔨 Latest commit	c5e1238
🔍 Latest deploy log	https://app.netlify.com/projects/edgelang/deploys/69b1d4b66f9d0f0008e954dd
😎 Deploy Preview	https://deploy-preview-71--edgelang.netlify.app
📱 Preview on mobile	Toggle QR Code... Use your smartphone camera to open QR code link.

---

To edit notification comments on pull requests, go to your Netlify project configuration.

[github-actions]

Gas Snapshot Diff

Changed (6) | Unchanged (137)

Test	O0	O1	O2	O3
test_mappings::counter_inc(address)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)
test_mappings::nested_set(address,address,uint256)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)
test_mappings::map_set(address,uint256)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)	+3 (+0.0%)
test_mappings::nested_two_spenders(address,address,address,uint256,uint256)	+6 (+0.0%)	+6 (+0.0%)	+6 (+0.0%)	+6 (+0.0%)
test_mappings::two_keys(address,address,uint256,uint256)	+6 (+0.0%)	+6 (+0.0%)	+6 (+0.0%)	+6 (+0.0%)
test_mappings::map_add(address,uint256)	+3 (+0.1%)	+3 (+0.1%)	+3 (+0.1%)	+3 (+0.1%)
TOTAL	+24 (+0.0%)	+24 (+0.0%)	+24 (+0.0%)	+24 (+0.0%)

Regressions at O3 (6)

Test	O3
test_mappings::counter_inc(address)	+3 (+0.0%)
test_mappings::nested_set(address,address,uint256)	+3 (+0.0%)
test_mappings::map_set(address,uint256)	+3 (+0.0%)
test_mappings::nested_two_spenders(address,address,address,uint256,uint256)	+6 (+0.0%)
test_mappings::two_keys(address,address,uint256,uint256)	+6 (+0.0%)
test_mappings::map_add(address,uint256)	+3 (+0.1%)