gelang 0.1.3 → 0.1.5

package/python/pyeffic/emitters/zig.py

@@ -13,31 +13,40 @@ from ..analyzer import FuncUnit
 SPEC = Spec(
     name="zig",
     types={"int": "i64", "float": "f64", "bool": "bool", "str": "[]const u8", "None": "void"},
-    list_type="[]const i64",
-    list_param_type="[]const i64",
+    list_type="std.ArrayList({T})",
+    list_param_type="*std.ArrayList(i64)",
     list_elem_type="i64",
+    list_slice="geListSlice(i64, {x}.items, @as(usize, @intCast({start})), @as(usize, @intCast({stop})))",
+    list_copy="geListCopy(i64, {x}.items)",
     borrow_list_arg=False,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi})",
-    len_call="@as(i64, @intCast({x}.len))",
-    list_len="@as(i64, @intCast({x}.len))",
+    len_call="@as(i64, @intCast({x}.items.len))",
+    list_len="@as(i64, @intCast({x}.items.len))",
     print_int='std.io.getStdOut().writer().print("{{d}}\\n", .{{{v}}}) catch unreachable',
     print_float='std.io.getStdOut().writer().print("{{d}}\\n", .{{{v}}}) catch unreachable',
     print_str='std.io.getStdOut().writer().print("{{s}}\\n", .{{{v}}}) catch unreachable',
-    print_bool='std.io.getStdOut().writer().print("{}\\n", .{{{v}}}) catch unreachable',
+    print_bool='std.io.getStdOut().writer().print("{{s}}\\n", .{{if ({v}) "True" else "False"}}) catch unreachable',
     print_generic='std.io.getStdOut().writer().print("{{any}}\\n", .{{{v}}}) catch unreachable',
+    list_sort="std.mem.sort(i64, {x}.items, {{}}, std.sort.asc(i64))",
+    list_reverse="std.mem.reverse(i64, {x}.items)",
+    print_list='gePrintList({v}.items)',
     int_cast="@as(i64, {x})",
     float_cast="@as(f64, {x})",
     float_div="(@as(f64, {l}) / @as(f64, {r}))",
     floor_div="@divFloor({l}, {r})",
-    sum_call="blk: {{ var s: i64 = 0; for ({it}) |v| {{ s += v; }} break :blk s; }}",
-    abs_int="@intCast(if ({x} < 0) -{x} else {x})",
+    sum_call="blk: {{ var s: i64 = 0; for ({it}.items) |v| {{ s += v; }} break :blk s; }}",
+    abs_int="@as(i64, @intCast(if ({x} < 0) -{x} else {x}))",
     abs_float="@abs({x})",
-    min_call="@min({it}...)",
-    max_call="@max({it}...)",
+    min2_call="@min({a}, {b})",
+    max2_call="@max({a}, {b})",
+    min_call="blk: {{ var __m = {it}.items[0]; for ({it}.items) |v| {{ if (v < __m) __m = v; }} break :blk __m; }}",
+    max_call="blk: {{ var __m = {it}.items[0]; for ({it}.items) |v| {{ if (v > __m) __m = v; }} break :blk __m; }}",
     pow_call="std.math.pow(i64, {l}, {r})",
+    pow_int="std.math.pow(i64, {l}, {r})",
+    pow_float="std.math.pow(f64, {l}, {r})",
     append_call="{x}.append({v}) catch unreachable",
-    index_call="{x}[@as(usize, @intCast({i}))]",
+    index_call="{x}.items[@as(usize, @intCast({i}))]",
     comment="//",
     fn_template="{sig} {{\n{body}\n}}",
     main_template="",
