browser-py 0.1.0__py3-none-any.whl

numeric_ir.py

@@ -0,0 +1,315 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from mypy.build import build
+from mypyc.build import get_mypy_config
+from mypyc.errors import Errors
+from mypyc.ir.func_ir import FuncIR, all_values
+from mypyc.ir.module_ir import ModuleIR
+from mypyc.ir.ops import (
+   Assign,
+   BasicBlock,
+   Box,
+   Branch,
+   Call,
+   CallC,
+   Cast,
+   ComparisonOp,
+   Float,
+   FloatComparisonOp,
+   FloatNeg,
+   FloatOp,
+   GetAttr,
+   Goto,
+   Integer,
+   IntOp,
+   KeepAlive,
+   LoadLiteral,
+   Op,
+   PrimitiveOp,
+   RaiseStandardError,
+   Return,
+   SetAttr,
+   Unbox,
+   Unreachable,
+   Value,
+)
+from mypyc.ir.pprint import format_func
+from mypyc.irbuild.main import build_ir
+from mypyc.irbuild.mapper import Mapper
+from mypyc.options import CompilerOptions
+
+from numeric_source import read_numeric_source
+
+
+@dataclass
+class Region:
+   block: BasicBlock | None
+   stop: BasicBlock | None
+   active: frozenset[BasicBlock]
+   text: str
+
+
+def load_ir(inputs: tuple[Path, ...]) -> dict[str, ModuleIR]:
+   compiler_options = CompilerOptions()
+   config = get_mypy_config([str(path) for path in inputs], None, compiler_options, None)
+   sources = config[0]
+   all_sources = config[1]
+   options = config[2]
+   options.cache_dir = "/tmp/python-js-mypy-cache"
+   result = build(all_sources, options)
+   if result.errors:
+      raise RuntimeError("\n".join(result.errors))
+   errors = Errors(options)
+   modules = []
+   for item in sources:
+      tree = result.graph[item.module].tree
+      if tree is not None:
+         modules.append(tree)
+      else:
+         raise RuntimeError("mypy did not produce a syntax tree for " + item.module)
+   modules_ir = build_ir(modules, result.graph, result.types, Mapper({}), compiler_options, errors)
+   if errors.num_errors:
+      raise RuntimeError("\n".join(errors.new_messages()))
+   return modules_ir
+
+
+def value_text(value: Value, names: dict[Value, str]) -> str:
+   if isinstance(value, Integer):
+      return str(value.numeric_value())
+   if isinstance(value, Float):
+      return repr(value.value)
+   return names[value]
+
+
+def arguments(values: list[Value], names: dict[Value, str]) -> list[str]:
+   result = []
+   for value in values:
+      result.append(value_text(value, names))
+   return result
+
+
+def statement(op: Op, names: dict[Value, str], constructors: frozenset[str]) -> str:
+   if isinstance(op, Assign):
+      return f"{value_text(op.dest, names)} = {value_text(op.src, names)};"
+   if isinstance(op, (FloatOp, FloatComparisonOp, ComparisonOp)):
+      symbol = op.op_str[op.op]
+      if symbol not in {"+", "-", "*", "/", "%", "==", "!=", "<", ">", "<=", ">="}:
+         raise NotImplementedError(symbol)
+      expr = f"{value_text(op.lhs, names)} {symbol} {value_text(op.rhs, names)}"
+   elif isinstance(op, FloatNeg):
+      expr = f"-{value_text(op.src, names)}"
+   elif isinstance(op, GetAttr):
+      expr = f"{value_text(op.obj, names)}.{op.attr}"
+   elif isinstance(op, SetAttr):
+      expr = f"({value_text(op.obj, names)}.{op.attr} = {value_text(op.src, names)}, true)"
+   elif isinstance(op, LoadLiteral) and isinstance(op.value, (int, float)):
+      expr = repr(op.value)
+   elif isinstance(op, (Box, Unbox, Cast)):
+      expr = value_text(op.src, names)
+   elif isinstance(op, KeepAlive):
+      return ""
+   elif isinstance(op, RaiseStandardError):
+      return f"throw new Error({op.class_name!r});"
+   elif isinstance(op, IntOp):
+      if (
+         op.op == IntOp.LEFT_SHIFT
+         and isinstance(op.rhs, Integer)
+         and op.rhs.numeric_value() == 1
+         and str(op.lhs.type) == "native_int"
+         and str(op.type) == "short_int"
+      ):
+         # mypyc tags len() integers; JavaScript keeps the untagged numeric length.
+         expr = value_text(op.lhs, names)
+      else:
+         raise NotImplementedError("Unsupported representation-level IntOp")
+   elif isinstance(op, PrimitiveOp):
+      name = op.desc.name
+      args = arguments(op.args, names)
+      comparisons = {"int_lt": "<", "int_le": "<=", "int_gt": ">", "int_eq": "=="}
+      if name in comparisons:
+         expr = f"{args[0]} {comparisons[name]} {args[1]}"
+      elif name == "var_object_size":
+         expr = f"{args[0]}.length"
+      elif name == "list_items":
+         expr = args[0]
+      elif name == "buf_init_item":
+         return f"{args[0]}[{args[1]}] = {args[2]};"
+      else:
+         raise NotImplementedError(f"primitive {name}")
+   elif isinstance(op, CallC):
+      name = op.function_name
+      args = arguments(op.args, names)
+      symbols = {"CPyTagged_Add": "+", "CPyTagged_Subtract": "-", "CPyTagged_Multiply": "*"}
+      if name in symbols:
+         expr = f"{args[0]} {symbols[name]} {args[1]}"
+      elif name == "CPyTagged_Remainder":
+         expr = f"((({args[0]} % {args[1]}) + {args[1]}) % {args[1]})"
+      elif name == "CPyFloat_FromTagged":
+         expr = args[0]
+      elif name == "PyList_New":
+         expr = f"new Array({args[0]})"
+      elif name in {"CPyList_GetItem", "CPyList_GetItemShort"}:
+         expr = f"{args[0]}[{args[1]}]"
+      elif name == "CPyList_SetItem":
+         expr = f"({args[0]}[{args[1]}] = {args[2]}, true)"
+      elif name == "PyList_Append":
+         expr = f"({args[0]}.push({args[1]}), 0)"
+      elif name == "PyNumber_InPlaceAdd":
+         expr = f"{args[0]} + {args[1]}"
+      elif name == "copysign":
+         expr = (
+            f"((({args[1]}) < 0 || Object.is({args[1]}, -0)) ? -Math.abs({args[0]}) : Math.abs({args[0]}))"
+         )
+      elif name == "PyTuple_Pack":
+         expr = f"[{', '.join(args[1:])}]"
+      elif name == "PyDict_New":
+         expr = "{}"
+      else:
+         raise NotImplementedError(f"C primitive {name}")
+   elif isinstance(op, Call) and op.fn.class_name is None:
+      if op.fn.name in constructors:
+         # mypyc passes dataclass positional/keyword containers; native JS consumes the positional fields.
+         expr = f"new {op.fn.name}(...{value_text(op.args[0], names)})"
+      else:
+         expr = f"{op.fn.name}({', '.join(arguments(op.args, names))})"
+   else:
+      raise NotImplementedError(f"unsupported IR {type(op).__name__}")
+   return f"{value_text(op, names)} = {expr};" if op in names else f"{expr};"
+
+
+def condition(branch: Branch, names: dict[Value, str]) -> str:
+   if branch.op == Branch.BOOL:
+      return ("!" if branch.negated else "") + value_text(branch.value, names)
+   raise NotImplementedError("Error-value branches are not supported")
+
+
+def emit_function(fn: FuncIR, constructors: frozenset[str]) -> str:
+   values = all_values(fn.arg_regs, fn.blocks)
+   names = {value: f"v{i}" for i, value in enumerate(values)}
+   blocks = fn.blocks
+   exceptional = set()
+   for block in blocks:
+      for op in block.ops:
+         if isinstance(op, RaiseStandardError):
+            exceptional.add(block)
+   successors: dict[BasicBlock, list[BasicBlock]] = {}
+   for block in blocks:
+      term = block.ops[-1]
+      successors[block] = []
+      if isinstance(term, (Goto, Branch)):
+         for target in term.targets():
+            if target not in exceptional:
+               successors[block].append(target)
+   # Postdominators reconcile each branch with its closest shared continuation before emission.
+   post = {block: set(blocks) if successors[block] else {block} for block in blocks}
+   while True:
+      updated = {}
+      for block in blocks:
+         shared = set(blocks) if successors[block] else set()
+         for target in successors[block]:
+            shared &= post[target]
+         updated[block] = {block} | shared
+      if updated == post:
+         break
+      post = updated
+   index = {block: i for i, block in enumerate(blocks)}
+   headers = set()
+   for block in blocks:
+      for target in successors[block]:
+         if index[target] <= index[block]:
+            headers.add(target)
+   signature = ", ".join(arguments(list(fn.arg_regs), names))
+   lines = [f"export function {fn.name}({signature}) {{"]
+   locals_ = [names[value] for value in values if value not in fn.arg_regs]
+   if locals_:
+      lines.append(f"let {', '.join(locals_)};")
+   emitted: set[BasicBlock] = set()
+   stack = [Region(blocks[0], None, frozenset(), "")]
+   while stack:
+      region = stack.pop()
+      if region.block is None:
+         lines.append(region.text)
+         continue
+      block = region.block
+      while block is not region.stop:
+         if block in emitted:
+            raise NotImplementedError(f"{fn.name}: unstructured CFG")
+         emitted.add(block)
+         term = block.ops[-1]
+         body = [statement(op, names, constructors) for op in block.ops[:-1]]
+         if block in headers and block not in region.active:
+            if isinstance(term, Branch) and block in post[term.true]:
+               lines.extend(["while (true) {", *body, f"if (!({condition(term, names)})) break;"])
+               stack.append(Region(term.false, region.stop, region.active, ""))
+               stack.append(Region(None, None, frozenset(), "}"))
+               stack.append(Region(term.true, block, region.active | {block}, ""))
+               break
+            raise NotImplementedError("Unsupported loop shape")
+         lines.extend(body)
+         if isinstance(term, Unreachable) and block in exceptional:
+            break
+         if isinstance(term, Return):
+            lines.append(f"return {value_text(term.value, names)};")
+            break
+         if isinstance(term, Goto):
+            block = term.label
+            continue
+         if isinstance(term, Branch):
+            if term.true in exceptional or term.false in exceptional:
+               error = term.true if term.true in exceptional else term.false
+               normal = term.false if error is term.true else term.true
+               cond = condition(term, names) if error is term.true else f"!({condition(term, names)})"
+               lines.append(f"if ({cond}) {{")
+               stack.append(Region(normal, region.stop, region.active, ""))
+               stack.append(Region(None, None, frozenset(), "}"))
+               stack.append(Region(error, None, frozenset(), ""))
+               break
+            common = post[term.true] & post[term.false]
+            if not common:
+               raise NotImplementedError("Conditional without a merge")
+            join = blocks[0]
+            depth = -1
+            for candidate in blocks:
+               if candidate in common and len(post[candidate]) > depth:
+                  join = candidate
+                  depth = len(post[candidate])
+            lines.append(f"if ({condition(term, names)}) {{")
+            stack.append(Region(join, region.stop, region.active, ""))
+            stack.append(Region(None, None, frozenset(), "}"))
+            stack.append(Region(term.false, join, region.active, ""))
+            stack.append(Region(None, None, frozenset(), "} else {"))
+            stack.append(Region(term.true, join, region.active, ""))
+            break
+         raise NotImplementedError(type(term).__name__)
+   return "\n".join([*lines, "}"])
+
+
+def emit_module(module: ModuleIR, fields: dict[str, list[str]]) -> tuple[str, str]:
+   functions = [fn for fn in module.functions if fn.name != "__top_level__"]
+   constructors = frozenset(fields)
+   imports: dict[str, set[str]] = {}
+   for fn in functions:
+      for block in fn.blocks:
+         for op in block.ops:
+            if isinstance(op, Call) and op.fn.module_name != module.fullname:
+               imports.setdefault(op.fn.module_name, set()).add(op.fn.name)
+   js = ""
+   for name, symbols in sorted(imports.items()):
+      js += f"import {{ {', '.join(sorted(symbols))} }} from './{name}.js';\n"
+   for cls in module.classes:
+      attributes = fields[cls.name]
+      js += f"export class {cls.name} {{\nconstructor({', '.join(attributes)}) {{\n"
+      for attribute in attributes:
+         js += f"this.{attribute} = {attribute};\n"
+      js += "}\n}\n"
+   for fn in functions:
+      js += emit_function(fn, constructors) + "\n"
+   dump = "\n\n".join("\n".join(format_func(fn)) for fn in module.functions)
+   return js, dump
+
+
+def compile_js(source: Path) -> tuple[str, str]:
+   parsed = read_numeric_source(source)
+   module = load_ir(tuple(parsed.trees))[source.stem]
+   return emit_module(module, parsed.schemas[source])

