@pineforge/codegen-pyodide 0.7.0

package/README.md

@@ -0,0 +1,25 @@
+# @pineforge/codegen-pyodide
+
+Gate-validated Pyodide payload for the PineScript v6 → C++ transpiler. Built and
+published from `pineforge-codegen-oss` by `.github/workflows/publish-pyodide.yml`.
+
+## Contents
+- `pineforge_codegen-<version>.tar.gz` — the gate-validated archive (unpack into Pyodide).
+- `pineforge_codegen/` — unpacked Python source (put on `PYTHONPATH` for Node oracle/grammar tooling).
+- `tables.json` — introspected codegen tables (the app renders `tables.generated.ts` from this).
+- `release.json` — `{ codegen, pyodide, python, emscripten, sha256 }`.
+- `index.mjs` — `release`, `tables`, `archivePath`, `codegenSourceDir`.
+
+## One-time bootstrap (maintainer, manual)
+This is a NEW package; npm OIDC Trusted Publishing can only be configured after
+the package exists:
+1. Build locally: `npm run gate:full && node scripts/build-npm-package.mjs`.
+2. From `npm/`, do the first publish with a granular npm token:
+   `npm publish --access=public` (one time).
+3. On npmjs.com, configure the package's Trusted Publisher: GitHub Actions,
+   repo `pineforge-4pass/pineforge-codegen-oss`, workflow `publish-pyodide.yml`.
+4. Thereafter releases publish via OIDC (no token): run `publish-pyodide.yml`
+   via **workflow_dispatch with `dry_run=false`**. NOTE: tag pushes currently run
+   a DRY-RUN only (a safe validation) — the sole real-publish path is dispatch +
+   `dry_run=false`. To switch to tag-driven releases later, change the publish
+   condition in the workflow.

package/index.mjs

@@ -0,0 +1,20 @@
+// Entry for @pineforge/codegen-pyodide. Resolves the packaged payload paths and
+// metadata so consumers (the app's build + Node oracle/grammar tooling) read
+// everything from this one dependency — no git submodule.
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+export const release = require("./release.json");
+export const tables = require("./tables.json");
+
+// Absolute path to the gate-validated Pyodide archive (gztar) to unpackArchive.
+export const archivePath = join(HERE, `pineforge_codegen-${release.codegen}.tar.gz`);
+
+// Absolute path to the unpacked Python source dir's PARENT — put on PYTHONPATH
+// so `import pineforge_codegen` resolves (oracle tests, grammar gen).
+export const sourceRoot = HERE;
+export const codegenSourceDir = join(HERE, "pineforge_codegen");

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pineforge/codegen-pyodide",
+  "version": "0.7.0",
+  "description": "Gate-validated Pyodide payload for the PineScript v6 -> C++ transpiler: archive (run in Pyodide), unpacked source, introspected tables, and release metadata.",
+  "type": "module",
+  "main": "index.mjs",
+  "exports": {
+    ".": "./index.mjs",
+    "./tables.json": "./tables.json",
+    "./release.json": "./release.json"
+  },
+  "files": [
+    "index.mjs",
+    "pineforge_codegen-*.tar.gz",
+    "pineforge_codegen/**/*",
+    "tables.json",
+    "release.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "pyodide": "314.0.0"
+  },
+  "keywords": ["pinescript", "transpiler", "pyodide", "codegen"],
+  "homepage": "https://github.com/pineforge-4pass/pineforge-codegen-oss",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pineforge-4pass/pineforge-codegen-oss.git"
+  },
+  "license": "PolyForm-Noncommercial-1.0.0"
+}

package/pineforge_codegen/__init__.py