@@ -50,16 +59,24 @@ SPEC = Spec(
     str_slice="{x}[{start}..{end}]",
     str_slice_start="{x}[{start}..]",
     str_slice_end="{x}[..{end}]",
-    list_concat="blk: {{ var t = std.ArrayList(i64).init(std.heap.page_allocator); t.appendSlice({l}) catch unreachable; t.appendSlice({r}) catch unreachable; break :blk t.toOwnedSlice() catch unreachable; }}",
-    foreach_template="for ({iter}) |{var}|",
+    list_concat="geListConcat(i64, {l}.items, {r}.items)",
+    str_split="geStrSplit({x}, {sep})",
+    str_join="geStrJoin({x}.items, {sep})",
+    str_upper="geStrUpper({x})",
+    str_lower="geStrLower({x})",
+    str_replace="geStrReplace({x}, {a}, {b})",
+    foreach_template="for ({iter}.items) |{var}|",
     try_template="// try/except limited in Zig\n// {body}\n// {handler}",
     struct_template="const {name} = struct {{\n{fields}\n}};",
     struct_field_template="    {type}: {name},",
     struct_new_template="fn {name}_new({params}) {name} {{\n{body}\n}}",
     dict_type="std.StringHashMap({V})",
+    set_type="std.AutoHashMap(i64, void)",
     dict_get="{d}.get({k}).?",
     dict_set="{d}.put({k}, {v}) catch unreachable",
     dict_contains="{d}.contains({k})",
+    set_len="@as(i64, @intCast({x}.count()))",
+    dict_len="@as(i64, @intCast({x}.count()))",
     tuple_type="[2]{T}",
     tuple_get="{t}[{i}]",
 )
@@ -112,69 +129,49 @@ class ZigEmitter(Emitter):
             elif isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
                 if node.func.attr == "append" and isinstance(node.func.value, ast.Name):
                     mutated.add(node.func.value.id)
+            elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+                # passing a list to a callee that mutates it counts as a
+                # mutation here, so the local must be `var`
+                for idx in self.func_mutated_params.get(node.func.id, ()):
+                    if idx < len(node.args):
+                        arg = node.args[idx]
+                        if isinstance(arg, ast.Name):
+                            mutated.add(arg.id)
         return mutated
 
     def emit(self, unit: FuncUnit) -> str:
-        """Override emit to track mutated variables and make mutable param copies."""
+        """Emit a function.
+
+        A list parameter is a `*std.ArrayList(i64)`, so no conversion is
+        needed: the callee mutates the caller's list directly. Only scalar
+        parameters that are reassigned need a mutable local, because Zig
+        parameters are immutable.
+        """
         self.mutated = self._find_mutated_vars(unit.body)
-        # Detect mutated list parameters (append, subscript assign, etc.)
-        self.mutated_list_params: set[str] = set()
-        for pname, ptype in unit.params:
-            if ptype == "list" and pname in self.mutated:
-                self.mutated_list_params.add(pname)
-        # Zig parameters are const — make mutable copies for any scalar param that's mutated
-        # List params that are mutated need ArrayList conversion
-        mutated_params = []
-        for pname, ptype in unit.params:
-            if pname in self.mutated and ptype != "list":
-                mutated_params.append(pname)
-        # We'll insert mutable copies as the first lines of the body
-        self._zig_mut_copies = mutated_params
-        self._zig_list_conversions = list(self.mutated_list_params)
+        self.mutated_list_params = {
+            pname for pname, ptype in unit.params
+            if ptype == "list" and pname in self.mutated
+        }
+        self.mutated_params = {
+            pname for pname, ptype in unit.params
+            if pname in self.mutated and ptype != "list"
+        }
         result = super().emit(unit)
-        if mutated_params or self.mutated_list_params:
-            # Insert mutable copies and list conversions right after the opening brace
+        if self.mutated_params:
             lines = result.split("\n")
-            insert_lines = []
-            for pname in mutated_params:
-                insert_lines.append(f"    var {pname}_ = {pname};")
-            for pname in self.mutated_list_params:
-                # Convert []const i64 to ArrayList for mutation
-                insert_lines.append(f"    var {pname}_list = std.ArrayList(i64).init(std.heap.page_allocator);")
-                insert_lines.append(f"    for ({pname}) |item| {{ {pname}_list.append(item) catch unreachable; }}")
+            insert = [f"    var {p}_ = {p};" for p in sorted(self.mutated_params)]
             for i, line in enumerate(lines):
-                if "{" in line and "fn" in lines[i]:
-                    for j, il in enumerate(insert_lines):
+                if "fn" in line and "{" in line:
+                    for j, il in enumerate(insert):
                         lines.insert(i + 1 + j, il)
                     break
             result = "\n".join(lines)
-            # Replace param references with mutable version
             import re
