neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

fn lower_member_access_expression(
    expr: &Expression,
    inner: &Expression,
    member: &Identifier,
    ctx: &mut LoweringContext,
    instructions: &mut Vec<Instruction>,
) -> bool {
    // `super.member` in a non-call context (e.g., reading a parent state variable).
    // The compiler flattens inheritance so base-specific members are not separately addressable.
    if matches!(inner, Expression::Variable(id) if id.name == "super") {
        ctx.record_error_with_suggestion(
            format!(
                "super.{} member access is not supported; use super.method() calls only",
                member.name
            ),
            "access the member directly by name, call super.method(), or extract shared logic into a named internal function",
        );
        instructions.push(Instruction::PushLiteral(LiteralValue::Integer(BigInt::zero())));
        return false;
    }

    if let Some(result) = try_lower_native_contract_constant(inner, member, instructions) {
        return result;
    }

    if let Some(result) = try_lower_syscalls_contract_constant(inner, member, instructions) {
        return result;
    }

    if let Some(result) = try_lower_selector_member_access(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_runtime_member_access(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_address_balance(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_length_property(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_current_key(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_current_value(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_code_property(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_type_bound_max(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_type_bound_min(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_interface_id(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_type_name(inner, member, ctx, instructions) {
        return result;
    }

    if let Some(result) = try_lower_type_code(inner, member, ctx, instructions) {
        return result;
    }

    lower_generic_member_access(expr, inner, member, ctx, instructions)
}