spl/stage1/test20_complex.spl

/* ===== å¤<C3A5>æ<EFBFBD>‚类型嵌套综å<C2BC>ˆæµ‹è¯• =====
 * test20_complex â€?结构体嵌套ã€<C3A3>切片ã€<C3A3>数组ã€<C3A3>方法ã€<C3A3>类型别å<C2AB><C3A5>ã€<C3A3>枚举等
 * 难度�/5
 */
/* ---- 基础结构�---- */
type Point = struct {
    x: i32,
    y: i32,
}

/* ---- 嵌套结构�---- */
type Rect = struct {
    min: Point,
    max: Point,
}

/* ---- å<>«åˆ‡ç‰‡å­—段的结构ä½?(核心 bug 测试) ---- */
type Buffer = struct {
    data: []u8,
    len: usize,
}

/* ---- å<>«æ•°ç»„字段的结构ä½?---- */
type MatrixRow = struct {
    items: [4]i32,
}

/* ---- å<>«æŒ‡é’ˆå­—段的结构ä½?---- */
type Node = struct {
    ptr: *i32,
    val: i32,
}

/* ---- 多层级嵌套：结构体里的结构体里的切片 ---- */
type Bundle = struct {
    name: *u8,
    buf: Buffer,
    row: MatrixRow,
    pt: Point,
}

/* ---- 枚举å<C2BE>«æ•°æ<C2B0>?---- */
type Status = enum {
    Active: i32;
    Inactive;
    Pending: Point;
}

/* ---- å<>«æ–¹æ³•çš„结构ä½?(方法定义在结构体内部) ---- */
type Counter = struct {
    val: i32,

    fn inc(self: *Counter) i32 {
        self.val = self.val + 1;
        ret self.val;
    }

    fn add(self: *Counter, n: i32) i32 {
        self.val = self.val + n;
        ret self.val;
    }

    fn reset(self: *Counter) {
        self.val = 0;
    }

    fn get(self: *Counter) i32 {
        ret self.val;
    }
}

/* ============================================================
 * 测试 1: 切片在结构体内部åˆ<C3A5>始åŒ?(ä¿®å¤<C3A5>çš„æ ¸å¿?bug)
 * ============================================================ */

fn test_slice_in_struct() i32 {
    var raw: [4]u8;
    raw[0] = 65; raw[1] = 66; raw[2] = 67; raw[3] = 68;

    /* Bug fix: { .ptr = ..., .len = ... } inside struct literal */
    var b: Buffer = Buffer { .data = .{ .ptr = &raw[0], .len = 4 }, .len = 4 };

    if b.len != 4 { ret 1; }
    if b.data[0] != 65 { ret 2; }
    if b.data[1] != 66 { ret 3; }
    if b.data[3] != 68 { ret 4; }

    /* Modify through slice �verify reflection */
    b.data[0] = 90;
    if raw[0] != 90 { ret 5; }

    /* Initialize with shorter slice */
    var b2: Buffer = Buffer { .data = .{ .ptr = &raw[2], .len = 2 }, .len = 2 };
    if b2.len != 2 { ret 6; }
    if b2.data[0] != 67 { ret 7; }

    /* Slice field assignment via field access */
    b2.data.ptr = &raw[0];
    b2.data.len = 4;
    if b2.data[0] != 90 { ret 8; }
    if b2.data.len != 4 { ret 9; }

    ret 0;
}

/* ============================================================
 * 测试 2: 结构体å<E2809C>«æ•°ç»„字段
 * ============================================================ */

fn test_struct_with_array() i32 {
    var mr: MatrixRow = MatrixRow { .items = [4]i32{10, 20, 30, 40} };

    if mr.items[0] != 10 { ret 1; }
    if mr.items[1] != 20 { ret 2; }
    if mr.items[2] != 30 { ret 3; }
    if mr.items[3] != 40 { ret 4; }

    /* 修改数组元素 */
    mr.items[2] = 99;
    if mr.items[2] != 99 { ret 5; }

    ret 0;
}

/* ============================================================
 * 测试 3: 嵌套结构体åˆ<C3A5>始化
 * ============================================================ */

fn test_nested_struct() i32 {
    var p: Point = Point { .x = 5, .y = 10 };
    if p.x != 5 { ret 1; }
    if p.y != 10 { ret 2; }

    /* 嵌套结构体字é<E28094>¢é‡<C3A9> */
    var r: Rect = Rect {
        .min = Point { .x = 1, .y = 2 },
        .max = Point { .x = 3, .y = 4 }
    };
    if r.min.x != 1 { ret 3; }
    if r.min.y != 2 { ret 4; }
    if r.max.x != 3 { ret 5; }
    if r.max.y != 4 { ret 6; }

    /* 修改嵌套字段 */
    r.min.x = 100;
    if r.min.x != 100 { ret 7; }
    if r.min.y != 2 { ret 8; }  /* unchanged */

    ret 0;
}