-            for pname in mutated_params:
-                old = result
-                result = re.sub(r'\b' + pname + r'\b', pname + "_", result)
-                result = re.sub(r'\b' + pname + r'_: ', pname + ': ', result, count=1)
-                result = result.replace(f"var {pname}_ = {pname}_;", f"var {pname}_ = {pname};")
-            # Replace list param references with ArrayList.items where indexing, or the list itself for append
-            for pname in self.mutated_list_params:
-                # Replace append calls: pname.append(v) -> pname_list.append(v)
-                result = re.sub(
-                    r'\b' + pname + r'\.append\(',
-                    pname + '_list.append(',
-                    result
-                )
-                # Replace indexing: pname[i] -> pname_list.items[i]
-                result = re.sub(
-                    r'\b' + pname + r'\[',
-                    pname + '_list.items[',
-                    result
-                )
-                # Replace len(pname) -> pname_list.items.len
-                result = re.sub(
-                    r'\b' + pname + r'\.len\b',
-                    pname + '_list.items.len',
-                    result
-                )
+            for pname in self.mutated_params:
+                result = re.sub(r"\b" + pname + r"\b", pname + "_", result)
+                result = re.sub(r"\b" + pname + r"_: ", pname + ": ", result, count=1)
+                result = result.replace(f"var {pname}_ = {pname}_;",
+                                        f"var {pname}_ = {pname};")
         return result
 
     def _is_mutated(self, var: str) -> bool:
@@ -194,12 +191,19 @@ class ZigEmitter(Emitter):
                 self.lines.append(f"{ind}_ = {self.expr(node.value)};")
                 return
         if isinstance(node, ast.AnnAssign) and node.value is not None:
+            # bare `list` gets its element type from the value
             target = node.target.id if isinstance(node.target, ast.Name) else self.expr(node.target)
             t = self._ann_type(node.annotation) if isinstance(node.target, ast.Name) else self.infer_type(node.value)
             if isinstance(node.target, ast.Name):
                 self.var_types[target] = t
                 self.declared.add(target)
             nt = self.py_to_native(t)
+            if t == "list":
+                # a bare `list` annotation carries no element type; take it
+                # from the value so `"a,b".split(",")` is a string list
+                elem = self._list_elem_of_value(node.value)
+                if elem and elem != self.spec.list_elem_type:
+                    nt = self.spec.list_type.format(T=elem)
             kw = self._decl_keyword(target)
             self.lines.append(f"{ind}{kw} {target}: {nt} = {self.expr(node.value)};")
             return
@@ -244,8 +248,16 @@ class ZigEmitter(Emitter):
             self.lines.append(f"{ind}while ({var} < {hi}) : ({var} += 1) {{")
         else:
             iter_s = self.expr(it)
-            self.var_types[var] = "long"
-            self.lines.append(f"{ind}for ({iter_s}) |{var}| {{")
+            if self.infer_type(it) == "dict":
+                # Zig has no allocator here, so walk the map's key iterator
+                # instead of materialising a key list.
+                self.var_types[var] = "str"
+                self.lines.append(f"{ind}var __keys_{var} = {iter_s}.keyIterator();")
+                self.lines.append(f"{ind}while (__keys_{var}.next()) |__kp_{var}| {{")
+                self.lines.append(f"{ind}    const {var} = __kp_{var}.*;")
+            else:
+                self.var_types[var] = "long"
+                self.lines.append(f"{ind}for ({iter_s}.items) |{var}| {{")
         self.indent_lvl += 1
         for s in node.body:
             self.stmt(s)
@@ -256,7 +268,7 @@ class ZigEmitter(Emitter):
         emit_name = unit.name.replace(".", "_")
         params = []
         for pname, ptype in unit.params:
-            nt = self.param_native_type(ptype)
+            nt = self.param_native_type(ptype, pname)
             params.append(f"{pname}: {nt}")
         ret = self.py_to_native(unit.ret_type) if unit.ret_type != "None" else "void"
         param_str = ", ".join(params)
@@ -303,6 +315,23 @@ def _emit_structs_zig(classes: list) -> str:
     return "\n".join(out)
 
 
