Handle globals

Author: johnsamuelwrites

multilingualprogramming/codegen/wat_generator.py

@@ -369,29 +369,33 @@ def _gen_stmt(self, stmt, indent: str):  # noqa: C901  # pylint: disable=too-man
                 self._emit(f"{indent};; unpacking declaration lowered")
             else:
                 name = _name(stmt.name)
-                self._locals.add(name)
                 self._emit(f"{indent};; let {name} = ...")
                 self._gen_expr(stmt.value, indent)
-                self._emit(f"{indent}local.set ${self._wat_symbol(name)}")
+                if not self._is_module_global(name):
+                    self._locals.add(name)
+                self._emit_name_set(name, indent)
                 self._update_assignment_tracking(name, stmt.value, indent)
 
         elif isinstance(stmt, Assignment):
             target = stmt.target
             if isinstance(target, Identifier):
                 name = target.name
-                self._locals.add(name)
                 op = stmt.op
                 if op == "=":
                     self._emit(f"{indent};; {name} = ...")
                     self._gen_expr(stmt.value, indent)
-                    self._emit(f"{indent}local.set ${self._wat_symbol(name)}")
+                    if not self._is_module_global(name):
+                        self._locals.add(name)
+                    self._emit_name_set(name, indent)
                     self._update_assignment_tracking(name, stmt.value, indent)
                 else:
                     # Compound assignment: a op= b
                     self._emit(f"{indent};; {name} {op} ...")
-                    self._emit(f"{indent}local.get ${self._wat_symbol(name)}")
+                    if not self._is_module_global(name):
+                        self._locals.add(name)
+                    self._emit_name_get(name, indent)
                     self._gen_augmented_op(op, stmt.value, indent)
-                    self._emit(f"{indent}local.set ${self._wat_symbol(name)}")
+                    self._emit_name_set(name, indent)
                     self._clear_assignment_tracking(name)
             elif (isinstance(target, AttributeAccess)
                   and isinstance(target.obj, Identifier)):
@@ -457,15 +461,16 @@ def _gen_stmt(self, stmt, indent: str):  # noqa: C901  # pylint: disable=too-man
         elif isinstance(stmt, AnnAssignment):
             if isinstance(stmt.target, Identifier):
                 name = stmt.target.name
-                self._locals.add(name)
                 self._emit(f"{indent};; annotated assignment {name}: ...")
                 if stmt.value is None:
                     self._emit(f"{indent}f64.const 0")
                     self._clear_assignment_tracking(name)
                 else:
                     self._gen_expr(stmt.value, indent)
                     self._update_assignment_tracking(name, stmt.value, indent)
-                self._emit(f"{indent}local.set ${self._wat_symbol(name)}")
+                if not self._is_module_global(name):
+                    self._locals.add(name)
+                self._emit_name_set(name, indent)
             else:
                 self._emit(f"{indent};; annotated assignment with complex target (nop in WAT)")
 
@@ -478,9 +483,10 @@ def _gen_stmt(self, stmt, indent: str):  # noqa: C901  # pylint: disable=too-man
             for target in stmt.targets:
                 if isinstance(target, Identifier):
                     name = target.name
-                    self._locals.add(name)
                     self._emit(f"{indent}local.get ${self._wat_symbol(tmp_name)}")
