gelang 0.1.3 → 0.1.5

package/CHANGELOG.md

@@ -53,6 +53,118 @@ All notable changes to GE. Format follows
   single-flavour files; `.ts.ge.py` is accepted as a legacy alias.
 - Build root defaults to `build/` (was `ge_build/`).
 - Package name on npm is `gelang`.
+## [0.1.5] — 2026-09-13
+
+### Zig is now a full backend
+
+Zig modelled a GE list as a `[]const i64` slice, which cannot grow, so
+`append`, `sort`, `split`, list comprehensions and `min`/`max` over a list
+were either rejected or emitted Zig that did not compile. Research into
+Zig's allocator conventions settled the design: a generated program runs
+start to finish, so a single **arena** is the right fit — not
+`page_allocator` (a syscall per allocation) and not
+`GeneralPurposeAllocator` (a debugging allocator).
+
+Lists are now `std.ArrayList(T)` over an arena that `main()` releases:
+
+- literals become `geListFrom(elem, &[_]elem{...})`; an empty literal is
+  `geListNew(elem)`
+- append, sort, reverse, index, len, iteration, slicing and printing all work
+- a list parameter is `*std.ArrayList`, so mutation in the callee is visible
+  to the caller, matching Python's reference semantics. Call sites pass
+  `&name`; an rvalue argument is bound to a temporary first.
+- passing a list to a mutating callee marks the local `var` (Zig rejects an
+  unmutated `var`)
+
+Also implemented for Zig: `str.split`, `str.join`, `str.replace`,
+`str.upper`, `str.lower` (all arena-allocated), sets as
+`AutoHashMap(elem, void)` with a deduplicating literal, and dict literals
+over the arena.
+
+### Fixed
+
+- Iterating a Rust list yields `&i64`, so `for x in xs: if x == n` did not
+  compile. The loop now uses `.cloned()`, which yields owned values for both
+  `i64` and `String`. Python semantics are unchanged.
+- Go rejects `int64(3.9)` for an untyped constant; `int()` now truncates
+  through `math.Trunc`, matching Python.
+- `list.sort()` and `list.reverse()` had no implementation and fell through
+  to `xs.sort()`, valid only in Rust and Kotlin.
+- `ge analyze` parsed hybrid `.ge` files as plain Python, reporting a syntax
+  error on the first block tag, and never lowered `.ge.ts` at all.
+- `ge react` wrote to `web/` instead of the documented `build/web/`.
+- `ge flutter` handed a `.ge.ui` file to the module resolver, which tried to
+  parse `Window {` as Python.
+- The return type of `str.upper()` and friends was not inferred, so `print`
+  used the generic format — a Zig `[]const u8` rendered as a byte array.
+- `scripts/e2e.py` aborted the whole run with `UnicodeEncodeError` when a
+  compiler diagnostic contained a character the console codec cannot encode.
+
+### Added
+
+- `scripts/e2e.py` — 118 end-to-end cases that compile and run real programs
+  on every installed backend and compare stdout with CPython.
+- `str_upper`, `str_lower`, `str_replace`, `set_len` and `dict_len` on the
+  shared `Spec`, so every backend expresses these the same way.
+
+### Known limitations
+
+- Tuples are supported at arity 2; other arities are rejected with
+  `error[GE009]` rather than emitting broken code.
+## [0.1.4] — 2026-09-13
+
+Found by `scripts/e2e.py`, a new harness that compiles and runs 118
+programs on every installed backend and compares stdout with CPython.
+
+### Fixed
+
+- **Wrong output.** `print(True)` printed lowercase `true` on Rust, C++,
+  Go, Zig and Kotlin; list printing used each target's native format
+  (`[1 2 3]` in Go, `{ 1, 2, 3 }` in Zig). Both now match Python.
+- **Dict iteration** walked `(key, value)` pairs instead of keys, so
+  `for k in d: d[k]` failed to compile on every backend.
+- **List slicing** was marked unsupported, which dropped the whole
+  function and surfaced as the misleading `main function not found`.
+  `xs[a:b]`, `xs[a:]`, `xs[:b]` and `xs[:]` are implemented everywhere.
+- **`str.split` / `str.join`** had no implementation at all.
+- **`str.replace`** had no implementation at all.
+- **`min(a, b)` / `max(a, b)`** emitted a bare call no target provides.
+- **`abs()`** on a literal was ambiguous in Rust, untyped in Zig, and
+  absent for `int64` in Go.
+- **Default arguments** were rejected outright. A call may now supply
+  between `n_required` and `len(params)` arguments.
+- **`set` annotations** became `f64`, because `set` was missing from the
+  native type mapping. Added `set_type` per backend.
+- **Lists of strings** could not be expressed: only Rust and C++ had a
+  `{T}` placeholder in `list_type`.
+- **C++ `std::sqrt`** appeared before `#include <cmath>`.
+- **Kotlin** used `Math.pow` (no such class in Kotlin/Native) and a
+  C-style ternary (Kotlin has no `?:`).
+- **C++ `upper()` / `lower()`** emitted a bare comment, so the program
+  compiled but did nothing.
+- **Rust string concatenation** moved the left operand.
+- **Emitter crashes**: when the entry function was rejected, zig, go,
+  kotlin and csharp raised `IndexError` instead of reporting the reason.
+- **`ge tools check`** disagreed with `ge doctor` because `CompilerInfo`
+  field names (`dotnet`, `kotlinc`) differ from the public toolchain
+  names.
+- **Zig** emitted a raw newline inside a string literal, and
+  `_mark_unsupported` produced a C-style comment, which Zig rejects.
+
+### Added
+
+- `scripts/e2e.py` — end-to-end tests against real toolchains.
+- `ge doctor` — runtime and toolchain check with install hints.
+
+### Known limitations
+
+- Zig models lists as fixed slices, so `list.append` is rejected with a
+  clear diagnostic rather than compiling. Switching the backend to
+  `std.ArrayList` needs an allocator threaded through every signature.
+- Tuples are supported at arity 2; other arities are rejected with a
+  diagnostic instead of emitting broken code.
+
+
 
 ## [0.1.0] — 2026-09-12
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gelang",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "One typed source language, compiled to Rust, C++, C#, Zig, Go, or Kotlin — chosen per function. Generates Flutter and React UIs from one DSL.",
   "keywords": [
     "ge",

package/python/pyeffic/analyzer.py

@@ -38,6 +38,11 @@ class FuncUnit:
     param_elem_types: dict[str, str] = field(default_factory=dict)
     # dict key/value types: {"d": ("str", "int")} means d is dict[str, int]
     param_dict_types: dict[str, tuple[str, str]] = field(default_factory=dict)
+    # Number of leading parameters without a default. Calls may
+    # supply between n_required_params and len(params) arguments.
+    n_required_params: int = 0
+    # Default expressions per parameter name, as source text.
+    param_defaults: dict[str, str] = field(default_factory=dict)
 
     def mark_unsupported(self, reason: str) -> None:
         self.supported = False
@@ -310,6 +315,19 @@ def parse_source_full(source: str) -> tuple[list[FuncUnit], list[ClassUnit]]:
             ret = _norm_type(node.returns)
             if ret not in SCALAR_TYPES and ret not in CONTAINER_TYPES and ret != "None" and ret not in _class_names:
                 ret = "any"
+            # Default arguments: a call may supply between n_required and
+            # len(params) arguments; the rest are filled in at the call site.
+            _args = node.args.args
+            _n_defaults = len(node.args.defaults)
+            _n_required = len(_args) - _n_defaults
+            _param_defaults: dict[str, str] = {}
+            for _i, _a in enumerate(_args):
+                if _i >= _n_required:
+                    _d = node.args.defaults[_i - _n_required]
+                    try:
+                        _param_defaults[_a.arg] = ast.unparse(_d)
+                    except Exception:
+                        _param_defaults[_a.arg] = ""
             unit = FuncUnit(
                 name=node.name,
                 lineno=node.lineno,
@@ -319,6 +337,8 @@ def parse_source_full(source: str) -> tuple[list[FuncUnit], list[ClassUnit]]:
                 source="\n".join(src_lines[node.lineno - 1 : node.end_lineno]),
                 param_elem_types=param_elem_types,
                 param_dict_types=param_dict_types,
+                n_required_params=_n_required,
+                param_defaults=_param_defaults,
             )
             # parse @rust/@cpp/@dart/@csharp/@zig/@go decorators for per-function backend selection
             for dec in node.decorator_list:

package/python/pyeffic/downloader.py

@@ -293,10 +293,22 @@ def get_tools_status() -> dict[str, dict]:
     """Get status of all known toolchains."""
     from .config import detect_compilers
     detected = detect_compilers()
+    # CompilerInfo field names differ from the public toolchain names
+    # (`dotnet` backs C#, `kotlinc` backs Kotlin), so map them explicitly.
+    fields = {
+        "rust": "rustc",
+        "cpp": "cpp",
+        "csharp": "dotnet",
+        "zig": "zig",
+        "go": "go",
+        "kotlin": "kotlinc",
+        "dart": "dart",
+    }
     status = {}
     for name in ["rust", "cpp", "csharp", "zig", "go", "kotlin", "dart"]:
-        available = is_toolchain_available(name) or getattr(detected, name, None) is not None
-        path = get_toolchain_path(name) or getattr(detected, name, None)
+        detected_path = getattr(detected, fields.get(name, name), None)
+        available = is_toolchain_available(name) or detected_path is not None
+        path = get_toolchain_path(name) or detected_path
         downloadable = name in DOWNLOAD_URLS
         status[name] = {
             "available": bool(available),