@xiaohuo123212/elench 0.0.0-stage → 0.1.0

package/src/test_parser.py.bak

@@ -0,0 +1,423 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+test_parser.py —— M0 解析器测试
+
+覆盖：
+  · 两份样例完整解析（M0 验收 ⑦）
+  · 关键构造的形状（target / model / effects / repeats / choose / kernel）
+  · 字符字面量、元组类型、&mut、命名实参、match 臂、`?`、`as`
+  · 错误恢复与终止符不匹配
+
+运行：
+  cd src; $env:PYTHONIOENCODING="utf-8"; python test_parser.py
+"""
+
+import os
+import sys
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+from lexer import Kind
+from parser import Node, parse_source
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SAMPLE = os.path.join(HERE, "..", "文档", "设计", "目前设计", "样例")
+
+
+# ---------------------------------------------------------------- 工具
+
+_passed = 0
+_failed = []
+
+
+def check(cond, name, detail=""):
+    global _passed
+    if cond:
+        _passed += 1
+    else:
+        _failed.append(f"{name}  {detail}")
+        print(f"  FAIL  {name}  {detail}")
+
+
+def items(mod, kind):
+    return [i for i in mod.children if i.kind == kind]
+
+
+def spec_by_name(mod, name):
+    for it in items(mod, "spec"):
+        if it.name == name:
+            return it
+    return None
+
+
+def clauses(spec):
+    """取出 spec 下的所有子句（在 spec-body 里）。"""
+    out = []
+    for c in spec.children:
+        if c.kind == "spec-body":
+            out.extend(x for x in c.children if x.kind == "clause")
+        elif c.kind == "clause":
+            out.append(c)
+    return out
+
+
+def clause(spec, name):
+    for c in clauses(spec):
+        if c.name == name:
+            return c
+    return None
+
+
+def models(spec):
+    out = []
+    for c in spec.children:
+        if c.kind == "spec-body":
+            out.extend(x for x in c.children if x.kind == "model")
+    return out
+
+
+def walk(node, kind, acc=None):
+    if acc is None:
+        acc = []
+    if node.kind == kind:
+        acc.append(node)
+    for c in node.children:
+        walk(c, kind, acc)
+    return acc
+
+
+def load(name):
+    with open(os.path.join(SAMPLE, name), "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# ---------------------------------------------------------------- 1. 样例
+
+def test_samples():
+    print("[1] 样例完整解析（M0 ⑦）")
+
+    tu = parse_source(load("calculator.tu"), "calculator.tu")
+    check(tu.ok, "calculator.tu 无诊断",
+          f"实际 {len(tu.diagnostics)} 条: "
+          + "; ".join(f"{d.code}@{d.line}:{d.col}" for d in tu.diagnostics[:3]))
+    check(len(items(tu.module, "use")) == 1, "tu: 1 个 use")
+    check(len(items(tu.module, "const")) == 12, "tu: 12 个 const",
+          f"实际 {len(items(tu.module, 'const'))}")
+    check(len(items(tu.module, "enum")) == 2, "tu: 2 个 enum")
+    check(len(items(tu.module, "spec")) == 10, "tu: 10 个 spec")
+
+    ai = parse_source(load("calculator.ai"), "calculator.ai")
+    check(ai.ok, "calculator.ai 无诊断",
+          f"实际 {len(ai.diagnostics)} 条: "
+          + "; ".join(f"{d.code}@{d.line}:{d.col}" for d in ai.diagnostics[:3]))
+    check(len(items(ai.module, "fn")) == 10, "ai: 10 个 fn")
+    check(len(items(ai.module, "const")) == 0, "ai: 零声明（F-4）")
+    check(len(items(ai.module, "use")) == 0, "ai: 零 use（F-8）")
+
+
+# ---------------------------------------------------------------- 2. spec 子句
+
+def test_spec_clauses():
+    print("[2] spec 子句形状")
+    tu = parse_source(load("calculator.tu"), "tu")
+    ev = spec_by_name(tu.module, "evaluate")
+
+    check(ev is not None, "找到 spec evaluate")
+    eff = clause(ev, "effects")
+    check(eff is not None and eff.value == ["alloc"], "evaluate.effects = {alloc}",
+          f"实际 {getattr(eff, 'value', None)}")
+
+    req = clause(ev, "requires")
+    check(req is not None and len(req.children) == 1, "evaluate 有 requires")
+    check(req.children[0].kind == "binary"
+          and req.children[0].value == "<=", "requires 是 <= 比较")
+
+    tgt = clause(ev, "target")
+    check(tgt is not None, "evaluate 有 target")
+    dims = [d.name for d in tgt.children]
+    check(dims == ["time", "allocation"], "target 两个维度 time/allocation",
+          f"实际 {dims}")
+
+    time_dim = tgt.children[0]
+    slots = [s.name for s in time_dim.children]
+    check(slots == ["max"], "time 维度只有 max 槽位（target 只有上限）",
+          f"实际 {slots}")
+
+    ms = models(ev)
+    check([m.name for m in ms] == ["normal", "stress"], "两个 model 场景",
+          f"实际 {[m.name for m in ms]}")
+    check(ms[0].children[0].name == "text", "model 的参数名是 text")
+
+    sd = spec_by_name(tu.module, "is_digit")
+    e2 = clause(sd, "effects")
+    check(e2 is not None and e2.value == "pure", "is_digit.effects = pure",
+          f"实际 {getattr(e2, 'value', None)}")
+
+    sr = spec_by_name(tu.module, "should_reduce")
+    rep = clause(sr, "repeats")
+    check(rep is not None, "should_reduce 有 repeats（T13 情形二）")
+
+
+# ---------------------------------------------------------------- 3. 类型
+
+def test_types():
+    print("[3] 类型形状")
+    tu = parse_source(load("calculator.tu"), "tu")
+
+    ev = spec_by_name(tu.module, "evaluate")
+    # ev.children: params, type-name(Result), spec-body
+    tys = [c for c in ev.children if c.kind.startswith("type")]
+    check(tys and tys[0].name == "Result", "evaluate 返回 Result")
+    check([t.name for t in tys[0].children] == ["i64", "CalcError"],
+          "Result 的两个类型参数")
+
+    p = spec_by_name(tu.module, "pop_until_open")
+    params = [c for c in p.children if c.kind == "params"][0]
+    refs = walk(params, "type-ref")
+    check(len(refs) == 2, "pop_until_open 两个 &mut 参数", f"实际 {len(refs)}")
+    check(all(r.value == "mut" for r in refs), "两个都是 &mut")
+
+    rn = spec_by_name(tu.module, "read_number")
+    tuples = walk(rn, "type-tuple")
+    check(len(tuples) == 1, "read_number 返回元组类型")
+    check([t.name for t in tuples[0].children] == ["i64", "u64"], "元组元素 i64, u64")
+
+    tk = spec_by_name(tu.module, "tokenize")
+    slices = walk(tk, "type-slice")
+    check(len(slices) == 1, "tokenize 参数是切片 []u8")
+
+
+# ---------------------------------------------------------------- 4. enum
+
+def test_enum():
+    print("[4] enum 与载荷")
+    tu = parse_source(load("calculator.tu"), "tu")
+    enums = {e.name: e for e in items(tu.module, "enum")}
+    check(set(enums) == {"Token", "CalcError"}, "两个 enum: Token / CalcError")
+
+    tok = enums["Token"]
+    names = [v.name for v in tok.children]
+    check(names[:2] == ["Number", "Plus"], "Token 变体顺序",
+          f"实际 {names[:2]}")
+
+    arith = [v for v in enums["CalcError"].children if v.name == "Arith"][0]
+    fields = [f.name for f in arith.children if f.kind == "field"]
+    check(fields == ["cause"], "CalcError.Arith 有具名载荷 cause")
+    ftype = [c for c in arith.children if c.kind == "field"][0].children[0]
+    check(ftype.name == "Arithmetic", "载荷类型是 Arithmetic")
+
+
+# ---------------------------------------------------------------- 5. 语句
+
+def test_statements():
+    print("[5] 语句形状")
+    ai = parse_source(load("calculator.ai"), "ai")
+
+    def fn(name):
+        for it in items(ai.module, "fn"):
+            if it.name == name:
+                return it
+        return None
+
+    ev = fn("evaluate")
+    check(ev.value["pub"] is True, "evaluate 是 pub")
+    body = [c for c in ev.children if c.kind == "block"][0]
+    kinds = [s.kind for s in body.children]
+    check(kinds == ["val-decl", "return"], "evaluate 体是 let + return", f"实际 {kinds}")
+    check(walk(body, "try"), "evaluate 用了 ?")
+
+    tk = fn("tokenize")
+    tbody = [c for c in tk.children if c.kind == "block"][0]
+    check(any(s.kind == "while" for s in tbody.children), "tokenize 有 while")
+    wh = [s for s in tbody.children if s.kind == "while"][0]
+    check(walk(wh, "if"), "while 体内有 if 链")
+    check(len(walk(wh, "method-call")) > 0, "有方法调用")
+
+    rd = fn("reduce")
+    rbody = [c for c in rd.children if c.kind == "block"][0]
+    mts = walk(rbody, "match")
+    check(len(mts) == 1, "reduce 体内有一个 match", f"实际 {len(mts)}")
+    mt = mts[0]
+    check(len(mt.children) == 5, "reduce 的 match 有 4 臂 + 判别式",
+          f"实际 {len(mt.children)}")
+    arms = [c for c in mt.children if c.kind == "arm"]
+    check(len(arms) == 4, "4 个臂")
+    check(any(walk(a, "pattern-wildcard") for a in arms), "有 _ 通配臂")
+
+    at = fn("apply_top")
+    abody = [c for c in at.children if c.kind == "block"][0]
+    named = walk(abody, "named-arg")
+    check(len(named) >= 1, "apply_top 有命名实参（cause = …）", f"实际 {len(named)}")
+
+    dv = fn("digit_value")
+    dbody = [c for c in dv.children if c.kind == "block"][0]
+    check(walk(dbody, "cast"), "digit_value 用了 as 转换")
+
+    sr = fn("should_reduce")
+    sbody = [c for c in sr.children if c.kind == "block"][0]
+    check(sbody.children[0].kind == "if", "should_reduce 以 if 开头")
+
+
+# ---------------------------------------------------------------- 6. 字符字面量
+
+def test_char_literals():
+    print("[6] 字符字面量（L18）")
+    tu = parse_source(load("calculator.tu"), "tu")
+    consts = {c.name: c for c in items(tu.module, "const")}
+    sp = consts["SPACE"]
+    lit = walk(sp, "lit-char")[0]
+    check(lit.value == "' '", "SPACE 的值是字符字面量 ' '", f"实际 {lit.value!r}")
+    check(walk(consts["OPEN_PAREN"], "lit-char"), "OPEN_PAREN 是字符字面量")
+
+
+# ---------------------------------------------------------------- 7. choose / kernel / ?!
+
+def test_choose_kernel_dispatch():
+    print("[7] choose / kernel / ?!（B-16、F-9）")
+    src = """
+spec average(scores: []u8) -> Result[u64, CalcError] {
+    effects   {alloc};
+    model small { scores: make_u8s(max_len = 16), };
+    target {
+        time      : { max: O(scores.length()) },
+        allocation: { max: 0 },
+    };
+    choose sum_kernel(scores: []u8) -> u64 {
+        over     {sum_by_index, sum_by_iter pending};
+        usemodel {small};
+        objective time;
+    } end choose
+} end spec
+"""
+    r = parse_source(src, "t.tu")
+    check(r.ok, "tu 片段无诊断",
+          "; ".join(f"{d.code}@{d.line}:{d.message}" for d in r.diagnostics[:2]))
+
+    spec = items(r.module, "spec")[0]
+    body = items(spec, "spec-body")[0]
+    chs = items(body, "choose")
+    check(len(chs) == 1, "choose 挂在 spec 里")
+    ch = chs[0]
+    check(ch.name == "sum_kernel", "choose 标签", ch.name)
+    names = {c.name: c.value for c in ch.children}
+    over = names.get("over") or {}
+    check(over.get("names") == ["sum_by_index", "sum_by_iter"], "over 名单",
+          f"实际 {over.get('names')}")
+    check(over.get("pending") == ["sum_by_iter"], "over 里的 pending 标记",
+          f"实际 {over.get('pending')}")
+    check(names.get("usemodel") == ["small"], "usemodel 集合")
+    check(names.get("objective") == "time", "objective")
+
+    ai_src = """
+pub fn average(scores: []u8) -> Result[u64, CalcError] {
+    val n = scores.length();
+    if n == 0 { return Err(CalcError.Empty); } end if
+    val total = ?!sum_kernel(scores);
+    return (total / n)?;
+} kernels sum_kernel(scores: []u8) -> u64 {
+    sum_by_index {
+        var s = 0; var i = 0;
+        while i < scores.length() { s = s + *scores.at(i); i = i + 1; } end while
+        return s;
+    }
+    sum_by_iter {
+        return 0;
+    }
+} end fn
+"""
+    r2 = parse_source(ai_src, "t.ai")
+    check(r2.ok, "ai 片段无诊断",
+          "; ".join(f"{d.code}@{d.line}:{d.message}" for d in r2.diagnostics[:2]))
+
+    disp = walk(r2.module, "dispatch")
+    check(len(disp) == 1, "一个 ?! 决策点")
+    check(disp[0].name == "sum_kernel", "标签名 sum_kernel")
+
+    fn = items(r2.module, "fn")[0]
+    ks = items(fn, "kernels")
+    check(len(ks) == 1, "fn 上一个 kernels 块")
+    cands = items(ks[0], "candidate")
+    check([c.name for c in cands] == ["sum_by_index", "sum_by_iter"], "两个候选",
+          str([c.name for c in cands]))
+
+
+# ---------------------------------------------------------------- 8. 错误与恢复
+
+def test_errors():
+    print("[8] 错误诊断与恢复")
+
+    r = parse_source("spec a() -> u64 { effects {}; } end spec", "x")
+    check(r.ok, "最简 spec 可解析",
+          "; ".join(f"{d.code}@{d.line}" for d in r.diagnostics))
+
+    r = parse_source("spec a() -> u64 { effects {}; } end fn", "x")
+    check(not r.ok, "end fn 错配 spec 应报错")
+    check(any(d.code == "E-Parse-EndKindMismatch" for d in r.diagnostics),
+          "报 E-Parse-EndKindMismatch",
+          f"实际 {[d.code for d in r.diagnostics]}")
+
+    r = parse_source("spec a() -> u64 { effects {};", "x")
+    check(not r.ok, "缺 } 应报错")
+    check(any(d.code.startswith("E-Parse") for d in r.diagnostics), "给出 E-Parse-* 诊断")
+
+    r = parse_source("} } garbage", "x")
+    check(not r.ok, "顶层垃圾应报错")
+    check(len(r.diagnostics) >= 1, "至少一条诊断")
+
+    # 恢复：坏一个 item 之后仍能解析后面的
+    r = parse_source("enum E { A, B } end enum\nspec ok() -> u64 { effects {}; } end spec\n", "x")
+    check(r.ok, "前面好后面也好时无诊断",
+          "; ".join(f"{d.code}@{d.line}" for d in r.diagnostics))
+    check(len(items(r.module, "spec")) == 1, "恢复后仍拿到 spec")
+
+    # 不允许死循环：大量垃圾必须终止
+    r = parse_source("§§§ " * 200, "x")
+    check(not r.ok, "垃圾输入报错")
+    check(len(r.diagnostics) > 0, "有诊断且未挂死")
+
+    r = parse_source("", "x")
+    check(r.ok, "空文件合法")
+    check(r.module is not None and len(r.module.children) == 0, "空模块零 item")
+
+
+# ---------------------------------------------------------------- 9. 确定性
+
+def test_determinism():
+    print("[9] 确定性（同输入同输出）")
+    src = load("calculator.ai")
+    a = parse_source(src, "ai")
+    b = parse_source(src, "ai")
+    check(a.ok and b.ok, "两次都成功")
+    check(a.module.dump() == b.module.dump(), "AST 转储逐字节相同")
+    da = [d.to_dict() for d in a.diagnostics]
+    db = [d.to_dict() for d in b.diagnostics]
+    check(da == db, "诊断相同")
+
+
+# ---------------------------------------------------------------- main
+
+def main():
+    test_samples()
+    test_spec_clauses()
+    test_types()
+    test_enum()
+    test_statements()
+    test_char_literals()
+    test_choose_kernel_dispatch()
+    test_errors()
+    test_determinism()
+
+    print()
+    total = _passed + len(_failed)
+    if _failed:
+        print(f"失败 {len(_failed)} / {total}")
+        for f in _failed:
+            print("  - " + f)
+        return 1
+    print(f"全部通过：{_passed} 项")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())