-                    self._emit(f"{indent}local.set ${self._wat_symbol(name)}")
+                    if not self._is_module_global(name):
+                        self._locals.add(name)
+                    self._emit_name_set(name, indent)
                     self._update_assignment_tracking(name, stmt.value, indent)
                 else:
                     self._emit(
@@ -686,38 +692,38 @@ def _gen_stmt(self, stmt, indent: str):  # noqa: C901  # pylint: disable=too-man
                 elif (isinstance(expr.func, AttributeAccess)
                       and expr.func.attr == "append"
                       and isinstance(expr.func.obj, Identifier)
-                      and expr.func.obj.name in self._list_locals
+                      and self._is_tracked_list_name(expr.func.obj.name)
                       and len(expr.args) == 1):
                     # lst.append(x) → allocate new list, update local
                     obj_name = expr.func.obj.name
                     self._emit(f"{indent};; {obj_name}.append(x)")
-                    self._gen_expr(expr.func.obj, indent)
+                    self._emit_name_get(obj_name, indent)
                     self._gen_expr(expr.args[0], indent)
                     self._emit(f"{indent}call $__list_append")
-                    self._emit(f"{indent}local.set ${self._wat_symbol(obj_name)}")
+                    self._emit_name_set(obj_name, indent)
                 elif (isinstance(expr.func, AttributeAccess)
                       and expr.func.attr == "pop"
                       and isinstance(expr.func.obj, Identifier)
-                      and expr.func.obj.name in self._list_locals
+                      and self._is_tracked_list_name(expr.func.obj.name)
                       and not expr.args):
                     # lst.pop() statement — result discarded
                     obj_name = expr.func.obj.name
                     self._emit(f"{indent};; {obj_name}.pop() (result discarded)")
-                    self._gen_expr(expr.func.obj, indent)
+                    self._emit_name_get(obj_name, indent)
                     self._emit(f"{indent}call $__list_pop")
                     self._emit(f"{indent}drop")
                 elif (isinstance(expr.func, AttributeAccess)
                       and expr.func.attr == "extend"
                       and isinstance(expr.func.obj, Identifier)
-                      and expr.func.obj.name in self._list_locals
+                      and self._is_tracked_list_name(expr.func.obj.name)
                       and len(expr.args) == 1):
                     # lst.extend(other) → allocate new list, update local
                     obj_name = expr.func.obj.name
                     self._emit(f"{indent};; {obj_name}.extend(other)")
-                    self._gen_expr(expr.func.obj, indent)
+                    self._emit_name_get(obj_name, indent)
                     self._gen_expr(expr.args[0], indent)
                     self._emit(f"{indent}call $__list_extend")
-                    self._emit(f"{indent}local.set ${self._wat_symbol(obj_name)}")
+                    self._emit_name_set(obj_name, indent)
                 else:
                     # Closure, constructor, builtin, or other non-WAT callable
                     self._emit(f"{indent};; unsupported call: {fname}(...) — not a WAT function")
@@ -1069,8 +1075,7 @@ def _gen_expr(self, node, indent: str):  # noqa: C901  # pylint: disable=too-man
                 self._emit(f"{indent}f64.const 0  ;; unsupported expr: DictLiteral")
 
         elif isinstance(node, Identifier):
-            if node.name in self._locals:
-                self._emit(f"{indent}local.get ${self._wat_symbol(node.name)}")
+            if self._emit_name_get(node.name, indent):
                 if node.name in self._string_len_locals:
                     len_local = self._string_len_locals[node.name]
                     self._emit(f"{indent}local.get ${self._wat_symbol(len_local)}")
@@ -1792,11 +1797,11 @@ def _gen_expr(self, node, indent: str):  # noqa: C901  # pylint: disable=too-man
         elif isinstance(node, IndexAccess):
             obj = node.obj
             if isinstance(obj, Identifier) and (
-                obj.name in self._list_locals or obj.name in self._tuple_locals
+                self._is_tracked_list_name(obj.name) or self._is_tracked_tuple_name(obj.name)
             ):
                 # list[i] / tuple[i]  →  load from base + 8 + i*8
                 self._emit(f"{indent};; {obj.name}[i]")
-                self._emit(f"{indent}local.get ${self._wat_symbol(obj.name)}")
+                self._emit_name_get(obj.name, indent)
                 self._emit(f"{indent}i32.trunc_f64_u")
                 self._gen_expr(node.index, indent)
                 self._emit(f"{indent}i32.trunc_f64_u")

multilingualprogramming/codegen/wat_generator_core.py

@@ -78,6 +78,10 @@ def _build_module(self) -> str:
         lines.append(
             '  (global $__last_exc_code (export "__last_exception_code") (mut i32) (i32.const 0))'
         )
+        for global_name in sorted(getattr(self, "_module_global_names", set())):
+            lines.append(
+                f'  (global ${self._wat_symbol(global_name)} (mut f64) (f64.const 0))'
+            )
         if self._lambda_table:
             n = len(self._lambda_table)
             lines.append(f'  (table {n} funcref)')

multilingualprogramming/codegen/wat_generator_oop.py

@@ -339,6 +339,7 @@ def _emit_function(self, func_def: FunctionDef, emitted_name: str | None = None)
         func_name = emitted_name or _name(func_def.name)
         param_names = _real_params(func_def)
         self._locals = set(param_names)
+        self._list_locals.update(self._func_param_list_names.get(func_name, set()))
 
         self._gen_stmts(func_def.body, "    ")
         body_instrs = list(self._instrs)

multilingualprogramming/codegen/wat_generator_orchestrator.py

@@ -7,10 +7,23 @@
 """Orchestration/state helpers for the WAT generator."""
 
 from multilingualprogramming.core.ir_nodes import IRProgram
-from multilingualprogramming.parser.ast_nodes import CallExpr, ClassDef, FunctionDef
+from multilingualprogramming.parser.ast_nodes import (
+    AnnAssignment,
+    Assignment,
+    AttributeAccess,
+    CallExpr,
+    ChainedAssignment,
+    ClassDef,
+    FunctionDef,
+    GlobalStatement,
+    Identifier,
+    IndexAccess,
+    VariableDeclaration,
+)
 
 from multilingualprogramming.codegen.wat_ir_adapter import lower_ir_to_wat_ast
 from multilingualprogramming.codegen.wat_generator_support import (
+    _LEN_NAMES,
     _extract_render_mode,
     _name,
     _real_params,
@@ -29,6 +42,7 @@ def generate(self, program, *, wasm_target: str = "browser") -> str:
             program = lower_ir_to_wat_ast(program)
 
         funcs, classes, top = self._split_program_sections(program)
+        self._collect_module_globals(funcs, classes, top)
         self._collect_function_metadata(funcs)
         self._collect_class_lowering(classes)
         self._collect_import_aliases(top)
@@ -58,6 +72,7 @@ def _collect_function_metadata(self, funcs: list[FunctionDef]) -> None:
             fname = _name(func.name)
             self._func_real_params[fname] = _real_params(func)
             self._func_render_modes[fname] = _extract_render_mode(func)
+            self._func_param_list_names[fname] = _infer_list_like_params(func)
             if self._returns_string_like(func):
                 self._string_return_funcs.add(fname)
 
@@ -96,6 +111,19 @@ def _save_func_state(self):
         self._reset_func_state()
         return saved
 
+    def _collect_module_globals(self, funcs: list, classes: list, top: list) -> None:
+        """Record module-scoped identifiers that must lower to mutable WASM globals."""
+        for stmt in top:
+            _record_module_global_assignment(self, stmt)
+        for func in funcs:
+            for name in _find_declared_global_names(func):
+                self._module_global_names.add(name)
+        for cls in classes:
+            for member in getattr(cls, "body", []) or []:
+                if isinstance(member, FunctionDef):
+                    for name in _find_declared_global_names(member):
+                        self._module_global_names.add(name)
+
 
 def _reset_generator_state(generator) -> None:
     """Reset all mutable per-module generation state for *generator*."""
@@ -150,6 +178,102 @@ def _reset_generator_state(generator) -> None:
         "_property_getters": {},
         "_class_ids": {},
         "_dispatch_func_names": {},
+        "_module_global_names": set(),
+        "_module_global_list_names": set(),
+        "_module_global_tuple_names": set(),
+        "_module_global_dict_names": set(),
+        "_func_param_list_names": {},
     }
     for name, value in state.items():
         setattr(generator, name, value)
+
+
+def _record_module_global_assignment(generator, stmt) -> None:
+    """Update tracked module-global names from a top-level assignment-like node."""
+    pairs = []
+    if isinstance(stmt, VariableDeclaration) and isinstance(stmt.name, Identifier):
+        pairs.append((stmt.name.name, stmt.value))
+    elif isinstance(stmt, Assignment) and isinstance(stmt.target, Identifier):
+        pairs.append((stmt.target.name, stmt.value))
+    elif isinstance(stmt, AnnAssignment) and isinstance(stmt.target, Identifier):
+        pairs.append((stmt.target.name, stmt.value))
+    elif isinstance(stmt, ChainedAssignment):
+        for target in stmt.targets:
+            if isinstance(target, Identifier):
+                pairs.append((target.name, stmt.value))
+    for name, value in pairs:
+        generator._module_global_names.add(name)
+        if generator._value_tracks_as_tuple(value):
+            generator._module_global_tuple_names.add(name)
+            generator._module_global_list_names.discard(name)
+        elif generator._value_tracks_as_list(value):
+            generator._module_global_list_names.add(name)
+            generator._module_global_tuple_names.discard(name)
+        else:
+            generator._module_global_list_names.discard(name)
+            generator._module_global_tuple_names.discard(name)
+
+
+def _find_declared_global_names(func_def: FunctionDef) -> set[str]:
+    """Return names referenced by ``global ...`` statements inside a function."""
+    names = set()
+
+    def visit(node):
+        if node is None:
+            return
+        if isinstance(node, GlobalStatement):
+            names.update(node.names)
+            return
+        if isinstance(node, list):
+            for item in node:
+                visit(item)
+            return
+        if isinstance(node, (str, int, float, bool)):
+            return
+        for value in getattr(node, "__dict__", {}).values():
+            visit(value)
+
+    visit(getattr(func_def, "body", []))
+    return names
+
+
+def _infer_list_like_params(func_def: FunctionDef) -> set[str]:
+    """Infer function parameters that should be treated as list-like in WAT."""
+    params = set(_real_params(func_def))
+    if not params:
+        return set()
+
+    inferred = set()
+
+    def visit(node):
+        if node is None:
+            return
+        if isinstance(node, IndexAccess) and isinstance(node.obj, Identifier):
+            if node.obj.name in params:
+                inferred.add(node.obj.name)
+        elif isinstance(node, CallExpr):
+            if (
+                _name(node.func) in _LEN_NAMES
+                and len(node.args) == 1
+                and isinstance(node.args[0], Identifier)
+                and node.args[0].name in params
+            ):
+                inferred.add(node.args[0].name)
+            if (
+                isinstance(node.func, AttributeAccess)
+                and isinstance(node.func.obj, Identifier)
+                and node.func.obj.name in params
+                and node.func.attr in ("append", "extend", "pop")
+            ):
+                inferred.add(node.func.obj.name)
+        if isinstance(node, list):
+            for item in node:
+                visit(item)
+            return
+        if isinstance(node, (str, int, float, bool)):
+            return
+        for value in getattr(node, "__dict__", {}).values():
+            visit(value)
+
+    visit(getattr(func_def, "body", []))
+    return inferred