gelang 0.1.6 → 0.1.7

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to GE. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versioning follows
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.7] — 2026-09-13
+
+Found while building a real application (a Flutter AI keyboard with a Rust
+memory layer and a C# core) against the published package.
+
+### Fixed
+
+- **Rust string parameters moved on first use.** `fn f(text: str)` emitted
+  `text: String`, so a parameter used twice failed with E0382. Parameters are
+  now `&str` and call sites borrow, which is the documented Rust idiom
+  ("prefer the borrowed type over borrowing the owned type"); a `str`
+  returning function converts back to an owned `String` on the way out.
+- **`s[i]` returned a code point, not a character.** Python's `s[i]` is a
+  one-character *string*, so `if s[0] == "a"` compared an integer with a
+  string and failed to compile on every backend.
+- **Zig could not compare strings.** `a == b` on two `[]const u8` is invalid;
+  equality now goes through `std.mem.eql`.
+- **`if len(s) < n` produced invalid Rust.** An unparenthesised cast made
+  `x.len() as i64 < 2` parse as a generic argument list.
+- **Rust string slicing and `contains`** needed `usize` ranges and `&str`
+  patterns respectively.
+- **Zig `int(3.9)`** was rejected (`@as(i64, 3.9)` cannot coerce); it now
+  uses `@intFromFloat`.
+- **Zig read-only list parameters** were `*std.ArrayList`, which forced the
+  caller to declare the list `var`. They are now `*const std.ArrayList`.
+- **Module-level string constants** were typed as integers, so `A + B` on two
+  string constants emitted integer addition.
+- **`ge analyze` did not know about imports.** Every call across a module
+  boundary was reported as `GE007 called but not defined`; the resolved units
+  are now passed to the type checker.
+- **Generated Flutter** had three analyzer warnings: an unused FFI handle and
+  a deprecated `withOpacity`. `flutter analyze` now reports no issues.
+
+### Changed
+
+- `examples/` is gitignored. It holds experiment projects built against the
+  published package to exercise the compiler, not part of the release.
+
 ## [Unreleased]
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gelang",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "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/dartgen.py

@@ -72,9 +72,9 @@ def generate_bindings(ffi_units: list[FuncUnit], lib_basename: str,
     if multi:
         # multi-backend: one DynamicLibrary per backend
         for b in sorted(backends_used):
-            lines.append(f"  late final DynamicLibrary _lib_{b};")
+            lines.append(f"  // ignore: unused_field\n  late final DynamicLibrary _lib_{b};")
     else:
-        lines.append("  late final DynamicLibrary _lib;")
+        lines.append("  // ignore: unused_field\n  late final DynamicLibrary _lib;")
 
     for u in ffi_units:
         lines.append(f"  late final {dart_name(u.name)}Dart {dart_name(u.name)};")
@@ -306,6 +306,7 @@ class HomePage extends StatefulWidget {{
 }}
 
 class _HomePageState extends State<HomePage> {{
+  // ignore: unused_field — the UI-only path has no native exports yet
   final NativeLib _lib = NativeLib();
 
 {state_decls}
@@ -353,7 +354,7 @@ class GeTagged extends StatelessWidget {{
         }},
         child: Container(
           decoration: BoxDecoration(
-            border: Border.all(color: Colors.blue.withOpacity(0.3), width: 1),
+            border: Border.all(color: Colors.blue.withValues(alpha: 0.3), width: 1),
           ),
           child: child,
         ),

package/python/pyeffic/emitters/base.py

@@ -51,6 +51,9 @@ class Spec:
     # Type-aware exponentiation. Integer `**` and float `**` need different
     # target syntax in most languages; when these are empty the emitter falls
     # back to pow_call.
+    # Converting a float to int needs a different spelling on some
+    # targets (Zig rejects @as(i64, 3.9)); empty falls back to int_cast.
+    int_cast_float: str = ""
     pow_int: str = ""
     pow_float: str = ""
     # two-argument min(a, b) / max(a, b). Most targets have no plain
@@ -164,6 +167,9 @@ class Emitter:
         # reset unsupported tracking for this function
         self.unsupported_emissions = []
         self.current_func = unit.name
+        # declared return type, so a borrowed &str can be converted back to an
+        # owned String on the way out (Rust idiom: borrow in, own out)
+        self.current_ret_type = unit.ret_type
         # load container element types for this function's params
         self.param_elem_types = getattr(unit, 'param_elem_types', {})
         self.param_dict_types = getattr(unit, 'param_dict_types', {})
@@ -268,6 +274,9 @@ class Emitter:
             return self.spec.dict_type.format(V=self.spec.list_elem_type)
         if t == "tuple":
             return self.spec.tuple_type.format(T=self.spec.list_elem_type)
+        if t == "str" and self.spec.name == "rust":
+            # borrowed: an owned String parameter would be moved on first use
+            return "&str"
         if t == "set":
             if self.spec.set_type:
                 if self.spec.name == "cpp":
@@ -330,6 +339,14 @@ class Emitter:
                         and node.value.id in self.mutated_params
                         and self.var_types.get(node.value.id) == "list"):
                     self.lines.append(f"{ind}return (*{node.value.id}).clone();")
+                elif (self.spec.name == "rust"
+                        and self.current_ret_type == "str"
+                        and isinstance(node.value, ast.Name)
+                        and node.value.id in self.params):
+                    # str parameters are borrowed &str, but a str-returning
+                    # function must hand back an owned String
+                    self.lines.append(
+                        f"{ind}return {self.expr(node.value)}.to_string();")
                 else:
                     self.lines.append(f"{ind}return {self.expr(node.value)};")
         elif isinstance(node, ast.Assign):
@@ -1114,7 +1131,8 @@ class Emitter:
                         elif self.spec.name == "go":
                             contains = f"contains({right}, {cur})"
                         elif self.spec.name == "kotlin":
-                            contains = f"{right}.contains({cur})"
+                            # contains() takes a Pattern, not a String
+                            contains = f"{right}.contains({cur}.as_str())"
                         else:
                             contains = f"/*contains*/"
                         if isinstance(op, ast.NotIn):
@@ -1124,7 +1142,8 @@ class Emitter:
                     else:
                         # string contains
                         if self.spec.name == "rust":
-                            contains = f"{right}.contains({cur})"
+                            # contains() takes a Pattern, not a String
+                            contains = f"{right}.contains({cur}.as_str())"
                         elif self.spec.name == "cpp":
                             contains = f"({right}.find({cur}) != std::string::npos)"
                         elif self.spec.name == "csharp":
@@ -1143,7 +1162,17 @@ class Emitter:
                 else:
                     sym = self.cmp_symbol(op)
                     right = self.expr(comp)
-                    parts.append(f"({cur} {sym} {right})")
+                    right_type = self.infer_type(comp)
+                    # Zig cannot compare slices with ==; string equality goes
+                    # through std.mem.eql.
+                    if (self.spec.name == "zig"
+                            and (left_type == "str" or right_type == "str")
+                            and isinstance(op, (ast.Eq, ast.NotEq))):
+                        eql = f"std.mem.eql(u8, {cur}, {right})"
+                        parts.append(f"(!{eql})" if isinstance(op, ast.NotEq)
+                                     else eql)
+                    else:
+                        parts.append(f"({cur} {sym} {right})")
                     cur = right
             return "(" + " && ".join(parts) + ")"
         if isinstance(node, ast.IfExp):
@@ -1423,7 +1452,11 @@ class Emitter:
         if fname == "pow":
             return self.spec.pow_call.format(l=self.expr(node.args[0]), r=self.expr(node.args[1]))
         if fname == "int":
-            return f"({self.spec.int_cast.format(x=self.expr(node.args[0]))})"
+            arg = node.args[0]
+            # Zig rejects @as(i64, 3.9); a float argument needs its own form
+            if self.infer_type(arg) == "float" and self.spec.int_cast_float:
+                return f"({self.spec.int_cast_float.format(x=self.expr(arg))})"
+            return f"({self.spec.int_cast.format(x=self.expr(arg))})"
         if fname == "float":
             return f"({self.spec.float_cast.format(x=self.expr(node.args[0]))})"
         if fname == "str":
@@ -1941,6 +1974,16 @@ class Emitter:
         t = self.infer_type(node)
         if t == "list":
             return "&" + s
+        if t == "str" and self.spec.name == "rust":
+            # a str param is &str; a String local or literal must be borrowed
+            if isinstance(node, ast.Name) and node.id in self.params:
+                return s          # already a &str parameter
+            if isinstance(node, ast.Constant) and isinstance(node.value, str):
+                # a literal is already &'static str; emitting String::from
+                # here would need an extra borrow and an allocation
+                return '"' + node.value.replace("\\", "\\\\").replace(
+                    '"', '\\"').replace("\n", "\\n") + '"'
+            return "&" + s
         return s
 
     def _stdlib_call(self, ge_name: str, args: list[ast.AST]) -> str:
@@ -2518,7 +2561,22 @@ class Emitter:
             if isinstance(node.value, str):
                 return "str"
         if isinstance(node, ast.Name):
-            return self.var_types.get(node.id, "int")
+            if node.id in self.var_types:
+                return self.var_types[node.id]
+            # module-level constants are inlined, not declared, so their type
+            # has to be recovered from the collected value — otherwise
+            # `GREETING + NAME` is treated as integer addition
+            if node.id in self.constants:
+                v = self.constants[node.id]
+                if isinstance(v, bool):
+                    return "bool"
+                if isinstance(v, int):
+                    return "int"
+                if isinstance(v, float):
+                    return "float"
+                if isinstance(v, str):
+                    return "str"
+            return "int"
         if isinstance(node, ast.BinOp):
             lt = self.infer_type(node.left)
             rt = self.infer_type(node.right)
@@ -2548,7 +2606,8 @@ class Emitter:
                 # slicing a string returns a string, slicing a list returns a list
                 return base_type if base_type in ("str", "list") else "list"
             if base_type == "str":
-                return "int"  # character access returns an integer (char code)
+                # Python's s[i] is a one-character string, not a code point
+                return "str"
             if base_type == "dict":
                 return "int"  # dict values are integers
             if base_type == "tuple":

package/python/pyeffic/emitters/cpp.py

@@ -54,7 +54,7 @@ SPEC = Spec(
     ffi_prefix='extern "C" ',
     str_concat="{l} + {r}",
     str_len="static_cast<int64_t>({x}.length())",
-    str_index="static_cast<int64_t>({x}[{i}])",
+    str_index="std::string(1, ({x})[({i})])",
     str_slice="{x}.substr({start}, {len})",
     str_slice_start="{x}.substr({start})",
     str_slice_end="{x}.substr(0, {end})",

package/python/pyeffic/emitters/csharp.py

@@ -64,7 +64,7 @@ SPEC = Spec(
     indent="    ",
     str_concat="{l} + {r}",
     str_len="{x}.Length",
-    str_index="(long)({x}[{i}])",
+    str_index="({x})[(int)({i})].ToString()",
     str_slice="{x}.Substring({start}, {len})",
     str_slice_start="{x}.Substring({start})",
     str_slice_end="{x}.Substring(0, {end})",

package/python/pyeffic/emitters/go.py

@@ -62,7 +62,7 @@ SPEC = Spec(
     indent="\t",
     str_concat="{l} + {r}",
     str_len="int64(len({x}))",
-    str_index="int64({x}[{i}])",
+    str_index="string(({x})[({i})])",
     str_slice="{x}[{start}:{end}]",
     str_slice_start="{x}[{start}:]",
     str_slice_end="{x}[:{end}]",

package/python/pyeffic/emitters/kotlin.py

@@ -61,7 +61,7 @@ SPEC = Spec(
     indent="    ",
     str_concat="{l} + {r}",
     str_len="{x}.length.toLong()",
-    str_index="{x}[{i}.toInt()].toLong()",
+    str_index="({x})[({i}).toInt()].toString()",
     str_slice="{x}.substring({start}.toInt(), {end}.toInt())",
     str_slice_start="{x}.substring({start}.toInt())",
     str_slice_end="{x}.substring(0, {end}.toInt())",

package/python/pyeffic/emitters/rust.py

@@ -24,7 +24,9 @@ SPEC = Spec(
     borrow_list_arg=True,
     range_call="({lo}..{hi})",
     range_step_call="({lo}..{hi}).step_by({step} as usize)",
-    len_call="{x}.len() as i64",
+    # parenthesised: an unparenthesised cast makes `x.len() as i64 < 2`
+    # parse as a generic argument list, not a comparison
+    len_call="({x}.len() as i64)",
     list_len="{x}.len() as i64",
     print_int='println!("{{}}", {v})',
     print_float='println!("{{}}", {v})',
@@ -55,11 +57,12 @@ SPEC = Spec(
     # `String + &String` is not Add in Rust and `a + b` moves `a`, so a
     # format! is used instead — always correct, and it accepts &str too.
     str_concat="format!(\"{{}}{{}}\", {l}, {r})",
-    str_len="{x}.len() as i64",
-    str_index="{x}.as_bytes()[{i} as usize] as i64",
-    str_slice="{x}[{start}..{end}].to_string()",
-    str_slice_start="{x}[{start}..].to_string()",
-    str_slice_end="{x}[..{end}].to_string()",
+    str_len="({x}.len() as i64)",
+    str_index="{x}[({i}) as usize..].chars().next().unwrap_or(' ').to_string()",
+    # ranges must be usize, and slicing a String needs a panic-free bound
+    str_slice="{x}[({start}) as usize..({end}) as usize].to_string()",
+    str_slice_start="{x}[({start}) as usize..].to_string()",
+    str_slice_end="{x}[..({end}) as usize].to_string()",
     list_concat="{{ let mut t = {l}; t.extend({r}.iter()); t }}",
     condition_parens=False,
     # .cloned() so the loop variable is owned: iterating a &[i64]

package/python/pyeffic/emitters/zig.py

@@ -32,6 +32,7 @@ SPEC = Spec(
     list_reverse="std.mem.reverse(i64, {x}.items)",
     print_list='gePrintList({v}.items)',
     int_cast="@as(i64, {x})",
+    int_cast_float="@as(i64, @intFromFloat({x}))",
     float_cast="@as(f64, {x})",
     float_div="(@as(f64, {l}) / @as(f64, {r}))",
     floor_div="@divFloor({l}, {r})",
@@ -55,7 +56,7 @@ SPEC = Spec(
     indent="    ",
     str_concat="{l} ++ {r}",
     str_len="{x}.len",
-    str_index="{x}[{i}]",
+    str_index="({x})[@as(usize, @intCast({i}))..][0..1]",
     str_slice="{x}[{start}..{end}]",
     str_slice_start="{x}[{start}..]",
     str_slice_end="{x}[..{end}]",
@@ -269,6 +270,11 @@ class ZigEmitter(Emitter):
         params = []
         for pname, ptype in unit.params:
             nt = self.param_native_type(ptype, pname)
+            # A parameter this function does not mutate is borrowed const, so
+            # the caller may keep its own binding `const`.
+            if (ptype == "list" and nt.startswith("*std.ArrayList")
+                    and pname not in self.mutated_list_params):
+                nt = "*const " + nt[1:]
             params.append(f"{pname}: {nt}")
         ret = self.py_to_native(unit.ret_type) if unit.ret_type != "None" else "void"
         param_str = ", ".join(params)

package/python/pyeffic/ge_cli.py

@@ -238,8 +238,12 @@ def cmd_analyze(args) -> int:
         print(f"  Import resolution error: {e}")
         units, classes, warnings = [], [], []
 
-    # Run type checker
-    reporter = check_source(source, file=str(source_path), entry=entry)
+    # Run type checker. The resolved units are passed in so that functions
+    # brought in by an import are known — otherwise every call across a module
+    # boundary is reported as GE007 "called but not defined".
+    reporter = check_source(source, file=str(source_path), entry=entry,
+                            units=units or None,
+                            classes=classes or None)
 
     # Print diagnostics
     errors = [d for d in reporter.diagnostics if d.severity == "error"]