efrog 0.4.0__py3-none-any.whl

efrog/decompilers/javascript.py

@@ -0,0 +1,472 @@
+"""JavaScript / TypeScript-lite → EML.
+
+Phase E2.5 — third decompiler. Wraps :mod:`esprima` (pure Python, no
+native deps) and lowers the same shape we accept in Python and C: a
+function declaration (or an arrow function bound at module scope)
+with a parameter list and a body that ends in a single returned
+expression.
+
+What we accept in this revision:
+
+  - ``function f(x, y) { return <expr>; }``
+  - ``const f = (x, y) => <expr>;`` and ``= (x) => { return ...; }``
+  - ``var`` / ``let`` / ``const`` local declarations → ``let`` bindings
+  - ``Math.exp(...)``, ``Math.sin(...)``, ``Math.PI``, etc.
+  - Numeric literals (``1.5``, ``2e-3``) and unary ``+``/``-``
+  - JS arithmetic operators with ECMAScript precedence
+  - ``cond ? then : else`` ternaries (lowered branch-free)
+
+What we don't (yet):
+
+  - ``if`` / ``for`` / ``while`` / ``switch`` (E3)
+  - Object literals, destructuring, classes, ``this`` (E3+)
+  - String operations, template literals, regular expressions
+  - TypeScript type annotations are *tolerated* (esprima parses
+    plain JS) — pass ``--lang javascript`` for ``.ts`` files that
+    don't actually use generics or annotations.
+
+Anything else raises :class:`EFrogError` pointing at later phases.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import esprima
+
+from .python import (
+    DecompiledFunction,
+    DecompiledModule,
+    EFrogError,
+    _BUILTIN_FUNCS,
+    _PYTHON_TO_EML_FN,
+    _chain_order,
+    _emit_float,
+)
+
+
+# ── Public entry points ──────────────────────────────────────────────
+
+
+def decompile_javascript_source(
+    source: str,
+    *,
+    source_path: Optional[str] = None,
+    module_name_override: Optional[str] = None,
+) -> DecompiledModule:
+    try:
+        tree = esprima.parseScript(source, {"loc": True})
+    except esprima.Error as exc:
+        raise EFrogError(f"JavaScript parse error: {exc}") from exc
+
+    module_name = (
+        module_name_override
+        or _module_name_from_path(source_path)
+        or "module"
+    )
+    mod = DecompiledModule(name=module_name, source_path=source_path)
+
+    for node in tree.body:
+        decl = _as_function_declaration(node)
+        if decl is None:
+            # Top-level statements we don't decompile (imports, side-effects)
+            # are silently skipped — same convention as the Python decompiler.
+            continue
+        mod.functions.append(_decompile_function(decl, mod))
+
+    if not mod.functions:
+        raise EFrogError(
+            "no top-level function declarations found — nothing to decompile"
+        )
+    return mod
+
+
+def decompile_javascript_file(path: str) -> DecompiledModule:
+    with open(path, "r", encoding="utf-8") as f:
+        return decompile_javascript_source(f.read(), source_path=path)
+
+
+# ── Helpers: top-level recognition ──────────────────────────────────
+
+
+@dataclass
+class _FuncShape:
+    name: str
+    params: List[object]
+    body: object   # BlockStatement or expression node
+    body_is_expr: bool
+
+
+@dataclass
+class _Ctx:
+    mod: DecompiledModule
+
+
+def _module_name_from_path(path: Optional[str]) -> Optional[str]:
+    if not path:
+        return None
+    stem = os.path.splitext(os.path.basename(path))[0]
+    return stem or None
+
+
+def _as_function_declaration(node) -> Optional[_FuncShape]:
+    """Return a :class:`_FuncShape` if `node` is a top-level function we
+    can decompile (declaration form or `const NAME = (…) => …`)."""
+    t = node.type
+    if t == "FunctionDeclaration":
+        return _FuncShape(
+            name=node.id.name,
+            params=node.params,
+            body=node.body,
+            body_is_expr=False,
+        )
+    if t == "VariableDeclaration":
+        if len(node.declarations) != 1:
+            return None
+        d = node.declarations[0]
+        if d.id.type != "Identifier" or d.init is None:
+            return None
+        init_t = d.init.type
+        if init_t == "ArrowFunctionExpression":
+            return _FuncShape(
+                name=d.id.name,
+                params=d.init.params,
+                body=d.init.body,
+                body_is_expr=(d.init.body.type != "BlockStatement"),
+            )
+        if init_t == "FunctionExpression":
+            return _FuncShape(
+                name=d.id.name,
+                params=d.init.params,
+                body=d.init.body,
+                body_is_expr=False,
+            )
+    return None
+
+
+# ── Function decompilation ──────────────────────────────────────────
+
+
+def _decompile_function(shape: _FuncShape, mod: DecompiledModule) -> DecompiledFunction:
+    args: List[Tuple[str, str]] = []
+    for p in shape.params:
+        if p.type != "Identifier":
+            # Default values, rest params, destructuring patterns —
+            # all out of scope for the math-substrate slice.
+            raise EFrogError(
+                f"unsupported param node `{p.type}` in JS decompiler"
+            )
+        args.append((p.name, "Real"))
+
+    ctx = _Ctx(mod=mod)
+    if shape.body_is_expr:
+        let_bindings: List[Tuple[str, str]] = []
+        body_expr = _expr(shape.body, 0, ctx)
+    else:
+        let_bindings, body_expr = _decompile_body(shape.body, ctx)
+
+    chain = _chain_order(body_expr)
+    for _, e in let_bindings:
+        chain = max(chain, _chain_order(e))
+
+    return DecompiledFunction(
+        name=shape.name,
+        args=args,
+        return_type="Real",
+        chain_order=chain,
+        let_bindings=let_bindings,
+        body_expr=body_expr,
+    )
+
+
+def _decompile_body(block, ctx: _Ctx) -> Tuple[List[Tuple[str, str]], str]:
+    if block is None or block.type != "BlockStatement":
+        raise EFrogError("function body must be a block")
+
+    let_bindings: List[Tuple[str, str]] = []
+    return_expr: Optional[str] = None
+    seen_return = False
+
+    for stmt in block.body:
+        if seen_return:
+            raise EFrogError("statements after return not supported in JS")
+
+        t = stmt.type
+        if t == "VariableDeclaration":
+            for d in stmt.declarations:
+                if d.id.type != "Identifier":
+                    raise EFrogError(
+                        "destructured declarations unsupported in JS"
+                    )
+                if d.init is None:
+                    raise EFrogError(
+                        f"local `{d.id.name}` declared without initializer"
+                    )
+                let_bindings.append((d.id.name, _expr(d.init, 0, ctx)))
+            continue
+
+        if t == "ExpressionStatement":
+            expr = stmt.expression
+            if expr.type != "AssignmentExpression":
+                raise EFrogError(
+                    f"top-level `{expr.type}` statement unsupported in JS"
+                )
+            if expr.left.type != "Identifier":
+                raise EFrogError("only assignments to a name supported in JS")
+            if expr.operator == "=":
+                let_bindings.append((expr.left.name, _expr(expr.right, 0, ctx)))
+            elif expr.operator in _COMPOUND_ASSIGN:
+                op = _COMPOUND_ASSIGN[expr.operator]
+                rhs = _expr(expr.right, 0, ctx)
+                let_bindings.append(
+                    (expr.left.name, f"{expr.left.name} {op} {rhs}")
+                )
+            else:
+                raise EFrogError(
+                    f"compound assign `{expr.operator}` unsupported in JS"
+                )
+            continue
+
+        if t == "ReturnStatement":
+            if stmt.argument is None:
+                raise EFrogError("bare `return;` not supported in JS")
+            return_expr = _expr(stmt.argument, 0, ctx)
+            seen_return = True
+            continue
+
+        raise EFrogError(
+            f"`{t}` not supported in JS decompiler "
+            f"(if/for/while go to E3+)"
+        )
+
+    if return_expr is None:
+        raise EFrogError("function has no `return` statement")
+    return let_bindings, return_expr
+
+
+_COMPOUND_ASSIGN = {
+    "+=": "+", "-=": "-", "*=": "*", "/=": "/", "%=": "%",
+}
+
+
+# ── Expression printer ──────────────────────────────────────────────
+
+
+# Subset of ECMA-262 binary operator precedence, restricted to what
+# the math substrate accepts. Higher binds tighter.
+_JS_PREC = {
+    "+":  10, "-":  10,
+    "*":  20, "/":  20, "%":  20,
+    "**": 30,
+}
+
+_JS_OP = {
+    "+":  "+", "-":  "-",
+    "*":  "*", "/":  "/", "%": "%",
+    "**": "^",
+}
+
+
+# JS `Math.<member>` → EML callable name. Anything not listed errors.
+_MATH_MEMBER = {
+    "exp":   "exp",
+    "log":   "log",
+    "log2":  "log2",
+    "log10": "log10",
+    "sin":   "sin",
+    "cos":   "cos",
+    "tan":   "tan",
+    "asin":  "asin",
+    "acos":  "acos",
+    "atan":  "atan",
+    "sinh":  "sinh",
+    "cosh":  "cosh",
+    "tanh":  "tanh",
+    "asinh": "asinh",
+    "acosh": "acosh",
+    "atanh": "atanh",
+    "sqrt":  "sqrt",
+    "pow":   "pow",
+    "abs":   "abs",
+    "min":   "min",
+    "max":   "max",
+    "floor": "floor",
+    "ceil":  "ceil",
+    "round": "round",
+}
+
+_MATH_CONSTS = {
+    "PI":      3.141592653589793,
+    "E":       2.718281828459045,
+    "LN2":     0.6931471805599453,
+    "LN10":    2.302585092994046,
+    "LOG2E":   1.4426950408889634,
+    "LOG10E":  0.4342944819032518,
+    "SQRT2":   1.4142135623730951,
+    "SQRT1_2": 0.7071067811865476,
+}
+
+
+def _expr(node, parent_prec: int, ctx: _Ctx) -> str:
+    t = node.type
+
+    if t == "Literal":
+        return _emit_literal(node)
+
+    if t == "Identifier":
+        return node.name
+
+    if t == "UnaryExpression":
+        if not node.prefix:
+            raise EFrogError("postfix unary operators unsupported in JS")
+        if node.operator == "-":
+            inner = _expr(node.argument, _JS_PREC["*"], ctx)
+            return _wrap(f"-{inner}", _JS_PREC["*"], parent_prec)
+        if node.operator == "+":
+            return _expr(node.argument, parent_prec, ctx)
+        if node.operator == "!":
+            ctx.mod.needs_step01 = True
+            return f"(1.0 - {_condition_expr(node.argument, ctx)})"
+        raise EFrogError(f"unary `{node.operator}` unsupported in JS")
+
+    if t in ("BinaryExpression", "LogicalExpression"):
+        op = node.operator
+        if op not in _JS_OP:
+            raise EFrogError(f"binary `{op}` unsupported in JS")
+        prec = _JS_PREC[op]
+        # `**` is right-associative in ECMAScript; everything else left-assoc.
+        if op == "**":
+            left  = _expr(node.left,  prec + 1, ctx)
+            right = _expr(node.right, prec, ctx)
+        else:
+            left  = _expr(node.left,  prec, ctx)
+            right = _expr(node.right, prec + 1, ctx)
+        return _wrap(f"{left} {_JS_OP[op]} {right}", prec, parent_prec)
+
+    if t == "CallExpression":
+        return _emit_call(node, ctx)
+
+    if t == "MemberExpression":
+        const = _member_constant(node)
+        if const is not None:
+            return _emit_float(const)
+        raise EFrogError(
+            f"member access `{_describe_member(node)}` unsupported in JS"
+        )
+
+    if t == "ConditionalExpression":
+        cond = _condition_expr(node.test, ctx)
+        then = _expr(node.consequent, 0, ctx)
+        otherwise = _expr(node.alternate, 0, ctx)
+        ctx.mod.needs_step01 = True
+        return f"lerp({otherwise}, {then}, {cond})"
+
+    raise EFrogError(f"`{t}` unsupported in JS decompiler")
+
+
+def _wrap(s: str, my_prec: int, parent_prec: int) -> str:
+    return f"({s})" if my_prec < parent_prec else s
+
+
+def _emit_literal(node) -> str:
+    v = node.value
+    if isinstance(v, bool):
+        return "1.0" if v else "0.0"
+    if isinstance(v, (int, float)):
+        return _emit_float(float(v))
+    raise EFrogError(f"unsupported literal: {v!r}")
+
+
+def _member_constant(node) -> Optional[float]:
+    if (
+        getattr(node, "object", None) is not None
+        and node.object.type == "Identifier"
+        and node.object.name == "Math"
+        and not node.computed
+        and node.property.type == "Identifier"
+    ):
+        return _MATH_CONSTS.get(node.property.name)
+    return None
+
+
+def _describe_member(node) -> str:
+    obj = node.object
+    obj_name = obj.name if obj.type == "Identifier" else "<expr>"
+    prop = node.property
+    prop_name = prop.name if prop.type == "Identifier" else "<expr>"
+    return f"{obj_name}.{prop_name}"
+
+
+def _emit_call(node, ctx: _Ctx) -> str:
+    name = _resolve_call_name(node.callee)
+    if name is None:
+        raise EFrogError(
+            f"unrecognised call target `{_describe_callee(node.callee)}`"
+        )
+    if name not in _BUILTIN_FUNCS:
+        raise EFrogError(
+            f"call to non-math function `{name}` unsupported in JS"
+        )
+    eml_name = _PYTHON_TO_EML_FN.get(name, name)
+    args = ", ".join(_expr(a, 0, ctx) for a in node.arguments)
+    return f"{eml_name}({args})"
+
+
+def _resolve_call_name(callee) -> Optional[str]:
+    if callee.type == "Identifier":
+        return callee.name
+    if (
+        callee.type == "MemberExpression"
+        and not callee.computed
+        and callee.object.type == "Identifier"
+        and callee.object.name == "Math"
+        and callee.property.type == "Identifier"
+    ):
+        return _MATH_MEMBER.get(callee.property.name)
+    return None
+
+
+def _describe_callee(callee) -> str:
+    if callee.type == "Identifier":
+        return callee.name
+    if callee.type == "MemberExpression":
+        return _describe_member(callee)
+    return f"<{callee.type}>"
+
+
+# ── Conditional → branch-free selector ──────────────────────────────
+
+
+_CMP_TEMPLATE = {
+    ">":   "step01(({left}) - ({right}))",
+    ">=":  "step01(({left}) - ({right}))",
+    "<":   "step01(({right}) - ({left}))",
+    "<=":  "step01(({right}) - ({left}))",
+}
+
+
+def _condition_expr(node, ctx: _Ctx) -> str:
+    t = node.type
+    if t == "BinaryExpression" and node.operator in _CMP_TEMPLATE:
+        ctx.mod.needs_step01 = True
+        left  = _expr(node.left,  0, ctx)
+        right = _expr(node.right, 0, ctx)
+        return _CMP_TEMPLATE[node.operator].format(left=left, right=right)
+
+    if t == "LogicalExpression":
+        if node.operator == "&&":
+            return f"(({_condition_expr(node.left, ctx)}) * ({_condition_expr(node.right, ctx)}))"
+        if node.operator == "||":
+            inv_l = f"(1.0 - {_condition_expr(node.left, ctx)})"
+            inv_r = f"(1.0 - {_condition_expr(node.right, ctx)})"
+            return f"(1.0 - ({inv_l} * {inv_r}))"
+
+    if t == "UnaryExpression" and node.operator == "!":
+        return f"(1.0 - {_condition_expr(node.argument, ctx)})"
+
+    raise EFrogError(
+        f"can't encode JS condition `{t}` branch-free; "
+        f"rewrite as <, <=, >, >=, &&, ||, !"
+    )