Uya 语言

n1.uya:(2:16): 错误: 数组索引安全证明失败
  变量: i, 数组大小: 10
  建议: 添加边界检查 (如 if i >= 0 && i < 10)

so.uya:(1:39): 错误: i32 溢出无法证明（--strict-overflow）：
  改用 try a + b、(a + b) catch、加区间守卫，或用饱和/包装运算符

fn add_checked(a: i32, b: i32) !i32 {
    return try a + b;      // 越界 -> error.Overflow
}

fn main() i32 {
    const p: i32 = add_checked(1, 2) catch |e| { return 1; };
    printf("in range: %d\n", p);

    const q: i32 = add_checked(2000000000, 2000000000) catch |e| {
        printf("overflow: caught\n");
        return 0;
    };
    printf("unreachable %d\n", q);
    return 0;
}

// 输出：
// in range: 3
// overflow: caught

uya build <file> [-o out] [--c99]   编译为可执行文件或 C 代码
uya check <file>                   只做词法 / 语法 / 类型检查
uya run <file> [-- args...]        编译并运行
uya test <file>                    运行 test 块
uya fmt <file>                     格式化
uya upm <sub>                      包管理

extern "libc" fn printf(fmt: *byte, ...) i32;

// 写法一：方法直接写在结构体体内，字段与方法同一个花括号
struct Point {
    x: i32,
    y: i32,

    fn norm2(self: &Self) i32 {
        return self.x *| self.x +| self.y *| self.y;
    }
}

// 写法二：字段单独声明，方法写在同名的 Type { ... } 方法块里
struct Rect {
    w: i32,
    h: i32
}

Rect {
    // 实例方法：首参是 receiver（&Self），用 obj.method() 调用
    fn area(self: &Self) i32 {
        return self.w *| self.h;
    }

    // 静态方法：首参不是 receiver，用 Type.method() 调用
    fn square(n: i32) Rect {
        return Rect{ w: n, h: n };
    }
}

fn main() i32 {
    const p: Point = Point{ x: 3, y: 4 };
    printf("Point.norm2 = %d\n", p.norm2());

    const r: Rect = Rect{ w: 3, h: 4 };
    printf("Rect.area   = %d\n", r.area());

    const s: Rect = Rect.square(5);
    printf("square(5)   = %d\n", s.area());

    // 静态方法返回的值可以继续链式调用
    printf("chain       = %d\n", Rect.square(6).area());
    return 0;
}

// 输出：
// Point.norm2 = 25
// Rect.area   = 12
// square(5)   = 25
// chain       = 36

extern "libc" fn printf(fmt: *byte, ...) i32;

fn main() i32 {
    printf("hello, uya\n");
    return 0;
}

// 输出：hello, uya

extern "libc" fn printf(fmt: *byte, ...) i32;

fn safe_get(arr: &[i32: 10], i: i32) !i32 {
    if i < 0 || i >= 10 {
        return error.OutOfBounds;
    }
    return arr[i];   // 到这里编译器已知 0 <= i < 10，直接访问
}

fn main() i32 {
    var arr: [i32: 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    const v: i32 = safe_get(&arr[0:10], 3) catch |e| {
        printf("out of bounds\n");
        return 1;
    };
    printf("v = %d\n", v);
    return 0;
}

// 输出：v = 3

struct Conf {
    port: i32 = 8080,
    debug: bool = false
}

fn main() i32 {
    const def: Conf = Conf{};
    const custom: Conf = Conf{ port: 9000 };
    printf("def.port = %d, custom.port = %d\n", def.port, custom.port);
    return 0;
}

// 输出：def.port = 8080, custom.port = 9000

struct Counter {
    value: atomic i32
}

Counter {
    fn bump(self: &Self) i32 {
        self.value += 1;             // 编译为原子 fetch_add
        const v: i32 = self.value;    // 原子 load
        return v;
    }
}

fn main() i32 {
    var c: Counter = Counter{ value: 0 };
    _ = c.bump();
    const v: i32 = c.bump();
    printf("counter = %d\n", v);
    return 0;
}

// 输出：counter = 2

interface IShape {
    fn area(self: &Self) i32;
}

struct Rect : IShape {
    w: i32,
    h: i32,

    fn area(self: &Self) i32 {
        return self.w *| self.h;   // 饱和乘法，不需要证明
    }
}

fn total(s: IShape) i32 {
    return s.area();
}

fn main() i32 {
    var r: Rect = Rect{ w: 3, h: 4 };
    printf("%d\n", total(r));    // 经接口调用
    printf("%d\n", r.area());    // 直接调用
    return 0;
}

// 输出：12 / 12

fn main() i32 {
    var arr: [i32: 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    const s: &[i32] = &arr[2:5];      // 从下标 2 起取 5 个元素

    printf("len = %d\n", @len(s));
    for 0..@len(s) |i| {            // 切片不能直接 for，走下标
        printf("%d ", s[i]);
    }
    printf("\n");

    for arr |&v| {                  // 引用迭代，可修改原数组
        *v = *v *| 2;
    }
    printf("arr[0] = %d\n", arr[0]);
    return 0;
}

// 输出：
// len = 5
// 2 3 4 5 6
// arr[0] = 0

extern "libc" fn malloc(n: usize) *void;
extern "libc" fn free(p: *void) void;

struct Buffer {
    p: *void,

    fn drop(self: Buffer) void {
        if self.p != null {
            free(self.p);
        }
    }
}

fn buffer_new(n: usize) !Buffer {
    const p: *void = malloc(n);
    if p == null {
        return error.OutOfMemory;
    }
    return Buffer{ p: p };
}

fn main() i32 {
    const b: Buffer = buffer_new(64) catch |e| {
        printf("alloc failed\n");
        return 1;
    };
    printf("allocated\n");
    return 0;    // b 离开作用域，drop 自动 free
}

// 输出：allocated