@@ -0,0 +1,53 @@
+"""PineScript v6 to C++ transpiler."""
+
+from .lexer import Lexer
+from .parser import Parser
+from .analyzer import Analyzer
+from .codegen import CodeGen
+from .pragmas import extract_pf_trace_pragmas
+from .support_checker import check_support_or_raise
+
+
+def transpile(pine_source: str, *, check_support: bool = True, filename: str = "<input>") -> str:
+    """Transpile PineScript v6 source code to C++ code.
+
+    Semantic rules enforced in :class:`Analyzer` (before codegen), including:
+    user ``enum`` blocks must appear **above** ``input.enum(Enum.member, ...)`` uses.
+
+    Before analysis, :func:`support_checker.check_support_or_raise` rejects
+    scripts that use language constructs PineForge cannot faithfully execute
+    (e.g. ``indicator()`` declarations, prohibited variables such as
+    ``bar_index``, disallowed ``request.security`` parameters). Pass
+    ``check_support=False`` to bypass this gate (intended for tests of legacy
+    fixtures only).
+
+    ``// @pf-trace name=expr`` pragmas are extracted from ``pine_source``
+    via a pre-pass (the lexer strips comments before the parser sees them)
+    and attached to the analyzer context for codegen. See
+    :mod:`pineforge_codegen.pragmas` for the syntax.
+
+    Args:
+        pine_source: PineScript v6 source string.
+        check_support: When True (default) the support checker runs after
+            parsing and raises ``CompileError`` on any unsupported feature
+            before semantic analysis or codegen.
+        filename: Source name threaded into every ``SourceLocation`` so the
+            ``file:line:col`` shown in ``CompileError`` (both ``str()`` and
+            :meth:`~pineforge_codegen.errors.CompileError.format`) points back
+            at the caller's file. Defaults to ``"<input>"``.
+
+    Returns:
+        Generated C++ source string.
+    """
+    pragmas = extract_pf_trace_pragmas(pine_source)
+    tokens = Lexer(pine_source, filename=filename).tokenize()
+    ast = Parser(tokens, source=pine_source, filename=filename).parse()
+    if check_support:
+        check_support_or_raise(ast, filename=filename)
+    ctx = Analyzer(ast, filename=filename).analyze()
+    # Attach after analysis: pragma expressions are not part of the
+    # program body, so the analyzer never inspects them; the codegen
+    # consumes them directly from the context to emit the on_bar tail
+    # ``if (trace_enabled_) { trace(...); ... }`` block.
+    ctx.pf_trace_pragmas = pragmas
+    return CodeGen(ctx).generate()

package/pineforge_codegen/analyzer/__init__.py

@@ -0,0 +1,60 @@
+"""Analyzer package facade.
+
+Historically the semantic analyzer lived in a single ``analyzer.py`` module
+that hit ~2,340 lines and ~74 methods on a single ``Analyzer`` class. This
+package is the structural skeleton for an incremental split: ``base.py``
+currently holds the original ``Analyzer`` verbatim, and future steps will
+peel focused mixins out into sibling files (e.g. ``visit_func``,
+``visit_udt``, ``visit_control``, ``visit_expr``, ``visit_call``, ``types``,
+``helpers``) without changing the public API:
+
+    from pineforge_codegen.analyzer import Analyzer            # primary
+    from pineforge_codegen.analyzer import AnalyzerContext     # context
+    from pineforge_codegen.analyzer import TA_CLASS_MAP, ...   # tables
+
+Re-exports preserved for ``support_checker.py``, ``codegen/base.py`` and
+external tests that imported the dataclasses or module-level dispatch
+tables. Add new helper modules under ``compiler/transpiler/analyzer/`` and
+re-export their public surface here.
+"""
+
+from .base import Analyzer
+from .contracts import (
+    # Output dataclasses (consumed by codegen + tests). Defined in
+    # contracts.py so the package's import graph stays a strict DAG.
+    AnalyzerContext,
+    FixnanCallSite,
+    FuncInfo,
+    MutableGlobalInfo,
+    SecurityCallInfo,
+    TACallSite,
+)
+from .tables import (
+    # Module-level dispatch tables (consumed by codegen + support_checker).
+    TA_CLASS_MAP,
+    TA_PERIOD_ARG,
+    TA_TUPLE_RETURNS,
+    TA_MULTI_CTOR,
+    TA_NO_CTOR,
+    BUILTIN_VARS,
+    BAR_FIELDS,
+    SKIP_FUNCS,
+)
+
+__all__ = [
+    "Analyzer",
+    "TACallSite",
+    "FuncInfo",
+    "FixnanCallSite",
+    "MutableGlobalInfo",
+    "SecurityCallInfo",
+    "AnalyzerContext",
+    "TA_CLASS_MAP",
+    "TA_PERIOD_ARG",
+    "TA_TUPLE_RETURNS",
+    "TA_MULTI_CTOR",
+    "TA_NO_CTOR",
+    "BUILTIN_VARS",
+    "BAR_FIELDS",
+    "SKIP_FUNCS",
+]