numeric_source.py

@@ -0,0 +1,266 @@
+from ast import (
+   AnnAssign,
+   AsyncFunctionDef,
+   Attribute,
+   Await,
+   Call,
+   ClassDef,
+   Constant,
+   Expr,
+   FunctionDef,
+   Global,
+   Import,
+   ImportFrom,
+   Lambda,
+   Module,
+   Name,
+   Nonlocal,
+   Starred,
+   Subscript,
+   expr,
+   parse,
+   walk,
+)
+from dataclasses import dataclass
+from pathlib import Path
+
+BUILTIN_ARITIES = (
+   ("int", (0, 1)),
+   ("float", (0, 1)),
+   ("len", (1,)),
+   ("range", (1, 2, 3)),
+   # Admission keeps these names for types/decorators; backends receive literals and generated constructors.
+   ("list", ()),
+   ("dataclass", ()),
+)
+
+
+# Source dataclasses define field order; both backends consume the same admitted model before emission.
+@dataclass
+class NumericSource:
+   trees: dict[Path, Module]
+   schemas: dict[Path, dict[str, list[str]]]
+
+
+def require_acyclic(edges: dict[str, set[str]], subject: str) -> None:
+   remaining = {name: len(edges[name]) for name in edges}
+   callers: dict[str, list[str]] = {name: [] for name in edges}
+   for name in edges:
+      for target in edges[name]:
+         callers[target].append(name)
+   ready = [name for name in remaining if remaining[name] == 0]
+   while ready:
+      name = ready.pop()
+      del remaining[name]
+      for caller in callers[name]:
+         remaining[caller] -= 1
+         if remaining[caller] == 0:
+            ready.append(caller)
+   if remaining:
+      raise NotImplementedError(subject + " must be acyclic: " + ", ".join(remaining))
+
+
+def numeric_annotation(node: expr | None, classes: set[str]) -> bool:
+   if isinstance(node, Constant):
+      return isinstance(node.value, str) and node.value in classes
+   if isinstance(node, Name):
+      return node.id in ("int", "float") or node.id in classes
+   if isinstance(node, Subscript):
+      return (
+         isinstance(node.value, Name)
+         and node.value.id == "list"
+         and isinstance(node.slice, Name)
+         and (node.slice.id in ("int", "float") or node.slice.id in classes)
+      )
+   return False
+
+
+def function_calls(
+   node: FunctionDef,
+   classes: dict[str, list[str]],
+   functions: dict[str, FunctionDef],
+   imports: dict[str, FunctionDef],
+) -> set[str]:
+   args = node.args
+   if (
+      node.decorator_list
+      or node.type_params
+      or args.defaults
+      or args.kw_defaults
+      or args.posonlyargs
+      or args.vararg
+      or args.kwarg
+      or args.kwonlyargs
+   ):
+      raise NotImplementedError("Numeric functions require plain positional parameters")
+   class_names = set(classes)
+   annotations = [arg.annotation for arg in args.args] + [node.returns]
+   for annotation in annotations:
+      if numeric_annotation(annotation, class_names):
+         continue
+      raise NotImplementedError("Explicit int/float or numeric-list signatures required")
+   arities = dict(BUILTIN_ARITIES)
+   for name in functions:
+      arities[name] = (len(functions[name].args.args),)
+   for name in imports:
+      arities[name] = (len(imports[name].args.args),)
+   for name in classes:
+      arities[name] = (len(classes[name]),)
+   for arg in args.args:
+      if arg.arg in arities:
+         raise NotImplementedError("Numeric parameters cannot shadow callables: " + arg.arg)
+   nodes = list(walk(node))
+   for item in nodes:
+      if isinstance(item, AnnAssign):
+         if numeric_annotation(item.annotation, class_names):
+            annotations.append(item.annotation)
+         else:
+            raise NotImplementedError("Only numeric local annotations are supported")
+   annotation_names: set[Name] = set()
+   for annotation in annotations:
+      if annotation is not None:
+         for item in walk(annotation):
+            if isinstance(item, Name):
+               annotation_names.add(item)
+   targets = {item.func for item in nodes if isinstance(item, Call)}
+   dependencies = set()
+   for item in nodes:
+      if isinstance(item, (Import, ImportFrom, AsyncFunctionDef, Await, Lambda)) or (
+         isinstance(item, (FunctionDef, ClassDef)) and item is not node
+      ):
+         raise NotImplementedError("Numeric functions cannot contain imports, closures, or async code")
+      if isinstance(item, (Global, Nonlocal)):
+         raise NotImplementedError("Numeric functions cannot declare nonlocal or global state")
+      if isinstance(item, Name) and item.id in arities:
+         if item in targets or item in annotation_names:
+            pass
+         else:
+            raise NotImplementedError("Numeric callables must be called directly")
+      if isinstance(item, Call):
+         if item.keywords or any(isinstance(argument, Starred) for argument in item.args):
+            raise NotImplementedError("Numeric calls require positional arguments")
+         if isinstance(item.func, Name) and item.func.id in arities:
+            if len(item.args) in arities[item.func.id]:
+               if item.func.id in functions:
+                  dependencies.add(item.func.id)
+            else:
+               raise NotImplementedError("Unsupported numeric positional arity: " + item.func.id)
+         elif isinstance(item.func, Attribute) and item.func.attr == "append":
+            if len(item.args) == 1:
+               continue
+            raise NotImplementedError("List append requires positional arity one")
+         else:
+            raise NotImplementedError("Only direct numeric calls and list append are supported")
+   return dependencies
+
+
+def read_numeric_source(source: Path) -> NumericSource:
+   pending = [source]
+   trees: dict[Path, Module] = {}
+   schemas: dict[Path, dict[str, list[str]]] = {}
+   definitions: dict[Path, dict[str, FunctionDef]] = {}
+   dependencies: dict[str, set[str]] = {}
+   reserved = {item[0] for item in BUILTIN_ARITIES}
+   while pending:
+      path = pending.pop()
+      if path in trees:
+         continue
+      tree = parse(path.read_text())
+      trees[path] = tree
+      fields: dict[str, list[str]] = {}
+      schemas[path] = fields
+      dependencies[path.stem] = set()
+      classes = {node.name for node in tree.body if isinstance(node, ClassDef)}
+      definitions[path] = {node.name: node for node in tree.body if isinstance(node, FunctionDef)}
+      symbols = set()
+      dataclass_imported = False
+      imports_open = True
+      for node in tree.body:
+         if isinstance(node, Expr) and isinstance(node.value, Constant) and isinstance(node.value.value, str):
+            continue
+         if isinstance(node, ImportFrom):
+            if not imports_open:
+               raise NotImplementedError("Numeric imports must precede definitions")
+            if node.level == 0 and node.module == "dataclasses" and len(node.names) == 1:
+               alias = node.names[0]
+               if alias.name == "dataclass" and alias.asname is None:
+                  if alias.name in symbols:
+                     raise NotImplementedError("Duplicate numeric symbol: " + alias.name)
+                  symbols.add(alias.name)
+                  dataclass_imported = True
+                  continue
+            if (
+               node.level == 0
+               and node.module is not None
+               and node.module.isidentifier()
+               and not node.module.startswith("__")
+               and node.module != "dataclasses"
+               and (path.parent / f"{node.module}.py").is_file()
+               and all(alias.asname is None and alias.name != "*" for alias in node.names)
+            ):
+               dependency = path.parent / f"{node.module}.py"
+               dependencies[path.stem].add(dependency.stem)
+               pending.append(dependency)
+               for alias in node.names:
+                  if alias.name in reserved:
+                     raise NotImplementedError("Import shadows a reserved numeric name: " + alias.name)
+                  if alias.name in symbols:
+                     raise NotImplementedError("Duplicate numeric symbol: " + alias.name)
+                  symbols.add(alias.name)
+               continue
+            raise NotImplementedError("Only direct local imports of compiled functions supported")
+         imports_open = False
+         if isinstance(node, (ClassDef, FunctionDef)):
+            if node.name in reserved:
+               raise NotImplementedError("Definition shadows a reserved numeric name: " + node.name)
+            if node.name in symbols:
+               raise NotImplementedError("Duplicate numeric symbol: " + node.name)
+            symbols.add(node.name)
+         if isinstance(node, ClassDef):
+            if (
+               node.bases
+               or node.keywords
+               or node.type_params
+               or len(node.decorator_list) != 1
+               or not isinstance(node.decorator_list[0], Name)
+               or node.decorator_list[0].id != "dataclass"
+               or not dataclass_imported
+            ):
+               raise NotImplementedError("Only plain required-field dataclasses are supported")
+            fields[node.name] = []
+            for item in node.body:
+               if (
+                  isinstance(item, AnnAssign)
+                  and isinstance(item.target, Name)
+                  and item.value is None
+                  and numeric_annotation(item.annotation, classes)
+               ):
+                  if item.target.id in fields[node.name]:
+                     raise NotImplementedError("Duplicate numeric dataclass field: " + item.target.id)
+                  fields[node.name].append(item.target.id)
+                  continue
+               raise NotImplementedError("Only required numeric annotation-only dataclass fields supported")
+            continue
+         if isinstance(node, FunctionDef):
+            continue
+         raise NotImplementedError(
+            "Only typed dataclasses/functions/imports/docstrings allowed at module scope"
+         )
+   require_acyclic(dependencies, "Numeric imports")
+   for path in trees:
+      imports: dict[str, FunctionDef] = {}
+      for node in trees[path].body:
+         if isinstance(node, ImportFrom) and node.module != "dataclasses":
+            exports = definitions[path.parent / f"{node.module}.py"]
+            for alias in node.names:
+               if alias.name in exports:
+                  imports[alias.name] = exports[alias.name]
+               else:
+                  raise NotImplementedError(
+                     f"Numeric imports must name functions defined in {node.module}: {alias.name}"
+                  )
+      calls = {}
+      for name in definitions[path]:
+         calls[name] = function_calls(definitions[path][name], schemas[path], definitions[path], imports)
+      require_acyclic(calls, "Numeric calls")
+   return NumericSource(trees, schemas)