/* ============================================================
 * 测试 4: 结构体æˆ<C3A6>员方æ³?(实例方法调用)
 * ============================================================ */

fn test_struct_method() i32 {
    var c: Counter = Counter { .val = 0 };

    /* 实例方法调用 c.inc(&c) */
    var r1: i32 = c.inc(&c);
    if r1 != 1 { ret 1; }
    if c.val != 1 { ret 2; }

    /* 带å<C2A6>‚数方法调ç”?c.add(&c, n) */
    var r2: i32 = c.add(&c, 5);
    if r2 != 6 { ret 3; }
    if c.val != 6 { ret 4; }

    /* 连续调用 (显å¼<C3A5> self) */
    c.reset(&c);
    if c.val != 0 { ret 5; }

    c.add(&c, 10);
    c.inc(&c);
    var r3: i32 = c.get(&c);
    if r3 != 11 { ret 6; }

    ret 0;
}

/* ============================================================
 * 测试 5: 结构体å<E2809C>«æŒ‡é’ˆå­—段
 * ============================================================ */

fn test_ptr_in_struct() i32 {
    var v: i32 = 42;
    var n: Node = Node { .ptr = &v, .val = 99 };

    if n.val != 99 { ret 1; }
    if n.ptr[0] != 42 { ret 2; }

    /* 通过指针修改 */
    v = 100;
    if n.ptr[0] != 100 { ret 3; }

    /* 通过指针在结构体内修�*/
    n.ptr[0] = 200;
    if v != 200 { ret 4; }

    ret 0;
}

/* ============================================================
 * 测试 6: 多层级å¤<C3A5>æ<EFBFBD>‚嵌å¥?
 * ============================================================ */

fn test_complex_nesting() i32 {
    var str_data: [5]u8;
    str_data[0] = 72; str_data[1] = 101;
    str_data[2] = 108; str_data[3] = 108; str_data[4] = 111;

    var bundle: Bundle = Bundle {
        .name = &str_data[0],
        .buf = Buffer { .data = .{ .ptr = &str_data[1], .len = 3 }, .len = 3 },
        .row = MatrixRow { .items = [4]i32{1, 2, 3, 4} },
        .pt = Point { .x = -5, .y = 15 }
    };

    /* Verify name */
    if bundle.name[0] != 72 { ret 1; }
    if bundle.name[4] != 111 { ret 2; }

    /* Verify nested slice */
    if bundle.buf.len != 3 { ret 3; }
    if bundle.buf.data[0] != 101 { ret 4; }
    if bundle.buf.data[2] != 108 { ret 5; }

    /* Verify array field */
    if bundle.row.items[0] != 1 { ret 6; }
    if bundle.row.items[3] != 4 { ret 7; }

    /* Verify nested struct field */
    if bundle.pt.x != -5 { ret 8; }
    if bundle.pt.y != 15 { ret 9; }

    /* Modify nested slice */
    bundle.buf.data[1] = 87; /* 'W' */
    if str_data[2] != 87 { ret 10; }

    /* Modify nested array */
    bundle.row.items[2] = 33;
    if bundle.row.items[2] != 33 { ret 11; }

    ret 0;
}

/* ============================================================
 * 测试 7: 枚举å<C2BE>«ç»“构体数æ<C2B0>®
 * ============================================================ */

fn test_enum_complex() i32 {
    var s: Status = Status { .Active = 42 };

    /* Verify active variant */
    match s {
        .Active[val] => {
            if val != 42 { ret 1; }
        },
        .Inactive => {
            ret 2;
        },
        .Pending[p] => {
            ret 3;
        }
    }

    /* Test Inactive variant */
    var s2: Status = Status { .Inactive };
    var is_inactive: i32 = 0;
    match s2 {
        .Active[val] => {},
        .Inactive => { is_inactive = 1; },
        .Pending[p] => {}
    }
    if is_inactive != 1 { ret 4; }

    /* Test Pending variant with struct data */
    var s3: Status = Status { .Pending = Point { .x = 7, .y = 8 } };
    match s3 {
        .Active[val] => { ret 5; },
        .Inactive => { ret 6; },
        .Pending[p] => {
            if p.x != 7 { ret 7; }
            if p.y != 8 { ret 8; }
        }
    }

    ret 0;
}

/* ============================================================
 * 主函�
 * ============================================================ */

fn main() i32 {
    var r: i32;

    r = test_slice_in_struct();
    if r != 0 { ret r; }

    r = test_struct_with_array();
    if r != 0 { ret r + 100; }

    r = test_nested_struct();
    if r != 0 { ret r + 200; }

    r = test_struct_method();
    if r != 0 { ret r + 300; }

    r = test_ptr_in_struct();
    if r != 0 { ret r + 400; }

    r = test_complex_nesting();
    if r != 0 { ret r + 500; }

    r = test_enum_complex();
    if r != 0 { ret r + 600; }

    ret 0;
}