+def _precompute_mutated_params(emitter, units) -> None:
+    """Record which parameters each function mutates.
+
+    The emitter normally learns this as it emits each unit, so a function
+    defined after its caller would not be known yet. Doing it up front makes
+    call-site handling independent of definition order.
+    """
+    for u in units:
+        if u.body is None:
+            continue
+        mutated = emitter._find_mutated_vars(u.body.body)
+        indices = {i for i, (pname, _pt) in enumerate(u.params)
+                   if pname in mutated}
+        if indices:
+            emitter.func_mutated_params[u.name] = indices
+
+
 def emit_zig(units: list[FuncUnit], entry: str | None,
              library_mode: bool = False,
              extern_fns: list[FuncUnit] | None = None,
@@ -315,8 +344,14 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
     extern_fns: functions from other backends that this Zig code calls.
     """
     emitter = ZigEmitter(SPEC)
+    emitter.func_signatures = {
+        u.name: ([p for p, _t in u.params],
+                 dict(getattr(u, 'param_defaults', {})))
+        for u in units
+    }
     emitter.library_mode = library_mode
     emitter.constants = constants or {}
+    _precompute_mutated_params(emitter, units)
     emitted: dict[str, str] = {}
     fns: list[str] = []
 
@@ -388,19 +423,33 @@ def emit_zig(units: list[FuncUnit], entry: str | None,
 
     if entry_u.name != "main":
         if entry_u.ret_type == "None":
-            wrapper = "pub fn main() void {\n    " + entry_u.name + "();\n}\n"
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    " + entry_u.name + "();\n}\n")
         else:
-            wrapper = f"pub fn main() void {{\n    _ = {entry_u.name}();\n}}\n"
+            wrapper = (f"pub fn main() void {{\n"
+                       f"    defer _ = ge_arena.deinit();\n"
+                       f"    _ = {entry_u.name}();\n}}\n")
         fns.append(wrapper)
+    elif not fns:
+        # the entry function was rejected during emission; the pipeline
+        # already has the reason, so emit a stub rather than crashing
+        return prelude, emitted
     else:
         # Zig main() must return void (or u8 for exit code)
-        # Rename the user's main() to __ge_main() and add a wrapper
+        # Rename the user's main() to __ge_main() and add a wrapper that also
+        # releases the arena.
         if entry_u.ret_type != "None":
             fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "fn __ge_main(")
-            wrapper = "pub fn main() void {\n    _ = __ge_main();\n}\n"
-            fns.append(wrapper)
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    _ = __ge_main();\n}\n")
         else:
-            fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "pub fn main(")
+            fns[-1] = fns[-1].replace(f"fn {entry_u.name}(", "fn __ge_main(")
+            wrapper = ("pub fn main() void {\n"
+                       "    defer _ = ge_arena.deinit();\n"
+                       "    __ge_main();\n}\n")
+        fns.append(wrapper)
 
     program = prelude + "\n".join(fns) + "\n"
     # inject stdlib runtime

package/python/pyeffic/ge_cli.py

@@ -211,11 +211,27 @@ def cmd_analyze(args) -> int:
         return 1
 
     source = source_path.read_text(encoding="utf-8")
+    original_source = source
     entry = args.entry or "main"
 
+    # Lower non-Python flavours (.ge hybrid, .ge.ts) before analysis, exactly
+    # as build() does. Without this, `ge analyze` parses a hybrid file as
+    # plain Python and reports a syntax error on the first block tag.
+    # resolve_imports lowers internally, so it gets the original source.
+    from .frontends import frontend_for
+    from .frontends.typescript import TypeScriptSyntaxError
+    from .modules import _lower_source
+
+    if frontend_for(source_path) != "python":
+        try:
+            source = _lower_source(source, source_path)
+        except TypeScriptSyntaxError as exc:
+            print(f"Error: {exc}", file=sys.stderr)
+            return 1
+
     # Resolve imports first
     try:
-        units, classes, warnings = resolve_imports(source, source_path)
+        units, classes, warnings = resolve_imports(original_source, source_path)
         for w in warnings:
             print(f"  warning: {w}")
     except Exception as e:
@@ -411,8 +427,96 @@ def _print_flutter(report) -> None:
         print(f"  ! {e}")
 
 
+def _ui_node_to_tree(node) -> dict:
+    """Convert a .ge.ui WidgetNode into the dict dartgen.generate_main wants."""
+    if node is None:
+        return {"kind": "Column", "children": [], "align": "center"}
+    d: dict = {"kind": node.kind}
+    if node.children:
+        d["children"] = [_ui_node_to_tree(c) for c in node.children]
+    child = node.props.get("child")
+    if child is not None and hasattr(child, "kind"):
+        d["child"] = _ui_node_to_tree(child)
+    if node.text is not None:
+        d["text"] = node.text
+    elif "text" in node.props:
+        d["text"] = node.props["text"]
+    if node.label is not None:
+        d["label"] = node.label
+    elif "label" in node.props:
+        d["label"] = node.props["label"]
+    if node.state:
+        d["state"] = node.state
+    style = node.props.get("style") or node.style_dict.get("style")
+    if style:
+        d["style"] = style
+    for key in ("align", "padding", "color", "hint"):
+        if key in node.props:
+            d[key] = node.props[key]
+    if node.action:
+        d["action"] = node.action
+    return d
+
+
+def _flutter_from_ui(args, ui_path: Path) -> int:
+    """`ge flutter foo.ge.ui` — generate a Flutter project from the UI DSL."""
+    from .ui_dsl import parse_ui_file
+    from .dartgen import generate_main, generate_pubspec
+    from .config import Config
+
+    try:
+        screen = parse_ui_file(ui_path)
+    except SyntaxError as e:
+        print(f"error: invalid .ge.ui — {e}", file=sys.stderr)
+        return 1
+
+    app_name = args.app_name or ui_path.stem
+    cfg = Config(out_dir=Path(args.out_dir), target="mobile")
+    project_dir = cfg.target_dir / app_name
+    lib_dir = project_dir / "lib"
+    lib_dir.mkdir(parents=True, exist_ok=True)
+
+    tree = _ui_node_to_tree(screen.root)
+    title = screen.title or app_name
+    main_dart = generate_main(tree, [], app_title=title)
+
+    (lib_dir / "main.dart").write_text(main_dart, encoding="utf-8")
+    # generate_main always imports bindings.dart; a UI-only project has no
+    # FFI exports, so emit the stub rather than leaving a dangling import.
+    from .dartgen import generate_bindings
+    (lib_dir / "bindings.dart").write_text(
+        generate_bindings([], app_name), encoding="utf-8")
+    (project_dir / "pubspec.yaml").write_text(
+        generate_pubspec(app_name), encoding="utf-8")
+
+    print(GE_BANNER)
+    print()
+    print(f"== GE flutter app: {project_dir} ==")
+    print(f"Title       : {title}")
+    print(f"Dart files  : {lib_dir / 'main.dart'}")
+    print(f"\nNext: cd {project_dir} && flutter pub get && flutter run")
+
+    dart = _find_dart()
+    if dart:
+        r = subprocess.run([dart, "analyze", str(lib_dir)],
+                           capture_output=True, text=True, timeout=120)
+        out = ((r.stdout or "") + (r.stderr or "")).strip()
+        print(out[:1200] if out else "(analyzer: no output)")
+        print("Dart analysis: " + ("PASS" if r.returncode == 0 else "issues found"))
+    else:
+        print("\n(dart not found — install Flutter to validate generated Dart)")
+    return 0
+
+
 def cmd_flutter(args) -> int:
-    source = _maybe_transpile_ts(Path(args.file))
+    src_path = Path(args.file)
+    # A .ge.ui file is a UI definition, not GE source. `ge flutter` used to
+    # hand it to the module resolver, which tried to parse `Window {` as
+    # Python and failed. Generate the Dart UI directly instead.
+    if src_path.suffix == ".ui":
+        return _flutter_from_ui(args, src_path)
+
+    source = _maybe_transpile_ts(src_path)
     # a Flutter app is a mobile artifact, so it always lands in build/mobile/
     cfg = Config(out_dir=Path(args.out_dir), target="mobile",
                  force_backend=None if args.backend == "auto" else args.backend,
@@ -502,12 +606,14 @@ def cmd_react(args) -> int:
         return 1
 
     app_name = args.app_name or ui_path.stem.replace(".ge", "")
-    # default: sibling web/frontend next to the ui/ directory
+    # Output goes under the target-aware build root so every artifact of a
+    # project lives in one place: build/web/frontend. An explicit -o wins.
     if args.out_dir:
         out_dir = Path(args.out_dir)
     else:
-        base = ui_path.parent.parent if ui_path.parent.name == "ui" else ui_path.parent
-        out_dir = base / "web" / "frontend"
+        from .config import Config
+        cfg = Config(target="web")
+        out_dir = cfg.target_dir / "frontend"
 
     files = generate_react_app(screen, app_name)
     written = write_react_app(files, out_dir, force=args.force)