+
+```
+
+### Hand-built boxes-and-arrows (when Mermaid's layout fights you)
+
+Modules as `+ flowchart LR + A[OrderHandler] --> B[OrderValidator] + B --> C[OrderRepo] + C -.leak.-> D[PricingClient] + classDef leak stroke:#dc2626,stroke-width:2px; + class C,D leak ++
`s with borders and labels. Arrows as inline SVG `` or `` elements positioned absolutely over a relative container. Reach for this when you want the "after" diagram to feel like one thick-bordered deep module with greyed-out internals — Mermaid won't render that with the right weight.
+
+### Cross-section (good for layered shallowness)
+
+Stack horizontal bands (`h-12 border-l-4`) to show layers a call passes through. Before: 6 thin layers each doing nothing. After: 1 thick band labelled with the consolidated responsibility.
+
+### Mass diagram (good for "interface as wide as implementation")
+
+Two rectangles per module — one for interface surface area, one for implementation. Before: interface rectangle is nearly as tall as the implementation rectangle (shallow). After: interface rectangle is short, implementation rectangle is tall (deep).
+
+### Call-graph collapse
+
+Before: a tree of function calls rendered as nested boxes. After: the same tree collapsed into one box, with the now-internal calls shown faded inside it.
+
+## Style guidance
+
+- Lean editorial, not corporate-dashboard. Generous whitespace. Serif optional for headings (`font-serif` works well with stone/slate).
+- Colour sparingly: one accent (emerald or indigo) plus red for leakage and amber for warnings.
+- Keep diagrams ~320px tall so before/after sits comfortably side by side without scrolling.
+- Use `text-xs uppercase tracking-wider` for module labels inside diagrams — they should read as schematic, not as UI.
+- The only scripts are the Tailwind CDN and the Mermaid ESM import. The report is otherwise static — no app code, no interactivity beyond Mermaid's own rendering.
+
+## Top recommendation section
+
+One larger card. Candidate name, one sentence on why, anchor link to its card. That's it.
+
+## Tone
+
+Plain English, concise — but the architectural nouns and verbs come straight from [LANGUAGE.md](LANGUAGE.md). Concision is not an excuse to drift.
+
+**Use exactly:** module, interface, implementation, depth, deep, shallow, seam, adapter, leverage, locality.
+
+**Never substitute:** component, service, unit (for module) · API, signature (for interface) · boundary (for seam) · layer, wrapper (for module, when you mean module).
+
+**Phrasings that fit the style:**
+
+- "Order intake module is shallow — interface nearly matches the implementation."
+- "Pricing leaks across the seam."
+- "Deepen: one interface, one place to test."
+- "Two adapters justify the seam: HTTP in prod, in-memory in tests."
+
+**Wins bullets** name the gain in glossary terms: *"locality: bugs concentrate in one module"*, *"leverage: one interface, N call sites"*, *"interface shrinks; implementation absorbs the wrappers"*. Don't write *"easier to maintain"* or *"cleaner code"* — those terms aren't in the glossary and don't earn their place.
+
+No hedging, no throat-clearing, no "it's worth noting that…". If a sentence could be a bullet, make it a bullet. If a bullet could be cut, cut it. If a term isn't in [LANGUAGE.md](LANGUAGE.md), reach for one that is before inventing a new one.
diff --git a/.agents/skills/improve-codebase-architecture/INTERFACE-DESIGN.md b/.agents/skills/improve-codebase-architecture/INTERFACE-DESIGN.md
new file mode 100644
index 00000000..3197723a
--- /dev/null
+++ b/.agents/skills/improve-codebase-architecture/INTERFACE-DESIGN.md
@@ -0,0 +1,44 @@
+# Interface Design
+
+When the user wants to explore alternative interfaces for a chosen deepening candidate, use this parallel sub-agent pattern. Based on "Design It Twice" (Ousterhout) — your first idea is unlikely to be the best.
+
+Uses the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**, **leverage**.
+
+## Process
+
+### 1. Frame the problem space
+
+Before spawning sub-agents, write a user-facing explanation of the problem space for the chosen candidate:
+
+- The constraints any new interface would need to satisfy
+- The dependencies it would rely on, and which category they fall into (see [DEEPENING.md](DEEPENING.md))
+- A rough illustrative code sketch to ground the constraints — not a proposal, just a way to make the constraints concrete
+
+Show this to the user, then immediately proceed to Step 2. The user reads and thinks while the sub-agents work in parallel.
+
+### 2. Spawn sub-agents
+
+Spawn 3+ sub-agents in parallel using the Agent tool. Each must produce a **radically different** interface for the deepened module.
+
+Prompt each sub-agent with a separate technical brief (file paths, coupling details, dependency category from [DEEPENING.md](DEEPENING.md), what sits behind the seam). The brief is independent of the user-facing problem-space explanation in Step 1. Give each agent a different design constraint:
+
+- Agent 1: "Minimize the interface — aim for 1–3 entry points max. Maximise leverage per entry point."
+- Agent 2: "Maximise flexibility — support many use cases and extension."
+- Agent 3: "Optimise for the most common caller — make the default case trivial."
+- Agent 4 (if applicable): "Design around ports & adapters for cross-seam dependencies."
+
+Include both [LANGUAGE.md](LANGUAGE.md) vocabulary and CONTEXT.md vocabulary in the brief so each sub-agent names things consistently with the architecture language and the project's domain language.
+
+Each sub-agent outputs:
+
+1. Interface (types, methods, params — plus invariants, ordering, error modes)
+2. Usage example showing how callers use it
+3. What the implementation hides behind the seam
+4. Dependency strategy and adapters (see [DEEPENING.md](DEEPENING.md))
+5. Trade-offs — where leverage is high, where it's thin
+
+### 3. Present and compare
+
+Present designs sequentially so the user can absorb each one, then compare them in prose. Contrast by **depth** (leverage at the interface), **locality** (where change concentrates), and **seam placement**.
+
+After comparing, give your own recommendation: which design you think is strongest and why. If elements from different designs would combine well, propose a hybrid. Be opinionated — the user wants a strong read, not a menu.
diff --git a/.agents/skills/improve-codebase-architecture/LANGUAGE.md b/.agents/skills/improve-codebase-architecture/LANGUAGE.md
new file mode 100644
index 00000000..530c2763
--- /dev/null
+++ b/.agents/skills/improve-codebase-architecture/LANGUAGE.md
@@ -0,0 +1,53 @@
+# Language
+
+Shared vocabulary for every suggestion this skill makes. Use these terms exactly — don't substitute "component," "service," "API," or "boundary." Consistent language is the whole point.
+
+## Terms
+
+**Module**
+Anything with an interface and an implementation. Deliberately scale-agnostic — applies equally to a function, class, package, or tier-spanning slice.
+_Avoid_: unit, component, service.
+
+**Interface**
+Everything a caller must know to use the module correctly. Includes the type signature, but also invariants, ordering constraints, error modes, required configuration, and performance characteristics.
+_Avoid_: API, signature (too narrow — those refer only to the type-level surface).
+
+**Implementation**
+What's inside a module — its body of code. Distinct from **Adapter**: a thing can be a small adapter with a large implementation (a Postgres repo) or a large adapter with a small implementation (an in-memory fake). Reach for "adapter" when the seam is the topic; "implementation" otherwise.
+
+**Depth**
+Leverage at the interface — the amount of behaviour a caller (or test) can exercise per unit of interface they have to learn. A module is **deep** when a large amount of behaviour sits behind a small interface. A module is **shallow** when the interface is nearly as complex as the implementation.
+
+**Seam** _(from Michael Feathers)_
+A place where you can alter behaviour without editing in that place. The *location* at which a module's interface lives. Choosing where to put the seam is its own design decision, distinct from what goes behind it.
+_Avoid_: boundary (overloaded with DDD's bounded context).
+
+**Adapter**
+A concrete thing that satisfies an interface at a seam. Describes *role* (what slot it fills), not substance (what's inside).
+
+**Leverage**
+What callers get from depth. More capability per unit of interface they have to learn. One implementation pays back across N call sites and M tests.
+
+**Locality**
+What maintainers get from depth. Change, bugs, knowledge, and verification concentrate at one place rather than spreading across callers. Fix once, fixed everywhere.
+
+## Principles
+
+- **Depth is a property of the interface, not the implementation.** A deep module can be internally composed of small, mockable, swappable parts — they just aren't part of the interface. A module can have **internal seams** (private to its implementation, used by its own tests) as well as the **external seam** at its interface.
+- **The deletion test.** Imagine deleting the module. If complexity vanishes, the module wasn't hiding anything (it was a pass-through). If complexity reappears across N callers, the module was earning its keep.
+- **The interface is the test surface.** Callers and tests cross the same seam. If you want to test *past* the interface, the module is probably the wrong shape.
+- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a seam unless something actually varies across it.
+
+## Relationships
+
+- A **Module** has exactly one **Interface** (the surface it presents to callers and tests).
+- **Depth** is a property of a **Module**, measured against its **Interface**.
+- A **Seam** is where a **Module**'s **Interface** lives.
+- An **Adapter** sits at a **Seam** and satisfies the **Interface**.
+- **Depth** produces **Leverage** for callers and **Locality** for maintainers.
+
+## Rejected framings
+
+- **Depth as ratio of implementation-lines to interface-lines** (Ousterhout): rewards padding the implementation. We use depth-as-leverage instead.
+- **"Interface" as the TypeScript `interface` keyword or a class's public methods**: too narrow — interface here includes every fact a caller must know.
+- **"Boundary"**: overloaded with DDD's bounded context. Say **seam** or **interface**.
diff --git a/.agents/skills/improve-codebase-architecture/SKILL.md b/.agents/skills/improve-codebase-architecture/SKILL.md
new file mode 100644
index 00000000..c12b263b
--- /dev/null
+++ b/.agents/skills/improve-codebase-architecture/SKILL.md
@@ -0,0 +1,81 @@
+---
+name: improve-codebase-architecture
+description: Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.
+---
+
+# Improve Codebase Architecture
+
+Surface architectural friction and propose **deepening opportunities** — refactors that turn shallow modules into deep ones. The aim is testability and AI-navigability.
+
+## Glossary
+
+Use these terms exactly in every suggestion. Consistent language is the point — don't drift into "component," "service," "API," or "boundary." Full definitions in [LANGUAGE.md](LANGUAGE.md).
+
+- **Module** — anything with an interface and an implementation (function, class, package, slice).
+- **Interface** — everything a caller must know to use the module: types, invariants, error modes, ordering, config. Not just the type signature.
+- **Implementation** — the code inside.
+- **Depth** — leverage at the interface: a lot of behaviour behind a small interface. **Deep** = high leverage. **Shallow** = interface nearly as complex as the implementation.
+- **Seam** — where an interface lives; a place behaviour can be altered without editing in place. (Use this, not "boundary.")
+- **Adapter** — a concrete thing satisfying an interface at a seam.
+- **Leverage** — what callers get from depth.
+- **Locality** — what maintainers get from depth: change, bugs, knowledge concentrated in one place.
+
+Key principles (see [LANGUAGE.md](LANGUAGE.md) for the full list):
+
+- **Deletion test**: imagine deleting the module. If complexity vanishes, it was a pass-through. If complexity reappears across N callers, it was earning its keep.
+- **The interface is the test surface.**
+- **One adapter = hypothetical seam. Two adapters = real seam.**
+
+This skill is _informed_ by the project's domain model. The domain language gives names to good seams; ADRs record decisions the skill should not re-litigate.
+
+## Process
+
+### 1. Explore
+
+Read the project's domain glossary and any ADRs in the area you're touching first.
+
+Then use the Agent tool with `subagent_type=Explore` to walk the codebase. Don't follow rigid heuristics — explore organically and note where you experience friction:
+
+- Where does understanding one concept require bouncing between many small modules?
+- Where are modules **shallow** — interface nearly as complex as the implementation?
+- Where have pure functions been extracted just for testability, but the real bugs hide in how they're called (no **locality**)?
+- Where do tightly-coupled modules leak across their seams?
+- Which parts of the codebase are untested, or hard to test through their current interface?
+
+Apply the **deletion test** to anything you suspect is shallow: would deleting it concentrate complexity, or just move it? A "yes, concentrates" is the signal you want.
+
+### 2. Present candidates as an HTML report
+
+Write a self-contained HTML file to the OS temp directory so nothing lands in the repo. Resolve the temp dir from `$TMPDIR`, falling back to `/tmp` (or `%TEMP%` on Windows), and write to `/architecture-review-.html` so each run gets a fresh file. Open it for the user — `xdg-open ` on Linux, `open ` on macOS, `start ` on Windows — and tell them the absolute path.
+
+The report uses **Tailwind via CDN** for layout and styling, and **Mermaid via CDN** for diagrams where a graph/flow/sequence reliably communicates the structure. Mix Mermaid with hand-crafted CSS/SVG visuals — use Mermaid when relationships are graph-shaped (call graphs, dependencies, sequences), and hand-built divs/SVG when you want something more editorial (mass diagrams, cross-sections, collapse animations). Each candidate gets a **before/after visualisation**. Be visual.
+
+For each candidate, the same template as before, but rendered as a card:
+
+- **Files** — which files/modules are involved
+- **Problem** — why the current architecture is causing friction
+- **Solution** — plain English description of what would change
+- **Benefits** — explained in terms of locality and leverage, and how tests would improve
+- **Before / After diagram** — side-by-side, custom-drawn, illustrating the shallowness and the deepening
+- **Recommendation strength** — one of `Strong`, `Worth exploring`, `Speculative`, rendered as a badge
+
+End the report with a **Top recommendation** section: which candidate you'd tackle first and why.
+
+**Use CONTEXT.md vocabulary for the domain, and [LANGUAGE.md](LANGUAGE.md) vocabulary for the architecture.** If `CONTEXT.md` defines "Order," talk about "the Order intake module" — not "the FooBarHandler," and not "the Order service."
+
+**ADR conflicts**: if a candidate contradicts an existing ADR, only surface it when the friction is real enough to warrant revisiting the ADR. Mark it clearly in the card (e.g. a warning callout: _"contradicts ADR-0007 — but worth reopening because…"_). Don't list every theoretical refactor an ADR forbids.
+
+See [HTML-REPORT.md](HTML-REPORT.md) for the full HTML scaffold, diagram patterns, and styling guidance.
+
+Do NOT propose interfaces yet. After the file is written, ask the user: "Which of these would you like to explore?"
+
+### 3. Grilling loop
+
+Once the user picks a candidate, drop into a grilling conversation. Walk the design tree with them — constraints, dependencies, the shape of the deepened module, what sits behind the seam, what tests survive.
+
+Side effects happen inline as decisions crystallize:
+
+- **Naming a deepened module after a concept not in `CONTEXT.md`?** Add the term to `CONTEXT.md` — same discipline as `/grill-with-docs` (see [CONTEXT-FORMAT.md](../grill-with-docs/CONTEXT-FORMAT.md)). Create the file lazily if it doesn't exist.
+- **Sharpening a fuzzy term during the conversation?** Update `CONTEXT.md` right there.
+- **User rejects the candidate with a load-bearing reason?** Offer an ADR, framed as: _"Want me to record this as an ADR so future architecture reviews don't re-suggest it?"_ Only offer when the reason would actually be needed by a future explorer to avoid re-suggesting the same thing — skip ephemeral reasons ("not worth it right now") and self-evident ones. See [ADR-FORMAT.md](../grill-with-docs/ADR-FORMAT.md).
+- **Want to explore alternative interfaces for the deepened module?** See [INTERFACE-DESIGN.md](INTERFACE-DESIGN.md).
diff --git a/AGENTS.md b/AGENTS.md
index e5523cf6..a2b1ce07 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -65,7 +65,7 @@ printf "const x = 2 + 2; x;" | ./build/GocciaScriptLoader # Execute stdin source
./build/GocciaScriptLoader example.js --coverage # Execute with line and branch coverage
./build/GocciaScriptLoader example.js --coverage --coverage-format=lcov --coverage-output=coverage.lcov # Coverage with lcov output
./build/GocciaScriptLoader example.js --coverage --coverage-format=json --coverage-output=coverage.json # Coverage with JSON output
-./build/GocciaScriptLoader example.js --asi # Execute with automatic semicolon insertion
+./build/GocciaScriptLoader example.js --compat-asi # Execute with automatic semicolon insertion
./build/GocciaScriptLoader example.js --strict-types # Enforce type annotations at runtime (interpreter and bytecode)
./build/GocciaScriptLoader example.js --source-type=module # Load entry as a module (top-level this is undefined; default is script)
./build/GocciaScriptLoader example.js --output=json # Execute with structured JSON output
@@ -94,7 +94,7 @@ printf '1;\n---\n2;\n' | ./build/GocciaScriptLoader --multifile # Split stdin on
./build/GocciaREPL --mode=bytecode --timing # Bytecode REPL with per-line timing
./build/GocciaREPL --import-map=imports.json # Start the REPL with an explicit import map
./build/GocciaREPL --config=./configs/dev.json # Start the REPL with an explicit config path (skips auto-discovery)
-./build/GocciaREPL --asi # Start the REPL with automatic semicolon insertion
+./build/GocciaREPL --compat-asi # Start the REPL with automatic semicolon insertion
./build/GocciaREPL --unsafe-ffi # Start the REPL with FFI enabled
./build/GocciaREPL --log=repl.log # Start the REPL with console log capture
./build/GocciaREPL --stack-size=5000 # Start the REPL with custom call stack depth limit
@@ -138,7 +138,7 @@ printf 'suite("stdin", () => { bench("sum", { run: () => 1 + 1 }); });\n' | ./bu
./build/GocciaBundler example.js --source-map # Write .map source map alongside .gbc
printf "const x = 2 + 2; x;" | ./build/GocciaBundler --output=out.gbc # Compile stdin to .gbc
./build/GocciaBundler src/ --jobs=4 # Compile with 4 parallel workers
-./build/GocciaBundler example.js --asi # Compile with automatic semicolon insertion
+./build/GocciaBundler example.js --compat-asi # Compile with automatic semicolon insertion
./build/GocciaBundler example.js --multifile --output=dist/ # Split on '---' and emit one .gbc per section into dist/
./build/GocciaBundler example.js --config=./configs/release.toml # Compile with an explicit config path (skips auto-discovery)
```
@@ -168,12 +168,12 @@ All CLI options can be set via `goccia.json` (or `.json5` / `.toml`) discovered
```json
// goccia.json
-{ "asi": true, "mode": "bytecode", "timeout": 5000, "allowed-hosts": ["api.example.com"] }
+{ "compat-asi": true, "mode": "bytecode", "timeout": 5000, "allowed-hosts": ["api.example.com"] }
```
```json
// tests/language/asi/goccia.json — enables ASI for this subtree
-{ "asi": true }
+{ "compat-asi": true }
```
```json
diff --git a/CONTEXT.md b/CONTEXT.md
index 6c1d3ebf..c8f37c0c 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -23,7 +23,7 @@ An installable host or special-purpose feature added to a runtime, such as conso
_Avoid_: Core language built-in when the feature belongs to the optional runtime surface.
**Runtime profile**:
-A named bundle of runtime extensions used by a CLI frontend or embedding host.
+A named bundle of runtime extensions used by a CLI host or embedding host.
_Avoid_: Mode, preset.
**Runtime surface**:
@@ -52,20 +52,24 @@ _Avoid_: Runtime, runtime profile.
The implementation object behind an execution mode. GocciaScript has an interpreter executor and a bytecode executor.
_Avoid_: Execution backend, runtime.
-**Source frontend**:
-The shared source-processing pipeline that turns source text into an AST before execution.
-_Avoid_: CLI frontend when discussing lexer/parser/AST behavior.
+**Source pipeline**:
+The shared source-processing pipeline that turns source text into an AST before execution. It owns parser policy and exposes purpose-specific parse entry points for full source, module source, dynamic Function parsing, and expression fragments.
+_Avoid_: Source frontend, CLI host when discussing lexer/parser/AST behavior.
-**CLI frontend**:
+**Parser policy**:
+The source-pipeline settings that determine how source text is parsed, including source type and the compatibility flag set.
+_Avoid_: Separate parser booleans when discussing the policy as a whole.
+
+**CLI host**:
A command-line program that hosts the engine or runtime for a specific workflow.
-_Avoid_: Source frontend.
+_Avoid_: CLI frontend, source pipeline.
**CLI option**:
A named command-line control such as `--mode=bytecode`, `--output=json`, or `--print`. Use it as the umbrella term for named CLI controls, whether they take a value or not.
_Avoid_: CLI flag when the option takes a value.
**CLI flag**:
-A boolean CLI option that toggles behavior by its presence, such as `--print`, `--asi`, or `--unsafe-ffi`.
+A boolean CLI option that toggles behavior by its presence, such as `--print`, `--compat-asi`, or `--unsafe-ffi`.
_Avoid_: CLI flag for value-taking controls.
**Positional argument**:
@@ -77,7 +81,7 @@ The initial script or module file path that starts a single program run. It anch
_Avoid_: Input file when only the initial program path matters.
**Input file**:
-Any file processed by a CLI frontend, especially batch-capable tools such as the Test Runner, Benchmark Runner, Bundler, or multifile processing.
+Any file processed by a CLI host, especially batch-capable tools such as the Test Runner, Benchmark Runner, Bundler, or multifile processing.
_Avoid_: Entry file when referring to a batch member or per-file result.
**Config key**:
@@ -110,8 +114,12 @@ _Avoid_: Generic VM layer.
The textual contents of GocciaScript code, independent of whether it came from a file, stdin, or an embedding host.
_Avoid_: Source file when referring to in-memory contents.
+**Preprocessor**:
+A source-to-source transformation applied before the source pipeline lexes and parses source text. JSX is the current preprocessor.
+_Avoid_: JSX flag when referring to the general mechanism.
+
**Source type**:
-The setting that chooses whether an entry file is evaluated as script source or module source.
+The setting that chooses whether an entry file is evaluated as script source or module source. It may be explicit or inferred from the entry file name.
_Avoid_: Mode, module mode, script mode.
**Script source**:
@@ -123,15 +131,15 @@ Source evaluated with module entry semantics, including module `this`, imports,
_Avoid_: Script source.
**Script Loader**:
-The CLI frontend that executes source files, stdin, or `.gbc` artifacts.
+The CLI host that executes source files, stdin, or `.gbc` artifacts.
_Avoid_: Script executor.
**Bare Script Loader**:
-The CLI frontend that executes through the core engine without attaching the runtime surface.
+The CLI host that executes through the core engine without attaching the runtime surface.
_Avoid_: Loader profile.
**Bundler**:
-The CLI frontend that compiles source to `.gbc` artifacts without executing the program.
+The CLI host that compiles source to `.gbc` artifacts without executing the program.
_Avoid_: Compiler when referring to the user-facing tool.
### Values And Bindings
@@ -187,8 +195,12 @@ A class or object shorthand function that receives its call-site receiver as `th
_Avoid_: Arrow method.
**Compatibility flag**:
-An explicit boolean CLI flag or config value that enables an excluded ECMAScript legacy behavior or stricter runtime check.
-_Avoid_: Feature flag when the option exists for compatibility or enforcement semantics.
+An explicit boolean CLI flag or config value, using canonical `compat-*` spelling, that enables an excluded ECMAScript compatibility behavior.
+_Avoid_: Feature flag when the option exists for compatibility semantics.
+
+**Compatibility flag set**:
+The aggregate source-pipeline setting that carries enabled compatibility flags together, such as `compat-asi`, `compat-var`, `compat-function`, or `compat-non-strict-mode`.
+_Avoid_: Separate compatibility booleans when a caller is passing the whole parser compatibility policy.
## Flagged Ambiguities
@@ -222,8 +234,8 @@ Use **user-defined function** for source-defined functions in general. Use **arr
**Script Loader**:
Use **Script Loader** for `GocciaScriptLoader`. Avoid **script executor** except when describing the generic act of executing source.
-**Frontend**:
-Use **source frontend** for lexer/parser/AST work. Use **CLI frontend** for command-line programs.
+**Frontend/backend terminology**:
+Avoid frontend/backend terminology in GocciaScript architecture. Use **source pipeline** for lexer/parser/AST work and **CLI host** for command-line programs.
## Example Dialogue
diff --git a/README.md b/README.md
index bc1932f6..d5d8d8d5 100644
--- a/README.md
+++ b/README.md
@@ -99,10 +99,12 @@ printf "print('hello from bare');" | ./build/GocciaScriptLoaderBare
./build/GocciaScriptLoaderBare example.js
```
-`GocciaScriptLoaderBare` accepts an explicit entry file, `-`, or no positional argument for stdin. It reads source text in the CLI frontend and passes it to `TGocciaEngine`; it exposes a CLI-local `print(...args)` helper for stdout, but does not attach `TGocciaRuntime`. Like `GocciaScriptLoader`, it is silent by default — pass `--print` to emit the script's last value (the explicit `print(...)` helper is unaffected by `--print`).
+`GocciaScriptLoaderBare` accepts an explicit entry file, `-`, or no positional argument for stdin. It reads source text in the CLI host and passes it to `TGocciaEngine`; it exposes a CLI-local `print(...args)` helper for stdout, but does not attach `TGocciaRuntime`. Like `GocciaScriptLoader`, it is silent by default — pass `--print` to emit the script's last value (the explicit `print(...)` helper is unaffected by `--print`).
Script files may start with a Unix shebang line like `#!/usr/bin/env goccia`; GocciaScript ignores that first line during lexing.
+Files ending in `.mjs` are loaded as module source by default, matching JavaScript runtime convention. Use `--source-type=script` to override that inference, or `--source-type=module` / `"source-type": "module"` to force module source for other extensions.
+
### Run via Bytecode
GocciaScript includes bytecode execution. The public bytecode artifact is `.gbc`.
@@ -239,11 +241,11 @@ For a full guided walkthrough, see the [Tutorial](docs/tutorial.md). For the com
## Architecture
-GocciaScript supports two execution modes that share the same source frontend (lexer, parser, AST):
+GocciaScript supports two execution modes that share the same source pipeline (preprocessors, lexer, parser, AST):
```mermaid
flowchart LR
- Source["Source Code"] --> Lexer --> Parser --> AST
+ Source["Source Code"] --> Preprocessors["Preprocessors"] --> Lexer --> Parser --> AST
AST --> Interpreter["Tree-Walk Interpreter"] --> Result1["Result"]
AST --> Compiler["Bytecode Compiler"] --> VM["Goccia VM"] --> Result2["Result"]
```
diff --git a/docs/architecture.md b/docs/architecture.md
index dc9153fa..bd9fe4e1 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1,32 +1,34 @@
# Architecture
-*How source flows through the engine: shared source frontend, two execution modes, and the main Pascal layers.*
+*How source flows through the engine: shared source pipeline, two execution modes, and the main Pascal layers.*
## Executive Summary
- **Engine/runtime split** — `TGocciaEngine` orchestrates parsing, execution, core language built-ins, and source text execution; `Goccia.Runtime` attaches runtime globals, file helpers, and extensions
- **Execution mode abstraction** — `TGocciaExecutor` is the abstract class; `TGocciaInterpreterExecutor` and `TGocciaBytecodeExecutor` implement it independently
-- **Shared source frontend** — Lexer, Parser, and AST are shared between execution modes
+- **Shared source pipeline** — Preprocessors, lexer, parser, warning data, source maps, and AST artifacts are shared between execution modes
- **Shared execution substrate** — Both execution modes share the same value types, core scope model, runtime extension mechanism, and mark-and-sweep GC
- **Goccia-specific** — The bytecode VM operates directly on `TGocciaValue`, not a generic VM abstraction
- **No cross-dependency** — The bytecode executor has no dependency on the interpreter or evaluator units
## Overview
-GocciaScript has two execution modes: interpreter mode (tree-walk over the AST) and bytecode mode (`TGocciaVM`). A single `TGocciaEngine` class orchestrates both, delegating execution to a pluggable `TGocciaExecutor`. Both execution modes share the same source frontend, value system, core language built-ins, and garbage collector. Runtime globals are attached through runtime extensions; see [Main Layers](#main-layers) for the `Goccia.Engine` / `Goccia.Runtime` split. See [Bytecode VM](bytecode-vm.md) for the bytecode executor's architecture.
+GocciaScript has two execution modes: interpreter mode (tree-walk over the AST) and bytecode mode (`TGocciaVM`). A single `TGocciaEngine` class orchestrates both, delegating execution to a pluggable `TGocciaExecutor`. Both execution modes share the same source pipeline, value system, core language built-ins, and garbage collector. Runtime globals are attached through runtime extensions; see [Main Layers](#main-layers) for the `Goccia.Engine` / `Goccia.Runtime` split. See [Bytecode VM](bytecode-vm.md) for the bytecode executor's architecture.
+
+The source pipeline public API is `TGocciaSourcePipeline` in `Goccia.SourcePipeline`. `Parse` accepts source text plus `TGocciaSourcePipelineOptions` (preprocessors, compatibility flag set, and source type) and returns an owning `TGocciaSourcePipelineResult` containing the AST, generated-source lines, source map, timings, and warnings as data. Narrow source-pipeline entry points cover module source, dynamic `Function` validation/wrapper parsing, and expression fragments so hosts do not construct or configure `TGocciaParser` directly. Embedders that want to run source should continue using `TGocciaEngine.Execute` or the `RunScript*` helpers; direct source-pipeline use is for hosts that need parse artifacts, such as bytecode compilation paths.
## Pipelines
### Interpreter
```text
-Source -> JSX Transformer (optional) -> Lexer -> Parser -> Interpreter -> Evaluator -> TGocciaValue
+Source -> Preprocessors (optional, e.g. JSX) -> Lexer -> Parser -> Interpreter -> Evaluator -> TGocciaValue
```
### Bytecode
```text
-Source -> JSX Transformer (optional) -> Lexer -> Parser -> Compiler -> Goccia Bytecode -> TGocciaVM -> TGocciaValue
+Source -> Preprocessors (optional, e.g. JSX) -> Lexer -> Parser -> Compiler -> Goccia Bytecode -> TGocciaVM -> TGocciaValue
```
## Main Layers
@@ -38,8 +40,7 @@ Source -> JSX Transformer (optional) -> Lexer -> Parser -> Compiler -> Goccia By
| Executor abstraction | `Goccia.Executor` | Abstract `TGocciaExecutor` base class |
| Interpreter executor | `Goccia.Executor.Interpreter` (`TGocciaInterpreterExecutor`) | Tree-walk execution via `TGocciaInterpreter` |
| Bytecode executor | `Goccia.Executor.Bytecode` (`TGocciaBytecodeExecutor`) | Bytecode compile + VM execution; no interpreter dependency |
-| JSX | `Goccia.JSX.Transformer` | Optional pre-pass converting JSX to `createElement` calls |
-| Source frontend | `Goccia.Lexer`, `Goccia.Parser`, `Goccia.AST.*` | Source text to AST |
+| Source pipeline | `Goccia.SourcePipeline`, `Goccia.JSX.Transformer`, `Goccia.Lexer`, `Goccia.Parser`, `Goccia.AST.*` | Source text to AST, including parser policy, preprocessor dispatch, source maps, warning data, and generated-source lines |
| Interpreter | `Goccia.Interpreter`, `Goccia.Evaluator.*` | Tree-walk execution |
| Bytecode compiler | `Goccia.Compiler*` | AST to bytecode templates/modules |
| Bytecode format | `Goccia.Bytecode*` | Opcodes, templates, modules, binary I/O, debug info |
@@ -50,7 +51,7 @@ Source -> JSX Transformer (optional) -> Lexer -> Parser -> Compiler -> Goccia By
For **tree-walk execution**, see [Interpreter](interpreter.md); for **bytecode execution**, see [Bytecode VM](bytecode-vm.md). For **canonical terminology**, see [GocciaScript Context](../CONTEXT.md). For **recurring implementation patterns** and Define vs Assign implementation details, see [Core patterns](core-patterns.md).
-Source type belongs to the `SourceType` property on `TGocciaEngine`, because script source and module source change language execution (`this`, import metadata, and top-level scope lifetime). `TGocciaRuntimeCore` may be attached to an engine, but it does not decide the entry file's source type. File-backed convenience APIs and the default filesystem module content provider live in `Goccia.Runtime`; runtime globals are added by installing concrete `TGocciaRuntimeExtension` classes or by applying a profile such as `TGocciaLoaderRuntimeProfile`. Engine APIs accept source text or caller-provided `TStringList` instances. CLI frontends may still read their entry file or stdin before constructing the engine, as `GocciaScriptLoaderBare` does, but that file read is outside the engine API and does not attach runtime globals.
+Source type belongs to the `SourceType` property on `TGocciaEngine`, because script source and module source change language execution (`this`, import metadata, and top-level scope lifetime). File names ending in `.mjs` infer module source unless an explicit source type is provided. `TGocciaRuntimeCore` may be attached to an engine, but it does not decide the entry file's source type. File-backed convenience APIs and the default filesystem module content provider live in `Goccia.Runtime`; runtime globals are added by installing concrete `TGocciaRuntimeExtension` classes or by applying a profile such as `TGocciaLoaderRuntimeProfile`. Engine APIs accept source text or caller-provided `TStringList` instances. CLI hosts may still read their entry file or stdin before constructing the engine, as `GocciaScriptLoaderBare` does, but that file read is outside the engine API and does not attach runtime globals.
## Design Direction
@@ -69,12 +70,12 @@ The CLI tools share a two-level application class hierarchy and a declarative op
- `TGocciaApplication` (`Goccia.Application.pas`) — embeddable base for any GocciaScript host. Manages GC lifecycle (`Initialize`/`Shutdown`) and unified error handling (`HandleError` virtual). No CLI dependency.
- `TGocciaCLIApplication` (`Goccia.CLI.Application.pas`) — extends `TGocciaApplication` with CLI concerns: argument parsing, help generation, option registration, and coverage/profiler singleton lifecycle. Tools override `Configure` (register options) and `ExecuteWithPaths` (business logic).
-**Option class hierarchy** (`CLI.Options.pas`):
+**Option class hierarchy**:
-- `TGocciaOptionBase` → `TGocciaFlagOption`, `TGocciaStringOption`, `TGocciaIntegerOption`, `TGocciaRepeatableOption`, `TGocciaEnumOption`
+- `CLI.Options.pas` provides generic primitives: `TOptionBase` → `TFlagOption`, `TStringOption`, `TIntegerOption`, `TRepeatableOption`, `TEnumOption`
- The parser calls `Option.Apply(Value)` via virtual dispatch — no pointer arithmetic
-- `TGocciaEnumOption` uses RTTI (`GetEnumName` + prefix stripping) to auto-discover valid values
-- Predefined option groups (`TGocciaEngineOptions`, `TGocciaCoverageOptions`, `TGocciaProfilerOptions`) bundle related options with owning lifecycle
+- `TEnumOption` uses RTTI (`GetEnumName` + prefix stripping) to auto-discover valid values
+- `Goccia.CLI.Options.pas` owns Goccia-specific groups (`TGocciaEngineOptions`, `TGocciaCoverageOptions`, `TGocciaProfilerOptions`) and the compatibility flag registry used by each CLI host
**CLI lifecycle** (`TGocciaCLIApplication.Execute`):
@@ -140,7 +141,7 @@ This replaces a previous `threadvar`-cache approach where intrinsic prototypes s
The interpreter and bytecode executors are **intentionally separate control-flow mechanisms** (tree-walk vs register VM). Sharing the **same** `TGocciaValue` model and virtual property access is the architectural consolidation point; you should not try to merge those executors into one execution path.
-- **Beneficial separation** — Different layers solving different problems: the lexer/parser/AST source frontend vs `Goccia.Evaluator.*` vs `Goccia.Compiler.*` vs `Goccia.VM.*`; standalone format parsers (`Goccia.JSON`, `Goccia.TOML`, …) vs thin `Goccia.Builtins.*` adapters. Duplication *across* those boundaries is often *different representations of the same spec* (AST vs opcodes vs byte streams), not copy-paste to delete blindly.
+- **Beneficial separation** — Different layers solving different problems: the lexer/parser/AST source pipeline vs `Goccia.Evaluator.*` vs `Goccia.Compiler.*` vs `Goccia.VM.*`; standalone format parsers (`Goccia.JSON`, `Goccia.TOML`, …) vs thin `Goccia.Builtins.*` adapters. Duplication *across* those boundaries is often *different representations of the same spec* (AST vs opcodes vs byte streams), not copy-paste to delete blindly.
- **Harmful duplication** — The **same rule** maintained twice without a seam: e.g. identical helper functions in two compiler units, or compile-time type compatibility (`TypesAreCompatible`) drifting from runtime `OP_CHECK_TYPE` behavior. That class of duplication should be centralized (shared helpers, single runtime check implementation) so policy stays consistent.
diff --git a/docs/build-system.md b/docs/build-system.md
index b3815424..b35d5d74 100644
--- a/docs/build-system.md
+++ b/docs/build-system.md
@@ -211,7 +211,8 @@ The first file found is loaded and applied as the **root config**. When running
1. **CLI options** (highest priority — always win)
2. **Per-file config** (`goccia.toml`, `goccia.json5`, or `goccia.json` nearest to the file being processed)
3. **Root config** (discovered from the entry file's directory at startup, or supplied via `--config`)
-4. **System default** (engine defaults)
+4. **File extension default** (`.mjs` infers module source)
+5. **System default** (engine defaults)
**`--config=`** — Override auto-discovery and load the root config from an explicit location. Available on every CLI tool.
@@ -228,11 +229,13 @@ The path may be either a **file** (any registered extension — `.json`, `.json5
Relative paths are resolved against the current working directory. A missing file or a directory with no recognised `goccia.*` is a hard error so a typo is not silently ignored. CLI options still take precedence over values from the file, and per-file configs continue to be discovered normally for individual files.
+`source-type` follows that same precedence. Without an explicit CLI or config value, `.mjs` entry files are parsed and evaluated as module source; other script extensions default to script source.
+
```json
{
"mode": "bytecode",
"source-type": "module",
- "asi": true,
+ "compat-asi": true,
"compat-non-strict-mode": true,
"compat-loose-equality": true,
"compat-traditional-for-loop": true,
@@ -265,7 +268,7 @@ This is useful for test subdirectories that need specific flags. For example, `t
```json
{
- "asi": true
+ "compat-asi": true
}
```
@@ -280,7 +283,7 @@ Likewise, `tests/built-ins/FFI/goccia.json` enables FFI only for the FFI tests:
TOML equivalent (`goccia.toml`):
```toml
-asi = true
+compat-asi = true
mode = "bytecode"
unsafe-ffi = true
timeout = 5000
@@ -349,7 +352,7 @@ printf "const x = 2 + 2; x;" | ./build/GocciaBundler --output=out.gbc
./build/GocciaBundler example.jsx --source-map=out.map
# Enable automatic semicolon insertion during parsing
-./build/GocciaBundler example.js --asi
+./build/GocciaBundler example.js --compat-asi
# Parallel compilation (default: CPU count)
./build/GocciaBundler src/ --jobs=4
diff --git a/docs/built-ins.md b/docs/built-ins.md
index ce145c0c..5b950fd2 100644
--- a/docs/built-ins.md
+++ b/docs/built-ins.md
@@ -17,7 +17,7 @@ GocciaScript provides a set of built-in global objects that mirror JavaScript's
Core language built-ins (Math, Object, Array, Number, JSON, Symbol, Set, Map, WeakSet, WeakMap, Promise, Temporal, Intl, ArrayBuffer, Proxy, Reflect, etc.) are always registered unconditionally by the engine.
-Runtime globals (Console, JSON5, JSONL, TOML, YAML, CSV, TSV, Performance, TextEncoder/TextDecoder, URL, fetch, Headers, Response, SemVer) are registered by runtime extension classes under `source/units/Goccia.RuntimeExtensions.*.pas`. CLI frontends such as `GocciaScriptLoader` and `GocciaREPL` apply `TGocciaLoaderRuntimeProfile`; `GocciaTestRunner` applies the loader runtime profile plus `TGocciaTestingLibraryRuntimeExtension`; `GocciaBenchmarkRunner` applies the loader runtime profile plus `TGocciaBenchmarkRuntimeExtension`. `GocciaScriptLoaderBare` does not attach a runtime and exposes only a CLI-local `print(...args)` helper.
+Runtime globals (Console, JSON5, JSONL, TOML, YAML, CSV, TSV, Performance, TextEncoder/TextDecoder, URL, fetch, Headers, Response, SemVer) are registered by runtime extension classes under `source/units/Goccia.RuntimeExtensions.*.pas`. CLI hosts such as `GocciaScriptLoader` and `GocciaREPL` apply `TGocciaLoaderRuntimeProfile`; `GocciaTestRunner` applies the loader runtime profile plus `TGocciaTestingLibraryRuntimeExtension`; `GocciaBenchmarkRunner` applies the loader runtime profile plus `TGocciaBenchmarkRuntimeExtension`. `GocciaScriptLoaderBare` does not attach a runtime and exposes only a CLI-local `print(...args)` helper.
FFI is not part of the loader runtime profile. CLI tools install `TGocciaFFIRuntimeExtension` when `--unsafe-ffi` is passed or `"unsafe-ffi": true` is set in config.
@@ -53,7 +53,7 @@ Implements the [WHATWG Console Standard](https://developer.mozilla.org/en-US/doc
**Output capture:** The console supports an `OutputCallback` hook for capturing output programmatically (see [Embedding — Console Output Capture](embedding.md#console-output-capture)).
-Separately, the `TGocciaCLIApplication`-based frontends use `LogCallback` for `--log=`, which writes every console call to the specified file in `[method] line` format while preserving normal stdout output.
+Separately, the `TGocciaCLIApplication`-based CLI hosts use `LogCallback` for `--log=`, which writes every console call to the specified file in `[method] line` format while preserving normal stdout output.
### Math (`Goccia.Builtins.Math.pas`)
diff --git a/docs/bytecode-vm.md b/docs/bytecode-vm.md
index a4caa060..cb9dfb76 100644
--- a/docs/bytecode-vm.md
+++ b/docs/bytecode-vm.md
@@ -4,7 +4,7 @@
## Executive Summary
-- **Two execution modes** — tree-walk interpreter (default) and bytecode VM (`--mode=bytecode`), sharing the same source frontend, runtime objects, and GC
+- **Two execution modes** — tree-walk interpreter (default) and bytecode VM (`--mode=bytecode`), sharing the same source pipeline, runtime objects, and GC
- **Executor abstraction** — `TGocciaBytecodeExecutor` implements `TGocciaExecutor` with no dependency on the interpreter or evaluator
- **Goccia-owned VM** — executes directly on `TGocciaValue` with tagged `TGocciaRegister` values; not a generic VM layer
- **Opcode space** — core instructions (0-127) for hot paths, non-core generic ops (128-166), and semantic/helper instructions (167-255) for colder operations like imports/exports
@@ -250,7 +250,7 @@ During code review, the following findings were investigated and determined to b
## Related documents
-- [Architecture](architecture.md) — Shared source frontend and both execution modes at a glance
+- [Architecture](architecture.md) — Shared source pipeline and both execution modes at a glance
- [Interpreter](interpreter.md) — Tree-walk execution (`Goccia.Interpreter`, `Goccia.Evaluator.*`)
- [Core patterns](core-patterns.md) — Recurring Pascal conventions
- [GocciaScript Context](../CONTEXT.md) — Canonical project terminology
diff --git a/docs/decision-log.md b/docs/decision-log.md
index 118e7cb3..60049bd6 100644
--- a/docs/decision-log.md
+++ b/docs/decision-log.md
@@ -17,6 +17,10 @@ Chronological record of key architectural and implementation decisions, newest f
---
+**2026-05-24** · `parser` — Parser policy now lives behind the source pipeline instead of being repeated at host call sites. `TGocciaSourcePipeline` owns compatibility/source-type mapping and exposes narrow parse entry points for full source, module source, dynamic `Function` validation/wrapping, and expression fragments; module loading consumes a module-specific result rather than the full host-facing parse report. [architecture.md § Overview](architecture.md#overview). [embedding.md § Engine API](embedding.md#engine-api).
+
+**2026-05-24** · `parser` — ASI now uses the compatibility flag surface as `--compat-asi` / `"compat-asi"` with no legacy alias. Goccia-specific CLI option metadata lives in `Goccia.CLI.Options`, where compatibility flags are table-driven and resolved into the source-pipeline compatibility set; embedders use `TGocciaEngine.Compatibility` rather than per-flag convenience properties. [language.md § Automatic Semicolon Insertion](language.md#automatic-semicolon-insertion). [embedding.md § Preprocessors and Compatibility](embedding.md#preprocessors-and-compatibility).
+
**2026-05-20** · `parser` — Function declarations use explicit statement nodes. Replaced the temporary `IsFunctionDeclaration` flag on `TGocciaVariableDeclaration` with `TGocciaFunctionDeclaration` and `TGocciaExportFunctionDeclaration`, while keeping function expressions on `TGocciaFunctionExpression`. This keeps declaration paths readable and maintainable, and gives parser, interpreter, bytecode, export, hoisting, and redeclaration logic exact AST semantics instead of inferring declaration intent from variable-declaration shape.
**2026-05-18** · `runtime` — Runtime host features are now class-based extensions installed onto `TGocciaRuntimeCore`, rather than a broad runtime-global selector. `GocciaScriptLoader` / `GocciaREPL` apply `TGocciaLoaderRuntimeProfile`; `GocciaTestRunner` layers `TGocciaTestingLibraryRuntimeExtension`; `GocciaBenchmarkRunner` layers `TGocciaBenchmarkRuntimeExtension`; FFI remains an explicit `--unsafe-ffi` extension. Feature-specific APIs such as fetch host restrictions and JSON5/TOML/YAML globals injection live on concrete extensions and are reached through runtime dispatch, keeping the base runtime extension generic and making smaller host surfaces easier to link. [architecture.md](architecture.md#main-layers). [embedding.md](embedding.md#runtime-extensions).
diff --git a/docs/embedding.md b/docs/embedding.md
index 7c261688..a5d76778 100644
--- a/docs/embedding.md
+++ b/docs/embedding.md
@@ -47,7 +47,9 @@ These helpers create, execute, and clean up in a single call. The `TGocciaEngine
| `TGocciaRuntime.RunScriptFromStringList(Source, FileName)` | Execute from a `TStringList` through the runtime layer |
All methods return `TGocciaScriptResult` — a record containing the result value, per-phase timing (in microseconds), and the filename.
-`SourceType` is an engine-level language option, not a runtime option. Set `Engine.SourceType` (or use the CLI `--source-type=script|module`) to choose script source or module source for the entry file. File loading is separate: `TGocciaEngine` one-shot helpers accept source text or caller-provided `TStringList` instances only, while `TGocciaRuntime.RunScriptFromFile` is the runtime convenience API for loading an entry file.
+`SourceType` is an engine-level language option, not a runtime option. Set `Engine.SourceType` (or use the CLI `--source-type=script|module`) to choose script source or module source for the entry file. File names ending in `.mjs` infer module source unless an explicit source type is provided. File loading is separate: `TGocciaEngine` one-shot helpers accept source text or caller-provided `TStringList` instances only, while `TGocciaRuntime.RunScriptFromFile` is the runtime convenience API for loading an entry file.
+
+`TGocciaEngine.Execute` remains the public "run the whole source pipeline and execute" API for embedders. Hosts that need parse artifacts without executing can call `TGocciaSourcePipeline.Parse` directly; its result object owns the AST and source map until the caller frees the result or transfers ownership with `TakeProgramNode` / `TakeSourceMap`. Hosts should use the source-pipeline entry points for module source, dynamic `Function` validation, and expression fragments rather than constructing `TGocciaParser` directly; this keeps parser policy in one place.
### Instance Usage (Long-Lived Engine)
@@ -98,13 +100,13 @@ Callers must pass an explicit executor — `TGocciaInterpreterExecutor` (in `Goc
### Automatic Semicolon Insertion
-ASI is disabled by default. To enable ECMAScript-compliant automatic semicolon insertion (ES2026 §12.10), set the `ASIEnabled` property after creating the engine:
+ASI is disabled by default. To enable ECMAScript-compliant automatic semicolon insertion (ES2026 §12.10), include `cfASI` in the engine compatibility set after creating the engine:
```pascal
Executor := TGocciaInterpreterExecutor.Create;
try
Engine := TGocciaEngine.Create('app.js', Source, Executor);
- Engine.ASIEnabled := True; // Semicolons are now optional per ES2026 rules
+ Engine.Compatibility := [cfASI]; // Semicolons are now optional per ES2026 rules
Engine.Execute;
finally
Engine.Free;
@@ -204,7 +206,7 @@ Scripts can then import using the alias:
import { formatDate } from "@/utils/dates";
```
-`TGocciaModuleResolver` also exposes `LoadImportMap(path)` and `DiscoverProjectConfig(startDirectory)` helpers for browser-style import map JSON and `goccia.json` project configuration files. The shared CLI frontends (`GocciaScriptLoader`, `GocciaTestRunner`, and `GocciaBenchmarkRunner`) all use `Goccia.Modules.Configuration.ConfigureModuleResolver(...)` on top of this resolver surface.
+`TGocciaModuleResolver` also exposes `LoadImportMap(path)` and `DiscoverProjectConfig(startDirectory)` helpers for browser-style import map JSON and `goccia.json` project configuration files. The shared CLI hosts (`GocciaScriptLoader`, `GocciaTestRunner`, and `GocciaBenchmarkRunner`) all use `Goccia.Modules.Configuration.ConfigureModuleResolver(...)` on top of this resolver surface.
**Config file discovery is automatic for CLI apps** — `TGocciaCLIApplication` discovers `goccia.toml` / `goccia.json5` / `goccia.json` (priority order: TOML > JSON5 > JSON) from the entry file's directory upward and applies config values before execution. When embedding the engine directly, this does not happen automatically. To replicate it, use the general-purpose `CLI.ConfigFile` unit (`DiscoverConfigFile`, `ApplyConfigFile`). Note that `ApplyConfigFile` only handles `.json` by default — to support `.json5` and `.toml`, register their parsers first via `RegisterConfigParser` (see `Goccia.CLI.Application.pas` for the pattern). For import-map resolution only, use `TGocciaModuleResolver.DiscoverProjectConfig` and `LoadImportMap`. See [Configuration File](build-system.md#configuration-file-gocciajson) for the full reference.
@@ -439,7 +441,7 @@ ConsoleExtension.BuiltinConsole.LogCallback := MyHandler.OnLog;
ConsoleExtension.BuiltinConsole.Enabled := False; // no stdout, but LogCallback still fires
```
-The CLI frontends based on `TGocciaCLIApplication` (ScriptLoader, TestRunner, BenchmarkRunner, and REPL) apply a runtime profile and use `LogCallback` internally for `--log=`, which captures console output to a log file in `[method] line` format. The TestRunner silences workers via `Enabled := False` (not by replacing JS methods), so `LogCallback` fires on every console call even in parallel mode. File writes are serialized with a critical section so `--log` is thread-safe even with `--jobs=N`.
+The CLI hosts based on `TGocciaCLIApplication` (ScriptLoader, TestRunner, BenchmarkRunner, and REPL) apply a runtime profile and use `LogCallback` internally for `--log=`, which captures console output to a log file in `[method] line` format. The TestRunner silences workers via `Enabled := False` (not by replacing JS methods), so `LogCallback` fires on every console call even in parallel mode. File writes are serialized with a critical section so `--log` is thread-safe even with `--jobs=N`.
## Built-in Registration
@@ -505,29 +507,28 @@ Runtime globals can be reduced by installing only a concrete extension, for exam
|--------|------|---------|---------|
| `Preprocessors` | `TGocciaPreprocessors` | `[ppJSX]` | Source transformations before parsing |
| `Compatibility` | `TGocciaCompatibilityFlags` | `[]` | Parser behavior toggles |
-| `SourceType` | `TGocciaSourceType` | `stScript` | Load entry as script source (default) or module source |
+| `SourceType` | `TGocciaSourceType` | `stScript` | Load entry as script source (default) or module source; `.mjs` file names infer `stModule` |
| `StrictTypes` | `Boolean` | `False` | Runtime enforcement of type annotations (works in both interpreter and bytecode); setter propagates to the active executor and interpreter scope |
-| `NonStrictModeEnabled` | `Boolean` | `False` | Enables script source compatibility semantics for `arguments`, `with`, silent assignment failures, legacy `delete` return values, and regular-function nullish `this`; module source remains strict |
-| `TraditionalForLoopsEnabled` | `Boolean` | `False` | Enables traditional `for(init; test; update)` compatibility semantics |
-| `WhileLoopsEnabled` | `Boolean` | `False` | Enables `while` and `do...while` compatibility semantics |
```pascal
Executor := TGocciaInterpreterExecutor.Create;
try
Engine := TGocciaEngine.Create('app.js', Source, Executor);
Engine.Preprocessors := []; // Disable JSX
- Engine.ASIEnabled := True; // Enable ASI (convenience for cfASI)
+ Engine.Compatibility := [
+ cfASI,
+ cfNonStrictMode,
+ cfTraditionalFor,
+ cfWhileLoops
+ ]; // Enable selected compatibility semantics
Engine.SourceType := stModule; // Run entry as module source (top-level this is undefined; import.meta resolves)
- Engine.NonStrictModeEnabled := True; // Enable selected non-strict compatibility semantics
- Engine.TraditionalForLoopsEnabled := True; // Enable traditional for-loop compatibility
- Engine.WhileLoopsEnabled := True; // Enable while/do-while compatibility
Engine.StrictTypes := True; // Enforce type annotations in both execution modes
finally
Executor.Free;
end;
```
-When `SourceType` is `stModule`, `Execute` runs the entry program in a fresh module scope (`skModule`) with `this = undefined`, mirroring the semantics imported modules already receive from the module loader (ES2026 §16.2.1.6.4). The CLI surface for this is `--source-type=script|module` and the matching `goccia.json` key `"source-type"`.
+When `SourceType` is `stModule`, `Execute` runs the entry program in a fresh module scope (`skModule`) with `this = undefined`, mirroring the semantics imported modules already receive from the module loader (ES2026 §16.2.1.6.4). The CLI surface for this is `--source-type=script|module` and the matching `goccia.json` key `"source-type"`. Without an explicit source type, `.mjs` entry files are loaded as module source.
**Top-level binding persistence differs between source types.** With `SourceType = stScript`, the engine reuses `Interpreter.GlobalScope` across every call to `Execute`, which is what makes the [long-lived engine pattern](#instance-usage-long-lived-engine) above work: `const x = 42` defined in one `Execute` is visible to the next. With `SourceType = stModule`, each `Execute` allocates a brand-new `skModule` child scope, so top-level `let`/`const`/`class` declarations live and die with that single call. If callers need cross-`Execute` persistence, keep `SourceType` at `stScript` (the default) or expose the desired symbols through the global scope (e.g. `Engine.RegisterGlobal(...)` or `Engine.Interpreter.GlobalScope.DefineLexicalBinding(...)`).
@@ -926,7 +927,7 @@ The repository includes five embedding examples:
| `GocciaREPL` | `source/app/GocciaREPL.dpr` | Interactive read-eval-print loop (long-lived engine) |
| `GocciaTestRunner` | `source/app/GocciaTestRunner.dpr` | Runs test suites with the test-runner runtime profile |
| `GocciaBenchmarkRunner` | `source/app/GocciaBenchmarkRunner.dpr` | Runs benchmarks with the benchmark-runner runtime profile from files or stdin |
-| `GocciaBundler` | `source/app/GocciaBundler.dpr` | Bundler CLI frontend — compiles source files to `.gbc` without execution |
+| `GocciaBundler` | `source/app/GocciaBundler.dpr` | Bundler CLI host — compiles source files to `.gbc` without execution |
These serve as reference implementations for the patterns described above.
diff --git a/docs/interpreter.md b/docs/interpreter.md
index da394a9f..70fe24c9 100644
--- a/docs/interpreter.md
+++ b/docs/interpreter.md
@@ -94,7 +94,7 @@ Scopes form a tree with parent pointers, implementing lexical scoping:
- **`OnError` on scopes** — Each scope carries a reference to the error handler callback, inherited from its parent. This allows closures and callbacks to always find the correct error handler without global state.
- **Temporal Dead Zone** — `let`/`const` bindings are registered before initialization, enforcing TDZ semantics (accessing before `=` throws `ReferenceError`).
- **Module scope isolation** — Modules execute in `skModule` scopes (children of the global scope), preventing module-internal variables from leaking into the global scope.
-- **Module path resolution** — `TGocciaModuleResolver` handles alias expansion via its inherited `Resolve` method using import-map semantics (exact match for keys without `/`, prefix match for keys with `/`, longest matching key wins), resolves `./` and `../` paths relative to the importing file's directory, tries the shared module import extensions (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.json`, `.json5`, `.jsonl`, `.toml`, `.yaml`, `.yml`, `.txt`, `.md`) and index files for extensionless imports, then expands to an absolute path. `TGocciaModuleResolver.LoadImportMap` resolves import-map values relative to the map file and `DiscoverProjectConfig` walks parent directories looking for `goccia.json`. CLI applications also discover a project-level `goccia.toml`, `goccia.json5`, or `goccia.json` (in that priority order) starting from the entry file's directory via `CLI.ConfigFile.DiscoverConfigFile`. Config keys mirror CLI option names (for example, `mode`, `asi`, `timeout`), and CLI options override config values. Config files support `"extends"` to inherit from a base config, enabling per-directory overrides (e.g. `tests/language/asi/goccia.json` enables ASI for that subtree). Absolute paths are used as cache keys to prevent loading the same file via different relative paths. Global modules (bare specifiers registered via `Engine.RegisterGlobalModule`) are checked before the resolver runs. Custom resolvers can be injected by subclassing `TGocciaModuleResolver` and overriding the `Resolve` method.
+- **Module path resolution** — `TGocciaModuleResolver` handles alias expansion via its inherited `Resolve` method using import-map semantics (exact match for keys without `/`, prefix match for keys with `/`, longest matching key wins), resolves `./` and `../` paths relative to the importing file's directory, tries the shared module import extensions (`.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`, `.json`, `.json5`, `.jsonl`, `.toml`, `.yaml`, `.yml`, `.txt`, `.md`) and index files for extensionless imports, then expands to an absolute path. `TGocciaModuleResolver.LoadImportMap` resolves import-map values relative to the map file and `DiscoverProjectConfig` walks parent directories looking for `goccia.json`. CLI applications also discover a project-level `goccia.toml`, `goccia.json5`, or `goccia.json` (in that priority order) starting from the entry file's directory via `CLI.ConfigFile.DiscoverConfigFile`. Config keys mirror CLI option names (for example, `mode`, `compat-asi`, `timeout`), and CLI options override config values. Config files support `"extends"` to inherit from a base config, enabling per-directory overrides (e.g. `tests/language/asi/goccia.json` enables ASI for that subtree). Absolute paths are used as cache keys to prevent loading the same file via different relative paths. Global modules (bare specifiers registered via `Engine.RegisterGlobalModule`) are checked before the resolver runs. Custom resolvers can be injected by subclassing `TGocciaModuleResolver` and overriding the `Resolve` method.
- **Circular dependency handling** — Modules are added to the cache (`FModules`) before execution and to a loading set (`FLoadingModules`) for the duration. If a circular import is encountered, the partially-populated module is returned from cache. Inline exports (`export const`) that execute before the circular import point are available; `export { x }` declarations processed post-execution are not. This matches the observable behavior of ES module live bindings for the common case.
- **Namespace imports** — `import * as ns from "./module.js"` now materializes a namespace object from `TGocciaModule.ExportsTable` instead of being skipped by the parser. The namespace object is created with a null prototype, populated with enumerable read-only data properties for each export, then frozen before binding. The result is an import-time snapshot rather than a live export mirror, which keeps namespace imports lightweight while matching the expected read-only shape for both JavaScript modules and structured-data modules.
- **JSON module imports** — Files ending in `.json` are handled by `LoadJsonModule`, which parses the file via `TGocciaJSONParser` (`Goccia.JSON` unit) and exposes each top-level object key as a named export. JSON modules bypass the lexer/parser/evaluator pipeline entirely, keeping the import path unified (`import { key } from "./file.json"`). Non-object JSON root values (arrays, primitives) produce a module with no exports. JSON modules participate in the same caching and path resolution as JS modules.
@@ -172,13 +172,13 @@ For fetch-backed Promises, these integration points also pump fetch completions
**`queueMicrotask`:** The global `queueMicrotask(callback)` function enqueues a user-provided callback into the same microtask queue used by Promise reactions. This matches the [HTML spec](https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#microtask-queuing). If a `queueMicrotask` callback throws, the error is silently discarded and the queue keeps draining — remaining microtasks and Promise reactions still run. This matches the observable behavior in Node.js/browsers where uncaught microtask errors don't prevent other microtasks from executing.
-**Error safety:** Both `Execute` and `ExecuteProgram` wrap the drain in a `try..finally` that calls `ClearQueue` and discards pending fetch completions. If the interpreter throws, stale microtasks and fetch callbacks are discarded rather than leaking into subsequent executions; outstanding fetch workers are detached so cleanup does not wait on network I/O that can no longer affect the script. After a successful drain, both queues are already empty, so cleanup is a no-op.
+**Error safety:** `TGocciaEngine.Execute` wraps the whole source pipeline and execution path in a `try..finally` that calls `ClearQueue` and discards pending fetch completions. If the interpreter throws, stale microtasks and fetch callbacks are discarded rather than leaking into subsequent executions; outstanding fetch workers are detached so cleanup does not wait on network I/O that can no longer affect the script. Lower-level callers that bypass `Execute` and call `ExecuteProgram` directly still get the idle drain, but they own any surrounding runtime cleanup.
**GC safety:** During `DrainQueue`, each microtask's handler, value, and result promise are temp-rooted to prevent collection mid-callback.
## Related documents
-- [Architecture](architecture.md) — Shared source frontend, both execution modes, main layers, design direction
+- [Architecture](architecture.md) — Shared source pipeline, both execution modes, main layers, design direction
- [Bytecode VM](bytecode-vm.md) — Compiler output, opcodes, `TGocciaVM`
- [Core patterns](core-patterns.md) — Recurring implementation patterns
- [GocciaScript Context](../CONTEXT.md) — Canonical project terminology
diff --git a/docs/language-tables.md b/docs/language-tables.md
index d5d28463..0551d944 100644
--- a/docs/language-tables.md
+++ b/docs/language-tables.md
@@ -25,7 +25,7 @@
| `while` / `do...while` | ES1 | Opt-in for JavaScript compatibility (`--compat-while-loops`); disabled by default |
| `with` statement | ES1 | Opt-in for script source (`--compat-non-strict-mode`) for compatibility with object-environment lookup, `Symbol.unscopables`, closure capture, method-call receivers, and non-strict write failures — prefer explicit property access |
| `delete` non-strict return values | ES1 | Strict by default; script source `--compat-non-strict-mode` makes `delete identifier` handle declared bindings, configurable global object properties, and unresolvable names with legacy booleans; non-configurable property deletion returns `false` |
-| ASI (automatic semicolon insertion) | ES1 | Opt-in (`--asi`) |
+| ASI (automatic semicolon insertion) | ES1 | Opt-in (`--compat-asi`) |
| Global `parseInt`, `parseFloat`, `isNaN`, `isFinite` | ES1 | Excluded — use `Number.*` |
| `let` / `const` | ES2015 | Supported |
| Arrow functions | ES2015 | Supported |
diff --git a/docs/language.md b/docs/language.md
index 5456097d..99a8905e 100644
--- a/docs/language.md
+++ b/docs/language.md
@@ -9,7 +9,7 @@
- **TC39 proposals** — Decorators, decorator metadata, pattern matching, types as comments, enums, `Math.clamp`
- **Excluded by design** — `eval`, wildcard re-exports
- **Graceful handling** — Parser-recognized excluded or disabled syntax (`==`/`!=` when `--compat-loose-equality` is off, `while`/`do...while` when `--compat-while-loops` is off, `with` when `--compat-non-strict-mode` is off, traditional `for(;;)` when `--compat-traditional-for-loop` is off) parses successfully but executes as a no-op with a warning and suggestion
-- **Opt-in toggles** — ASI (`--asi`), `var` declarations (`--compat-var`), `function` keyword (`--compat-function`), non-strict Script compatibility (`--compat-non-strict-mode` for `arguments`, `with`, silent assignment failures, legacy `delete` returns, and sloppy `this`), loose equality (`--compat-loose-equality`), traditional `for(init; test; update)` loops (`--compat-traditional-for-loop`), `while`/`do...while` loops (`--compat-while-loops`), runtime type enforcement (`--strict-types`)
+- **Opt-in toggles** — ASI (`--compat-asi`), `var` declarations (`--compat-var`), `function` keyword (`--compat-function`), non-strict Script compatibility (`--compat-non-strict-mode` for `arguments`, `with`, silent assignment failures, legacy `delete` returns, and sloppy `this`), loose equality (`--compat-loose-equality`), traditional `for(init; test; update)` loops (`--compat-traditional-for-loop`), `while`/`do...while` loops (`--compat-while-loops`), runtime type enforcement (`--strict-types`)
- **Default preprocessors** — JSX (enabled by default via `DefaultPreprocessors`)
GocciaScript implements a curated subset of ECMAScript. This document details what's supported, what's excluded, and the rationale for each decision. For quick-reference tables of every feature and TC39 proposal, see [Language Tables](language-tables.md).
@@ -160,7 +160,7 @@ const fn = async () => {
### Modules
-ES module syntax with default, named, and namespace imports/exports. Project code convention prefers named exports for internal modules, but default imports and exports are language-supported. Supported source file extensions: `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`. Structured-data imports are also supported for `.json`, `.json5`, `.jsonl`, `.toml`, `.yaml`, `.yml`, `.csv`, and `.tsv`, and text-asset imports are supported for `.txt` and `.md`. Module paths are resolved relative to the importing file. File extensions can be omitted — the resolver tries source, structured-data, and text-asset extensions in order. Directory imports resolve to `index` files. The CLI tools support WHATWG-style import maps through `--import-map=`, `--alias key=value`, and implicit `goccia.json` discovery.
+ES module syntax with default, named, and namespace imports/exports. Project code convention prefers named exports for internal modules, but default imports and exports are language-supported. Supported source file extensions: `.js`, `.jsx`, `.ts`, `.tsx`, `.mjs`; `.mjs` entry files default to module source. Structured-data imports are also supported for `.json`, `.json5`, `.jsonl`, `.toml`, `.yaml`, `.yml`, `.csv`, and `.tsv`, and text-asset imports are supported for `.txt` and `.md`. Module paths are resolved relative to the importing file. File extensions can be omitted — the resolver tries source, structured-data, and text-asset extensions in order. Directory imports resolve to `index` files. The CLI tools support WHATWG-style import maps through `--import-map=`, `--alias key=value`, and implicit `goccia.json` discovery.
```javascript
// Named imports (with or without extension)
@@ -656,7 +656,7 @@ console.log(x); // 5
With `let`/`const`, accessing before declaration is a `ReferenceError` (Temporal Dead Zone), which catches bugs early.
-When enabled (CLI: `--compat-var`, engine API: `Engine.VarEnabled := True`, config: `{"compat-var": true}`), `var` declarations follow ES2026 §14.3.2 semantics: function-scoped (escapes blocks), hoisted to function top as `undefined`, redeclaration allowed, no TDZ, with destructuring and for-of support. Var bindings are stored in a separate binding map (`FVarBindings`) on function/module/global scopes, distinct from lexical bindings. See [interpreter.md § Scope Chain Design](interpreter.md#scope-chain-design).
+When enabled (CLI: `--compat-var`, engine API: include `cfVar` in `Engine.Compatibility`, config: `{"compat-var": true}`), `var` declarations follow ES2026 §14.3.2 semantics: function-scoped (escapes blocks), hoisted to function top as `undefined`, redeclaration allowed, no TDZ, with destructuring and for-of support. Var bindings are stored in a separate binding map (`FVarBindings`) on function/module/global scopes, distinct from lexical bindings. See [interpreter.md § Scope Chain Design](interpreter.md#scope-chain-design).
### `function` Keyword
@@ -677,7 +677,7 @@ GocciaScript provides two function definition styles that cover most use cases w
- **Arrow functions** (`(x) => x + 1`) — Lexical `this`, no hoisting, no own `arguments`. Use for standalone functions, callbacks, and closures.
- **Shorthand methods** (`method() {}`) — Call-site `this`. Use in object literals and class definitions where `this` binding is needed.
-When enabled (CLI: `--compat-function`, engine API: `Engine.FunctionEnabled := True`, config: `{"compat-function": true}`), `function` declarations and expressions are supported. Their implicit `arguments` object still requires `--compat-non-strict-mode`.
+When enabled (CLI: `--compat-function`, engine API: include `cfFunction` in `Engine.Compatibility`, config: `{"compat-function": true}`), `function` declarations and expressions are supported. Their implicit `arguments` object still requires `--compat-non-strict-mode`.
- **Function declarations** (`function name(params) { body }`) parse as `TGocciaFunctionDeclaration` nodes whose body is backed by `TGocciaFunctionExpression`, which produces call-site `this` binding (not lexical). Declarations are hoisted: both the name and the function value are available before the declaration is reached, matching ES2026 §15.2.6 semantics. Uses the same var binding infrastructure (`DefineVariableBinding`) as `--compat-var`.
- **Function expressions** (`const f = function(params) { body }`) parse as `TGocciaFunctionExpression` nodes. Named function expressions (`const f = function g(params) { body }`) create a read-only self-binding of the name (`g`) visible only inside the function body for recursion, matching ES2026 §15.2.4 semantics.
@@ -687,7 +687,7 @@ When enabled (CLI: `--compat-function`, engine API: `Engine.FunctionEnabled := T
### Loose Equality (`==` and `!=`)
-**Opt-in.** Excluded by default; use `===` and `!==` unless you are running compatibility code. Available via `--compat-loose-equality` (CLI flag, `Engine.LooseEqualityEnabled`, or `{"compat-loose-equality": true}` in config).
+**Opt-in.** Excluded by default; use `===` and `!==` unless you are running compatibility code. Available via `--compat-loose-equality` (CLI flag, `cfLooseEquality` in `Engine.Compatibility`, or `{"compat-loose-equality": true}` in config).
When enabled, `==` and `!=` follow [ES2026 §7.2.13 IsLooselyEqual](https://tc39.es/ecma262/2026/multipage/abstract-operations.html#sec-islooselyequal) in both interpreter and bytecode modes, including `null == undefined`, string/number coercion, boolean-to-number coercion, BigInt/string and BigInt/number comparisons, and object `ToPrimitive` conversion.
@@ -720,7 +720,7 @@ Strict equality requires matching types, eliminating this entire class of bugs.
### `arguments` Object
-**Opt-in for script source.** Excluded by default; prefer rest parameters. Available via `--compat-non-strict-mode` (CLI flag, `Engine.NonStrictModeEnabled`, or `{"compat-non-strict-mode": true}` in config). Module source remains strict even when this flag is enabled. When enabled in script source, ordinary functions, shorthand methods, accessors, and generators create an unmapped, array-like `arguments` object whose indexed entries and `length` reflect the call's argument list without aliasing parameter variables. Arrow functions do not create their own `arguments`; they resolve it lexically from the nearest enclosing ordinary function or method that has one. `arguments` is an ordinary identifier, not a reserved keyword, so parameters or body-level lexical declarations named `arguments` shadow the implicit object.
+**Opt-in for script source.** Excluded by default; prefer rest parameters. Available via `--compat-non-strict-mode` (CLI flag, `cfNonStrictMode` in `Engine.Compatibility`, or `{"compat-non-strict-mode": true}` in config). Module source remains strict even when this flag is enabled. When enabled in script source, ordinary functions, shorthand methods, accessors, and generators create an unmapped, array-like `arguments` object whose indexed entries and `length` reflect the call's argument list without aliasing parameter variables. Arrow functions do not create their own `arguments`; they resolve it lexically from the nearest enclosing ordinary function or method that has one. `arguments` is an ordinary identifier, not a reserved keyword, so parameters or body-level lexical declarations named `arguments` shadow the implicit object.
### Automatic Semicolon Insertion
@@ -738,9 +738,9 @@ GocciaScript requires explicit semicolons by default, preventing this class of b
```bash
# Enable ASI via CLI, or use a subtree goccia.json for tests
-./build/GocciaScriptLoader example.js --asi
+./build/GocciaScriptLoader example.js --compat-asi
./build/GocciaTestRunner tests/language/asi
-./build/GocciaREPL --asi
+./build/GocciaREPL --compat-asi
```
```pascal
@@ -749,7 +749,7 @@ Executor := TGocciaInterpreterExecutor.Create;
try
Engine := TGocciaEngine.Create(FileName, Source, Executor);
try
- Engine.ASIEnabled := True;
+ Engine.Compatibility := [cfASI];
Engine.Execute;
finally
Engine.Free;
@@ -767,7 +767,7 @@ When enabled, GocciaScript follows the ECMAScript ASI rules (ES2026 §12.10):
### Traditional `for(init; test; update)` Loop
-**Opt-in for JavaScript compatibility.** Excluded by default. Available via `--compat-traditional-for-loop` (CLI flag, `Engine.TraditionalForLoopsEnabled`, or `{"compat-traditional-for-loop": true}` in config) when a program or conformance suite needs ECMAScript `for(init; test; update)` semantics.
+**Opt-in for JavaScript compatibility.** Excluded by default. Available via `--compat-traditional-for-loop` (CLI flag, `cfTraditionalFor` in `Engine.Compatibility`, or `{"compat-traditional-for-loop": true}` in config) when a program or conformance suite needs ECMAScript `for(init; test; update)` semantics.
When disabled (default), the parser accepts the syntax but treats it as a no-op and emits a warning. When enabled, `for(init; test; update) body` is fully supported in both interpreter and bytecode modes:
@@ -791,7 +791,7 @@ items.reduce((acc, item) => acc + item, 0);
### `while` and `do...while`
-**Opt-in for JavaScript compatibility.** Excluded by default. Available via `--compat-while-loops` (CLI flag, `Engine.WhileLoopsEnabled`, or `{"compat-while-loops": true}` in config) when a program or conformance suite needs ECMAScript `while` or `do...while` semantics.
+**Opt-in for JavaScript compatibility.** Excluded by default. Available via `--compat-while-loops` (CLI flag, `cfWhileLoops` in `Engine.Compatibility`, or `{"compat-while-loops": true}` in config) when a program or conformance suite needs ECMAScript `while` or `do...while` semantics.
When disabled (default), the parser accepts `while` and `do...while` syntax but treats each loop as a no-op and emits a warning. When enabled, both loop forms are supported in interpreter and bytecode modes:
@@ -816,7 +816,7 @@ do {
### `with` Statement
-**Opt-in for script source.** Excluded by default; use explicit property access. Available via `--compat-non-strict-mode` (CLI flag, `Engine.NonStrictModeEnabled`, or `{"compat-non-strict-mode": true}` in config). Module source remains strict even when this flag is enabled. When enabled in script source, `with (object) statement` evaluates the object expression, converts it with `ToObject`, and resolves unqualified identifiers through that object before falling back to outer lexical scopes. `Symbol.unscopables` is honored. Calls to functions resolved through the object environment use that object as `this`, closures created inside the body retain the object environment, and writes through non-writable or setter-less object properties silently keep the original value instead of throwing. When disabled (default), the parser accepts the syntax but treats the statement as a no-op and emits a warning suggesting explicit property access or the flag. `with` creates ambiguous scope and is forbidden by JavaScript strict mode, so new GocciaScript code should prefer explicit property access. The keyword is reserved (it cannot be used as a variable name), but it can be used as a property name (for example, `obj.with`).
+**Opt-in for script source.** Excluded by default; use explicit property access. Available via `--compat-non-strict-mode` (CLI flag, `cfNonStrictMode` in `Engine.Compatibility`, or `{"compat-non-strict-mode": true}` in config). Module source remains strict even when this flag is enabled. When enabled in script source, `with (object) statement` evaluates the object expression, converts it with `ToObject`, and resolves unqualified identifiers through that object before falling back to outer lexical scopes. `Symbol.unscopables` is honored. Calls to functions resolved through the object environment use that object as `this`, closures created inside the body retain the object environment, and writes through non-writable or setter-less object properties silently keep the original value instead of throwing. When disabled (default), the parser accepts the syntax but treats the statement as a no-op and emits a warning suggesting explicit property access or the flag. `with` creates ambiguous scope and is forbidden by JavaScript strict mode, so new GocciaScript code should prefer explicit property access. The keyword is reserved (it cannot be used as a variable name), but it can be used as a property name (for example, `obj.with`).
### Non-Strict Assignment Semantics
diff --git a/docs/spikes/lexer-performance-simplification.md b/docs/spikes/lexer-performance-simplification.md
index bf48d50c..b2a3fadd 100644
--- a/docs/spikes/lexer-performance-simplification.md
+++ b/docs/spikes/lexer-performance-simplification.md
@@ -146,6 +146,6 @@ Final verification after the lexer and docs work:
./build.pas clean tests
./build/Goccia.Lexer.Test
./build.pas clean testrunner
-./build/GocciaTestRunner tests --asi --unsafe-ffi --no-progress
+./build/GocciaTestRunner tests --compat-asi --unsafe-ffi --no-progress
git diff --check
```
diff --git a/docs/spikes/parser-hot-dispatch-performance.md b/docs/spikes/parser-hot-dispatch-performance.md
index 5f515daf..4fdda694 100644
--- a/docs/spikes/parser-hot-dispatch-performance.md
+++ b/docs/spikes/parser-hot-dispatch-performance.md
@@ -88,7 +88,7 @@ This was not strong enough to claim as a standalone optimization. It stayed in t
## Final Dispatch Map
-Twenty production runs per case. Values are median parser phase duration from `GocciaScriptLoader --output=json --asi`.
+Twenty production runs per case. Values are median parser phase duration from `GocciaScriptLoader --output=json --compat-asi`.
The baseline loader was built from a temporary detached clean `HEAD` worktree. The final loader was built from this parser branch. Both loaders parsed the same generated files, with runs alternated to reduce ordering bias.
diff --git a/docs/testing.md b/docs/testing.md
index 8ba9f056..afbad685 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -378,7 +378,7 @@ Pascal unit tests (`*.Test.pas`) exist as a tertiary layer for behavior that can
The `GocciaTestRunner` program:
1. Scans the provided path for `.js`, `.jsx`, `.ts`, `.tsx`, and `.mjs` files.
-2. For each file, creates a fresh `TGocciaEngine`, attaches `TGocciaRuntimeCore`, applies the test-runner runtime profile, and installs the FFI runtime extension when `--unsafe-ffi` or the file's `goccia.json` enables it.
+2. For each file, creates a fresh `TGocciaEngine`, applies source type from CLI/config or `.mjs` inference, attaches `TGocciaRuntimeCore`, applies the test-runner runtime profile, and installs the FFI runtime extension when `--unsafe-ffi` or the file's `goccia.json` enables it.
3. Loads the source and appends a `runTests()` call.
4. Executes the script — `describe`/`test` blocks register themselves during execution. Nested `describe` blocks are supported; suite names are composed with ` > ` separators (e.g., `"Outer > Inner"`). Skip state is inherited by nested describes.
5. `runTests()` executes all registered tests and collects results.
diff --git a/logo.png b/logo.png
index 587a273c..bbe42c73 100644
Binary files a/logo.png and b/logo.png differ
diff --git a/logo.svg b/logo.svg
new file mode 100644
index 00000000..b91f637d
--- /dev/null
+++ b/logo.svg
@@ -0,0 +1,3164 @@
+
+
+
diff --git a/scripts/build-logo.ts b/scripts/build-logo.ts
new file mode 100755
index 00000000..88e0de17
--- /dev/null
+++ b/scripts/build-logo.ts
@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+/**
+ * Trace a raster logo into SVG using ImageMagick and vtracer.
+ *
+ * Pipeline:
+ * 1. ImageMagick preserves source alpha, or flood-fills an opaque background.
+ * 2. vtracer clusters colors and emits detailed SVG paths.
+ *
+ * One-time setup:
+ * brew install imagemagick
+ * mkdir -p ~/.cache/goccia-logo-venv/bin
+ * curl -sL https://github.com/visioncortex/vtracer/releases/download/0.6.4/vtracer-aarch64-apple-darwin.tar.gz \
+ * | tar -xz -C ~/.cache/goccia-logo-venv/bin/
+ *
+ * Usage:
+ * scripts/build-logo.ts [output.svg]
+ */
+
+import { $ } from "bun";
+import { existsSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, join } from "node:path";
+
+const [, scriptName, sourceArg, outputArg] = Bun.argv;
+const usage = `usage: ${basename(scriptName ?? "build-logo.ts")} [output.svg]`;
+
+function fail(message: string): never {
+ console.error(message);
+ process.exit(1);
+}
+
+function isExecutable(path: string): boolean {
+ try {
+ return (statSync(path).mode & 0o111) !== 0;
+ } catch {
+ return false;
+ }
+}
+
+const source = sourceArg ?? "";
+const output = outputArg ?? "logo.svg";
+const magick = Bun.which("magick");
+const vtracer =
+ process.env.VTRACER ??
+ Bun.which("vtracer") ??
+ join(homedir(), ".cache/goccia-logo-venv/bin/vtracer");
+const traceSize = "1024x1024";
+const opaqueBackgroundFuzz = "8%";
+
+async function sourceHasTransparency(path: string): Promise {
+ const opaque = await $`${magick} identify -format "%[opaque]" ${path}`.text();
+ return opaque.trim() === "False";
+}
+
+if (source.length === 0) fail(usage);
+if (!existsSync(source) || !statSync(source).isFile()) {
+ fail(`source not found: ${source}`);
+}
+if (!magick) {
+ fail("ImageMagick is missing; install it with `brew install imagemagick`.");
+}
+if (!isExecutable(vtracer)) {
+ fail(`vtracer binary missing at ${vtracer} (see header comments).`);
+}
+
+const scratch = mkdtempSync(join(tmpdir(), "goccia-logo-"));
+
+try {
+ const cutout = join(scratch, "cut.png");
+
+ if (await sourceHasTransparency(source)) {
+ await $`${magick} ${source} -resize ${traceSize} ${cutout}`;
+ } else {
+ await $`${magick} ${source} -resize ${traceSize} -alpha set -bordercolor none -border 1x1 -fill none -fuzz ${opaqueBackgroundFuzz} -draw ${"color 0,0 floodfill"} -shave 1x1 ${cutout}`;
+ }
+
+ await $`${vtracer} --input ${cutout} --output ${output} --colormode color --hierarchical stacked --mode spline --filter_speckle 1 --color_precision 7 --gradient_step 2 --corner_threshold 60 --segment_length 3.5 --splice_threshold 45 --path_precision 3`;
+
+ console.log(`wrote ${output} (${statSync(output).size} bytes)`);
+} finally {
+ rmSync(scratch, { recursive: true, force: true });
+}
diff --git a/scripts/fetch-e2e.sh b/scripts/fetch-e2e.sh
index 9c6b2849..b2e36ea0 100755
--- a/scripts/fetch-e2e.sh
+++ b/scripts/fetch-e2e.sh
@@ -37,7 +37,7 @@ echo ""
run_js() {
echo "$1" > "$TMPFILE"
- "$LOADER" "$TMPFILE" --asi 2>&1
+ "$LOADER" "$TMPFILE" --compat-asi 2>&1
}
check() {
diff --git a/scripts/run_test262_suite.ts b/scripts/run_test262_suite.ts
index ffac97cc..95c85ef5 100644
--- a/scripts/run_test262_suite.ts
+++ b/scripts/run_test262_suite.ts
@@ -672,7 +672,7 @@ interface PerTestRecord {
// directives and modules decide strict semantics, while the flag exposes
// compatibility-gated syntax and implicit objects needed by the corpus.
const TEST262_BARE_FLAGS: readonly string[] = [
- "--asi",
+ "--compat-asi",
"--compat-var",
"--compat-function",
"--compat-traditional-for-loop",
diff --git a/scripts/test-cli-apps.ts b/scripts/test-cli-apps.ts
index 60d6e82d..f1e247a6 100644
--- a/scripts/test-cli-apps.ts
+++ b/scripts/test-cli-apps.ts
@@ -498,6 +498,33 @@ console.log("Bare Loader: module source type...");
if (proc.stdout.toString().trim() !== "true") throw new Error(`Bare module source expected true, got: ${proc.stdout.toString()}`);
}
+console.log("Bare Loader: .mjs module inference...");
+{
+ const tmp = makeTmp();
+ try {
+ const file = join(tmp, "entry.mjs");
+ writeFileSync(file, "this === undefined;\n");
+
+ const proc = Bun.spawnSync([BARE, "--print", file], {
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ if (proc.exitCode !== 0) throw new Error(`Bare .mjs source exited ${proc.exitCode}: ${proc.stderr.toString()}`);
+ if (proc.stdout.toString().trim() !== "true") throw new Error(`Bare .mjs source expected true, got: ${proc.stdout.toString()}`);
+
+ const scriptOverride = Bun.spawnSync([BARE, "--print", file, "--source-type=script"], {
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ if (scriptOverride.exitCode !== 0)
+ throw new Error(`Bare .mjs script override exited ${scriptOverride.exitCode}: ${scriptOverride.stderr.toString()}`);
+ if (scriptOverride.stdout.toString().trim() !== "false")
+ throw new Error(`Bare .mjs script override expected false, got: ${scriptOverride.stdout.toString()}`);
+ } finally {
+ clean(tmp);
+ }
+}
+
// --mode option: bare loader defaults to interpreter mode; both values must execute.
console.log("Bare Loader: --mode=interpreted...");
{
@@ -1655,7 +1682,7 @@ console.log("REPL: expression evaluation...");
console.log("REPL: ASI mode...");
{
- const out = await $`printf 'const x = 5\nx\n' | ${REPL} --asi 2>&1`.text();
+ const out = await $`printf 'const x = 5\nx\n' | ${REPL} --compat-asi 2>&1`.text();
if (!out.includes("5")) throw new Error(`ASI mode should produce 5, got: ${out}`);
}
@@ -1701,7 +1728,7 @@ console.log("Loader: HTTPS fetch smoke with --allowed-host...");
{
const { exitCode, json, stderr } = runLoaderJson(
'const response = await fetch("https://www.gstatic.com/generate_204", { method: "HEAD" });\nresponse.status;\n',
- ["--asi", "--allowed-host=www.gstatic.com"],
+ ["--compat-asi", "--allowed-host=www.gstatic.com"],
{ timeout: 10_000 },
);
if (exitCode !== 0) throw new Error(`HTTPS fetch should exit 0, got ${exitCode}: ${stderr}`);
diff --git a/scripts/test-cli-config.ts b/scripts/test-cli-config.ts
index 0cbadb16..e581cc1f 100644
--- a/scripts/test-cli-config.ts
+++ b/scripts/test-cli-config.ts
@@ -65,7 +65,7 @@ console.log("goccia.json loading...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
writeFileSync(join(tmp, "test.js"), "const x = 2 + 2\nx\n");
const out = await $`${LOADER} --print ${join(tmp, "test.js")} 2>&1`.text();
@@ -82,7 +82,7 @@ console.log("goccia.toml loading...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(tmp, "goccia.toml"), 'compat-asi = true\nmode = "bytecode"\n');
writeFileSync(join(tmp, "test.js"), "const x = 10\nx\n");
const out = await $`${LOADER} --print ${join(tmp, "test.js")} 2>&1`.text();
@@ -99,7 +99,7 @@ console.log("goccia.json5 loading...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json5"), '{asi: true, mode: "bytecode"}\n');
+ writeFileSync(join(tmp, "goccia.json5"), '{"compat-asi": true, mode: "bytecode"}\n');
writeFileSync(join(tmp, "test.js"), "const x = 10\nx\n");
const out = await $`${LOADER} ${join(tmp, "test.js")} 2>&1`.text();
@@ -115,9 +115,9 @@ console.log("Priority: TOML > JSON5 > JSON...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json"), '{"mode": "interpreted", "asi": true}\n');
- writeFileSync(join(tmp, "goccia.json5"), '{asi: true, mode: "interpreted"}\n');
- writeFileSync(join(tmp, "goccia.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"mode": "interpreted", "compat-asi": true}\n');
+ writeFileSync(join(tmp, "goccia.json5"), '{"compat-asi": true, mode: "interpreted"}\n');
+ writeFileSync(join(tmp, "goccia.toml"), 'compat-asi = true\nmode = "bytecode"\n');
writeFileSync(join(tmp, "test.js"), "const x = 1\nx\n");
const out = await $`${LOADER} ${join(tmp, "test.js")} 2>&1`.text();
@@ -134,7 +134,7 @@ console.log("Discovery from entry file directory...");
const tmp = makeTmp();
try {
mkdirSync(join(tmp, "src"), { recursive: true });
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
writeFileSync(join(tmp, "src", "test.js"), "const x = 7\nx\n");
const out = await $`${LOADER} --print ${join(tmp, "src", "test.js")} 2>&1`.text();
@@ -171,7 +171,7 @@ console.log("Config stack-size...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json"), '{"stack-size": 50, "asi": true}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"stack-size": 50, "compat-asi": true}\n');
writeFileSync(
join(tmp, "test.js"),
"let n=0; const f=()=>{n++;f()}; try{f()}catch(e){console.log(n)};\n",
@@ -190,7 +190,7 @@ console.log("Config without imports field...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true}\n');
writeFileSync(join(tmp, "test.js"), "const x = 42\nx\n");
const out = await $`${LOADER} --print ${join(tmp, "test.js")} 2>&1`.text();
@@ -210,7 +210,7 @@ console.log("Config with imports...");
writeFileSync(join(tmp, "lib", "utils.js"), "export const value = 99;\n");
writeFileSync(
join(tmp, "goccia.json"),
- '{"asi": true, "imports": {"utils": "./lib/utils.js"}}\n',
+ '{"compat-asi": true, "imports": {"utils": "./lib/utils.js"}}\n',
);
writeFileSync(join(tmp, "test.js"), 'import { value } from "utils"\nvalue\n');
@@ -227,7 +227,7 @@ console.log("Config extends...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "base.json"), '{"asi": true}\n');
+ writeFileSync(join(tmp, "base.json"), '{"compat-asi": true}\n');
writeFileSync(join(tmp, "goccia.json"), '{"extends": "base.json", "mode": "bytecode"}\n');
writeFileSync(join(tmp, "test.js"), "const x = 5\nx\n");
@@ -246,7 +246,7 @@ console.log("Config extends from subdirectory...");
const tmp = makeTmp();
try {
mkdirSync(join(tmp, "tests", "asi"), { recursive: true });
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true}\n');
writeFileSync(
join(tmp, "tests", "asi", "goccia.json"),
'{"extends": "../../goccia.json", "mode": "bytecode"}\n',
@@ -267,7 +267,7 @@ console.log("TestRunner respects config...");
{
const tmp = makeTmp();
try {
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
writeFileSync(
join(tmp, "test.js"),
[
@@ -336,7 +336,7 @@ console.log("Per-file ASI config across all apps...");
// ASI subdirectory
const asiDir = join(tmp, "asi");
mkdirSync(asiDir);
- writeFileSync(join(asiDir, "goccia.json"), '{"asi": true}\n');
+ writeFileSync(join(asiDir, "goccia.json"), '{"compat-asi": true}\n');
writeFileSync(join(asiDir, "test.js"), "const x = 42\nx\n");
writeFileSync(
join(asiDir, "test-runner.js"),
@@ -401,8 +401,8 @@ console.log("Per-file ASI config across all apps...");
const bundleStrictBad = await $`${BUNDLER} ${join(strictDir, "bad.js")} 2>&1`.nothrow();
if (bundleStrictBad.exitCode === 0) throw new Error("Bundler strict should reject bad.js");
- await $`${BUNDLER} ${join(strictDir, "bad.js")} --asi`.quiet();
- if (!existsSync(join(strictDir, "bad.gbc"))) throw new Error("Bundler --asi override should compile");
+ await $`${BUNDLER} ${join(strictDir, "bad.js")} --compat-asi`.quiet();
+ if (!existsSync(join(strictDir, "bad.gbc"))) throw new Error("Bundler --compat-asi override should compile");
// BenchmarkRunner (interpreted)
const benchInterp = Bun.spawnSync(
@@ -1050,7 +1050,7 @@ console.log("Multi-directory TestRunner...");
// Lenient subdirectory: ASI + compat-var
const lenientDir = join(tmp, "lenient");
mkdirSync(lenientDir);
- writeFileSync(join(lenientDir, "goccia.json"), '{"asi": true, "compat-var": true}\n');
+ writeFileSync(join(lenientDir, "goccia.json"), '{"compat-asi": true, "compat-var": true}\n');
writeFileSync(
join(lenientDir, "test.js"),
[
@@ -1099,7 +1099,7 @@ console.log("CLI options override file config...");
const noConfigDir = makeTmp();
try {
// Config enables ASI
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true}\n');
writeFileSync(join(tmp, "test.js"), "const x = 1\nx\n");
// No config dir
@@ -1113,22 +1113,22 @@ console.log("CLI options override file config...");
const noConfigRes = await $`${LOADER} ${join(noConfigDir, "test.js")} 2>&1`.nothrow();
if (!noConfigRes.text().includes("SyntaxError")) throw new Error("No config should reject");
- // CLI --asi overrides no-config
- const cliAsi = await $`${LOADER} --print ${join(noConfigDir, "test.js")} --asi 2>&1`.text();
- if (!containsLine(cliAsi, "1")) throw new Error(`CLI --asi should override, got: ${cliAsi}`);
+ // CLI --compat-asi overrides no-config
+ const cliAsi = await $`${LOADER} --print ${join(noConfigDir, "test.js")} --compat-asi 2>&1`.text();
+ if (!containsLine(cliAsi, "1")) throw new Error(`CLI --compat-asi should override, got: ${cliAsi}`);
- // CLI --asi bytecode
- const cliAsiBc = await $`${LOADER} --print ${join(noConfigDir, "test.js")} --asi --mode=bytecode 2>&1`.text();
- if (!containsLine(cliAsiBc, "1")) throw new Error(`CLI --asi bytecode should override, got: ${cliAsiBc}`);
+ // CLI --compat-asi bytecode
+ const cliAsiBc = await $`${LOADER} --print ${join(noConfigDir, "test.js")} --compat-asi --mode=bytecode 2>&1`.text();
+ if (!containsLine(cliAsiBc, "1")) throw new Error(`CLI --compat-asi bytecode should override, got: ${cliAsiBc}`);
// CLI --mode=interpreted overrides config mode
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
const overrideMode = await $`${LOADER} ${join(tmp, "test.js")} --mode=interpreted 2>&1`.text();
if (!overrideMode.includes("(interpreted)")) throw new Error(`CLI --mode=interpreted should override config, got: ${overrideMode}`);
- // Bundler CLI --asi overrides no-config
- await $`${BUNDLER} ${join(noConfigDir, "test.js")} --asi`.quiet();
- if (!existsSync(join(noConfigDir, "test.gbc"))) throw new Error("Bundler CLI --asi should compile");
+ // Bundler CLI --compat-asi overrides no-config
+ await $`${BUNDLER} ${join(noConfigDir, "test.js")} --compat-asi`.quiet();
+ if (!existsSync(join(noConfigDir, "test.gbc"))) throw new Error("Bundler CLI --compat-asi should compile");
} finally {
clean(tmp);
clean(noConfigDir);
@@ -1263,7 +1263,7 @@ console.log("--config= loads .json explicitly...");
// Script lives in tmp with no goccia.* anywhere on its parent chain.
writeFileSync(join(tmp, "test.js"), "const x = 11\nx\n");
// Config lives in a sibling directory; auto-discovery would never find it.
- writeFileSync(join(cfgDir, "custom.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(cfgDir, "custom.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${join(cfgDir, "custom.json")} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config=.json should enable bytecode, got: ${out}`);
@@ -1280,7 +1280,7 @@ console.log("--config= loads .toml explicitly...");
const cfgDir = makeTmp();
try {
writeFileSync(join(tmp, "test.js"), "const x = 21\nx\n");
- writeFileSync(join(cfgDir, "custom.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(cfgDir, "custom.toml"), 'compat-asi = true\nmode = "bytecode"\n');
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${join(cfgDir, "custom.toml")} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config=.toml should enable bytecode, got: ${out}`);
@@ -1297,7 +1297,7 @@ console.log("--config= loads .json5 explicitly...");
const cfgDir = makeTmp();
try {
writeFileSync(join(tmp, "test.js"), "const x = 31\nx\n");
- writeFileSync(join(cfgDir, "custom.json5"), '{asi: true, mode: "bytecode"}\n');
+ writeFileSync(join(cfgDir, "custom.json5"), '{"compat-asi": true, mode: "bytecode"}\n');
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${join(cfgDir, "custom.json5")} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config=.json5 should enable bytecode, got: ${out}`);
@@ -1313,7 +1313,7 @@ console.log("--config= with relative path resolves against cwd...");
const tmp = makeTmp();
try {
writeFileSync(join(tmp, "test.js"), "const x = 41\nx\n");
- writeFileSync(join(tmp, "custom.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(tmp, "custom.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
// Relative path; cwd is tmp.
const out = runCwd(LOADER, ["--print", "test.js", "--config=./custom.json"], tmp);
@@ -1336,7 +1336,7 @@ console.log("--config= finds goccia.json...");
const cfgDir = makeTmp();
try {
writeFileSync(join(tmp, "test.js"), "const x = 51\nx\n");
- writeFileSync(join(cfgDir, "goccia.json"), '{"asi": true, "mode": "bytecode"}\n');
+ writeFileSync(join(cfgDir, "goccia.json"), '{"compat-asi": true, "mode": "bytecode"}\n');
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${cfgDir} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config= with goccia.json should enable bytecode, got: ${out}`);
@@ -1354,9 +1354,9 @@ console.log("--config= respects priority TOML > JSON5 > JSON...");
try {
writeFileSync(join(tmp, "test.js"), "const x = 61\nx\n");
// All three present; TOML must win (matches auto-discovery priority).
- writeFileSync(join(cfgDir, "goccia.json"), '{"asi": true, "mode": "interpreted"}\n');
- writeFileSync(join(cfgDir, "goccia.json5"), '{asi: true, mode: "interpreted"}\n');
- writeFileSync(join(cfgDir, "goccia.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(cfgDir, "goccia.json"), '{"compat-asi": true, "mode": "interpreted"}\n');
+ writeFileSync(join(cfgDir, "goccia.json5"), '{"compat-asi": true, mode: "interpreted"}\n');
+ writeFileSync(join(cfgDir, "goccia.toml"), 'compat-asi = true\nmode = "bytecode"\n');
const out = await $`${LOADER} ${join(tmp, "test.js")} --config=${cfgDir} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config= should pick TOML over JSON5/JSON, got: ${out}`);
@@ -1372,7 +1372,7 @@ console.log("--config= with trailing slash works...");
const cfgDir = makeTmp();
try {
writeFileSync(join(tmp, "test.js"), "const x = 71\nx\n");
- writeFileSync(join(cfgDir, "goccia.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(cfgDir, "goccia.toml"), 'compat-asi = true\nmode = "bytecode"\n');
// Some shells/users will pass the directory with a trailing slash.
const out = await $`${LOADER} ${join(tmp, "test.js")} --config=${cfgDir + "/"} 2>&1`.text();
@@ -1390,7 +1390,7 @@ console.log("--config= does not walk upward...");
// Place a config in tmp; pass an empty subdirectory as --config.
// Auto-discovery would walk up and find tmp/goccia.toml, but the
// explicit directory form must NOT — it should error out.
- writeFileSync(join(tmp, "goccia.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(tmp, "goccia.toml"), 'compat-asi = true\nmode = "bytecode"\n');
const empty = join(tmp, "empty");
mkdirSync(empty);
writeFileSync(join(tmp, "test.js"), "const x = 81\nx\n");
@@ -1431,10 +1431,10 @@ console.log("--config skips auto-discovery of nearby goccia.*...");
const cfgDir = makeTmp();
try {
// Hostile config alongside the script; auto-discovery would pick this up.
- writeFileSync(join(tmp, "goccia.json"), '{"asi": true, "mode": "interpreted"}\n');
+ writeFileSync(join(tmp, "goccia.json"), '{"compat-asi": true, "mode": "interpreted"}\n');
writeFileSync(join(tmp, "test.js"), "const x = 101\nx\n");
// Explicit config selects bytecode.
- writeFileSync(join(cfgDir, "good.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(cfgDir, "good.toml"), 'compat-asi = true\nmode = "bytecode"\n');
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${join(cfgDir, "good.toml")} 2>&1`.text();
if (!out.includes("(bytecode)")) throw new Error(`--config should skip nearby goccia.json, got: ${out}`);
@@ -1454,7 +1454,7 @@ console.log("CLI options override values from --config...");
try {
writeFileSync(join(tmp, "test.js"), "const x = 111\nx\n");
// --config says interpreted...
- writeFileSync(join(cfgDir, "custom.toml"), 'asi = true\nmode = "interpreted"\n');
+ writeFileSync(join(cfgDir, "custom.toml"), 'compat-asi = true\nmode = "interpreted"\n');
// ...but a direct --mode=bytecode on the CLI must win.
const out = await $`${LOADER} --print ${join(tmp, "test.js")} --config=${join(cfgDir, "custom.toml")} --mode=bytecode 2>&1`.text();
@@ -1476,7 +1476,7 @@ console.log("--config works on TestRunner...");
const tmp = makeTmp();
const cfgDir = makeTmp();
try {
- writeFileSync(join(cfgDir, "ci.toml"), 'asi = true\nmode = "bytecode"\n');
+ writeFileSync(join(cfgDir, "ci.toml"), 'compat-asi = true\nmode = "bytecode"\n');
writeFileSync(
join(tmp, "test.js"),
[
@@ -1503,7 +1503,7 @@ console.log("--config works on Bundler...");
try {
// Bad-without-ASI source; --config supplies ASI so compile must succeed.
writeFileSync(join(tmp, "test.js"), "const x = 1\nx\n");
- writeFileSync(join(cfgDir, "goccia.json"), '{"asi": true}\n');
+ writeFileSync(join(cfgDir, "goccia.json"), '{"compat-asi": true}\n');
// Sanity: without --config, compile rejects (no goccia.* near tmp).
const noCfg = await $`${BUNDLER} ${join(tmp, "test.js")} 2>&1`.nothrow();
@@ -1523,7 +1523,7 @@ console.log("--config works on BenchmarkRunner...");
const tmp = makeTmp();
const cfgDir = makeTmp();
try {
- writeFileSync(join(cfgDir, "goccia.toml"), 'asi = true\n');
+ writeFileSync(join(cfgDir, "goccia.toml"), 'compat-asi = true\n');
writeFileSync(
join(tmp, "bench.js"),
[
diff --git a/scripts/test-cli-lexer.ts b/scripts/test-cli-lexer.ts
index 09ec17a3..daf237ca 100644
--- a/scripts/test-cli-lexer.ts
+++ b/scripts/test-cli-lexer.ts
@@ -69,7 +69,7 @@ console.log("String allows LS/PS (ES2019)...");
console.log("String line continuation...");
{
- const { exitCode, json } = runLoaderJson('"hello\\\nworld";\n', ["--print", "--asi"]);
+ const { exitCode, json } = runLoaderJson('"hello\\\nworld";\n', ["--print", "--compat-asi"]);
if (exitCode !== 0) {
throw new Error(`Line continuation should succeed, but failed`);
}
diff --git a/scripts/test-cli-parser.ts b/scripts/test-cli-parser.ts
index b18835b0..422b8f23 100644
--- a/scripts/test-cli-parser.ts
+++ b/scripts/test-cli-parser.ts
@@ -74,7 +74,7 @@ console.log("Unsupported optional private field access...");
console.log("ASI at EOF...");
{
- const asiRes = runLoaderJson("const value = 42", ["--asi"]);
+ const asiRes = runLoaderJson("const value = 42", ["--compat-asi"]);
if (asiRes.exitCode !== 0) throw new Error(`ASI should accept a final declaration at EOF without a semicolon`);
if (asiRes.json.ok !== true)
throw new Error(`ASI EOF declaration should succeed, got: ${JSON.stringify(asiRes.json)}`);
@@ -108,12 +108,12 @@ console.log("Unsupported var recovery (ASI and compat-var flags)...");
"console.log(after);",
"",
].join("\n");
- const asiRes = runLoaderJson(sourceBeforeDeclaration, ["--asi"]);
+ const asiRes = runLoaderJson(sourceBeforeDeclaration, ["--compat-asi"]);
if (asiRes.exitCode !== 0) throw new Error(`Unsupported var with ASI should preserve the following declaration`);
if (asiRes.json.ok !== true) throw new Error(`Unsupported var with ASI should succeed, got: ${JSON.stringify(asiRes.json)}`);
if (normalizeLineEndings(asiRes.json.output) !== "2\n") throw new Error(`Expected ASI recovery output 2, got: ${asiRes.json.output}`);
- const compatVarAsiRes = runLoaderJson(sourceBeforeDeclaration, ["--asi", "--compat-var"]);
+ const compatVarAsiRes = runLoaderJson(sourceBeforeDeclaration, ["--compat-asi", "--compat-var"]);
if (compatVarAsiRes.exitCode !== 0) throw new Error(`compat-var with ASI should parse var without an explicit semicolon`);
if (compatVarAsiRes.json.ok !== true) throw new Error(`compat-var with ASI should succeed, got: ${JSON.stringify(compatVarAsiRes.json)}`);
if (normalizeLineEndings(compatVarAsiRes.json.output) !== "2\n") throw new Error(`Expected compat-var ASI output 2, got: ${compatVarAsiRes.json.output}`);
diff --git a/scripts/test-cli.ts b/scripts/test-cli.ts
index 842981a1..5000018d 100644
--- a/scripts/test-cli.ts
+++ b/scripts/test-cli.ts
@@ -3,7 +3,7 @@
* test-cli.ts
*
* Common CLI options tested across all apps: stdin smoke, --help, --unsafe-ffi,
- * --asi, --compat-var, --compat-loose-equality, --compat-non-strict-mode,
+ * --compat-asi, --source-type, .mjs source-type inference, --compat-var, --compat-loose-equality, --compat-non-strict-mode,
* --compat-while-loops, --mode, --timeout, --max-instructions, --max-memory, --stack-size, --log,
* example scripts.
*/
@@ -113,31 +113,39 @@ console.log("--unsafe-ffi gating...");
if (jsonOn.files?.[0]?.result !== "object") throw new Error(`FFI with flag should be "object", got ${jsonOn.files?.[0]?.result}`);
}
-// -- --asi (Loader + Bundler) ---------------------------------------------------
+// -- --compat-asi (Loader + Bundler) ---------------------------------------------------
-console.log("--asi (Loader + Bundler)...");
+console.log("--compat-asi (Loader + Bundler)...");
{
const tmp = mkdtemp("goccia-asi-");
try {
const src = join(tmp, "no-semi.js");
writeFileSync(src, "const x = 42\nx\n");
- // Loader without --asi should fail
+ // Loader without --compat-asi should fail
const noAsi = await $`${LOADER} ${src} 2>&1`.nothrow();
- if (noAsi.exitCode === 0) throw new Error("Loader should reject without --asi");
- if (!noAsi.text().includes("SyntaxError")) throw new Error("Expected SyntaxError without --asi");
+ if (noAsi.exitCode === 0) throw new Error("Loader should reject without --compat-asi");
+ if (!noAsi.text().includes("SyntaxError")) throw new Error("Expected SyntaxError without --compat-asi");
- // Loader with --asi should succeed
- const withAsi = await $`${LOADER} --print ${src} --asi 2>&1`.text();
- if (!containsLine(withAsi, "42")) throw new Error(`Expected 42 with --asi, got: ${withAsi}`);
+ const oldAsi = await $`${LOADER} ${src} --asi 2>&1`.nothrow();
+ if (oldAsi.exitCode === 0) throw new Error("Loader should reject removed --asi alias");
+ if (!oldAsi.text().includes("Unknown option: --asi")) throw new Error(`Expected unknown --asi, got: ${oldAsi.text()}`);
- // Bundler without --asi should fail
+ // Loader with --compat-asi should succeed
+ const withAsi = await $`${LOADER} --print ${src} --compat-asi 2>&1`.text();
+ if (!containsLine(withAsi, "42")) throw new Error(`Expected 42 with --compat-asi, got: ${withAsi}`);
+
+ // Bundler without --compat-asi should fail
const bundleNoAsi = await $`${BUNDLER} ${src} 2>&1`.nothrow();
- if (bundleNoAsi.exitCode === 0) throw new Error("Bundler should reject without --asi");
+ if (bundleNoAsi.exitCode === 0) throw new Error("Bundler should reject without --compat-asi");
+
+ const bundleOldAsi = await $`${BUNDLER} ${src} --asi 2>&1`.nothrow();
+ if (bundleOldAsi.exitCode === 0) throw new Error("Bundler should reject removed --asi alias");
+ if (!bundleOldAsi.text().includes("Unknown option: --asi")) throw new Error(`Expected unknown --asi, got: ${bundleOldAsi.text()}`);
- // Bundler with --asi should succeed
- await $`${BUNDLER} ${src} --asi`.quiet();
- if (!existsSync(join(tmp, "no-semi.gbc"))) throw new Error("Bundler --asi should produce .gbc");
+ // Bundler with --compat-asi should succeed
+ await $`${BUNDLER} ${src} --compat-asi`.quiet();
+ if (!existsSync(join(tmp, "no-semi.gbc"))) throw new Error("Bundler --compat-asi should produce .gbc");
} finally {
clean(tmp);
}
@@ -393,6 +401,82 @@ console.log("--mode=bytecode...");
const bcOut = await $`echo 'const x = 2 + 2; x;' | ${LOADER} --print - --mode=bytecode`.text();
if (!containsLine(bcOut, "4")) throw new Error(`Bytecode expected 4 on its own line, got: ${bcOut}`);
if (!bcOut.includes("(bytecode)")) throw new Error(`Expected (bytecode) in output`);
+
+ const bcSplitOut = await $`echo 'const x = 2 + 2; x;' | ${LOADER} --print - --mode bytecode`.text();
+ if (!containsLine(bcSplitOut, "4")) throw new Error(`Bytecode split option expected 4 on its own line, got: ${bcSplitOut}`);
+ if (!bcSplitOut.includes("(bytecode)")) throw new Error(`Expected (bytecode) in split option output`);
+}
+
+// -- --source-type and .mjs module inference -----------------------------------
+
+console.log("--source-type and .mjs module inference (Loader + TestRunner + Bundler)...");
+{
+ const tmp = mkdtemp("goccia-source-type-");
+ try {
+ const moduleEntry = join(tmp, "entry.mjs");
+ writeFileSync(moduleEntry, "this === undefined;\n");
+
+ const loaderMjs = await $`${LOADER} --print ${moduleEntry} 2>&1`.text();
+ if (!containsLine(loaderMjs, "true")) throw new Error(`Loader .mjs should infer module source, got: ${loaderMjs}`);
+
+ const loaderMjsBytecode = await $`${LOADER} --print ${moduleEntry} --mode=bytecode 2>&1`.text();
+ if (!containsLine(loaderMjsBytecode, "true"))
+ throw new Error(`Loader .mjs bytecode should infer module source, got: ${loaderMjsBytecode}`);
+
+ const loaderScriptOverride = await $`${LOADER} --print ${moduleEntry} --source-type=script 2>&1`.text();
+ if (!containsLine(loaderScriptOverride, "false"))
+ throw new Error(`Loader --source-type=script should override .mjs inference, got: ${loaderScriptOverride}`);
+
+ const loaderScriptOverrideBytecode = await $`${LOADER} --print ${moduleEntry} --mode=bytecode --source-type=script 2>&1`.text();
+ if (!containsLine(loaderScriptOverrideBytecode, "false"))
+ throw new Error(`Loader bytecode --source-type=script should override .mjs inference, got: ${loaderScriptOverrideBytecode}`);
+
+ const testModuleEntry = join(tmp, "entry-test.mjs");
+ writeFileSync(
+ testModuleEntry,
+ [
+ "const topLevelThis = this;",
+ "const metaUrl = import.meta.url;",
+ 'test(".mjs top-level this", () => { expect(topLevelThis).toBeUndefined(); });',
+ 'test(".mjs import.meta", () => { expect(metaUrl.endsWith("entry-test.mjs")).toBe(true); });',
+ ].join("\n") + "\n",
+ );
+ const testRunnerMjs = await $`${TESTRUNNER} ${testModuleEntry} --no-progress 2>&1`.text();
+ if (!testRunnerMjs.includes("Passed: 2")) throw new Error(`TestRunner .mjs expected Passed: 2, got: ${testRunnerMjs}`);
+
+ const testRunnerMjsBytecode = await $`${TESTRUNNER} ${testModuleEntry} --mode=bytecode --no-progress 2>&1`.text();
+ if (!testRunnerMjsBytecode.includes("Passed: 2"))
+ throw new Error(`TestRunner .mjs bytecode expected Passed: 2, got: ${testRunnerMjsBytecode}`);
+
+ const testScriptOverride = join(tmp, "entry-test-script.mjs");
+ writeFileSync(
+ testScriptOverride,
+ [
+ "const topLevelThis = this;",
+ 'test(".mjs script override", () => { expect(topLevelThis === undefined).toBe(false); });',
+ ].join("\n") + "\n",
+ );
+ const testRunnerScript = await $`${TESTRUNNER} ${testScriptOverride} --source-type=script --no-progress 2>&1`.text();
+ if (!testRunnerScript.includes("Passed: 1"))
+ throw new Error(`TestRunner --source-type=script expected Passed: 1, got: ${testRunnerScript}`);
+
+ const testRunnerScriptBytecode = await $`${TESTRUNNER} ${testScriptOverride} --mode=bytecode --source-type=script --no-progress 2>&1`.text();
+ if (!testRunnerScriptBytecode.includes("Passed: 1"))
+ throw new Error(`TestRunner bytecode --source-type=script expected Passed: 1, got: ${testRunnerScriptBytecode}`);
+
+ const strictModule = join(tmp, "strict-module.mjs");
+ writeFileSync(strictModule, "with ({ x: 1 }) { x; }\n");
+ const bundleModule = await $`${BUNDLER} ${strictModule} --compat-non-strict-mode 2>&1`.nothrow();
+ const bundleModuleOutput = bundleModule.text();
+ if (bundleModule.exitCode === 0 || !bundleModuleOutput.includes("'with' statements are not allowed in strict mode"))
+ throw new Error(`Bundler .mjs should infer strict module source, got: ${bundleModuleOutput}`);
+
+ const bundledScriptOut = join(tmp, "strict-module-script.gbc");
+ await $`${BUNDLER} ${strictModule} --source-type=script --compat-non-strict-mode --output=${bundledScriptOut}`.quiet();
+ if (!existsSync(bundledScriptOut)) throw new Error("Bundler --source-type=script should override .mjs inference and write bytecode");
+ } finally {
+ clean(tmp);
+ }
}
// -- --timeout (Loader: infinite loop, both execution modes) --------------------
@@ -435,19 +519,19 @@ console.log("--max-instructions (bytecode)...");
console.log("--max-memory (default positive)...");
{
- const { json } = runLoaderJson("Goccia.gc.maxBytes\n", ["--asi"]);
+ const { json } = runLoaderJson("Goccia.gc.maxBytes\n", ["--compat-asi"]);
if (typeof json.files?.[0]?.result !== "number" || json.files[0].result <= 0) throw new Error(`Default maxBytes should be positive, got ${json.files?.[0]?.result}`);
}
console.log("--max-memory (override)...");
{
- const { json } = runLoaderJson("Goccia.gc.maxBytes\n", ["--max-memory=5000000", "--asi"]);
+ const { json } = runLoaderJson("Goccia.gc.maxBytes\n", ["--max-memory=5000000", "--compat-asi"]);
if (json.files?.[0]?.result !== 5000000) throw new Error(`Override maxBytes should be 5000000, got ${json.files?.[0]?.result}`);
}
console.log("--max-memory (OOM triggers RangeError)...");
{
- const res = await $`echo 'Array.from({length:5000},(_,i)=>({x:i}));' | ${LOADER} --max-memory=200000 --asi 2>&1`.nothrow();
+ const res = await $`echo 'Array.from({length:5000},(_,i)=>({x:i}));' | ${LOADER} --max-memory=200000 --compat-asi 2>&1`.nothrow();
const out = res.text();
if (res.exitCode !== 1) throw new Error(`OOM exit code should be 1, got ${res.exitCode}`);
if (!out.includes("RangeError")) throw new Error(`OOM output should contain RangeError`);
@@ -468,7 +552,7 @@ console.log("--max-memory (manual gc reclaims inside active calls)...");
for (const modeArgs of [[], ["--mode=bytecode"]] as const) {
const label = modeArgs.length > 0 ? modeArgs.join(" ") : "interpreter";
- const { exitCode, json, stderr } = runLoaderJson(src, ["--max-memory=500000", "--asi", ...modeArgs], { timeout: 30_000 });
+ const { exitCode, json, stderr } = runLoaderJson(src, ["--max-memory=500000", "--compat-asi", ...modeArgs], { timeout: 30_000 });
if (exitCode !== 0) throw new Error(`Manual GC active-call ${label} exit code should be 0, got ${exitCode}: ${JSON.stringify(json)}${stderr}`);
if (typeof json.files?.[0]?.result !== "number" || json.files[0].result <= 0) throw new Error(`Manual GC active-call ${label} should return positive bytesAllocated`);
if ((json.memory?.gc?.collections ?? 0) < 30) throw new Error(`Manual GC active-call ${label} should report at least 30 collections, got ${json.memory?.gc?.collections}`);
@@ -477,7 +561,7 @@ console.log("--max-memory (manual gc reclaims inside active calls)...");
console.log("--max-memory (maxBytes readonly)...");
{
- const res = await $`echo 'Goccia.gc.maxBytes = 999' | ${LOADER} --asi 2>&1`.nothrow();
+ const res = await $`echo 'Goccia.gc.maxBytes = 999' | ${LOADER} --compat-asi 2>&1`.nothrow();
if (res.exitCode !== 1) throw new Error(`Read-only exit code should be 1, got ${res.exitCode}`);
if (!res.text().includes("TypeError")) throw new Error(`Read-only should mention TypeError`);
}
diff --git a/skills-lock.json b/skills-lock.json
index a4225547..8bb0bed8 100644
--- a/skills-lock.json
+++ b/skills-lock.json
@@ -11,6 +11,24 @@
"sourceType": "github",
"computedHash": "9e1c8b3103f92fa8092568a44fe64858de7c5c9dc65ce4bea8f168080e889cfd"
},
+ "grill-with-docs": {
+ "source": "mattpocock/skills",
+ "sourceType": "github",
+ "skillPath": "skills/engineering/grill-with-docs/SKILL.md",
+ "computedHash": "a5c65e76275008b469962f7bee8b34866f1c9b0709f4886e71c8e731735640e4"
+ },
+ "handoff": {
+ "source": "mattpocock/skills",
+ "sourceType": "github",
+ "skillPath": "skills/productivity/handoff/SKILL.md",
+ "computedHash": "1a78d774f8a59db5daa6e65e20a6596872fa8cde769f9a6e3a09b678dd5ae8cc"
+ },
+ "improve-codebase-architecture": {
+ "source": "mattpocock/skills",
+ "sourceType": "github",
+ "skillPath": "skills/engineering/improve-codebase-architecture/SKILL.md",
+ "computedHash": "ef32aea0a8fab9b365ff9e08a95f8d353e20ca21ea46ec2e73587c86dd341351"
+ },
"resolve-reviews": {
"source": "pbakaus/agent-reviews",
"sourceType": "github",
diff --git a/source/app/Goccia.CLI.Application.pas b/source/app/Goccia.CLI.Application.pas
index d8412322..ec4d980e 100644
--- a/source/app/Goccia.CLI.Application.pas
+++ b/source/app/Goccia.CLI.Application.pas
@@ -12,6 +12,7 @@ interface
CLI.Options,
Goccia.Application,
+ Goccia.CLI.Options,
Goccia.Engine,
Goccia.Executor,
Goccia.Executor.Bytecode,
@@ -20,19 +21,19 @@ interface
type
TGocciaCLIApplication = class(TGocciaApplication)
private
- FHelp: TGocciaFlagOption;
- FJobs: TGocciaIntegerOption;
- FLog: TGocciaStringOption;
- FMultifile: TGocciaFlagOption;
- FConfig: TGocciaStringOption;
+ FHelp: TFlagOption;
+ FJobs: TIntegerOption;
+ FLog: TStringOption;
+ FMultifile: TFlagOption;
+ FConfig: TStringOption;
FLogFileHandle: TextFile;
FLogLock: TRTLCriticalSection;
FLogFileOpen: Boolean;
FEngineOptions: TGocciaEngineOptions;
FCoverageOptions: TGocciaCoverageOptions;
FProfilerOptions: TGocciaProfilerOptions;
- FOwnedOptions: TGocciaOptionBaseList;
- FAllOptions: TGocciaOptionArray;
+ FOwnedOptions: TOptionBaseList;
+ FAllOptions: TOptionArray;
FSourceRegistry: TGocciaSourceRegistry;
procedure BuildAllOptions;
procedure InitializeSingletons;
@@ -49,11 +50,11 @@ TGocciaCLIApplication = class(TGocciaApplication)
function AddEngineOptions: TGocciaEngineOptions;
function AddCoverageOptions: TGocciaCoverageOptions;
function AddProfilerOptions: TGocciaProfilerOptions;
- function AddFlag(const AName, AHelp: string): TGocciaFlagOption;
- function AddString(const AName, AHelp: string): TGocciaStringOption;
- function AddInteger(const AName, AHelp: string): TGocciaIntegerOption;
- function AddRepeatable(const AName, AHelp: string): TGocciaRepeatableOption;
- function Add(const AOption: TGocciaOptionBase): TGocciaOptionBase;
+ function AddFlag(const AName, AHelp: string): TFlagOption;
+ function AddString(const AName, AHelp: string): TStringOption;
+ function AddInteger(const AName, AHelp: string): TIntegerOption;
+ function AddRepeatable(const AName, AHelp: string): TRepeatableOption;
+ function Add(const AOption: TOptionBase): TOptionBase;
procedure ConfigureCreatedEngine(const AEngine: TGocciaEngine;
const AFileConfig: TConfigEntryArray); virtual;
procedure HandleConsoleLog(const AMethod, ALine: string);
@@ -63,7 +64,7 @@ TGocciaCLIApplication = class(TGocciaApplication)
function DiscoverFileConfig(
const AFileName: string): TConfigEntryArray;
function AnyFileConfigEnablesFlag(const AFiles: TStrings;
- const AFlag: TGocciaFlagOption): Boolean;
+ const AFlag: TFlagOption): Boolean;
function CreateEngine(const AFileName: string;
const ASource: TStringList;
const AExecutor: TGocciaExecutor): TGocciaEngine;
@@ -105,8 +106,9 @@ TGocciaCLIApplication = class(TGocciaApplication)
end;
function ResolveSourceTypeOption(
- const AOption: TGocciaEnumOption;
- const AFileConfig: TConfigEntryArray): Goccia.Engine.TGocciaSourceType;
+ const AOption: TEnumOption;
+ const AFileConfig: TConfigEntryArray;
+ const AFileName: string): Goccia.Engine.TGocciaSourceType;
implementation
@@ -326,7 +328,7 @@ function GetProcessorCount: Integer;
constructor TGocciaCLIApplication.Create(const AName: string);
begin
inherited Create(AName);
- FOwnedOptions := TGocciaOptionBaseList.Create(True);
+ FOwnedOptions := TOptionBaseList.Create(True);
FEngineOptions := nil;
FCoverageOptions := nil;
FProfilerOptions := nil;
@@ -359,7 +361,7 @@ destructor TGocciaCLIApplication.Destroy;
procedure TGocciaCLIApplication.BuildAllOptions;
var
- Combined: array of TGocciaOptionArray;
+ Combined: array of TOptionArray;
Count, I: Integer;
begin
Count := 0;
@@ -416,31 +418,31 @@ function TGocciaCLIApplication.AddProfilerOptions: TGocciaProfilerOptions;
Result := FProfilerOptions;
end;
-function TGocciaCLIApplication.AddFlag(const AName, AHelp: string): TGocciaFlagOption;
+function TGocciaCLIApplication.AddFlag(const AName, AHelp: string): TFlagOption;
begin
- Result := TGocciaFlagOption.Create(AName, AHelp);
+ Result := TFlagOption.Create(AName, AHelp);
FOwnedOptions.Add(Result);
end;
-function TGocciaCLIApplication.AddString(const AName, AHelp: string): TGocciaStringOption;
+function TGocciaCLIApplication.AddString(const AName, AHelp: string): TStringOption;
begin
- Result := TGocciaStringOption.Create(AName, AHelp);
+ Result := TStringOption.Create(AName, AHelp);
FOwnedOptions.Add(Result);
end;
-function TGocciaCLIApplication.AddInteger(const AName, AHelp: string): TGocciaIntegerOption;
+function TGocciaCLIApplication.AddInteger(const AName, AHelp: string): TIntegerOption;
begin
- Result := TGocciaIntegerOption.Create(AName, AHelp);
+ Result := TIntegerOption.Create(AName, AHelp);
FOwnedOptions.Add(Result);
end;
-function TGocciaCLIApplication.AddRepeatable(const AName, AHelp: string): TGocciaRepeatableOption;
+function TGocciaCLIApplication.AddRepeatable(const AName, AHelp: string): TRepeatableOption;
begin
- Result := TGocciaRepeatableOption.Create(AName, AHelp);
+ Result := TRepeatableOption.Create(AName, AHelp);
FOwnedOptions.Add(Result);
end;
-function TGocciaCLIApplication.Add(const AOption: TGocciaOptionBase): TGocciaOptionBase;
+function TGocciaCLIApplication.Add(const AOption: TOptionBase): TOptionBase;
begin
FOwnedOptions.Add(AOption);
Result := AOption;
@@ -465,7 +467,7 @@ function TGocciaCLIApplication.DiscoverFileConfig(
end;
function TGocciaCLIApplication.AnyFileConfigEnablesFlag(
- const AFiles: TStrings; const AFlag: TGocciaFlagOption): Boolean;
+ const AFiles: TStrings; const AFlag: TFlagOption): Boolean;
var
I: Integer;
begin
@@ -481,23 +483,32 @@ function TGocciaCLIApplication.AnyFileConfigEnablesFlag(
{ Resolve --source-type / config "source-type" into the engine's
TGocciaSourceType enum. Priority: CLI option > per-file config > root
- config > default (script).
+ config > file-extension default (.mjs is module) > default (script).
- CLI option and root config values are validated by TGocciaEnumOption.Apply
- before they reach this function (invalid values raise TGocciaParseError
+ CLI option and root config values are validated by TEnumOption.Apply
+ before they reach this function (invalid values raise TParseError
at parse/apply time). Per-file config values come in as raw strings via
FindConfigEntry, so we validate here: 'module' and 'script' are accepted
case-insensitively, anything else emits a stderr warning and falls back
- to stScript so a typo never silently flips into module source. }
+ to the file-extension default. }
+function DefaultSourceTypeForFileName(
+ const AFileName: string): Goccia.Engine.TGocciaSourceType;
+begin
+ if IsModuleSourceFileName(AFileName) then
+ Exit(Goccia.Engine.stModule);
+ Result := Goccia.Engine.stScript;
+end;
+
function ResolveSourceTypeOption(
- const AOption: TGocciaEnumOption;
- const AFileConfig: TConfigEntryArray): Goccia.Engine.TGocciaSourceType;
+ const AOption: TEnumOption;
+ const AFileConfig: TConfigEntryArray;
+ const AFileName: string): Goccia.Engine.TGocciaSourceType;
var
ValueStr, NormalizedValue: string;
begin
if AOption.FromCommandLine then
begin
- if AOption.Matches(CLI.Options.stModule) then
+ if AOption.Matches(Goccia.CLI.Options.stModule) then
Exit(Goccia.Engine.stModule);
Exit(Goccia.Engine.stScript);
end;
@@ -511,18 +522,19 @@ function ResolveSourceTypeOption(
Exit(Goccia.Engine.stScript);
WriteLn(StdErr, Format(
'Warning: invalid per-file config value for "source-type": %s '
- + '(valid: script, module). Falling back to script.', [ValueStr]));
- Exit(Goccia.Engine.stScript);
+ + '(valid: script, module). Falling back to file extension default.',
+ [ValueStr]));
+ Exit(DefaultSourceTypeForFileName(AFileName));
end;
if AOption.Present then
begin
- if AOption.Matches(CLI.Options.stModule) then
+ if AOption.Matches(Goccia.CLI.Options.stModule) then
Exit(Goccia.Engine.stModule);
Exit(Goccia.Engine.stScript);
end;
- Result := Goccia.Engine.stScript;
+ Result := DefaultSourceTypeForFileName(AFileName);
end;
{ Apply per-file config entries to the engine.
@@ -531,7 +543,7 @@ function ResolveSourceTypeOption(
so that a per-file config can override a root-level config value. }
procedure ApplyFileConfigToEngine(const AEngine: TGocciaEngine;
const AEngineOptions: TGocciaEngineOptions;
- const AFileConfig: TConfigEntryArray);
+ const AFileConfig: TConfigEntryArray; const AFileName: string);
var
ValueStr: string;
MemoryLimit: Int64;
@@ -543,36 +555,13 @@ procedure ApplyFileConfigToEngine(const AEngine: TGocciaEngine;
if not Assigned(AEngineOptions) then
Exit;
- { ASI: CLI flag > per-file config > root config > default (false) }
- AEngine.ASIEnabled := ResolveFlagOption(AEngineOptions.ASI, AFileConfig);
-
- { source-type: CLI option > per-file config > root config > default (script) }
+ { source-type: CLI option > per-file config > root config > .mjs > script }
AEngine.SourceType := ResolveSourceTypeOption(
- AEngineOptions.SourceType, AFileConfig);
-
- { compat-var: CLI flag > per-file config > root config > default (false) }
- AEngine.VarEnabled := ResolveFlagOption(
- AEngineOptions.CompatVar, AFileConfig);
-
- { compat-function: CLI flag > per-file config > root config > default (false) }
- AEngine.FunctionEnabled := ResolveFlagOption(
- AEngineOptions.CompatFunction, AFileConfig);
-
- { compat-traditional-for-loop: CLI flag > per-file config > root config > default (false) }
- AEngine.TraditionalForLoopsEnabled := ResolveFlagOption(
- AEngineOptions.CompatTraditionalFor, AFileConfig);
-
- { compat-while-loops: CLI flag > per-file config > root config > default (false) }
- AEngine.WhileLoopsEnabled := ResolveFlagOption(
- AEngineOptions.CompatWhileLoops, AFileConfig);
-
- { compat-loose-equality: CLI flag > per-file config > root config > default (false) }
- AEngine.LooseEqualityEnabled := ResolveFlagOption(
- AEngineOptions.CompatLooseEquality, AFileConfig);
+ AEngineOptions.SourceType, AFileConfig, AFileName);
- { compat-non-strict-mode: CLI flag > per-file config > root config > default (false) }
- AEngine.NonStrictModeEnabled := ResolveFlagOption(
- AEngineOptions.CompatNonStrictMode, AFileConfig);
+ { compatibility flags: CLI flag > per-file config > root config > default (empty) }
+ AEngine.Compatibility := ResolveCompatibilityFlags(
+ AEngineOptions, AFileConfig);
{ strict-types: CLI flag > per-file config > root config > default (false) }
AEngine.StrictTypes := ResolveFlagOption(
@@ -661,10 +650,10 @@ function TGocciaCLIApplication.CreateEngine(const AFileName: string;
end;
ConfigureCreatedEngine(Result, FileConfig);
if Assigned(FEngineOptions) then
- ApplyFileConfigToEngine(Result, FEngineOptions, FileConfig);
+ ApplyFileConfigToEngine(Result, FEngineOptions, FileConfig, AFileName);
if AExecutor is TGocciaBytecodeExecutor then
TGocciaBytecodeExecutor(AExecutor).GlobalBackedTopLevel :=
- Result.SourceType = stScript;
+ Result.SourceType = Goccia.Engine.stScript;
except
Result.Free;
raise;
@@ -965,19 +954,19 @@ procedure TGocciaCLIApplication.Execute;
begin
Configure;
- FHelp := TGocciaFlagOption.Create('help', 'Show this help message');
+ FHelp := TFlagOption.Create('help', 'Show this help message');
FHelp.ShortName := 'h';
- FJobs := TGocciaIntegerOption.Create('jobs', 'Number of parallel worker threads');
+ FJobs := TIntegerOption.Create('jobs', 'Number of parallel worker threads');
FJobs.ShortName := 'j';
- FLog := TGocciaStringOption.Create('log', 'Write console output to a log file');
+ FLog := TStringOption.Create('log', 'Write console output to a log file');
- FMultifile := TGocciaFlagOption.Create('multifile',
+ FMultifile := TFlagOption.Create('multifile',
'Split each input (file or stdin) on "---" lines and run each ' +
'section as an independent file');
- FConfig := TGocciaStringOption.Create('config',
+ FConfig := TStringOption.Create('config',
'Path to a config file or a directory containing one (skips auto-discovery)');
BuildAllOptions;
diff --git a/source/app/Goccia.CLI.EngineSetup.pas b/source/app/Goccia.CLI.EngineSetup.pas
index 5611d85f..adee764c 100644
--- a/source/app/Goccia.CLI.EngineSetup.pas
+++ b/source/app/Goccia.CLI.EngineSetup.pas
@@ -5,7 +5,7 @@
interface
uses
- CLI.Options;
+ Goccia.CLI.Options;
procedure InitializeCoverageIfEnabled(const AOptions: TGocciaCoverageOptions);
procedure ShutdownCoverageIfEnabled(const AOptions: TGocciaCoverageOptions);
@@ -43,11 +43,11 @@ procedure InitializeProfilerIfEnabled(const AOptions: TGocciaProfilerOptions);
TGocciaProfiler.Instance.Enabled := True;
case AOptions.Mode.Value of
- CLI.Options.pmOpcodes:
+ Goccia.CLI.Options.pmOpcodes:
TGocciaProfiler.Instance.Mode := [Goccia.Profiler.pmOpcodes];
- CLI.Options.pmFunctions:
+ Goccia.CLI.Options.pmFunctions:
TGocciaProfiler.Instance.Mode := [Goccia.Profiler.pmFunctions];
- CLI.Options.pmAll:
+ Goccia.CLI.Options.pmAll:
TGocciaProfiler.Instance.Mode := [Goccia.Profiler.pmOpcodes,
Goccia.Profiler.pmFunctions];
end;
diff --git a/source/app/Goccia.CLI.Help.pas b/source/app/Goccia.CLI.Help.pas
index 70381317..e341242c 100644
--- a/source/app/Goccia.CLI.Help.pas
+++ b/source/app/Goccia.CLI.Help.pas
@@ -8,7 +8,7 @@ interface
CLI.Options;
function GenerateHelpText(const AProgramName, AUsageLine: string;
- const AOptions: TGocciaOptionArray): string;
+ const AOptions: TOptionArray): string;
implementation
@@ -39,7 +39,7 @@ function FindOrAddGroup(var AGroups: array of TGroupEntry;
end;
function GenerateHelpText(const AProgramName, AUsageLine: string;
- const AOptions: TGocciaOptionArray): string;
+ const AOptions: TOptionArray): string;
const
MAX_GROUPS = 32;
COLUMN_GAP = 2;
@@ -49,7 +49,7 @@ function GenerateHelpText(const AProgramName, AUsageLine: string;
GroupCount: Integer;
MaxWidth, I, J, GroupIndex: Integer;
FormattedName, Header, Padding: string;
- Option: TGocciaOptionBase;
+ Option: TOptionBase;
begin
GroupCount := 0;
MaxWidth := 0;
@@ -84,7 +84,7 @@ function GenerateHelpText(const AProgramName, AUsageLine: string;
for J := 0 to Groups[I].Lines.Count - 1 do
begin
FormattedName := Groups[I].Lines[J];
- Option := TGocciaOptionBase(Groups[I].Lines.Objects[J]);
+ Option := TOptionBase(Groups[I].Lines.Objects[J]);
Padding := StringOfChar(' ', MaxWidth - Length(FormattedName) + COLUMN_GAP);
diff --git a/source/app/Goccia.CLI.Options.pas b/source/app/Goccia.CLI.Options.pas
new file mode 100644
index 00000000..4937caea
--- /dev/null
+++ b/source/app/Goccia.CLI.Options.pas
@@ -0,0 +1,335 @@
+unit Goccia.CLI.Options;
+
+{$I Goccia.inc}
+
+interface
+
+uses
+ CLI.ConfigFile,
+ CLI.Options,
+
+ Goccia.SourcePipeline;
+
+type
+ TGocciaExecutionMode = (emInterpreted, emBytecode);
+ TGocciaSourceType = (stScript, stModule);
+
+ TGocciaCompatibilityFlagDescriptor = record
+ OptionName: string;
+ HelpText: string;
+ end;
+
+ TGocciaEngineOptions = class
+ private
+ FMode: TEnumOption;
+ FSourceType: TEnumOption;
+ FCompatibilityFlags: array[TGocciaCompatibility] of TFlagOption;
+ FImportMap: TStringOption;
+ FAliases: TRepeatableOption;
+ FTimeout: TIntegerOption;
+ FMaxMemory: TInt64Option;
+ FMaxInstructions: TInt64Option;
+ FUnsafeFFI: TFlagOption;
+ FUnsafeFunctionConstructor: TFlagOption;
+ FStackSize: TIntegerOption;
+ FStrictTypes: TFlagOption;
+ FAllowedHosts: TRepeatableOption;
+ FInspectDepth: TIntegerOption;
+ public
+ constructor Create;
+ destructor Destroy; override;
+
+ function Options: TOptionArray;
+ function CompatibilityFlagOption(
+ const AFlag: TGocciaCompatibility): TFlagOption;
+
+ property Mode: TEnumOption read FMode;
+ property SourceType: TEnumOption read FSourceType;
+ property ImportMap: TStringOption read FImportMap;
+ property Aliases: TRepeatableOption read FAliases;
+ property Timeout: TIntegerOption read FTimeout;
+ property MaxMemory: TInt64Option read FMaxMemory;
+ property MaxInstructions: TInt64Option read FMaxInstructions;
+ property UnsafeFFI: TFlagOption read FUnsafeFFI;
+ property UnsafeFunctionConstructor: TFlagOption read FUnsafeFunctionConstructor;
+ property StackSize: TIntegerOption read FStackSize;
+ property StrictTypes: TFlagOption read FStrictTypes;
+ property AllowedHosts: TRepeatableOption read FAllowedHosts;
+ property InspectDepth: TIntegerOption read FInspectDepth;
+ end;
+
+ TGocciaCoverageFormat = (cfLcov, cfJson);
+
+ TGocciaCoverageOptions = class
+ private
+ FEnabled: TFlagOption;
+ FFormat: TEnumOption;
+ FOutputPath: TStringOption;
+ public
+ constructor Create;
+ destructor Destroy; override;
+
+ function Options: TOptionArray;
+
+ property Enabled: TFlagOption read FEnabled;
+ property Format: TEnumOption read FFormat;
+ property OutputPath: TStringOption read FOutputPath;
+ end;
+
+ TGocciaProfileMode = (pmOpcodes, pmFunctions, pmAll);
+ TGocciaProfileFormat = (pfFlamegraph);
+
+ TGocciaProfilerOptions = class
+ private
+ FMode: TEnumOption;
+ FOutputPath: TStringOption;
+ FFormat: TEnumOption;
+ public
+ constructor Create;
+ destructor Destroy; override;
+
+ function Options: TOptionArray;
+
+ property Mode: TEnumOption read FMode;
+ property OutputPath: TStringOption read FOutputPath;
+ property Format: TEnumOption read FFormat;
+ end;
+
+function CompatibilityFlagDescriptor(
+ const AFlag: TGocciaCompatibility): TGocciaCompatibilityFlagDescriptor;
+function ResolveCompatibilityFlags(const AEngineOptions: TGocciaEngineOptions;
+ const AFileConfig: TConfigEntryArray): TGocciaCompatibilityFlags;
+function TryApplyCompatibilityFlagArg(const AArg: string;
+ var AFlags: TGocciaCompatibilityFlags): Boolean;
+
+implementation
+
+const
+ ENGINE_FIXED_OPTION_COUNT = 13;
+
+ SOURCE_COMPATIBILITY_FLAGS: array[TGocciaCompatibility]
+ of TGocciaCompatibilityFlagDescriptor = (
+ (OptionName: 'compat-asi';
+ HelpText: 'Enable automatic semicolon insertion (compatibility)'),
+ (OptionName: 'compat-var';
+ HelpText: 'Enable var declarations (compatibility)'),
+ (OptionName: 'compat-function';
+ HelpText: 'Enable function declarations and expressions (compatibility)'),
+ (OptionName: 'compat-traditional-for-loop';
+ HelpText: 'Enable traditional C-style for(init; test; update) loops (compatibility)'),
+ (OptionName: 'compat-while-loops';
+ HelpText: 'Enable while and do...while loops (compatibility)'),
+ (OptionName: 'compat-loose-equality';
+ HelpText: 'Enable loose equality and inequality (== and !=) (compatibility)'),
+ (OptionName: 'compat-non-strict-mode';
+ HelpText: 'Enable non-strict-mode compatibility semantics')
+ );
+
+function CompatibilityFlagCount: Integer;
+begin
+ Result := Ord(High(TGocciaCompatibility)) - Ord(Low(TGocciaCompatibility))
+ + 1;
+end;
+
+function CompatibilityFlagDescriptor(
+ const AFlag: TGocciaCompatibility): TGocciaCompatibilityFlagDescriptor;
+begin
+ Result := SOURCE_COMPATIBILITY_FLAGS[AFlag];
+end;
+
+function ResolveCompatibilityFlags(const AEngineOptions: TGocciaEngineOptions;
+ const AFileConfig: TConfigEntryArray): TGocciaCompatibilityFlags;
+var
+ Flag: TGocciaCompatibility;
+begin
+ Result := [];
+ if not Assigned(AEngineOptions) then
+ Exit;
+
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ if ResolveFlagOption(AEngineOptions.CompatibilityFlagOption(Flag),
+ AFileConfig) then
+ Include(Result, Flag);
+end;
+
+function TryApplyCompatibilityFlagArg(const AArg: string;
+ var AFlags: TGocciaCompatibilityFlags): Boolean;
+var
+ Flag: TGocciaCompatibility;
+begin
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ if AArg = '--' + SOURCE_COMPATIBILITY_FLAGS[Flag].OptionName then
+ begin
+ Include(AFlags, Flag);
+ Exit(True);
+ end;
+
+ Result := False;
+end;
+
+{ TGocciaEngineOptions }
+
+constructor TGocciaEngineOptions.Create;
+var
+ Flag: TGocciaCompatibility;
+begin
+ inherited Create;
+ FMode := TEnumOption.Create('mode',
+ 'Execution mode', 'Engine');
+ FSourceType := TEnumOption.Create('source-type',
+ 'Source loading kind (default: script; .mjs infers module)', 'Engine');
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ FCompatibilityFlags[Flag] := TFlagOption.Create(
+ SOURCE_COMPATIBILITY_FLAGS[Flag].OptionName,
+ SOURCE_COMPATIBILITY_FLAGS[Flag].HelpText, 'Engine');
+ FImportMap := TStringOption.Create('import-map',
+ 'Path to import map JSON file', 'Engine');
+ FAliases := TRepeatableOption.Create('alias',
+ 'Import alias (e.g. @/=./src/)', 'Engine');
+ FTimeout := TIntegerOption.Create('timeout',
+ 'Per-file timeout in milliseconds', 'Engine');
+ FMaxMemory := TInt64Option.Create('max-memory',
+ 'GC heap byte limit (RangeError on exceed)', 'Engine');
+ FMaxInstructions := TInt64Option.Create('max-instructions',
+ 'Maximum execution steps before aborting', 'Engine');
+ FUnsafeFFI := TFlagOption.Create('unsafe-ffi',
+ 'Enable the FFI global (foreign function interface)', 'Runtime');
+ FUnsafeFunctionConstructor := TFlagOption.Create('unsafe-function-constructor',
+ 'Enable the Function constructor (dynamic code generation)', 'Engine');
+ FStackSize := TIntegerOption.Create('stack-size',
+ 'Maximum call stack depth (0 = no limit)', 'Engine');
+ FStrictTypes := TFlagOption.Create('strict-types',
+ 'Enforce type annotations at runtime (interpreter and bytecode)', 'Engine');
+ FAllowedHosts := TRepeatableOption.Create('allowed-host',
+ 'Hostname allowed for fetch requests (repeatable)', 'Engine');
+ FAllowedHosts.ConfigName := 'allowed-hosts';
+ FInspectDepth := TIntegerOption.Create('inspect-depth',
+ 'Maximum object inspection depth for console output (default: 5)', 'Engine');
+end;
+
+destructor TGocciaEngineOptions.Destroy;
+var
+ Flag: TGocciaCompatibility;
+begin
+ FMode.Free;
+ FSourceType.Free;
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ FCompatibilityFlags[Flag].Free;
+ FImportMap.Free;
+ FAliases.Free;
+ FTimeout.Free;
+ FMaxMemory.Free;
+ FMaxInstructions.Free;
+ FUnsafeFFI.Free;
+ FUnsafeFunctionConstructor.Free;
+ FStackSize.Free;
+ FStrictTypes.Free;
+ FAllowedHosts.Free;
+ FInspectDepth.Free;
+ inherited Destroy;
+end;
+
+function TGocciaEngineOptions.Options: TOptionArray;
+var
+ Flag: TGocciaCompatibility;
+ Index: Integer;
+begin
+ SetLength(Result, ENGINE_FIXED_OPTION_COUNT + CompatibilityFlagCount);
+ Index := 0;
+ Result[Index] := FMode;
+ Inc(Index);
+ Result[Index] := FSourceType;
+ Inc(Index);
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ begin
+ Result[Index] := FCompatibilityFlags[Flag];
+ Inc(Index);
+ end;
+ Result[Index] := FImportMap;
+ Inc(Index);
+ Result[Index] := FAliases;
+ Inc(Index);
+ Result[Index] := FTimeout;
+ Inc(Index);
+ Result[Index] := FMaxMemory;
+ Inc(Index);
+ Result[Index] := FMaxInstructions;
+ Inc(Index);
+ Result[Index] := FUnsafeFFI;
+ Inc(Index);
+ Result[Index] := FUnsafeFunctionConstructor;
+ Inc(Index);
+ Result[Index] := FStackSize;
+ Inc(Index);
+ Result[Index] := FStrictTypes;
+ Inc(Index);
+ Result[Index] := FAllowedHosts;
+ Inc(Index);
+ Result[Index] := FInspectDepth;
+end;
+
+function TGocciaEngineOptions.CompatibilityFlagOption(
+ const AFlag: TGocciaCompatibility): TFlagOption;
+begin
+ Result := FCompatibilityFlags[AFlag];
+end;
+
+{ TGocciaCoverageOptions }
+
+constructor TGocciaCoverageOptions.Create;
+begin
+ inherited Create;
+ FEnabled := TFlagOption.Create('coverage',
+ 'Enable line and branch coverage', 'Coverage');
+ FFormat := TEnumOption.Create('coverage-format',
+ 'Coverage output format', 'Coverage');
+ FOutputPath := TStringOption.Create('coverage-output',
+ 'Coverage output file path', 'Coverage');
+end;
+
+destructor TGocciaCoverageOptions.Destroy;
+begin
+ FEnabled.Free;
+ FFormat.Free;
+ FOutputPath.Free;
+ inherited Destroy;
+end;
+
+function TGocciaCoverageOptions.Options: TOptionArray;
+begin
+ SetLength(Result, 3);
+ Result[0] := FEnabled;
+ Result[1] := FFormat;
+ Result[2] := FOutputPath;
+end;
+
+{ TGocciaProfilerOptions }
+
+constructor TGocciaProfilerOptions.Create;
+begin
+ inherited Create;
+ FMode := TEnumOption.Create('profile',
+ 'Profiling mode', 'Profiler');
+ FOutputPath := TStringOption.Create('profile-output',
+ 'Profile output file path', 'Profiler');
+ FFormat := TEnumOption.Create('profile-format',
+ 'Profile output format', 'Profiler');
+end;
+
+destructor TGocciaProfilerOptions.Destroy;
+begin
+ FMode.Free;
+ FOutputPath.Free;
+ FFormat.Free;
+ inherited Destroy;
+end;
+
+function TGocciaProfilerOptions.Options: TOptionArray;
+begin
+ SetLength(Result, 3);
+ Result[0] := FMode;
+ Result[1] := FOutputPath;
+ Result[2] := FFormat;
+end;
+
+end.
diff --git a/source/app/GocciaBenchmarkRunner.dpr b/source/app/GocciaBenchmarkRunner.dpr
index 203260f8..e3d4b047 100644
--- a/source/app/GocciaBenchmarkRunner.dpr
+++ b/source/app/GocciaBenchmarkRunner.dpr
@@ -5,11 +5,9 @@ program GocciaBenchmarkRunner;
uses
{$IFDEF UNIX}cthreads,{$ENDIF}
Classes,
- Generics.Collections,
SysUtils,
TimingUtils,
- TextSemantics,
Goccia.Application,
Goccia.Arguments.Collection,
@@ -18,6 +16,7 @@ uses
Goccia.Builtins.Benchmark,
Goccia.Bytecode.Module,
Goccia.CLI.Application,
+ Goccia.CLI.Options,
CLI.ConfigFile,
CLI.Options,
Goccia.Constants.PropertyNames,
@@ -30,9 +29,6 @@ uses
Goccia.FileExtensions,
Goccia.GarbageCollector,
Goccia.InstructionLimit,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
- Goccia.Parser,
Goccia.Profiler,
Goccia.Profiler.Report,
Goccia.Runtime,
@@ -43,11 +39,10 @@ uses
Goccia.Scope,
Goccia.ScriptLoader.Input,
Goccia.CLI.JSON.Reporter,
- Goccia.SourceMap,
+ Goccia.SourcePipeline,
Goccia.Terminal.Colors,
Goccia.TextFiles,
Goccia.Timeout,
- Goccia.Token,
Goccia.Values.ArrayValue,
Goccia.Values.Error,
Goccia.Values.ObjectValue,
@@ -189,10 +184,10 @@ end;
type
TBenchmarkRunnerApp = class(TGocciaCLIApplication)
private
- FNoProgress: TGocciaFlagOption;
- FProfileDeterministic: TGocciaFlagOption;
- FFormats: TGocciaRepeatableOption;
- FOutputFile: TGocciaStringOption;
+ FNoProgress: TFlagOption;
+ FProfileDeterministic: TFlagOption;
+ FFormats: TRepeatableOption;
+ FOutputFile: TStringOption;
FCanPrintProfile: Boolean;
FWorkerProgressEnabled: Boolean;
function ProfilingEnabled: Boolean;
@@ -410,21 +405,19 @@ procedure TBenchmarkRunnerApp.CollectBenchmarkFileBytecode(
const AShowProgress: Boolean);
var
Source: TStringList;
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- ProgramNode: TGocciaProgram;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ PipelineResult: TGocciaSourcePipelineResult;
Module: TGocciaCompiledModule;
Executor: TGocciaBytecodeExecutor;
Engine: TGocciaEngine;
GC: TGarbageCollector;
FileResult: TBenchmarkFileResult;
ScriptResult: TGocciaObjectValue;
- LexStart, LexEnd, ParseEnd, CompileEnd, ExecEnd, BenchStart: Int64;
+ LexStart, CompileStart, CompileEnd, ExecEnd, BenchStart: Int64;
+ LexTimeNanoseconds, ParseTimeNanoseconds: Int64;
begin
Source := nil;
+ PipelineResult := nil;
try
try
Source := SourceRegistry.Load(AFileName);
@@ -437,13 +430,6 @@ begin
Exit;
end;
end;
- SourceText := StringListToLFText(Source);
- if ppJSX in TGocciaEngine.DefaultPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- JSXResult.SourceMap.Free;
- end;
try
Executor := TGocciaBytecodeExecutor.Create;
@@ -451,35 +437,21 @@ begin
Engine := CreateEngine(AFileName, Source, Executor);
try
LexStart := GetNanoseconds;
- Lexer := TGocciaLexer.Create(SourceText, AFileName);
+ PipelineOptions.Preprocessors := Engine.Preprocessors;
+ PipelineOptions.Compatibility := Engine.Compatibility;
+ PipelineOptions.SourceType := Engine.SourceType;
+ PipelineResult := TGocciaSourcePipeline.Parse(Source, AFileName,
+ PipelineOptions);
+ LexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ ParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
+
+ CompileStart := GetNanoseconds;
try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
-
- Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := Engine.ASIEnabled;
- Parser.VarDeclarationsEnabled := Engine.VarEnabled;
- Parser.FunctionDeclarationsEnabled := Engine.FunctionEnabled;
- Parser.TraditionalForLoopsEnabled := Engine.TraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := Engine.WhileLoopsEnabled;
- Parser.LooseEqualityEnabled := Engine.LooseEqualityEnabled;
- Parser.NonStrictModeEnabled := Engine.NonStrictModeEnabled or
- (Engine.SourceType = stModule);
- try
- ProgramNode := Parser.Parse;
- ParseEnd := GetNanoseconds;
-
- try
- Module := Engine.CompileModule(ProgramNode);
- CompileEnd := GetNanoseconds;
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
+ Module := Engine.CompileModule(PipelineResult.ProgramNode);
+ CompileEnd := GetNanoseconds;
finally
- Lexer.Free;
+ PipelineResult.Free;
+ PipelineResult := nil;
end;
ConfigureBenchmarkRuntime(Engine, AShowProgress, True);
@@ -495,9 +467,9 @@ begin
FileResult.FileName := AFileName;
FileResult.DeterministicProfile := FProfileDeterministic.Present;
- FileResult.LexTimeNanoseconds := LexEnd - LexStart;
- FileResult.ParseTimeNanoseconds := ParseEnd - LexEnd;
- FileResult.CompileTimeNanoseconds := CompileEnd - ParseEnd;
+ FileResult.LexTimeNanoseconds := LexTimeNanoseconds;
+ FileResult.ParseTimeNanoseconds := ParseTimeNanoseconds;
+ FileResult.CompileTimeNanoseconds := CompileEnd - CompileStart;
BenchStart := GetNanoseconds;
ScriptResult := RunRegisteredBenchmarks(Engine,
FProfileDeterministic.Present);
@@ -549,6 +521,7 @@ begin
MakeErrorFileResult(AFileName, E.Message, AReporter);
end;
finally
+ PipelineResult.Free;
if Assigned(TGarbageCollector.Instance) then
TGarbageCollector.Instance.Collect;
Source.Free;
@@ -646,63 +619,39 @@ procedure TBenchmarkRunnerApp.CollectBenchmarkSourceBytecode(
const ASource: TStringList; const AFileName: string;
const AReporter: TBenchmarkReporter; const AShowProgress: Boolean);
var
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- ProgramNode: TGocciaProgram;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ PipelineResult: TGocciaSourcePipelineResult;
Module: TGocciaCompiledModule;
Executor: TGocciaBytecodeExecutor;
Engine: TGocciaEngine;
GC: TGarbageCollector;
FileResult: TBenchmarkFileResult;
ScriptResult: TGocciaObjectValue;
- LexStart, LexEnd, ParseEnd, CompileEnd, ExecEnd, BenchStart: Int64;
+ LexStart, CompileStart, CompileEnd, ExecEnd, BenchStart: Int64;
+ LexTimeNanoseconds, ParseTimeNanoseconds: Int64;
begin
- SourceText := StringListToLFText(ASource);
- if ppJSX in TGocciaEngine.DefaultPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- JSXResult.SourceMap.Free;
- end;
-
+ PipelineResult := nil;
try
Executor := TGocciaBytecodeExecutor.Create;
try
Engine := CreateEngine(AFileName, ASource, Executor);
try
LexStart := GetNanoseconds;
- Lexer := TGocciaLexer.Create(SourceText, AFileName);
+ PipelineOptions.Preprocessors := Engine.Preprocessors;
+ PipelineOptions.Compatibility := Engine.Compatibility;
+ PipelineOptions.SourceType := Engine.SourceType;
+ PipelineResult := TGocciaSourcePipeline.Parse(ASource, AFileName,
+ PipelineOptions);
+ LexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ ParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
+
+ CompileStart := GetNanoseconds;
try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
-
- Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := Engine.ASIEnabled;
- Parser.VarDeclarationsEnabled := Engine.VarEnabled;
- Parser.FunctionDeclarationsEnabled := Engine.FunctionEnabled;
- Parser.TraditionalForLoopsEnabled := Engine.TraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := Engine.WhileLoopsEnabled;
- Parser.LooseEqualityEnabled := Engine.LooseEqualityEnabled;
- Parser.NonStrictModeEnabled := Engine.NonStrictModeEnabled or
- (Engine.SourceType = stModule);
- try
- ProgramNode := Parser.Parse;
- ParseEnd := GetNanoseconds;
-
- try
- Module := Engine.CompileModule(ProgramNode);
- CompileEnd := GetNanoseconds;
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
+ Module := Engine.CompileModule(PipelineResult.ProgramNode);
+ CompileEnd := GetNanoseconds;
finally
- Lexer.Free;
+ PipelineResult.Free;
+ PipelineResult := nil;
end;
ConfigureBenchmarkRuntime(Engine, AShowProgress, True);
@@ -718,9 +667,9 @@ begin
FileResult.FileName := AFileName;
FileResult.DeterministicProfile := FProfileDeterministic.Present;
- FileResult.LexTimeNanoseconds := LexEnd - LexStart;
- FileResult.ParseTimeNanoseconds := ParseEnd - LexEnd;
- FileResult.CompileTimeNanoseconds := CompileEnd - ParseEnd;
+ FileResult.LexTimeNanoseconds := LexTimeNanoseconds;
+ FileResult.ParseTimeNanoseconds := ParseTimeNanoseconds;
+ FileResult.CompileTimeNanoseconds := CompileEnd - CompileStart;
BenchStart := GetNanoseconds;
ScriptResult := RunRegisteredBenchmarks(Engine,
FProfileDeterministic.Present);
@@ -1082,19 +1031,19 @@ begin
EngineOptions.Mode.Apply('bytecode');
if ProfilerOptions.OutputPath.Present and not ProfilerOptions.Mode.Present then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--profile-output requires --profile=opcodes|functions|all.');
if ProfilerOptions.Format.Matches(pfFlamegraph) and
not ProfilerOptions.OutputPath.Present then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--profile-format=flamegraph requires --profile-output=.');
end;
procedure TBenchmarkRunnerApp.AfterExecute;
var
ProfileOpcodes, ProfileFunctions: Boolean;
- ProfileMode: CLI.Options.TGocciaProfileMode;
+ ProfileMode: Goccia.CLI.Options.TGocciaProfileMode;
begin
ProfileOpcodes := False;
ProfileFunctions := False;
@@ -1102,10 +1051,10 @@ begin
if ProfilerOptions.Mode.Present then
begin
ProfileMode := ProfilerOptions.Mode.Value;
- ProfileOpcodes := (ProfileMode = CLI.Options.pmOpcodes) or
- (ProfileMode = CLI.Options.pmAll);
- ProfileFunctions := (ProfileMode = CLI.Options.pmFunctions) or
- (ProfileMode = CLI.Options.pmAll);
+ ProfileOpcodes := (ProfileMode = Goccia.CLI.Options.pmOpcodes) or
+ (ProfileMode = Goccia.CLI.Options.pmAll);
+ ProfileFunctions := (ProfileMode = Goccia.CLI.Options.pmFunctions) or
+ (ProfileMode = Goccia.CLI.Options.pmAll);
end;
if (ProfileOpcodes or ProfileFunctions) and
diff --git a/source/app/GocciaBundler.dpr b/source/app/GocciaBundler.dpr
index 0f25c780..0dd6dc2c 100644
--- a/source/app/GocciaBundler.dpr
+++ b/source/app/GocciaBundler.dpr
@@ -5,11 +5,9 @@ program GocciaBundler;
uses
{$IFDEF UNIX}cthreads,{$ENDIF}
Classes,
- Generics.Collections,
SysUtils,
TimingUtils,
- TextSemantics,
Goccia.Application,
Goccia.AST.Node,
@@ -17,33 +15,29 @@ uses
Goccia.Bytecode.Module,
CLI.ConfigFile,
Goccia.CLI.Application,
+ Goccia.CLI.Options,
CLI.Options,
Goccia.Compiler,
Goccia.Engine,
Goccia.FileExtensions,
Goccia.GarbageCollector,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
- Goccia.Parser,
Goccia.ScriptLoader.Input,
+ Goccia.SourcePipeline,
Goccia.SourceMap,
Goccia.TextFiles,
Goccia.Threading,
Goccia.Threading.Init,
- Goccia.Token,
FileUtils in 'units/FileUtils.pas';
type
TBundlerApp = class(TGocciaCLIApplication)
private
- FOutputPath: TGocciaStringOption;
- FSourceMap: TGocciaStringOption;
+ FOutputPath: TStringOption;
+ FSourceMap: TStringOption;
function ParseSource(const ASource: TStringList; const AFileName: string;
- const AASIEnabled, AVarEnabled, AFunctionEnabled,
- ATraditionalForLoopsEnabled, AWhileLoopsEnabled, ALooseEqualityEnabled,
- ANonStrictModeEnabled: Boolean;
+ const AOptions: TGocciaSourcePipelineOptions;
out ALexTimeNanoseconds, AParseTimeNanoseconds: Int64;
out ASourceMap: TGocciaSourceMap): TGocciaProgram;
function CompileSource(const ASource: TStringList;
@@ -79,8 +73,8 @@ begin
AddEngineOptions;
FOutputPath := AddString('output',
'Output path (single file) or output directory (multiple files)');
- FSourceMap := AddString('source-map',
- 'Write a .map source map file (optional: explicit path)');
+ FSourceMap := TStringOption(Add(TOptionalStringOption.Create('source-map',
+ 'Write a .map source map file (optional: explicit path)')));
end;
{ TBundlerApp - Validate }
@@ -93,78 +87,36 @@ end;
{ TBundlerApp - Core logic }
function TBundlerApp.ParseSource(const ASource: TStringList;
- const AFileName: string; const AASIEnabled, AVarEnabled,
- AFunctionEnabled, ATraditionalForLoopsEnabled,
- AWhileLoopsEnabled, ALooseEqualityEnabled, ANonStrictModeEnabled: Boolean;
+ const AFileName: string; const AOptions: TGocciaSourcePipelineOptions;
out ALexTimeNanoseconds, AParseTimeNanoseconds: Int64;
out ASourceMap: TGocciaSourceMap): TGocciaProgram;
var
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- Warning: TGocciaParserWarning;
- StartTime, LexEnd, ParseEnd: Int64;
- OrigLine, OrigCol, I: Integer;
+ PipelineResult: TGocciaSourcePipelineResult;
+ Warning: TGocciaSourcePipelineWarning;
+ I: Integer;
begin
- StartTime := GetNanoseconds;
- SourceText := StringListToLFText(ASource);
-
ASourceMap := nil;
- if ppJSX in TGocciaEngine.DefaultPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- ASourceMap := JSXResult.SourceMap;
- if Assigned(ASourceMap) then
- ASourceMap.SetSourceContent(0, StringListToLFText(ASource));
- end;
+ PipelineResult := TGocciaSourcePipeline.Parse(ASource, AFileName, AOptions);
try
- Lexer := TGocciaLexer.Create(SourceText, AFileName);
- try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
- ALexTimeNanoseconds := LexEnd - StartTime;
-
- Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := AASIEnabled;
- Parser.VarDeclarationsEnabled := AVarEnabled;
- Parser.FunctionDeclarationsEnabled := AFunctionEnabled;
- Parser.TraditionalForLoopsEnabled := ATraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := AWhileLoopsEnabled;
- Parser.LooseEqualityEnabled := ALooseEqualityEnabled;
- Parser.NonStrictModeEnabled := ANonStrictModeEnabled;
- try
- Result := Parser.Parse;
- ParseEnd := GetNanoseconds;
- AParseTimeNanoseconds := ParseEnd - LexEnd;
-
- if not GIsWorkerThread then
- for I := 0 to Parser.WarningCount - 1 do
- begin
- Warning := Parser.GetWarning(I);
- WriteLn(SysUtils.Format('Warning: %s', [Warning.Message]));
- if Warning.Suggestion <> '' then
- WriteLn(SysUtils.Format(' Suggestion: %s', [Warning.Suggestion]));
- if Assigned(ASourceMap) and
- ASourceMap.Translate(Warning.Line, Warning.Column, OrigLine, OrigCol) then
- WriteLn(SysUtils.Format(' --> %s:%d:%d', [AFileName, OrigLine, OrigCol]))
- else
- WriteLn(SysUtils.Format(' --> %s:%d:%d',
- [AFileName, Warning.Line, Warning.Column]));
- end;
- finally
- Parser.Free;
+ ALexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ AParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
+
+ if not GIsWorkerThread then
+ for I := 0 to PipelineResult.WarningCount - 1 do
+ begin
+ Warning := PipelineResult.Warnings[I];
+ WriteLn(SysUtils.Format('Warning: %s', [Warning.Message]));
+ if Warning.Suggestion <> '' then
+ WriteLn(SysUtils.Format(' Suggestion: %s', [Warning.Suggestion]));
+ WriteLn(SysUtils.Format(' --> %s:%d:%d',
+ [AFileName, Warning.Line, Warning.Column]));
end;
- finally
- Lexer.Free;
- end;
- except
- ASourceMap.Free;
- ASourceMap := nil;
- raise;
+
+ Result := PipelineResult.TakeProgramNode;
+ ASourceMap := PipelineResult.TakeSourceMap;
+ finally
+ PipelineResult.Free;
end;
end;
@@ -204,43 +156,32 @@ var
LexTimeNanoseconds, ParseTimeNanoseconds: Int64;
SourceMap: TGocciaSourceMap;
FileConfig: TConfigEntryArray;
- EffectiveASI, EffectiveVar, EffectiveFunction, EffectiveStrictTypes,
- EffectiveTraditionalFor, EffectiveWhileLoops, EffectiveLooseEquality,
- EffectiveNonStrictMode: Boolean;
+ EffectiveStrictTypes: Boolean;
EffectiveSourceType: TGocciaSourceType;
+ EffectiveCompatibility: TGocciaCompatibilityFlags;
+ PipelineOptions: TGocciaSourcePipelineOptions;
begin
- { Resolve ASI and compatibility flags: CLI flag > per-file config >
- root config > default (false). }
+ { Resolve source pipeline flags: CLI flag > per-file config >
+ root config > default. }
FileConfig := DiscoverFileConfig(AFileName);
- EffectiveASI := ResolveFlagOption(EngineOptions.ASI, FileConfig);
- EffectiveVar := ResolveFlagOption(
- EngineOptions.CompatVar, FileConfig);
- EffectiveFunction := ResolveFlagOption(
- EngineOptions.CompatFunction, FileConfig);
- EffectiveTraditionalFor := ResolveFlagOption(
- EngineOptions.CompatTraditionalFor, FileConfig);
- EffectiveWhileLoops := ResolveFlagOption(
- EngineOptions.CompatWhileLoops, FileConfig);
- EffectiveLooseEquality := ResolveFlagOption(
- EngineOptions.CompatLooseEquality, FileConfig);
- EffectiveNonStrictMode := ResolveFlagOption(
- EngineOptions.CompatNonStrictMode, FileConfig);
+ EffectiveCompatibility := ResolveCompatibilityFlags(
+ EngineOptions, FileConfig);
EffectiveSourceType := ResolveSourceTypeOption(EngineOptions.SourceType,
- FileConfig);
+ FileConfig, AFileName);
EffectiveStrictTypes := ResolveFlagOption(
EngineOptions.StrictTypes, FileConfig);
CompiledModule := nil;
- ProgramNode := ParseSource(ASource, AFileName, EffectiveASI, EffectiveVar,
- EffectiveFunction, EffectiveTraditionalFor, EffectiveWhileLoops,
- EffectiveLooseEquality, EffectiveNonStrictMode or
- (EffectiveSourceType = stModule),
+ PipelineOptions.Preprocessors := TGocciaEngine.DefaultPreprocessors;
+ PipelineOptions.Compatibility := EffectiveCompatibility;
+ PipelineOptions.SourceType := EffectiveSourceType;
+ ProgramNode := ParseSource(ASource, AFileName, PipelineOptions,
LexTimeNanoseconds, ParseTimeNanoseconds, SourceMap);
try
Compiler := TGocciaCompiler.Create(AFileName);
try
Compiler.StrictTypes := EffectiveStrictTypes;
- Compiler.NonStrictMode := EffectiveNonStrictMode and
+ Compiler.NonStrictMode := (cfNonStrictMode in EffectiveCompatibility) and
(EffectiveSourceType = stScript);
CompiledModule := Compiler.Compile(ProgramNode);
WriteSourceMapIfEnabled(SourceMap, AFileName);
@@ -341,7 +282,7 @@ var
I: Integer;
begin
if not FOutputPath.Present then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--output= is required when compiling from stdin.');
Source := ReadSourceFromText(Input);
@@ -349,7 +290,7 @@ begin
if MultifileEnabled then
begin
if not DirectoryExists(FOutputPath.Value) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--output must be a directory when --multifile is set with stdin.');
// Ownership of Source transfers to SplitStdinMultifile.
@@ -377,7 +318,7 @@ begin
end;
if DirectoryExists(FOutputPath.Value) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--output must be a file when compiling from stdin.');
try
@@ -502,12 +443,12 @@ begin
not DirectoryExists(FOutputPath.Value) and
((APaths.Count > 1) or
((APaths.Count = 1) and DirectoryExists(APaths[0]))) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--output must be a directory when compiling multiple files.');
if MultifileEnabled and FOutputPath.Present and
(FOutputPath.Value <> '') and not DirectoryExists(FOutputPath.Value) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--output= cannot be combined with --multifile (an input '
+ 'may expand to multiple sections); pass a directory or omit '
+ '--output.');
@@ -515,13 +456,13 @@ begin
if (FSourceMap.ValueOr('') <> '') and
((APaths.Count > 1) or
((APaths.Count = 1) and DirectoryExists(APaths[0]))) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--source-map= supports a single input file or stdin.');
// Use Present rather than the value to catch the bare --source-map
// form too — see ScriptLoader for the rationale.
if FSourceMap.Present and MultifileEnabled then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--source-map cannot be combined with --multifile (an input '
+ 'may expand to multiple sections).');
diff --git a/source/app/GocciaREPL.dpr b/source/app/GocciaREPL.dpr
index 5b291b1d..8d14be43 100644
--- a/source/app/GocciaREPL.dpr
+++ b/source/app/GocciaREPL.dpr
@@ -5,16 +5,15 @@ program GocciaREPL;
uses
{$IFDEF UNIX}cthreads,{$ENDIF}
Classes,
- Generics.Collections,
SysUtils,
TimingUtils,
- TextSemantics,
Goccia.Application,
Goccia.AST.Node,
Goccia.Bytecode.Module,
Goccia.CLI.Application,
+ Goccia.CLI.Options,
CLI.ConfigFile,
CLI.Options,
Goccia.Engine,
@@ -24,19 +23,16 @@ uses
Goccia.Error,
Goccia.Error.Detail,
Goccia.GarbageCollector,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
Goccia.MicrotaskQueue,
- Goccia.Parser,
Goccia.REPL.Formatter,
Goccia.REPL.LineEditor,
Goccia.Runtime,
Goccia.RuntimeExtensions.Console,
Goccia.RuntimeExtensions.FFI,
Goccia.RuntimeProfiles.Loader,
+ Goccia.SourcePipeline,
Goccia.Terminal.Colors,
Goccia.TextFiles,
- Goccia.Token,
Goccia.Values.Error,
Goccia.Values.Primitives,
Goccia.Version;
@@ -47,7 +43,7 @@ const
type
TREPLApp = class(TGocciaCLIApplication)
private
- FTiming: TGocciaFlagOption;
+ FTiming: TFlagOption;
procedure InitializeRuntime(const AEngine: TGocciaEngine);
protected
procedure Configure; override;
@@ -112,14 +108,11 @@ var
{ Bytecode mode }
BcExecutor: TGocciaBytecodeExecutor;
ResultValue: TGocciaValue;
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- ProgramNode: TGocciaProgram;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ PipelineResult: TGocciaSourcePipelineResult;
Module: TGocciaCompiledModule;
- StartTime, LexEnd, ParseEnd, CompileEnd, ExecEnd: Int64;
+ StartTime, CompileStart, CompileEnd, ExecStart, ExecEnd: Int64;
+ LexTimeNanoseconds, ParseTimeNanoseconds: Int64;
begin
if APaths.Count > 0 then
begin
@@ -161,58 +154,38 @@ begin
Source.Add(Line);
StartTime := GetNanoseconds;
- LexEnd := StartTime;
- ParseEnd := StartTime;
+ CompileStart := StartTime;
CompileEnd := StartTime;
+ ExecStart := StartTime;
ExecEnd := StartTime;
+ LexTimeNanoseconds := 0;
+ ParseTimeNanoseconds := 0;
+ PipelineResult := nil;
try
- SourceText := StringListToLFText(Source);
+ PipelineOptions.Preprocessors := Eng.Preprocessors;
+ PipelineOptions.Compatibility := Eng.Compatibility;
+ PipelineOptions.SourceType := Eng.SourceType;
+ PipelineResult := TGocciaSourcePipeline.Parse(Source,
+ REPL_FILE_NAME, PipelineOptions);
+ LexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ ParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
- if ppJSX in TGocciaEngine.DefaultPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- JSXResult.SourceMap.Free;
- end;
-
- Lexer := TGocciaLexer.Create(SourceText, REPL_FILE_NAME);
+ CompileStart := GetNanoseconds;
try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
-
- Parser := TGocciaParser.Create(Tokens, REPL_FILE_NAME,
- Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := Eng.ASIEnabled;
- Parser.VarDeclarationsEnabled := Eng.VarEnabled;
- Parser.FunctionDeclarationsEnabled := Eng.FunctionEnabled;
- Parser.TraditionalForLoopsEnabled := Eng.TraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := Eng.WhileLoopsEnabled;
- Parser.LooseEqualityEnabled := Eng.LooseEqualityEnabled;
- Parser.NonStrictModeEnabled := Eng.NonStrictModeEnabled or
- (Eng.SourceType = stModule);
- try
- ProgramNode := Parser.Parse;
- ParseEnd := GetNanoseconds;
-
- try
- Module := Eng.CompileModule(ProgramNode);
- CompileEnd := GetNanoseconds;
-
- ResultValue := Eng.RunModuleForSourceType(Module,
- REPL_FILE_NAME);
- ExecEnd := GetNanoseconds;
-
- if ResultValue <> nil then
- WriteLn(FormatREPLValue(ResultValue, IsColorTerminal));
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
+ Module := Eng.CompileModule(PipelineResult.ProgramNode);
+ CompileEnd := GetNanoseconds;
finally
- Lexer.Free;
+ PipelineResult.Free;
+ PipelineResult := nil;
end;
+
+ ExecStart := GetNanoseconds;
+ ResultValue := Eng.RunModuleForSourceType(Module,
+ REPL_FILE_NAME);
+ ExecEnd := GetNanoseconds;
+
+ if ResultValue <> nil then
+ WriteLn(FormatREPLValue(ResultValue, IsColorTerminal));
except
on E: Exception do
begin
@@ -230,10 +203,10 @@ begin
if FTiming.Present then
WriteLn(SysUtils.Format(
' Lex: %s | Parse: %s | Compile: %s | Execute: %s | Total: %s',
- [FormatDuration(LexEnd - StartTime),
- FormatDuration(ParseEnd - LexEnd),
- FormatDuration(CompileEnd - ParseEnd),
- FormatDuration(ExecEnd - CompileEnd),
+ [FormatDuration(LexTimeNanoseconds),
+ FormatDuration(ParseTimeNanoseconds),
+ FormatDuration(CompileEnd - CompileStart),
+ FormatDuration(ExecEnd - ExecStart),
FormatDuration(ExecEnd - StartTime)]));
end;
finally
diff --git a/source/app/GocciaScriptLoader.dpr b/source/app/GocciaScriptLoader.dpr
index 7190f89b..abd76791 100644
--- a/source/app/GocciaScriptLoader.dpr
+++ b/source/app/GocciaScriptLoader.dpr
@@ -17,6 +17,7 @@ uses
Goccia.Bytecode.Binary,
Goccia.Bytecode.Module,
Goccia.CLI.Application,
+ Goccia.CLI.Options,
CLI.ConfigFile,
CLI.Options,
Goccia.Constants.PropertyNames,
@@ -31,9 +32,6 @@ uses
Goccia.FileExtensions,
Goccia.GarbageCollector,
Goccia.InstructionLimit,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
- Goccia.Parser,
Goccia.Profiler,
Goccia.Profiler.Report,
Goccia.Runtime,
@@ -44,13 +42,13 @@ uses
Goccia.ScriptLoader.Globals,
Goccia.ScriptLoader.Input,
Goccia.CLI.JSON.Reporter,
+ Goccia.SourcePipeline,
Goccia.SourceMap,
Goccia.Terminal.Colors,
Goccia.TextFiles,
Goccia.Threading,
Goccia.Threading.Init,
Goccia.Timeout,
- Goccia.Token,
Goccia.Values.Error,
Goccia.Values.ObjectValue,
Goccia.Values.Primitives,
@@ -98,12 +96,12 @@ type
TScriptLoaderApp = class(TGocciaCLIApplication)
private
- FOutputPath: TGocciaStringOption;
- FSilent: TGocciaFlagOption;
- FPrint: TGocciaFlagOption;
- FSourceMap: TGocciaStringOption;
- FGlobalFiles: TGocciaRepeatableOption;
- FInlineGlobals: TGocciaRepeatableOption;
+ FOutputPath: TStringOption;
+ FSilent: TFlagOption;
+ FPrint: TFlagOption;
+ FSourceMap: TStringOption;
+ FGlobalFiles: TRepeatableOption;
+ FInlineGlobals: TRepeatableOption;
FLastPaths: TStringList;
procedure InitializeRuntime(const AEngine: TGocciaEngine);
@@ -111,12 +109,11 @@ type
function IsJsonOutput: Boolean;
function IsCompactJsonOutput: Boolean;
function ParseSource(const ASource: TStringList; const AFileName: string;
- const APreprocessors: TGocciaPreprocessors; const ASuppressWarnings: Boolean;
- const AASIEnabled, AVarEnabled, AFunctionEnabled,
- ATraditionalForLoopsEnabled, AWhileLoopsEnabled, ALooseEqualityEnabled,
- ANonStrictModeEnabled: Boolean;
+ const AOptions: TGocciaSourcePipelineOptions;
+ const ASuppressWarnings: Boolean;
out ALexTimeNanoseconds, AParseTimeNanoseconds: Int64;
- out ASourceMap: TGocciaSourceMap): TGocciaProgram;
+ out ASourceMap: TGocciaSourceMap;
+ out AGeneratedSourceLines: TStringList): TGocciaProgram;
procedure WriteSourceMapIfEnabled(const ASourceMap: TGocciaSourceMap;
const AFileName: string);
procedure ConfigureConsole(const AConsole: TGocciaConsole;
@@ -289,8 +286,8 @@ begin
FSilent := AddFlag('silent', 'Suppress console output from the script');
FPrint := AddFlag('print',
'Print the script''s last value to stdout (mirrors node -p / bun --print / deno eval -p)');
- FSourceMap := AddString('source-map',
- 'Write a .map source map file (optional: explicit path)');
+ FSourceMap := TStringOption(Add(TOptionalStringOption.Create('source-map',
+ 'Write a .map source map file (optional: explicit path)')));
FGlobalFiles := AddRepeatable('globals',
'Inject globals from a JSON/JSON5/TOML/YAML file or a module with named exports');
FInlineGlobals := AddRepeatable('global',
@@ -333,7 +330,7 @@ begin
inherited Validate;
if EngineOptions.Timeout.Present and (EngineOptions.Timeout.Value < 0) then
- raise TGocciaParseError.Create('--timeout must be 0 or greater.');
+ raise TParseError.Create('--timeout must be 0 or greater.');
// --profile-format implies --profile=functions when no explicit --profile given
if ProfilerOptions.Format.Present and not ProfilerOptions.Mode.Present then
@@ -344,90 +341,56 @@ begin
EngineOptions.Mode.Apply('bytecode');
if ProfilerOptions.OutputPath.Present and not ProfilerOptions.Mode.Present then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--profile-output requires --profile=opcodes|functions|all.');
if ProfilerOptions.Format.Matches(pfFlamegraph) and
not ProfilerOptions.OutputPath.Present then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--profile-format=flamegraph requires --profile-output=.');
end;
{ TScriptLoaderApp - Core logic }
function TScriptLoaderApp.ParseSource(const ASource: TStringList;
- const AFileName: string; const APreprocessors: TGocciaPreprocessors;
- const ASuppressWarnings: Boolean; const AASIEnabled, AVarEnabled,
- AFunctionEnabled, ATraditionalForLoopsEnabled,
- AWhileLoopsEnabled, ALooseEqualityEnabled, ANonStrictModeEnabled: Boolean;
+ const AFileName: string; const AOptions: TGocciaSourcePipelineOptions;
+ const ASuppressWarnings: Boolean;
out ALexTimeNanoseconds, AParseTimeNanoseconds: Int64;
- out ASourceMap: TGocciaSourceMap): TGocciaProgram;
+ out ASourceMap: TGocciaSourceMap;
+ out AGeneratedSourceLines: TStringList): TGocciaProgram;
var
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- Warning: TGocciaParserWarning;
- StartTime, LexEnd, ParseEnd: Int64;
- OrigLine, OrigCol, I: Integer;
+ PipelineResult: TGocciaSourcePipelineResult;
+ Warning: TGocciaSourcePipelineWarning;
+ I: Integer;
begin
- StartTime := GetNanoseconds;
- SourceText := StringListToLFText(ASource);
-
ASourceMap := nil;
- if ppJSX in APreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- ASourceMap := JSXResult.SourceMap;
- if Assigned(ASourceMap) then
- ASourceMap.SetSourceContent(0, StringListToLFText(ASource));
- end;
+ AGeneratedSourceLines := nil;
+ PipelineResult := TGocciaSourcePipeline.Parse(ASource, AFileName, AOptions);
try
- Lexer := TGocciaLexer.Create(SourceText, AFileName);
- try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
- ALexTimeNanoseconds := LexEnd - StartTime;
-
- Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := AASIEnabled;
- Parser.VarDeclarationsEnabled := AVarEnabled;
- Parser.FunctionDeclarationsEnabled := AFunctionEnabled;
- Parser.TraditionalForLoopsEnabled := ATraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := AWhileLoopsEnabled;
- Parser.LooseEqualityEnabled := ALooseEqualityEnabled;
- Parser.NonStrictModeEnabled := ANonStrictModeEnabled;
- try
- Result := Parser.Parse;
- ParseEnd := GetNanoseconds;
- AParseTimeNanoseconds := ParseEnd - LexEnd;
+ ALexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ AParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
- if (not ASuppressWarnings) and (not GIsWorkerThread) then
- for I := 0 to Parser.WarningCount - 1 do
- begin
- Warning := Parser.GetWarning(I);
- WriteLn(SysUtils.Format('Warning: %s', [Warning.Message]));
- if Warning.Suggestion <> '' then
- WriteLn(SysUtils.Format(' Suggestion: %s', [Warning.Suggestion]));
- if Assigned(ASourceMap) and
- ASourceMap.Translate(Warning.Line, Warning.Column, OrigLine, OrigCol) then
- WriteLn(SysUtils.Format(' --> %s:%d:%d', [AFileName, OrigLine, OrigCol]))
- else
- WriteLn(SysUtils.Format(' --> %s:%d:%d', [AFileName, Warning.Line, Warning.Column]));
- end;
- finally
- Parser.Free;
+ if (not ASuppressWarnings) and (not GIsWorkerThread) then
+ for I := 0 to PipelineResult.WarningCount - 1 do
+ begin
+ Warning := PipelineResult.Warnings[I];
+ WriteLn(SysUtils.Format('Warning: %s', [Warning.Message]));
+ if Warning.Suggestion <> '' then
+ WriteLn(SysUtils.Format(' Suggestion: %s', [Warning.Suggestion]));
+ WriteLn(SysUtils.Format(' --> %s:%d:%d',
+ [AFileName, Warning.Line, Warning.Column]));
end;
- finally
- Lexer.Free;
+
+ Result := PipelineResult.TakeProgramNode;
+ ASourceMap := PipelineResult.TakeSourceMap;
+ if Assigned(PipelineResult.GeneratedSourceLines) then
+ begin
+ AGeneratedSourceLines := TStringList.Create;
+ AGeneratedSourceLines.Assign(PipelineResult.GeneratedSourceLines);
end;
- except
- ASourceMap.Free;
- ASourceMap := nil;
- raise;
+ finally
+ PipelineResult.Free;
end;
end;
@@ -660,7 +623,9 @@ var
Module: TGocciaCompiledModule;
Executor: TGocciaBytecodeExecutor;
Engine: TGocciaEngine;
+ PipelineOptions: TGocciaSourcePipelineOptions;
SourceMap: TGocciaSourceMap;
+ GeneratedSourceLines: TStringList;
StartTime, CompileStart, CompileEnd, ExecEnd: Int64;
begin
StartTime := GetNanoseconds;
@@ -671,21 +636,23 @@ begin
ConfigureConsole(RuntimeConsole(Engine), ACapture);
ApplyDataGlobalsToEngine(Engine);
- ProgramNode := ParseSource(ASource, AFileName, TGocciaEngine.DefaultPreprocessors,
- IsJsonOutput, Engine.ASIEnabled, Engine.VarEnabled, Engine.FunctionEnabled,
- Engine.TraditionalForLoopsEnabled, Engine.WhileLoopsEnabled,
- Engine.LooseEqualityEnabled, Engine.NonStrictModeEnabled or
- (Engine.SourceType = stModule),
+ PipelineOptions.Preprocessors := Engine.Preprocessors;
+ PipelineOptions.Compatibility := Engine.Compatibility;
+ PipelineOptions.SourceType := Engine.SourceType;
+ ProgramNode := ParseSource(ASource, AFileName, PipelineOptions,
+ IsJsonOutput,
Result.Timing.LexTimeNanoseconds,
- Result.Timing.ParseTimeNanoseconds, SourceMap);
+ Result.Timing.ParseTimeNanoseconds, SourceMap,
+ GeneratedSourceLines);
try
WriteSourceMapIfEnabled(SourceMap, AFileName);
if Assigned(TGocciaCoverageTracker.Instance) and
- TGocciaCoverageTracker.Instance.Enabled and Assigned(ASource) then
+ TGocciaCoverageTracker.Instance.Enabled and
+ Assigned(GeneratedSourceLines) then
begin
TGocciaCoverageTracker.Instance.RegisterSourceFile(
- AFileName, CountExecutableLines(ASource));
+ AFileName, CountExecutableLines(GeneratedSourceLines));
if Assigned(SourceMap) then
TGocciaCoverageTracker.Instance.RegisterSourceMap(
AFileName, SourceMap.Clone);
@@ -698,6 +665,7 @@ begin
finally
ProgramNode.Free;
SourceMap.Free;
+ GeneratedSourceLines.Free;
end;
StartExecutionTimeout(EngineOptions.Timeout.ValueOr(0));
@@ -1298,13 +1266,13 @@ begin
if FSourceMap.Present and (FSourceMap.ValueOr('') = '') and
((APaths.Count = 0) or
((APaths.Count = 1) and IsStdinPath(APaths[0]))) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--source-map= is required when reading source from stdin.');
if (FSourceMap.ValueOr('') <> '') and
((APaths.Count > 1) or
((APaths.Count = 1) and DirectoryExists(APaths[0]))) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--source-map= supports a single input file or stdin.');
// Use Present rather than the value to catch the bare --source-map
@@ -1312,7 +1280,7 @@ begin
// user passing --source-map alongside --multifile is almost certainly
// signalling intent that does not match the multi-output reality.
if FSourceMap.Present and MultifileEnabled then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'--source-map cannot be combined with --multifile (an input '
+ 'may expand to multiple sections).');
@@ -1370,7 +1338,7 @@ begin
for I := 0 to APaths.Count - 1 do
begin
if IsStdinPath(APaths[I]) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'stdin is supported only as the sole input.');
if DirectoryExists(APaths[I]) then
RawFiles.AddStrings(FindAllFiles(APaths[I], ScriptExtensions))
@@ -1402,7 +1370,7 @@ begin
--output=json mode and by GocciaTestRunner / GocciaBenchmarkRunner. }
for I := 0 to APaths.Count - 1 do
if IsStdinPath(APaths[I]) then
- raise TGocciaParseError.Create(
+ raise TParseError.Create(
'stdin is supported only as the sole input.');
for I := 0 to APaths.Count - 1 do
@@ -1431,7 +1399,7 @@ end;
procedure TScriptLoaderApp.AfterExecute;
var
ProfileOpcodes, ProfileFunctions: Boolean;
- ProfileMode: CLI.Options.TGocciaProfileMode;
+ ProfileMode: Goccia.CLI.Options.TGocciaProfileMode;
begin
if (CoverageOptions.Enabled.Present or CoverageOptions.Format.Present or
CoverageOptions.OutputPath.Present) and
@@ -1459,10 +1427,10 @@ begin
if ProfilerOptions.Mode.Present then
begin
ProfileMode := ProfilerOptions.Mode.Value;
- ProfileOpcodes := (ProfileMode = CLI.Options.pmOpcodes) or
- (ProfileMode = CLI.Options.pmAll);
- ProfileFunctions := (ProfileMode = CLI.Options.pmFunctions) or
- (ProfileMode = CLI.Options.pmAll);
+ ProfileOpcodes := (ProfileMode = Goccia.CLI.Options.pmOpcodes) or
+ (ProfileMode = Goccia.CLI.Options.pmAll);
+ ProfileFunctions := (ProfileMode = Goccia.CLI.Options.pmFunctions) or
+ (ProfileMode = Goccia.CLI.Options.pmAll);
end;
if (ProfileOpcodes or ProfileFunctions) and
diff --git a/source/app/GocciaScriptLoaderBare.dpr b/source/app/GocciaScriptLoaderBare.dpr
index d42a080c..fe1ee139 100644
--- a/source/app/GocciaScriptLoaderBare.dpr
+++ b/source/app/GocciaScriptLoaderBare.dpr
@@ -9,12 +9,14 @@ uses
TextSemantics,
Goccia.Arguments.Collection,
+ Goccia.CLI.Options,
Goccia.Engine,
Goccia.Error,
Goccia.Error.Detail,
Goccia.Executor,
Goccia.Executor.Bytecode,
Goccia.Executor.Interpreter,
+ Goccia.FileExtensions,
Goccia.GarbageCollector,
Goccia.InstructionLimit,
Goccia.ScriptLoader.Input,
@@ -35,18 +37,13 @@ type
TBareExecutionMode = (bemInterpreted, bemBytecode);
TBareOptions = record
- ASI: Boolean;
- CompatVar: Boolean;
- CompatFunction: Boolean;
- CompatTraditionalFor: Boolean;
- CompatWhileLoops: Boolean;
- CompatLooseEquality: Boolean;
- CompatNonStrictMode: Boolean;
+ Compatibility: TGocciaCompatibilityFlags;
StrictTypes: Boolean;
UnsafeFunctionConstructor: Boolean;
Print: Boolean;
Mode: TBareExecutionMode;
SourceType: TGocciaSourceType;
+ SourceTypeExplicit: Boolean;
FileName: string;
TimeoutMs: Integer;
MaxMemoryBytes: Int64;
@@ -75,20 +72,22 @@ begin
end;
procedure PrintUsage;
+var
+ Flag: TGocciaCompatibility;
+ Descriptor: TGocciaCompatibilityFlagDescriptor;
begin
WriteLn('Usage: GocciaScriptLoaderBare [file|-] [options]');
WriteLn('');
WriteLn('Options:');
- WriteLn(' --asi Enable automatic semicolon insertion');
- WriteLn(' --compat-var Enable var declarations');
- WriteLn(' --compat-function Enable function declarations/expressions');
- WriteLn(' --compat-traditional-for-loop Enable traditional C-style for(;;) loops');
- WriteLn(' --compat-while-loops Enable while and do...while loops');
- WriteLn(' --compat-loose-equality Enable loose equality (== and !=)');
- WriteLn(' --compat-non-strict-mode Enable non-strict-mode compatibility');
+ for Flag := Low(TGocciaCompatibility) to High(TGocciaCompatibility) do
+ begin
+ Descriptor := CompatibilityFlagDescriptor(Flag);
+ WriteLn(Format(' --%-28s %s', [Descriptor.OptionName,
+ Descriptor.HelpText]));
+ end;
WriteLn(' --strict-types Enforce type annotations at runtime');
WriteLn(' --mode=interpreted|bytecode Execution mode (default: interpreted)');
- WriteLn(' --source-type=script|module Load entry as script source or module source');
+ WriteLn(' --source-type=script|module Load entry as script source or module source (.mjs infers module)');
WriteLn(' --unsafe-function-constructor Enable dynamic Function constructor');
WriteLn(' --print Print the script''s last value (incl. undefined)');
WriteLn(' --timeout=MS Per-file cooperative timeout in milliseconds');
@@ -115,6 +114,7 @@ begin
AOptions.SourceType := stModule
else
raise Exception.Create('Invalid --source-type value: ' + AValue);
+ AOptions.SourceTypeExplicit := True;
end;
procedure ParseTimeout(const AValue: string; var AOptions: TBareOptions);
@@ -156,18 +156,13 @@ var
I: Integer;
Arg: string;
begin
- Result.ASI := False;
- Result.CompatVar := False;
- Result.CompatFunction := False;
- Result.CompatTraditionalFor := False;
- Result.CompatWhileLoops := False;
- Result.CompatLooseEquality := False;
- Result.CompatNonStrictMode := False;
+ Result.Compatibility := [];
Result.StrictTypes := False;
Result.UnsafeFunctionConstructor := False;
Result.Print := False;
Result.Mode := bemInterpreted;
Result.SourceType := stScript;
+ Result.SourceTypeExplicit := False;
Result.FileName := STDIN_PATH_MARKER;
Result.TimeoutMs := 0;
Result.MaxMemoryBytes := 0;
@@ -181,20 +176,10 @@ begin
PrintUsage;
Halt(0);
end
- else if Arg = '--asi' then
- Result.ASI := True
- else if Arg = '--compat-var' then
- Result.CompatVar := True
- else if Arg = '--compat-function' then
- Result.CompatFunction := True
- else if Arg = '--compat-traditional-for-loop' then
- Result.CompatTraditionalFor := True
- else if Arg = '--compat-while-loops' then
- Result.CompatWhileLoops := True
- else if Arg = '--compat-loose-equality' then
- Result.CompatLooseEquality := True
- else if Arg = '--compat-non-strict-mode' then
- Result.CompatNonStrictMode := True
+ else if TryApplyCompatibilityFlagArg(Arg, Result.Compatibility) then
+ begin
+ { handled by source compatibility flag registry }
+ end
else if Arg = '--strict-types' then
Result.StrictTypes := True
else if Arg = '--unsafe-function-constructor' then
@@ -219,6 +204,10 @@ begin
else
raise Exception.Create('Unexpected argument: ' + Arg);
end;
+
+ if (not Result.SourceTypeExplicit) and
+ IsModuleSourceFileName(Result.FileName) then
+ Result.SourceType := stModule;
end;
function ReadBareSource(const AFileName: string): TStringList;
@@ -232,13 +221,7 @@ end;
procedure ConfigureEngine(const AEngine: TGocciaEngine;
const AOptions: TBareOptions);
begin
- AEngine.ASIEnabled := AOptions.ASI;
- AEngine.VarEnabled := AOptions.CompatVar;
- AEngine.FunctionEnabled := AOptions.CompatFunction;
- AEngine.TraditionalForLoopsEnabled := AOptions.CompatTraditionalFor;
- AEngine.WhileLoopsEnabled := AOptions.CompatWhileLoops;
- AEngine.LooseEqualityEnabled := AOptions.CompatLooseEquality;
- AEngine.NonStrictModeEnabled := AOptions.CompatNonStrictMode;
+ AEngine.Compatibility := AOptions.Compatibility;
AEngine.StrictTypes := AOptions.StrictTypes;
AEngine.SourceType := AOptions.SourceType;
AEngine.FunctionConstructor.Enabled := AOptions.UnsafeFunctionConstructor;
diff --git a/source/app/GocciaTestRunner.dpr b/source/app/GocciaTestRunner.dpr
index 8540cdd8..9cd46cca 100644
--- a/source/app/GocciaTestRunner.dpr
+++ b/source/app/GocciaTestRunner.dpr
@@ -5,17 +5,16 @@ program GocciaTestRunner;
uses
{$IFDEF UNIX}cthreads,{$ENDIF}
Classes,
- Generics.Collections,
StrUtils,
SysUtils,
TimingUtils,
- TextSemantics,
Goccia.Application,
Goccia.AST.Node,
Goccia.Bytecode.Module,
Goccia.CLI.Application,
+ Goccia.CLI.Options,
CLI.ConfigFile,
CLI.Options,
Goccia.Coverage,
@@ -30,22 +29,18 @@ uses
Goccia.GarbageCollector,
Goccia.InstructionLimit,
Goccia.JSON.Utils,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
- Goccia.Parser,
Goccia.Runtime,
Goccia.RuntimeExtensions.Console,
Goccia.RuntimeExtensions.FFI,
Goccia.RuntimeProfiles.TestRunner,
Goccia.Scope,
Goccia.ScriptLoader.Input,
- Goccia.SourceMap,
+ Goccia.SourcePipeline,
Goccia.Builtins.TestingLibrary,
Goccia.CLI.JSON.Reporter,
Goccia.Terminal.Colors,
Goccia.TextFiles,
Goccia.Timeout,
- Goccia.Token,
Goccia.Values.ArrayValue,
Goccia.Values.Error,
Goccia.Values.ObjectValue,
@@ -124,13 +119,13 @@ type
TTestRunnerApp = class(TGocciaCLIApplication)
private
- FNoProgress: TGocciaFlagOption;
- FNoResults: TGocciaFlagOption;
- FExitOnFirst: TGocciaFlagOption;
- FSilent: TGocciaFlagOption;
- FOutputFile: TGocciaStringOption;
- FTestTimeout: TGocciaIntegerOption;
- FDescribeTimeout: TGocciaIntegerOption;
+ FNoProgress: TFlagOption;
+ FNoResults: TFlagOption;
+ FExitOnFirst: TFlagOption;
+ FSilent: TFlagOption;
+ FOutputFile: TStringOption;
+ FTestTimeout: TIntegerOption;
+ FDescribeTimeout: TIntegerOption;
procedure InitializeRuntime(const AEngine: TGocciaEngine);
procedure InitializeRuntimeWithUnsafeFFI(const AEngine: TGocciaEngine);
protected
@@ -601,14 +596,9 @@ function TTestRunnerApp.RunGocciaScriptBytecode(const AFileName: string;
APreloadedSource: TStringList): TTestFileResult;
var
Source: TStringList;
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- SourceMap: TGocciaSourceMap;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
- Warning: TGocciaParserWarning;
- ProgramNode: TGocciaProgram;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ PipelineResult: TGocciaSourcePipelineResult;
+ Warning: TGocciaSourcePipelineWarning;
Module: TGocciaCompiledModule;
Executor: TGocciaBytecodeExecutor;
Engine: TGocciaEngine;
@@ -616,13 +606,15 @@ var
ResultValue: TGocciaValue;
GC: TGarbageCollector;
ResultValueRooted: Boolean;
- OrigLine, OrigCol, I: Integer;
- LexStart, LexEnd, ParseEnd, CompileEnd, ExecEnd: Int64;
+ I: Integer;
+ LexStart, CompileStart, CompileEnd, ExecEnd: Int64;
+ LexTimeNanoseconds, ParseTimeNanoseconds: Int64;
begin
ScriptResult := CreateDefaultScriptResult;
ResultValue := nil;
GC := TGarbageCollector.Instance;
ResultValueRooted := False;
+ PipelineResult := nil;
if Assigned(GC) then
GC.AddTempRoot(ScriptResult);
@@ -649,16 +641,7 @@ begin
Source.Add(Format('runTests({ exitOnFirstFailure: %s, showTestResults: false });',
[BoolToStr(FExitOnFirst.Present, 'true', 'false')]));
- SourceText := StringListToLFText(Source);
- SourceMap := nil;
- if ppJSX in TGocciaEngine.DefaultPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- SourceMap := JSXResult.SourceMap;
- end;
-
- try try
+ try
Executor := TGocciaBytecodeExecutor.Create;
try
Engine := CreateEngine(AFileName, Source, Executor);
@@ -670,59 +653,43 @@ begin
end;
LexStart := GetNanoseconds;
- Lexer := TGocciaLexer.Create(SourceText, AFileName);
- try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
-
- Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := Engine.ASIEnabled;
- Parser.VarDeclarationsEnabled := Engine.VarEnabled;
- Parser.FunctionDeclarationsEnabled := Engine.FunctionEnabled;
- Parser.TraditionalForLoopsEnabled := Engine.TraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := Engine.WhileLoopsEnabled;
- Parser.LooseEqualityEnabled := Engine.LooseEqualityEnabled;
- Parser.NonStrictModeEnabled := Engine.NonStrictModeEnabled or
- (Engine.SourceType = stModule);
- try
- ProgramNode := Parser.Parse;
- ParseEnd := GetNanoseconds;
-
- if Assigned(TGocciaCoverageTracker.Instance) and
- TGocciaCoverageTracker.Instance.Enabled then
- begin
- TGocciaCoverageTracker.Instance.RegisterSourceFile(
- AFileName, CountExecutableLines(Lexer.SourceLines));
- if Assigned(SourceMap) then
- TGocciaCoverageTracker.Instance.RegisterSourceMap(
- AFileName, SourceMap.Clone);
- end;
-
- if (not FSilent.Present) and (not GIsWorkerThread) and (not IsJsonOutput) then
- for I := 0 to Parser.WarningCount - 1 do
- begin
- Warning := Parser.GetWarning(I);
- WriteLn(Format('Warning: %s', [Warning.Message]));
- if Warning.Suggestion <> '' then
- WriteLn(Format(' Suggestion: %s', [Warning.Suggestion]));
- if Assigned(SourceMap) and SourceMap.Translate(Warning.Line, Warning.Column, OrigLine, OrigCol) then
- WriteLn(Format(' --> %s:%d:%d', [AFileName, OrigLine, OrigCol]))
- else
- WriteLn(Format(' --> %s:%d:%d', [AFileName, Warning.Line, Warning.Column]));
- end;
- try
- Module := Engine.CompileModule(ProgramNode);
- CompileEnd := GetNanoseconds;
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
- finally
- Lexer.Free;
+ PipelineOptions.Preprocessors := Engine.Preprocessors;
+ PipelineOptions.Compatibility := Engine.Compatibility;
+ PipelineOptions.SourceType := Engine.SourceType;
+ PipelineResult := TGocciaSourcePipeline.Parse(Source, AFileName,
+ PipelineOptions);
+ LexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ ParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
+
+ if Assigned(TGocciaCoverageTracker.Instance) and
+ TGocciaCoverageTracker.Instance.Enabled then
+ begin
+ TGocciaCoverageTracker.Instance.RegisterSourceFile(
+ AFileName,
+ CountExecutableLines(PipelineResult.GeneratedSourceLines));
+ if Assigned(PipelineResult.SourceMap) then
+ TGocciaCoverageTracker.Instance.RegisterSourceMap(
+ AFileName, PipelineResult.SourceMap.Clone);
end;
+ if (not FSilent.Present) and (not GIsWorkerThread) and
+ (not IsJsonOutput) then
+ for I := 0 to PipelineResult.WarningCount - 1 do
+ begin
+ Warning := PipelineResult.Warnings[I];
+ WriteLn(Format('Warning: %s', [Warning.Message]));
+ if Warning.Suggestion <> '' then
+ WriteLn(Format(' Suggestion: %s', [Warning.Suggestion]));
+ WriteLn(Format(' --> %s:%d:%d',
+ [AFileName, Warning.Line, Warning.Column]));
+ end;
+
+ CompileStart := GetNanoseconds;
+ Module := Engine.CompileModule(PipelineResult.ProgramNode);
+ CompileEnd := GetNanoseconds;
+ PipelineResult.Free;
+ PipelineResult := nil;
+
StartExecutionTimeout(EngineOptions.Timeout.ValueOr(DEFAULT_TIMEOUT_MS));
StartInstructionLimit(EngineOptions.MaxInstructions.ValueOr(0));
try
@@ -743,9 +710,9 @@ begin
Result.TestResult := ScriptResult;
Result.Timing.Result := ResultValue;
- Result.Timing.LexTimeNanoseconds := LexEnd - LexStart;
- Result.Timing.ParseTimeNanoseconds := ParseEnd - LexEnd;
- Result.Timing.CompileTimeNanoseconds := CompileEnd - ParseEnd;
+ Result.Timing.LexTimeNanoseconds := LexTimeNanoseconds;
+ Result.Timing.ParseTimeNanoseconds := ParseTimeNanoseconds;
+ Result.Timing.CompileTimeNanoseconds := CompileEnd - CompileStart;
Result.Timing.ExecuteTimeNanoseconds := ExecEnd - CompileEnd;
Result.Timing.TotalTimeNanoseconds := ExecEnd - LexStart;
Result.Timing.FileName := AFileName;
@@ -786,10 +753,8 @@ begin
end;
end;
end;
- finally
- SourceMap.Free;
- end;
finally
+ PipelineResult.Free;
if ResultValueRooted and Assigned(GC) then
GC.RemoveTempRoot(ResultValue);
if Assigned(GC) then
diff --git a/source/shared/CLI.ConfigFile.Test.pas b/source/shared/CLI.ConfigFile.Test.pas
index d0e180fa..ec556ee2 100644
--- a/source/shared/CLI.ConfigFile.Test.pas
+++ b/source/shared/CLI.ConfigFile.Test.pas
@@ -220,16 +220,16 @@ procedure TConfigFileTests.WriteRawFile(const APath: string;
procedure TConfigFileTests.TestJSONStringValue;
var
Dir, Path: string;
- Flag: TGocciaFlagOption;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
WriteTextFile(Path, '{"mode": "bytecode"}');
- Mode := TGocciaStringOption.Create('mode', 'Execution mode');
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Mode := TStringOption.Create('mode', 'Execution mode');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 2);
Options[0] := Mode;
@@ -249,14 +249,14 @@ procedure TConfigFileTests.TestJSONStringValue;
procedure TConfigFileTests.TestJSONIntegerValue;
var
Dir, Path: string;
- Timeout: TGocciaIntegerOption;
- Options: TGocciaOptionArray;
+ Timeout: TIntegerOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
WriteTextFile(Path, '{"timeout": 5000}');
- Timeout := TGocciaIntegerOption.Create('timeout', 'Timeout');
+ Timeout := TIntegerOption.Create('timeout', 'Timeout');
try
SetLength(Options, 1);
Options[0] := Timeout;
@@ -273,60 +273,60 @@ procedure TConfigFileTests.TestJSONIntegerValue;
procedure TConfigFileTests.TestJSONBooleanTrueIncluded;
var
Dir, Path: string;
- ASI: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
- WriteTextFile(Path, '{"asi": true}');
+ WriteTextFile(Path, '{"feature": true}');
- ASI := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
- Options[0] := ASI;
+ Options[0] := Flag;
ApplyConfigFile(Path, Options);
- Expect(ASI.Present).ToBe(True);
+ Expect(Flag.Present).ToBe(True);
finally
- ASI.Free;
+ Flag.Free;
end;
end;
procedure TConfigFileTests.TestJSONBooleanFalseOmitted;
var
Dir, Path: string;
- ASI: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
- WriteTextFile(Path, '{"asi": false}');
+ WriteTextFile(Path, '{"feature": false}');
- ASI := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
- Options[0] := ASI;
+ Options[0] := Flag;
ApplyConfigFile(Path, Options);
- Expect(ASI.Present).ToBe(False);
+ Expect(Flag.Present).ToBe(False);
finally
- ASI.Free;
+ Flag.Free;
end;
end;
procedure TConfigFileTests.TestJSONArrayProducesMultipleEntries;
var
Dir, Path: string;
- Aliases: TGocciaRepeatableOption;
- Options: TGocciaOptionArray;
+ Aliases: TRepeatableOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
WriteTextFile(Path, '{"alias": ["@/=./src/", "config=./config.js"]}');
- Aliases := TGocciaRepeatableOption.Create('alias', 'Aliases');
+ Aliases := TRepeatableOption.Create('alias', 'Aliases');
try
SetLength(Options, 1);
Options[0] := Aliases;
@@ -345,14 +345,14 @@ procedure TConfigFileTests.TestJSONArrayProducesMultipleEntries;
procedure TConfigFileTests.TestJSONNestedObjectSkipped;
var
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
WriteTextFile(Path, '{"imports": {"@/": "./src/"}, "mode": "bytecode"}');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 1);
Options[0] := Mode;
@@ -369,14 +369,14 @@ procedure TConfigFileTests.TestJSONNestedObjectSkipped;
procedure TConfigFileTests.TestJSONNullSkipped;
var
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'test.json';
WriteTextFile(Path, '{"mode": null}');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 1);
Options[0] := Mode;
@@ -393,16 +393,16 @@ procedure TConfigFileTests.TestJSONNullSkipped;
procedure TConfigFileTests.TestApplyFlagOption;
var
- Flag: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
Options[0] := Flag;
SetLength(Entries, 1);
- Entries[0].Key := 'asi';
+ Entries[0].Key := 'feature';
Entries[0].Value := 'true';
ApplyConfigEntries(Entries, Options);
@@ -415,16 +415,16 @@ procedure TConfigFileTests.TestApplyFlagOption;
procedure TConfigFileTests.TestApplyFlagFalseNotSet;
var
- Flag: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
Options[0] := Flag;
SetLength(Entries, 1);
- Entries[0].Key := 'asi';
+ Entries[0].Key := 'feature';
Entries[0].Value := 'false';
ApplyConfigEntries(Entries, Options);
@@ -437,11 +437,11 @@ procedure TConfigFileTests.TestApplyFlagFalseNotSet;
procedure TConfigFileTests.TestApplyStringOption;
var
- Opt: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Opt: TStringOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Opt := TGocciaStringOption.Create('output', 'Output path');
+ Opt := TStringOption.Create('output', 'Output path');
try
SetLength(Options, 1);
Options[0] := Opt;
@@ -460,11 +460,11 @@ procedure TConfigFileTests.TestApplyStringOption;
procedure TConfigFileTests.TestApplyIntegerOption;
var
- Opt: TGocciaIntegerOption;
- Options: TGocciaOptionArray;
+ Opt: TIntegerOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Opt := TGocciaIntegerOption.Create('timeout', 'Timeout');
+ Opt := TIntegerOption.Create('timeout', 'Timeout');
try
SetLength(Options, 1);
Options[0] := Opt;
@@ -486,11 +486,11 @@ procedure TConfigFileTests.TestApplyIntegerOption;
procedure TConfigFileTests.TestApplyEnumOption;
var
- Opt: TGocciaEnumOption;
- Options: TGocciaOptionArray;
+ Opt: TEnumOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Opt := TGocciaEnumOption.Create('mode', 'Execution mode');
+ Opt := TEnumOption.Create('mode', 'Execution mode');
try
SetLength(Options, 1);
Options[0] := Opt;
@@ -509,11 +509,11 @@ procedure TConfigFileTests.TestApplyEnumOption;
procedure TConfigFileTests.TestApplyRepeatableOption;
var
- Opt: TGocciaRepeatableOption;
- Options: TGocciaOptionArray;
+ Opt: TRepeatableOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Opt := TGocciaRepeatableOption.Create('alias', 'Aliases');
+ Opt := TRepeatableOption.Create('alias', 'Aliases');
try
SetLength(Options, 1);
Options[0] := Opt;
@@ -536,11 +536,11 @@ procedure TConfigFileTests.TestApplyRepeatableOption;
procedure TConfigFileTests.TestApplyUnknownKeySkipped;
var
- Flag: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
Options[0] := Flag;
@@ -561,28 +561,28 @@ procedure TConfigFileTests.TestApplyUnknownKeySkipped;
procedure TConfigFileTests.TestApplyConfigFileJSON;
var
Dir, Path: string;
- ASI: TGocciaFlagOption;
- Timeout: TGocciaIntegerOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Timeout: TIntegerOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.json';
- WriteTextFile(Path, '{"asi": true, "timeout": 2000}');
+ WriteTextFile(Path, '{"feature": true, "timeout": 2000}');
- ASI := TGocciaFlagOption.Create('asi', 'ASI');
- Timeout := TGocciaIntegerOption.Create('timeout', 'Timeout');
+ Flag := TFlagOption.Create('feature', 'Flag');
+ Timeout := TIntegerOption.Create('timeout', 'Timeout');
try
SetLength(Options, 2);
- Options[0] := ASI;
+ Options[0] := Flag;
Options[1] := Timeout;
ApplyConfigFile(Path, Options);
- Expect(ASI.Present).ToBe(True);
+ Expect(Flag.Present).ToBe(True);
Expect(Timeout.Present).ToBe(True);
Expect(Timeout.Value).ToBe(2000);
finally
- ASI.Free;
+ Flag.Free;
Timeout.Free;
end;
end;
@@ -592,17 +592,17 @@ procedure TConfigFileTests.TestApplyConfigFileJSONPreservesUTF8;
JSON_BYTES = '{"mode":"Jos' + #$C3#$A9 + '","alias":["caf' + #$C3#$A9 +
'=./d' + #$C3#$A9 + 'j' + #$C3#$A0 + '.js"]}';
var
- Alias: TGocciaRepeatableOption;
+ Alias: TRepeatableOption;
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.json';
WriteRawFile(Path, JSON_BYTES);
- Alias := TGocciaRepeatableOption.Create('alias', 'Alias');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Alias := TRepeatableOption.Create('alias', 'Alias');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 2);
Options[0] := Mode;
@@ -623,15 +623,15 @@ procedure TConfigFileTests.TestApplyConfigFileJSONPreservesUTF8;
procedure TConfigFileTests.TestApplyConfigFileUnregisteredExtensionRaises;
var
Dir, Path: string;
- Flag: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
Raised: Boolean;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.xyz';
WriteTextFile(Path, 'whatever');
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
Options[0] := Flag;
@@ -655,14 +655,14 @@ procedure TConfigFileTests.TestApplyConfigFileUnregisteredExtensionRaises;
procedure TConfigFileTests.TestOptionCanBeModifiedAfterConfigApply;
var
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.json';
WriteTextFile(Path, '{"mode": "bytecode"}');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 1);
Options[0] := Mode;
@@ -682,14 +682,14 @@ procedure TConfigFileTests.TestOptionCanBeModifiedAfterConfigApply;
procedure TConfigFileTests.TestApplySkipsAlreadyPresentOption;
var
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.json';
WriteTextFile(Path, '{"mode": "bytecode"}');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 1);
Options[0] := Mode;
@@ -710,30 +710,30 @@ procedure TConfigFileTests.TestApplySkipsAlreadyPresentOption;
procedure TConfigFileTests.TestExtendsLoadsBaseConfig;
var
Dir, BasePath, ChildPath: string;
- ASI: TGocciaFlagOption;
- Timeout: TGocciaIntegerOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Timeout: TIntegerOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
BasePath := IncludeTrailingPathDelimiter(Dir) + 'base.json';
ChildPath := IncludeTrailingPathDelimiter(Dir) + 'goccia.json';
- WriteTextFile(BasePath, '{"asi": true, "timeout": 3000}');
+ WriteTextFile(BasePath, '{"feature": true, "timeout": 3000}');
WriteTextFile(ChildPath, '{"extends": "base.json"}');
- ASI := TGocciaFlagOption.Create('asi', 'ASI');
- Timeout := TGocciaIntegerOption.Create('timeout', 'Timeout');
+ Flag := TFlagOption.Create('feature', 'Flag');
+ Timeout := TIntegerOption.Create('timeout', 'Timeout');
try
SetLength(Options, 2);
- Options[0] := ASI;
+ Options[0] := Flag;
Options[1] := Timeout;
ApplyConfigFile(ChildPath, Options);
- Expect(ASI.Present).ToBe(True);
+ Expect(Flag.Present).ToBe(True);
Expect(Timeout.Present).ToBe(True);
Expect(Timeout.Value).ToBe(3000);
finally
- ASI.Free;
+ Flag.Free;
Timeout.Free;
end;
end;
@@ -741,40 +741,40 @@ procedure TConfigFileTests.TestExtendsLoadsBaseConfig;
procedure TConfigFileTests.TestExtendsChildOverridesParent;
var
Dir, BasePath, ChildPath: string;
- Mode: TGocciaStringOption;
- ASI: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Flag: TFlagOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
BasePath := IncludeTrailingPathDelimiter(Dir) + 'base.json';
ChildPath := IncludeTrailingPathDelimiter(Dir) + 'goccia.json';
- WriteTextFile(BasePath, '{"mode": "interpreted", "asi": true}');
+ WriteTextFile(BasePath, '{"mode": "interpreted", "feature": true}');
WriteTextFile(ChildPath, '{"extends": "base.json", "mode": "bytecode"}');
- Mode := TGocciaStringOption.Create('mode', 'Mode');
- ASI := TGocciaFlagOption.Create('asi', 'ASI');
+ Mode := TStringOption.Create('mode', 'Mode');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 2);
Options[0] := Mode;
- Options[1] := ASI;
+ Options[1] := Flag;
ApplyConfigFile(ChildPath, Options);
{ Child's mode overrides parent's }
Expect(Mode.Value).ToBe('bytecode');
- { Parent's asi is inherited }
- Expect(ASI.Present).ToBe(True);
+ { Parent's feature is inherited }
+ Expect(Flag.Present).ToBe(True);
finally
Mode.Free;
- ASI.Free;
+ Flag.Free;
end;
end;
procedure TConfigFileTests.TestExtendsCircularRaises;
var
Dir, PathA, PathB: string;
- Flag: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Flag: TFlagOption;
+ Options: TOptionArray;
Raised: Boolean;
begin
Dir := CreateTempDirectory;
@@ -783,7 +783,7 @@ procedure TConfigFileTests.TestExtendsCircularRaises;
WriteTextFile(PathA, '{"extends": "b.json"}');
WriteTextFile(PathB, '{"extends": "a.json"}');
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
SetLength(Options, 1);
Options[0] := Flag;
@@ -814,8 +814,8 @@ function DummyTOMLParser(const AContent: string): TConfigEntryArray;
procedure TConfigFileTests.TestRegisterAndUseCustomParser;
var
Dir, Path: string;
- Mode: TGocciaStringOption;
- Options: TGocciaOptionArray;
+ Mode: TStringOption;
+ Options: TOptionArray;
begin
Dir := CreateTempDirectory;
Path := IncludeTrailingPathDelimiter(Dir) + 'config.toml';
@@ -823,7 +823,7 @@ procedure TConfigFileTests.TestRegisterAndUseCustomParser;
RegisterConfigParser('.toml', @DummyTOMLParser);
- Mode := TGocciaStringOption.Create('mode', 'Mode');
+ Mode := TStringOption.Create('mode', 'Mode');
try
SetLength(Options, 1);
Options[0] := Mode;
@@ -905,10 +905,10 @@ procedure TConfigFileTests.TestFindConfigEntryReturnsMatch;
SetLength(Entries, 2);
Entries[0].Key := 'mode';
Entries[0].Value := 'bytecode';
- Entries[1].Key := 'asi';
+ Entries[1].Key := 'feature';
Entries[1].Value := 'true';
- Expect(FindConfigEntry(Entries, 'asi', Value)).ToBe(True);
+ Expect(FindConfigEntry(Entries, 'feature', Value)).ToBe(True);
Expect(Value).ToBe('true');
end;
@@ -943,17 +943,17 @@ procedure TConfigFileTests.TestFindConfigEntryFirstMatchWins;
procedure TConfigFileTests.TestResolveFlagOptionCLIWins;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
Flag.Apply('');
Flag.MarkFromCommandLine;
{ Per-file config says false, but CLI should win }
SetLength(FileConfig, 1);
- FileConfig[0].Key := 'asi';
+ FileConfig[0].Key := 'feature';
FileConfig[0].Value := 'false';
Expect(ResolveFlagOption(Flag, FileConfig)).ToBe(True);
@@ -964,25 +964,25 @@ procedure TConfigFileTests.TestResolveFlagOptionCLIWins;
procedure TConfigFileTests.TestResolveFlagOptionPerFileOverridesRoot;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
- Options: TGocciaOptionArray;
+ Options: TOptionArray;
RootEntries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
- { Root config sets asi='false' — ApplyConfigEntries skips Apply for
+ { Root config sets feature='false' — ApplyConfigEntries skips Apply for
flag value 'false', so Present remains False. }
SetLength(Options, 1);
Options[0] := Flag;
SetLength(RootEntries, 1);
- RootEntries[0].Key := 'asi';
+ RootEntries[0].Key := 'feature';
RootEntries[0].Value := 'false';
ApplyConfigEntries(RootEntries, Options);
{ Per-file config says true — should override root }
SetLength(FileConfig, 1);
- FileConfig[0].Key := 'asi';
+ FileConfig[0].Key := 'feature';
FileConfig[0].Value := 'true';
Expect(ResolveFlagOption(Flag, FileConfig)).ToBe(True);
@@ -993,25 +993,25 @@ procedure TConfigFileTests.TestResolveFlagOptionPerFileOverridesRoot;
procedure TConfigFileTests.TestResolveFlagOptionPerFileFalseOverridesRoot;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
- Options: TGocciaOptionArray;
+ Options: TOptionArray;
RootEntries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
- { Simulate root config setting asi=true (Present but not FromCommandLine) }
+ { Simulate root config setting feature=true (Present but not FromCommandLine) }
SetLength(Options, 1);
Options[0] := Flag;
SetLength(RootEntries, 1);
- RootEntries[0].Key := 'asi';
+ RootEntries[0].Key := 'feature';
RootEntries[0].Value := 'true';
ApplyConfigEntries(RootEntries, Options);
Expect(Flag.Present).ToBe(True);
{ Per-file config says false — should override root }
SetLength(FileConfig, 1);
- FileConfig[0].Key := 'asi';
+ FileConfig[0].Key := 'feature';
FileConfig[0].Value := 'false';
Expect(ResolveFlagOption(Flag, FileConfig)).ToBe(False);
@@ -1022,18 +1022,18 @@ procedure TConfigFileTests.TestResolveFlagOptionPerFileFalseOverridesRoot;
procedure TConfigFileTests.TestResolveFlagOptionFallsBackToRoot;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
- Options: TGocciaOptionArray;
+ Options: TOptionArray;
RootEntries: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
- { Simulate root config setting asi=true }
+ { Simulate root config setting feature=true }
SetLength(Options, 1);
Options[0] := Flag;
SetLength(RootEntries, 1);
- RootEntries[0].Key := 'asi';
+ RootEntries[0].Key := 'feature';
RootEntries[0].Value := 'true';
ApplyConfigEntries(RootEntries, Options);
@@ -1048,14 +1048,14 @@ procedure TConfigFileTests.TestResolveFlagOptionFallsBackToRoot;
procedure TConfigFileTests.TestResolveFlagOptionEmptyStringEnablesFlag;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
{ Per-file config with empty string — matches ApplyConfigEntries behavior }
SetLength(FileConfig, 1);
- FileConfig[0].Key := 'asi';
+ FileConfig[0].Key := 'feature';
FileConfig[0].Value := '';
Expect(ResolveFlagOption(Flag, FileConfig)).ToBe(True);
@@ -1066,10 +1066,10 @@ procedure TConfigFileTests.TestResolveFlagOptionEmptyStringEnablesFlag;
procedure TConfigFileTests.TestResolveFlagOptionUsesConfigName;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('enable-ffi', 'FFI');
+ Flag := TFlagOption.Create('enable-ffi', 'FFI');
try
Flag.ConfigName := 'unsafe-ffi';
SetLength(FileConfig, 1);
@@ -1085,7 +1085,7 @@ procedure TConfigFileTests.TestResolveFlagOptionUsesConfigName;
procedure TConfigFileTests.TestResolveFlagOptionMixedAliasExtendsPrecedence;
var
Dir, BasePath, ChildPath: string;
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
begin
Dir := CreateTempDirectory;
@@ -1094,7 +1094,7 @@ procedure TConfigFileTests.TestResolveFlagOptionMixedAliasExtendsPrecedence;
WriteTextFile(BasePath, '{"unsafe-ffi": true}');
WriteTextFile(ChildPath, '{"extends": "base.json", "enable-ffi": false}');
- Flag := TGocciaFlagOption.Create('enable-ffi', 'FFI');
+ Flag := TFlagOption.Create('enable-ffi', 'FFI');
try
Flag.ConfigName := 'unsafe-ffi';
FileConfig := ParseConfigFile(ChildPath);
@@ -1107,10 +1107,10 @@ procedure TConfigFileTests.TestResolveFlagOptionMixedAliasExtendsPrecedence;
procedure TConfigFileTests.TestResolveFlagOptionDefaultsFalse;
var
- Flag: TGocciaFlagOption;
+ Flag: TFlagOption;
FileConfig: TConfigEntryArray;
begin
- Flag := TGocciaFlagOption.Create('asi', 'ASI');
+ Flag := TFlagOption.Create('feature', 'Flag');
try
{ No CLI, no root config, no per-file config — should default to False }
SetLength(FileConfig, 0);
diff --git a/source/shared/CLI.ConfigFile.pas b/source/shared/CLI.ConfigFile.pas
index 2b656700..c499ea0d 100644
--- a/source/shared/CLI.ConfigFile.pas
+++ b/source/shared/CLI.ConfigFile.pas
@@ -37,7 +37,7 @@ procedure RegisterConfigParser(const AExtension: string;
Flag options are only set when the value is 'true' or empty.
For repeatable options, values are accumulated even when Present. }
procedure ApplyConfigEntries(const AEntries: TConfigEntryArray;
- const AOptions: TGocciaOptionArray);
+ const AOptions: TOptionArray);
{ Parse a configuration file and return its entries without
applying them. Handles the "extends" key: if present, the
@@ -55,7 +55,7 @@ function ParseConfigFile(const APath: string): TConfigEntryArray;
by a built-in parser; other formats require prior registration
via RegisterConfigParser. }
procedure ApplyConfigFile(const APath: string;
- const AOptions: TGocciaOptionArray);
+ const AOptions: TOptionArray);
{ Walk up from AStartDirectory looking for a configuration file.
At each directory level, tries every combination of
@@ -78,7 +78,7 @@ function FindConfigEntry(const AEntries: TConfigEntryArray;
default (False). AFlag is the parsed option and AFileConfig the
per-file config entries. The config key is resolved from the
option metadata, checking ConfigName before LongName. }
-function ResolveFlagOption(const AFlag: TGocciaFlagOption;
+function ResolveFlagOption(const AFlag: TFlagOption;
const AFileConfig: TConfigEntryArray): Boolean;
implementation
@@ -292,8 +292,8 @@ function ParseJSONConfig(const AContent: string): TConfigEntryArray;
{ ── Apply entries to options ───────────────────────────────── }
-function FindOptionByName(const AOptions: TGocciaOptionArray;
- const AName: string): TGocciaOptionBase;
+function FindOptionByName(const AOptions: TOptionArray;
+ const AName: string): TOptionBase;
var
I: Integer;
begin
@@ -306,7 +306,7 @@ function FindOptionByName(const AOptions: TGocciaOptionArray;
end;
function FindOptionConfigEntry(const AEntries: TConfigEntryArray;
- const AOption: TGocciaOptionBase; out AValue: string): Boolean;
+ const AOption: TOptionBase; out AValue: string): Boolean;
var
I: Integer;
begin
@@ -322,10 +322,10 @@ function FindOptionConfigEntry(const AEntries: TConfigEntryArray;
end;
procedure ApplyConfigEntries(const AEntries: TConfigEntryArray;
- const AOptions: TGocciaOptionArray);
+ const AOptions: TOptionArray);
var
I: Integer;
- Option: TGocciaOptionBase;
+ Option: TOptionBase;
begin
for I := 0 to High(AEntries) do
begin
@@ -339,21 +339,21 @@ procedure ApplyConfigEntries(const AEntries: TConfigEntryArray;
them or when the child config explicitly set an empty array
(Present with zero values). }
if Option.Present and
- (not (Option is TGocciaRepeatableOption) or
+ (not (Option is TRepeatableOption) or
Option.FromCommandLine or
- (TGocciaRepeatableOption(Option).Values.Count = 0)) then
+ (TRepeatableOption(Option).Values.Count = 0)) then
Continue;
{ Empty-array sentinel: mark the option as present so the
explicit empty override is visible, but do not add a value. }
- if (Option is TGocciaRepeatableOption) and
+ if (Option is TRepeatableOption) and
(AEntries[I].Value = '') then
begin
Option.MarkPresent;
Continue;
end;
- if Option is TGocciaFlagOption then
+ if Option is TFlagOption then
begin
if (AEntries[I].Value = 'true') or (AEntries[I].Value = '') then
Option.Apply('');
@@ -464,7 +464,7 @@ function ParseConfigFile(const APath: string): TConfigEntryArray;
end;
procedure ApplyConfigFile(const APath: string;
- const AOptions: TGocciaOptionArray);
+ const AOptions: TOptionArray);
var
Entries: TConfigEntryArray;
begin
@@ -532,7 +532,7 @@ function FindConfigEntry(const AEntries: TConfigEntryArray;
{ ── Flag resolution ────────────────────────────────────────── }
-function ResolveFlagOption(const AFlag: TGocciaFlagOption;
+function ResolveFlagOption(const AFlag: TFlagOption;
const AFileConfig: TConfigEntryArray): Boolean;
var
ValueStr: string;
diff --git a/source/shared/CLI.Options.pas b/source/shared/CLI.Options.pas
index ba77204e..496174e8 100644
--- a/source/shared/CLI.Options.pas
+++ b/source/shared/CLI.Options.pas
@@ -11,9 +11,9 @@ interface
TypInfo;
type
- TGocciaParseError = class(Exception);
+ TParseError = class(Exception);
- TGocciaOptionBase = class
+ TOptionBase = class
private
FLongName: string;
FShortName: string;
@@ -26,6 +26,7 @@ TGocciaOptionBase = class
constructor Create(const ALongName, AHelpText: string; const AGroup: string = '');
procedure Apply(const AValue: string); virtual; abstract;
+ function ConsumesSeparateValue: Boolean; virtual;
function FormatForHelp: string; virtual; abstract;
function ValidValues: string; virtual;
@@ -33,7 +34,7 @@ TGocciaOptionBase = class
Used by the config layer to record that a key existed in the
config file even when no concrete values were produced (e.g.
an empty array). }
- procedure MarkPresent;
+ procedure MarkPresent; virtual;
{ Mark this option as having been set by the command line.
Called after ParseCommandLine so that per-file config can
@@ -51,19 +52,21 @@ TGocciaOptionBase = class
property FromCommandLine: Boolean read FFromCommandLine;
end;
- TGocciaOptionArray = array of TGocciaOptionBase;
+ TOptionArray = array of TOptionBase;
- TGocciaFlagOption = class(TGocciaOptionBase)
+ TFlagOption = class(TOptionBase)
public
procedure Apply(const AValue: string); override;
function FormatForHelp: string; override;
end;
- TGocciaStringOption = class(TGocciaOptionBase)
+ TStringOption = class(TOptionBase)
private
FValue: string;
public
+ procedure MarkPresent; override;
procedure Apply(const AValue: string); override;
+ function ConsumesSeparateValue: Boolean; override;
function FormatForHelp: string; override;
function ValueOr(const ADefault: string): string;
@@ -71,11 +74,18 @@ TGocciaStringOption = class(TGocciaOptionBase)
property Value: string read FValue;
end;
- TGocciaIntegerOption = class(TGocciaOptionBase)
+ TOptionalStringOption = class(TStringOption)
+ public
+ function ConsumesSeparateValue: Boolean; override;
+ function FormatForHelp: string; override;
+ end;
+
+ TIntegerOption = class(TOptionBase)
private
FValue: Integer;
public
procedure Apply(const AValue: string); override;
+ function ConsumesSeparateValue: Boolean; override;
function FormatForHelp: string; override;
function ValueOr(const ADefault: Integer): Integer;
@@ -83,11 +93,12 @@ TGocciaIntegerOption = class(TGocciaOptionBase)
property Value: Integer read FValue;
end;
- TGocciaInt64Option = class(TGocciaOptionBase)
+ TInt64Option = class(TOptionBase)
private
FValue: Int64;
public
procedure Apply(const AValue: string); override;
+ function ConsumesSeparateValue: Boolean; override;
function FormatForHelp: string; override;
function ValueOr(const ADefault: Int64): Int64;
@@ -95,7 +106,7 @@ TGocciaInt64Option = class(TGocciaOptionBase)
property Value: Int64 read FValue;
end;
- TGocciaRepeatableOption = class(TGocciaOptionBase)
+ TRepeatableOption = class(TOptionBase)
private
FValues: TStringList;
public
@@ -103,12 +114,13 @@ TGocciaRepeatableOption = class(TGocciaOptionBase)
destructor Destroy; override;
procedure Apply(const AValue: string); override;
+ function ConsumesSeparateValue: Boolean; override;
function FormatForHelp: string; override;
property Values: TStringList read FValues;
end;
- TGocciaEnumOption = class(TGocciaOptionBase)
+ TEnumOption = class(TOptionBase)
private
FOrdinal: Integer;
FPrefixLength: Integer;
@@ -118,6 +130,7 @@ TGocciaEnumOption = class(TGocciaOptionBase)
const APrefixLength: Integer = 2);
procedure Apply(const AValue: string); override;
+ function ConsumesSeparateValue: Boolean; override;
function FormatForHelp: string; override;
function ValidValues: string; override;
@@ -126,125 +139,35 @@ TGocciaEnumOption = class(TGocciaOptionBase)
function Matches(const AValue: T): Boolean;
end;
- TGocciaOptionBaseList = TObjectList;
+ TOptionBaseList = TObjectList;
- TGocciaOptionList = class
+ TOptionList = class
private
- FItems: TGocciaOptionBaseList;
+ FItems: TOptionBaseList;
public
constructor Create;
destructor Destroy; override;
function AddFlag(const ALongName, AHelpText: string;
- const AGroup: string = ''): TGocciaFlagOption;
+ const AGroup: string = ''): TFlagOption;
function AddString(const ALongName, AHelpText: string;
- const AGroup: string = ''): TGocciaStringOption;
+ const AGroup: string = ''): TStringOption;
function AddInteger(const ALongName, AHelpText: string;
- const AGroup: string = ''): TGocciaIntegerOption;
+ const AGroup: string = ''): TIntegerOption;
function AddRepeatable(const ALongName, AHelpText: string;
- const AGroup: string = ''): TGocciaRepeatableOption;
- function Add(const AOption: TGocciaOptionBase): TGocciaOptionBase;
-
- function Options: TGocciaOptionArray;
- end;
-
- TGocciaExecutionMode = (emInterpreted, emBytecode);
- TGocciaSourceType = (stScript, stModule);
-
- TGocciaEngineOptions = class
- private
- FMode: TGocciaEnumOption;
- FSourceType: TGocciaEnumOption;
- FASI: TGocciaFlagOption;
- FImportMap: TGocciaStringOption;
- FAliases: TGocciaRepeatableOption;
- FTimeout: TGocciaIntegerOption;
- FMaxMemory: TGocciaInt64Option;
- FMaxInstructions: TGocciaInt64Option;
- FUnsafeFFI: TGocciaFlagOption;
- FUnsafeFunctionConstructor: TGocciaFlagOption;
- FStackSize: TGocciaIntegerOption;
- FCompatVar: TGocciaFlagOption;
- FCompatFunction: TGocciaFlagOption;
- FCompatTraditionalFor: TGocciaFlagOption;
- FCompatWhileLoops: TGocciaFlagOption;
- FCompatLooseEquality: TGocciaFlagOption;
- FCompatNonStrictMode: TGocciaFlagOption;
- FStrictTypes: TGocciaFlagOption;
- FAllowedHosts: TGocciaRepeatableOption;
- FInspectDepth: TGocciaIntegerOption;
- public
- constructor Create;
- destructor Destroy; override;
-
- function Options: TGocciaOptionArray;
-
- property Mode: TGocciaEnumOption read FMode;
- property SourceType: TGocciaEnumOption read FSourceType;
- property ASI: TGocciaFlagOption read FASI;
- property ImportMap: TGocciaStringOption read FImportMap;
- property Aliases: TGocciaRepeatableOption read FAliases;
- property Timeout: TGocciaIntegerOption read FTimeout;
- property MaxMemory: TGocciaInt64Option read FMaxMemory;
- property MaxInstructions: TGocciaInt64Option read FMaxInstructions;
- property UnsafeFFI: TGocciaFlagOption read FUnsafeFFI;
- property UnsafeFunctionConstructor: TGocciaFlagOption read FUnsafeFunctionConstructor;
- property StackSize: TGocciaIntegerOption read FStackSize;
- property CompatVar: TGocciaFlagOption read FCompatVar;
- property CompatFunction: TGocciaFlagOption read FCompatFunction;
- property CompatTraditionalFor: TGocciaFlagOption read FCompatTraditionalFor;
- property CompatWhileLoops: TGocciaFlagOption read FCompatWhileLoops;
- property CompatLooseEquality: TGocciaFlagOption read FCompatLooseEquality;
- property CompatNonStrictMode: TGocciaFlagOption read FCompatNonStrictMode;
- property StrictTypes: TGocciaFlagOption read FStrictTypes;
- property AllowedHosts: TGocciaRepeatableOption read FAllowedHosts;
- property InspectDepth: TGocciaIntegerOption read FInspectDepth;
- end;
-
- TGocciaCoverageFormat = (cfLcov, cfJson);
-
- TGocciaCoverageOptions = class
- private
- FEnabled: TGocciaFlagOption;
- FFormat: TGocciaEnumOption;
- FOutputPath: TGocciaStringOption;
- public
- constructor Create;
- destructor Destroy; override;
-
- function Options: TGocciaOptionArray;
-
- property Enabled: TGocciaFlagOption read FEnabled;
- property Format: TGocciaEnumOption read FFormat;
- property OutputPath: TGocciaStringOption read FOutputPath;
- end;
+ const AGroup: string = ''): TRepeatableOption;
+ function Add(const AOption: TOptionBase): TOptionBase;
- TGocciaProfileMode = (pmOpcodes, pmFunctions, pmAll);
- TGocciaProfileFormat = (pfFlamegraph);
-
- TGocciaProfilerOptions = class
- private
- FMode: TGocciaEnumOption;
- FOutputPath: TGocciaStringOption;
- FFormat: TGocciaEnumOption;
- public
- constructor Create;
- destructor Destroy; override;
-
- function Options: TGocciaOptionArray;
-
- property Mode: TGocciaEnumOption read FMode;
- property OutputPath: TGocciaStringOption read FOutputPath;
- property Format: TGocciaEnumOption read FFormat;
+ function Options: TOptionArray;
end;
-function ConcatOptions(const AArrays: array of TGocciaOptionArray): TGocciaOptionArray;
+function ConcatOptions(const AArrays: array of TOptionArray): TOptionArray;
implementation
{ ConcatOptions }
-function ConcatOptions(const AArrays: array of TGocciaOptionArray): TGocciaOptionArray;
+function ConcatOptions(const AArrays: array of TOptionArray): TOptionArray;
var
TotalLength: Integer;
I, J, Offset: Integer;
@@ -263,9 +186,9 @@ function ConcatOptions(const AArrays: array of TGocciaOptionArray): TGocciaOptio
end;
end;
-{ TGocciaOptionBase }
+{ TOptionBase }
-constructor TGocciaOptionBase.Create(const ALongName, AHelpText: string;
+constructor TOptionBase.Create(const ALongName, AHelpText: string;
const AGroup: string);
begin
inherited Create;
@@ -278,47 +201,58 @@ constructor TGocciaOptionBase.Create(const ALongName, AHelpText: string;
FFromCommandLine := False;
end;
-procedure TGocciaOptionBase.MarkFromCommandLine;
+procedure TOptionBase.MarkFromCommandLine;
begin
FFromCommandLine := True;
end;
-procedure TGocciaOptionBase.MarkPresent;
+procedure TOptionBase.MarkPresent;
begin
FPresent := True;
end;
-function TGocciaOptionBase.ValidValues: string;
+function TOptionBase.ValidValues: string;
begin
Result := '';
end;
-{ TGocciaFlagOption }
+function TOptionBase.ConsumesSeparateValue: Boolean;
+begin
+ Result := False;
+end;
+
+{ TFlagOption }
-procedure TGocciaFlagOption.Apply(const AValue: string);
+procedure TFlagOption.Apply(const AValue: string);
begin
FPresent := True;
end;
-function TGocciaFlagOption.FormatForHelp: string;
+function TFlagOption.FormatForHelp: string;
begin
Result := '--' + LongName;
end;
-{ TGocciaStringOption }
+{ TStringOption }
-procedure TGocciaStringOption.Apply(const AValue: string);
+procedure TStringOption.MarkPresent;
+begin
+ FValue := '';
+ inherited MarkPresent;
+end;
+
+procedure TStringOption.Apply(const AValue: string);
begin
FValue := AValue;
FPresent := True;
end;
-function TGocciaStringOption.FormatForHelp: string;
+function TStringOption.FormatForHelp: string;
begin
Result := '--' + LongName + '=';
end;
-function TGocciaStringOption.ValueOr(const ADefault: string): string;
+function TStringOption.ValueOr(const ADefault: string): string;
begin
if FPresent then
Result := FValue
@@ -326,25 +260,42 @@ function TGocciaStringOption.ValueOr(const ADefault: string): string;
Result := ADefault;
end;
-{ TGocciaIntegerOption }
+function TStringOption.ConsumesSeparateValue: Boolean;
+begin
+ Result := True;
+end;
+
+{ TOptionalStringOption }
+
+function TOptionalStringOption.ConsumesSeparateValue: Boolean;
+begin
+ Result := False;
+end;
+
+function TOptionalStringOption.FormatForHelp: string;
+begin
+ Result := '--' + LongName + '[=]';
+end;
+
+{ TIntegerOption }
-procedure TGocciaIntegerOption.Apply(const AValue: string);
+procedure TIntegerOption.Apply(const AValue: string);
var
Parsed: Integer;
begin
if not TryStrToInt(AValue, Parsed) then
- raise TGocciaParseError.CreateFmt('Invalid integer value for --%s: %s',
+ raise TParseError.CreateFmt('Invalid integer value for --%s: %s',
[LongName, AValue]);
FValue := Parsed;
FPresent := True;
end;
-function TGocciaIntegerOption.FormatForHelp: string;
+function TIntegerOption.FormatForHelp: string;
begin
Result := '--' + LongName + '=';
end;
-function TGocciaIntegerOption.ValueOr(const ADefault: Integer): Integer;
+function TIntegerOption.ValueOr(const ADefault: Integer): Integer;
begin
if FPresent then
Result := FValue
@@ -352,25 +303,30 @@ function TGocciaIntegerOption.ValueOr(const ADefault: Integer): Integer;
Result := ADefault;
end;
-{ TGocciaInt64Option }
+function TIntegerOption.ConsumesSeparateValue: Boolean;
+begin
+ Result := True;
+end;
+
+{ TInt64Option }
-procedure TGocciaInt64Option.Apply(const AValue: string);
+procedure TInt64Option.Apply(const AValue: string);
var
Parsed: Int64;
begin
if not TryStrToInt64(AValue, Parsed) then
- raise TGocciaParseError.CreateFmt('Invalid integer value for --%s: %s',
+ raise TParseError.CreateFmt('Invalid integer value for --%s: %s',
[LongName, AValue]);
FValue := Parsed;
FPresent := True;
end;
-function TGocciaInt64Option.FormatForHelp: string;
+function TInt64Option.FormatForHelp: string;
begin
Result := '--' + LongName + '=';
end;
-function TGocciaInt64Option.ValueOr(const ADefault: Int64): Int64;
+function TInt64Option.ValueOr(const ADefault: Int64): Int64;
begin
if FPresent then
Result := FValue
@@ -378,35 +334,45 @@ function TGocciaInt64Option.ValueOr(const ADefault: Int64): Int64;
Result := ADefault;
end;
-{ TGocciaRepeatableOption }
+function TInt64Option.ConsumesSeparateValue: Boolean;
+begin
+ Result := True;
+end;
+
+{ TRepeatableOption }
-constructor TGocciaRepeatableOption.Create(const ALongName, AHelpText: string;
+constructor TRepeatableOption.Create(const ALongName, AHelpText: string;
const AGroup: string);
begin
inherited Create(ALongName, AHelpText, AGroup);
FValues := TStringList.Create;
end;
-destructor TGocciaRepeatableOption.Destroy;
+destructor TRepeatableOption.Destroy;
begin
FValues.Free;
inherited Destroy;
end;
-procedure TGocciaRepeatableOption.Apply(const AValue: string);
+procedure TRepeatableOption.Apply(const AValue: string);
begin
FValues.Add(AValue);
FPresent := True;
end;
-function TGocciaRepeatableOption.FormatForHelp: string;
+function TRepeatableOption.FormatForHelp: string;
begin
Result := '--' + LongName + ' ';
end;
-{ TGocciaEnumOption }
+function TRepeatableOption.ConsumesSeparateValue: Boolean;
+begin
+ Result := True;
+end;
+
+{ TEnumOption }
-constructor TGocciaEnumOption.Create(const ALongName, AHelpText: string;
+constructor TEnumOption.Create(const ALongName, AHelpText: string;
const AGroup: string; const APrefixLength: Integer);
begin
inherited Create(ALongName, AHelpText, AGroup);
@@ -414,7 +380,7 @@ constructor TGocciaEnumOption.Create(const ALongName, AHelpText: string;
FPrefixLength := APrefixLength;
end;
-function TGocciaEnumOption.JoinStrippedNames(
+function TEnumOption.JoinStrippedNames(
const ASeparator: string): string;
var
TypeData: PTypeData;
@@ -435,7 +401,7 @@ function TGocciaEnumOption.JoinStrippedNames(
end;
end;
-procedure TGocciaEnumOption.Apply(const AValue: string);
+procedure TEnumOption.Apply(const AValue: string);
var
TypeData: PTypeData;
I: Integer;
@@ -457,16 +423,16 @@ procedure TGocciaEnumOption.Apply(const AValue: string);
end;
end;
- raise TGocciaParseError.CreateFmt('Invalid value for --%s: %s (valid: %s)',
+ raise TParseError.CreateFmt('Invalid value for --%s: %s (valid: %s)',
[LongName, AValue, JoinStrippedNames(', ')]);
end;
-function TGocciaEnumOption.Value: T;
+function TEnumOption.Value: T;
begin
Move(FOrdinal, Result, SizeOf(T));
end;
-function TGocciaEnumOption.ValueOr(const ADefault: T): T;
+function TEnumOption.ValueOr(const ADefault: T): T;
begin
if FPresent then
Result := Value
@@ -474,7 +440,7 @@ function TGocciaEnumOption.ValueOr(const ADefault: T): T;
Result := ADefault;
end;
-function TGocciaEnumOption.Matches(const AValue: T): Boolean;
+function TEnumOption.Matches(const AValue: T): Boolean;
var
OrdinalValue: Integer;
begin
@@ -483,65 +449,70 @@ function TGocciaEnumOption.Matches(const AValue: T): Boolean;
Result := FPresent and (FOrdinal = OrdinalValue);
end;
-function TGocciaEnumOption.ValidValues: string;
+function TEnumOption.ValidValues: string;
begin
Result := JoinStrippedNames(', ');
end;
-function TGocciaEnumOption.FormatForHelp: string;
+function TEnumOption.FormatForHelp: string;
begin
Result := '--' + LongName + '=' + JoinStrippedNames('|');
end;
-{ TGocciaOptionList }
+function TEnumOption.ConsumesSeparateValue: Boolean;
+begin
+ Result := True;
+end;
+
+{ TOptionList }
-constructor TGocciaOptionList.Create;
+constructor TOptionList.Create;
begin
inherited Create;
- FItems := TGocciaOptionBaseList.Create(True);
+ FItems := TOptionBaseList.Create(True);
end;
-destructor TGocciaOptionList.Destroy;
+destructor TOptionList.Destroy;
begin
FItems.Free;
inherited Destroy;
end;
-function TGocciaOptionList.AddFlag(const ALongName, AHelpText: string;
- const AGroup: string): TGocciaFlagOption;
+function TOptionList.AddFlag(const ALongName, AHelpText: string;
+ const AGroup: string): TFlagOption;
begin
- Result := TGocciaFlagOption.Create(ALongName, AHelpText, AGroup);
+ Result := TFlagOption.Create(ALongName, AHelpText, AGroup);
FItems.Add(Result);
end;
-function TGocciaOptionList.AddString(const ALongName, AHelpText: string;
- const AGroup: string): TGocciaStringOption;
+function TOptionList.AddString(const ALongName, AHelpText: string;
+ const AGroup: string): TStringOption;
begin
- Result := TGocciaStringOption.Create(ALongName, AHelpText, AGroup);
+ Result := TStringOption.Create(ALongName, AHelpText, AGroup);
FItems.Add(Result);
end;
-function TGocciaOptionList.AddInteger(const ALongName, AHelpText: string;
- const AGroup: string): TGocciaIntegerOption;
+function TOptionList.AddInteger(const ALongName, AHelpText: string;
+ const AGroup: string): TIntegerOption;
begin
- Result := TGocciaIntegerOption.Create(ALongName, AHelpText, AGroup);
+ Result := TIntegerOption.Create(ALongName, AHelpText, AGroup);
FItems.Add(Result);
end;
-function TGocciaOptionList.AddRepeatable(const ALongName, AHelpText: string;
- const AGroup: string): TGocciaRepeatableOption;
+function TOptionList.AddRepeatable(const ALongName, AHelpText: string;
+ const AGroup: string): TRepeatableOption;
begin
- Result := TGocciaRepeatableOption.Create(ALongName, AHelpText, AGroup);
+ Result := TRepeatableOption.Create(ALongName, AHelpText, AGroup);
FItems.Add(Result);
end;
-function TGocciaOptionList.Add(const AOption: TGocciaOptionBase): TGocciaOptionBase;
+function TOptionList.Add(const AOption: TOptionBase): TOptionBase;
begin
FItems.Add(AOption);
Result := AOption;
end;
-function TGocciaOptionList.Options: TGocciaOptionArray;
+function TOptionList.Options: TOptionArray;
var
I: Integer;
begin
@@ -550,160 +521,4 @@ function TGocciaOptionList.Options: TGocciaOptionArray;
Result[I] := FItems[I];
end;
-{ TGocciaEngineOptions }
-
-constructor TGocciaEngineOptions.Create;
-begin
- inherited Create;
- FMode := TGocciaEnumOption.Create('mode',
- 'Execution mode', 'Engine');
- FSourceType := TGocciaEnumOption.Create('source-type',
- 'Source loading kind (default: script)', 'Engine');
- FASI := TGocciaFlagOption.Create('asi',
- 'Enable automatic semicolon insertion', 'Engine');
- FImportMap := TGocciaStringOption.Create('import-map',
- 'Path to import map JSON file', 'Engine');
- FAliases := TGocciaRepeatableOption.Create('alias',
- 'Import alias (e.g. @/=./src/)', 'Engine');
- FTimeout := TGocciaIntegerOption.Create('timeout',
- 'Per-file timeout in milliseconds', 'Engine');
- FMaxMemory := TGocciaInt64Option.Create('max-memory',
- 'GC heap byte limit (RangeError on exceed)', 'Engine');
- FMaxInstructions := TGocciaInt64Option.Create('max-instructions',
- 'Maximum execution steps before aborting', 'Engine');
- FUnsafeFFI := TGocciaFlagOption.Create('unsafe-ffi',
- 'Enable the FFI global (foreign function interface)', 'Runtime');
- FUnsafeFunctionConstructor := TGocciaFlagOption.Create('unsafe-function-constructor',
- 'Enable the Function constructor (dynamic code generation)', 'Engine');
- FStackSize := TGocciaIntegerOption.Create('stack-size',
- 'Maximum call stack depth (0 = no limit)', 'Engine');
- FCompatVar := TGocciaFlagOption.Create('compat-var',
- 'Enable var declarations (compatibility)', 'Engine');
- FCompatFunction := TGocciaFlagOption.Create('compat-function',
- 'Enable function declarations and expressions (compatibility)', 'Engine');
- FCompatTraditionalFor := TGocciaFlagOption.Create('compat-traditional-for-loop',
- 'Enable traditional C-style for(init; test; update) loops (compatibility)', 'Engine');
- FCompatWhileLoops := TGocciaFlagOption.Create('compat-while-loops',
- 'Enable while and do...while loops (compatibility)', 'Engine');
- FCompatLooseEquality := TGocciaFlagOption.Create('compat-loose-equality',
- 'Enable loose equality and inequality (== and !=) (compatibility)', 'Engine');
- FCompatNonStrictMode := TGocciaFlagOption.Create('compat-non-strict-mode',
- 'Enable non-strict-mode compatibility semantics', 'Engine');
- FStrictTypes := TGocciaFlagOption.Create('strict-types',
- 'Enforce type annotations at runtime (interpreter and bytecode)', 'Engine');
- FAllowedHosts := TGocciaRepeatableOption.Create('allowed-host',
- 'Hostname allowed for fetch requests (repeatable)', 'Engine');
- FAllowedHosts.ConfigName := 'allowed-hosts';
- FInspectDepth := TGocciaIntegerOption.Create('inspect-depth',
- 'Maximum object inspection depth for console output (default: 5)', 'Engine');
-end;
-
-destructor TGocciaEngineOptions.Destroy;
-begin
- FMode.Free;
- FSourceType.Free;
- FASI.Free;
- FImportMap.Free;
- FAliases.Free;
- FTimeout.Free;
- FMaxMemory.Free;
- FMaxInstructions.Free;
- FUnsafeFFI.Free;
- FUnsafeFunctionConstructor.Free;
- FStackSize.Free;
- FCompatVar.Free;
- FCompatFunction.Free;
- FCompatTraditionalFor.Free;
- FCompatWhileLoops.Free;
- FCompatLooseEquality.Free;
- FCompatNonStrictMode.Free;
- FStrictTypes.Free;
- FAllowedHosts.Free;
- FInspectDepth.Free;
- inherited Destroy;
-end;
-
-function TGocciaEngineOptions.Options: TGocciaOptionArray;
-begin
- SetLength(Result, 20);
- Result[0] := FMode;
- Result[1] := FSourceType;
- Result[2] := FASI;
- Result[3] := FImportMap;
- Result[4] := FAliases;
- Result[5] := FTimeout;
- Result[6] := FMaxMemory;
- Result[7] := FMaxInstructions;
- Result[8] := FUnsafeFFI;
- Result[9] := FUnsafeFunctionConstructor;
- Result[10] := FStackSize;
- Result[11] := FCompatVar;
- Result[12] := FCompatFunction;
- Result[13] := FCompatTraditionalFor;
- Result[14] := FCompatWhileLoops;
- Result[15] := FCompatLooseEquality;
- Result[16] := FCompatNonStrictMode;
- Result[17] := FStrictTypes;
- Result[18] := FAllowedHosts;
- Result[19] := FInspectDepth;
-end;
-
-{ TGocciaCoverageOptions }
-
-constructor TGocciaCoverageOptions.Create;
-begin
- inherited Create;
- FEnabled := TGocciaFlagOption.Create('coverage',
- 'Enable line and branch coverage', 'Coverage');
- FFormat := TGocciaEnumOption.Create('coverage-format',
- 'Coverage output format', 'Coverage');
- FOutputPath := TGocciaStringOption.Create('coverage-output',
- 'Coverage output file path', 'Coverage');
-end;
-
-destructor TGocciaCoverageOptions.Destroy;
-begin
- FEnabled.Free;
- FFormat.Free;
- FOutputPath.Free;
- inherited Destroy;
-end;
-
-function TGocciaCoverageOptions.Options: TGocciaOptionArray;
-begin
- SetLength(Result, 3);
- Result[0] := FEnabled;
- Result[1] := FFormat;
- Result[2] := FOutputPath;
-end;
-
-{ TGocciaProfilerOptions }
-
-constructor TGocciaProfilerOptions.Create;
-begin
- inherited Create;
- FMode := TGocciaEnumOption.Create('profile',
- 'Profiling mode', 'Profiler');
- FOutputPath := TGocciaStringOption.Create('profile-output',
- 'Profile output file path', 'Profiler');
- FFormat := TGocciaEnumOption.Create('profile-format',
- 'Profile output format', 'Profiler');
-end;
-
-destructor TGocciaProfilerOptions.Destroy;
-begin
- FMode.Free;
- FOutputPath.Free;
- FFormat.Free;
- inherited Destroy;
-end;
-
-function TGocciaProfilerOptions.Options: TGocciaOptionArray;
-begin
- SetLength(Result, 3);
- Result[0] := FMode;
- Result[1] := FOutputPath;
- Result[2] := FFormat;
-end;
-
end.
diff --git a/source/shared/CLI.Parser.Test.pas b/source/shared/CLI.Parser.Test.pas
index a2da18a8..38701717 100644
--- a/source/shared/CLI.Parser.Test.pas
+++ b/source/shared/CLI.Parser.Test.pas
@@ -3,11 +3,13 @@
{$I Shared.inc}
uses
+ Classes,
SysUtils,
TypInfo,
CLI.ConfigFile,
CLI.Options,
+ CLI.Parser,
TestingPascalLibrary,
Goccia.CLI.Help;
@@ -24,6 +26,9 @@ TCLIOptionsTests = class(TTestSuite)
procedure TestStringOptionApply;
procedure TestStringOptionValueOrWhenPresent;
procedure TestStringOptionValueOrWhenAbsent;
+ procedure TestStringOptionMarkPresentClearsValue;
+ procedure TestOptionalStringOptionParsing;
+ procedure TestRequiredValueOptionAcceptsDashPrefixedValues;
procedure TestIntegerOptionApply;
procedure TestIntegerOptionValueOrWhenPresent;
procedure TestIntegerOptionValueOrWhenAbsent;
@@ -51,14 +56,17 @@ procedure TCLIOptionsTests.SetupTests;
Test('StringOption.Apply stores the value', TestStringOptionApply);
Test('StringOption.ValueOr returns value when present', TestStringOptionValueOrWhenPresent);
Test('StringOption.ValueOr returns default when absent', TestStringOptionValueOrWhenAbsent);
+ Test('StringOption.MarkPresent clears existing value', TestStringOptionMarkPresentClearsValue);
+ Test('OptionalStringOption parsing keeps positionals', TestOptionalStringOptionParsing);
+ Test('Required value option accepts dash-prefixed values', TestRequiredValueOptionAcceptsDashPrefixedValues);
Test('IntegerOption.Apply parses integer value', TestIntegerOptionApply);
Test('IntegerOption.ValueOr returns value when present', TestIntegerOptionValueOrWhenPresent);
Test('IntegerOption.ValueOr returns default when absent', TestIntegerOptionValueOrWhenAbsent);
- Test('IntegerOption.Apply raises TGocciaParseError for non-integer', TestIntegerOptionInvalidValue);
+ Test('IntegerOption.Apply raises TParseError for non-integer', TestIntegerOptionInvalidValue);
Test('RepeatableOption accumulates multiple values', TestRepeatableOptionMultipleValues);
Test('EnumOption applies first value', TestEnumOptionFirstValue);
Test('EnumOption applies second value', TestEnumOptionSecondValue);
- Test('EnumOption raises TGocciaParseError for invalid value', TestEnumOptionInvalidValue);
+ Test('EnumOption raises TParseError for invalid value', TestEnumOptionInvalidValue);
Test('EnumOption.ValidValues returns comma-separated list', TestEnumOptionValidValues);
Test('EnumOption.FormatForHelp returns pipe-separated values', TestEnumOptionFormatForHelp);
Test('OptionList tracks added options', TestOptionListAddFlagAndString);
@@ -69,13 +77,13 @@ procedure TCLIOptionsTests.SetupTests;
Test('Config-applied option has Present but not FromCommandLine', TestConfigAppliedOptionNotFromCommandLine);
end;
-{ TGocciaFlagOption tests }
+{ TFlagOption tests }
procedure TCLIOptionsTests.TestFlagOptionNotPresentInitially;
var
- Opt: TGocciaFlagOption;
+ Opt: TFlagOption;
begin
- Opt := TGocciaFlagOption.Create('verbose', 'Enable verbose output');
+ Opt := TFlagOption.Create('verbose', 'Enable verbose output');
try
Expect(Opt.Present).ToBe(False);
finally
@@ -85,9 +93,9 @@ procedure TCLIOptionsTests.TestFlagOptionNotPresentInitially;
procedure TCLIOptionsTests.TestFlagOptionApply;
var
- Opt: TGocciaFlagOption;
+ Opt: TFlagOption;
begin
- Opt := TGocciaFlagOption.Create('verbose', 'Enable verbose output');
+ Opt := TFlagOption.Create('verbose', 'Enable verbose output');
try
Opt.Apply('');
Expect(Opt.Present).ToBe(True);
@@ -96,13 +104,13 @@ procedure TCLIOptionsTests.TestFlagOptionApply;
end;
end;
-{ TGocciaStringOption tests }
+{ TStringOption tests }
procedure TCLIOptionsTests.TestStringOptionApply;
var
- Opt: TGocciaStringOption;
+ Opt: TStringOption;
begin
- Opt := TGocciaStringOption.Create('output', 'Output path');
+ Opt := TStringOption.Create('output', 'Output path');
try
Opt.Apply('hello');
Expect(Opt.Present).ToBe(True);
@@ -114,9 +122,9 @@ procedure TCLIOptionsTests.TestStringOptionApply;
procedure TCLIOptionsTests.TestStringOptionValueOrWhenPresent;
var
- Opt: TGocciaStringOption;
+ Opt: TStringOption;
begin
- Opt := TGocciaStringOption.Create('output', 'Output path');
+ Opt := TStringOption.Create('output', 'Output path');
try
Opt.Apply('hello');
Expect(Opt.ValueOr('fallback')).ToBe('hello');
@@ -127,9 +135,9 @@ procedure TCLIOptionsTests.TestStringOptionValueOrWhenPresent;
procedure TCLIOptionsTests.TestStringOptionValueOrWhenAbsent;
var
- Opt: TGocciaStringOption;
+ Opt: TStringOption;
begin
- Opt := TGocciaStringOption.Create('output', 'Output path');
+ Opt := TStringOption.Create('output', 'Output path');
try
Expect(Opt.ValueOr('fallback')).ToBe('fallback');
finally
@@ -137,13 +145,99 @@ procedure TCLIOptionsTests.TestStringOptionValueOrWhenAbsent;
end;
end;
-{ TGocciaIntegerOption tests }
+procedure TCLIOptionsTests.TestStringOptionMarkPresentClearsValue;
+var
+ Opt: TStringOption;
+begin
+ Opt := TStringOption.Create('output', 'Output path');
+ try
+ Opt.Apply('configured.map');
+ Opt.MarkPresent;
+ Expect(Opt.Present).ToBe(True);
+ Expect(Opt.Value).ToBe('');
+ Expect(Opt.ValueOr('fallback')).ToBe('');
+ finally
+ Opt.Free;
+ end;
+end;
+
+procedure TCLIOptionsTests.TestOptionalStringOptionParsing;
+
+ procedure ExpectSourceMapParse(const AExpectedValue: string;
+ const AArgs: array of string);
+ var
+ Opt: TOptionalStringOption;
+ Options: TOptionArray;
+ Positionals: TStringList;
+ begin
+ Opt := TOptionalStringOption.Create('source-map', 'Write source map');
+ try
+ SetLength(Options, 1);
+ Options[0] := Opt;
+ Positionals := ParseArguments(AArgs, Options);
+ try
+ Expect(Opt.Present).ToBe(True);
+ Expect(Opt.Value).ToBe(AExpectedValue);
+ Expect(Positionals.Count).ToBe(1);
+ Expect(Positionals[0]).ToBe('positional');
+ finally
+ Positionals.Free;
+ end;
+ finally
+ Opt.Free;
+ end;
+ end;
+
+begin
+ ExpectSourceMapParse('', ['--source-map', 'positional']);
+ ExpectSourceMapParse('out.map', ['--source-map=out.map', 'positional']);
+end;
+
+procedure TCLIOptionsTests.TestRequiredValueOptionAcceptsDashPrefixedValues;
+var
+ IntegerOpt: TIntegerOption;
+ StringOpt: TStringOption;
+ Options: TOptionArray;
+ Positionals: TStringList;
+begin
+ IntegerOpt := TIntegerOption.Create('timeout', 'Timeout in ms');
+ try
+ SetLength(Options, 1);
+ Options[0] := IntegerOpt;
+ Positionals := ParseArguments(['--timeout', '-1'], Options);
+ try
+ Expect(IntegerOpt.Value).ToBe(-1);
+ Expect(Positionals.Count).ToBe(0);
+ finally
+ Positionals.Free;
+ end;
+ finally
+ IntegerOpt.Free;
+ end;
+
+ StringOpt := TStringOption.Create('output', 'Output path');
+ try
+ SetLength(Options, 1);
+ Options[0] := StringOpt;
+ Positionals := ParseArguments(['--output', '-tmp'], Options);
+ try
+ Expect(StringOpt.Value).ToBe('-tmp');
+ Expect(Positionals.Count).ToBe(0);
+ finally
+ Positionals.Free;
+ end;
+ finally
+ StringOpt.Free;
+ end;
+end;
+
+{ TIntegerOption tests }
procedure TCLIOptionsTests.TestIntegerOptionApply;
var
- Opt: TGocciaIntegerOption;
+ Opt: TIntegerOption;
begin
- Opt := TGocciaIntegerOption.Create('timeout', 'Timeout in ms');
+ Opt := TIntegerOption.Create('timeout', 'Timeout in ms');
try
Opt.Apply('42');
Expect(Opt.Present).ToBe(True);
@@ -155,9 +249,9 @@ procedure TCLIOptionsTests.TestIntegerOptionApply;
procedure TCLIOptionsTests.TestIntegerOptionValueOrWhenPresent;
var
- Opt: TGocciaIntegerOption;
+ Opt: TIntegerOption;
begin
- Opt := TGocciaIntegerOption.Create('timeout', 'Timeout in ms');
+ Opt := TIntegerOption.Create('timeout', 'Timeout in ms');
try
Opt.Apply('42');
Expect(Opt.ValueOr(100)).ToBe(42);
@@ -168,9 +262,9 @@ procedure TCLIOptionsTests.TestIntegerOptionValueOrWhenPresent;
procedure TCLIOptionsTests.TestIntegerOptionValueOrWhenAbsent;
var
- Opt: TGocciaIntegerOption;
+ Opt: TIntegerOption;
begin
- Opt := TGocciaIntegerOption.Create('timeout', 'Timeout in ms');
+ Opt := TIntegerOption.Create('timeout', 'Timeout in ms');
try
Expect(Opt.ValueOr(100)).ToBe(100);
finally
@@ -180,16 +274,16 @@ procedure TCLIOptionsTests.TestIntegerOptionValueOrWhenAbsent;
procedure TCLIOptionsTests.TestIntegerOptionInvalidValue;
var
- Opt: TGocciaIntegerOption;
+ Opt: TIntegerOption;
Raised: Boolean;
begin
- Opt := TGocciaIntegerOption.Create('timeout', 'Timeout in ms');
+ Opt := TIntegerOption.Create('timeout', 'Timeout in ms');
try
Raised := False;
try
Opt.Apply('notanumber');
except
- on E: TGocciaParseError do
+ on E: TParseError do
Raised := True;
end;
Expect(Raised).ToBe(True);
@@ -198,13 +292,13 @@ procedure TCLIOptionsTests.TestIntegerOptionInvalidValue;
end;
end;
-{ TGocciaRepeatableOption tests }
+{ TRepeatableOption tests }
procedure TCLIOptionsTests.TestRepeatableOptionMultipleValues;
var
- Opt: TGocciaRepeatableOption;
+ Opt: TRepeatableOption;
begin
- Opt := TGocciaRepeatableOption.Create('alias', 'Import alias');
+ Opt := TRepeatableOption.Create('alias', 'Import alias');
try
Opt.Apply('@/=./src/');
Opt.Apply('config=./config/default.js');
@@ -219,13 +313,13 @@ procedure TCLIOptionsTests.TestRepeatableOptionMultipleValues;
end;
end;
-{ TGocciaEnumOption tests — uses local TTestColor enum }
+{ TEnumOption tests — uses local TTestColor enum }
procedure TCLIOptionsTests.TestEnumOptionFirstValue;
var
- Opt: TGocciaEnumOption;
+ Opt: TEnumOption;
begin
- Opt := TGocciaEnumOption.Create('color', 'Pick a color');
+ Opt := TEnumOption.Create('color', 'Pick a color');
try
Opt.Apply('red');
Expect(Opt.Present).ToBe(True);
@@ -237,9 +331,9 @@ procedure TCLIOptionsTests.TestEnumOptionFirstValue;
procedure TCLIOptionsTests.TestEnumOptionSecondValue;
var
- Opt: TGocciaEnumOption;
+ Opt: TEnumOption;
begin
- Opt := TGocciaEnumOption.Create('color', 'Pick a color');
+ Opt := TEnumOption.Create('color', 'Pick a color');
try
Opt.Apply('blue');
Expect(Opt.Present).ToBe(True);
@@ -251,16 +345,16 @@ procedure TCLIOptionsTests.TestEnumOptionSecondValue;
procedure TCLIOptionsTests.TestEnumOptionInvalidValue;
var
- Opt: TGocciaEnumOption;
+ Opt: TEnumOption;
Raised: Boolean;
begin
- Opt := TGocciaEnumOption.Create('color', 'Pick a color');
+ Opt := TEnumOption.Create('color', 'Pick a color');
try
Raised := False;
try
Opt.Apply('invalid');
except
- on E: TGocciaParseError do
+ on E: TParseError do
Raised := True;
end;
Expect(Raised).ToBe(True);
@@ -271,9 +365,9 @@ procedure TCLIOptionsTests.TestEnumOptionInvalidValue;
procedure TCLIOptionsTests.TestEnumOptionValidValues;
var
- Opt: TGocciaEnumOption;
+ Opt: TEnumOption;
begin
- Opt := TGocciaEnumOption.Create('color', 'Pick a color');
+ Opt := TEnumOption.Create('color', 'Pick a color');
try
Expect(Opt.ValidValues).ToBe('red, blue');
finally
@@ -283,9 +377,9 @@ procedure TCLIOptionsTests.TestEnumOptionValidValues;
procedure TCLIOptionsTests.TestEnumOptionFormatForHelp;
var
- Opt: TGocciaEnumOption;
+ Opt: TEnumOption;
begin
- Opt := TGocciaEnumOption.Create('color', 'Pick a color');
+ Opt := TEnumOption.Create('color', 'Pick a color');
try
Expect(Opt.FormatForHelp).ToBe('--color=red|blue');
finally
@@ -293,14 +387,14 @@ procedure TCLIOptionsTests.TestEnumOptionFormatForHelp;
end;
end;
-{ TGocciaOptionList tests }
+{ TOptionList tests }
procedure TCLIOptionsTests.TestOptionListAddFlagAndString;
var
- List: TGocciaOptionList;
- Arr: TGocciaOptionArray;
+ List: TOptionList;
+ Arr: TOptionArray;
begin
- List := TGocciaOptionList.Create;
+ List := TOptionList.Create;
try
List.AddFlag('verbose', 'Enable verbose output');
List.AddString('output', 'Output file path');
@@ -317,11 +411,11 @@ procedure TCLIOptionsTests.TestOptionListAddFlagAndString;
procedure TCLIOptionsTests.TestConcatOptionsMergesTwoArrays;
var
- ListA, ListB: TGocciaOptionList;
- Combined: TGocciaOptionArray;
+ ListA, ListB: TOptionList;
+ Combined: TOptionArray;
begin
- ListA := TGocciaOptionList.Create;
- ListB := TGocciaOptionList.Create;
+ ListA := TOptionList.Create;
+ ListB := TOptionList.Create;
try
ListA.AddFlag('alpha', 'First flag');
ListA.AddString('beta', 'First string');
@@ -341,10 +435,10 @@ procedure TCLIOptionsTests.TestConcatOptionsMergesTwoArrays;
procedure TCLIOptionsTests.TestGenerateHelpText;
var
- List: TGocciaOptionList;
+ List: TOptionList;
HelpText: string;
begin
- List := TGocciaOptionList.Create;
+ List := TOptionList.Create;
try
List.AddFlag('verbose', 'Enable verbose output');
List.AddString('output', 'Output file path');
@@ -363,9 +457,9 @@ procedure TCLIOptionsTests.TestGenerateHelpText;
procedure TCLIOptionsTests.TestFromCommandLineIsFalseInitially;
var
- Opt: TGocciaFlagOption;
+ Opt: TFlagOption;
begin
- Opt := TGocciaFlagOption.Create('asi', 'Enable ASI');
+ Opt := TFlagOption.Create('feature', 'Enable feature');
try
Expect(Opt.FromCommandLine).ToBe(False);
finally
@@ -375,9 +469,9 @@ procedure TCLIOptionsTests.TestFromCommandLineIsFalseInitially;
procedure TCLIOptionsTests.TestMarkFromCommandLineSetsTrue;
var
- Opt: TGocciaFlagOption;
+ Opt: TFlagOption;
begin
- Opt := TGocciaFlagOption.Create('asi', 'Enable ASI');
+ Opt := TFlagOption.Create('feature', 'Enable feature');
try
Opt.Apply('');
Opt.MarkFromCommandLine;
@@ -390,16 +484,16 @@ procedure TCLIOptionsTests.TestMarkFromCommandLineSetsTrue;
procedure TCLIOptionsTests.TestConfigAppliedOptionNotFromCommandLine;
var
- Opt: TGocciaFlagOption;
- Options: TGocciaOptionArray;
+ Opt: TFlagOption;
+ Options: TOptionArray;
Entries: TConfigEntryArray;
begin
- Opt := TGocciaFlagOption.Create('asi', 'Enable ASI');
+ Opt := TFlagOption.Create('feature', 'Enable feature');
try
SetLength(Options, 1);
Options[0] := Opt;
SetLength(Entries, 1);
- Entries[0].Key := 'asi';
+ Entries[0].Key := 'feature';
Entries[0].Value := 'true';
ApplyConfigEntries(Entries, Options);
diff --git a/source/shared/CLI.Parser.pas b/source/shared/CLI.Parser.pas
index 96e848e0..1aad8ccc 100644
--- a/source/shared/CLI.Parser.pas
+++ b/source/shared/CLI.Parser.pas
@@ -11,8 +11,10 @@ interface
{ Parses command-line arguments against the given option definitions.
Returns a TStringList of positional (non-option) arguments; the caller
- owns the returned list. Raises TGocciaParseError for unknown options. }
-function ParseCommandLine(const AOptions: TGocciaOptionArray): TStringList;
+ owns the returned list. Raises TParseError for unknown options. }
+function ParseArguments(const AArgs: array of string;
+ const AOptions: TOptionArray): TStringList;
+function ParseCommandLine(const AOptions: TOptionArray): TStringList;
implementation
@@ -43,8 +45,8 @@ procedure SplitFlag(const AArg: string; out AName, AValue: string);
end;
end;
-function FindOption(const AOptions: TGocciaOptionArray;
- const AName: string): TGocciaOptionBase;
+function FindOption(const AOptions: TOptionArray;
+ const AName: string): TOptionBase;
var
I: Integer;
begin
@@ -54,8 +56,8 @@ function FindOption(const AOptions: TGocciaOptionArray;
Result := nil;
end;
-function FindOptionShort(const AOptions: TGocciaOptionArray;
- const AShortName: Char): TGocciaOptionBase;
+function FindOptionShort(const AOptions: TOptionArray;
+ const AShortName: Char): TOptionBase;
var
I: Integer;
begin
@@ -65,20 +67,30 @@ function FindOptionShort(const AOptions: TGocciaOptionArray;
Result := nil;
end;
-function ParseCommandLine(const AOptions: TGocciaOptionArray): TStringList;
+function LooksLikeOptionToken(const AArg: string): Boolean;
+begin
+ if Copy(AArg, 1, Length(LONG_FLAG_PREFIX)) = LONG_FLAG_PREFIX then
+ Exit(True);
+
+ Result := (Length(AArg) = 2) and
+ (AArg[1] = SHORT_FLAG_CHAR) and
+ not (AArg[2] in ['0'..'9']);
+end;
+
+function ParseArguments(const AArgs: array of string;
+ const AOptions: TOptionArray): TStringList;
var
- I, Count: Integer;
+ I: Integer;
Arg, Name, Value: string;
- Option: TGocciaOptionBase;
+ Option: TOptionBase;
HasEquals: Boolean;
begin
Result := TStringList.Create;
try
- I := 1;
- Count := ParamCount;
- while I <= Count do
+ I := 0;
+ while I <= High(AArgs) do
begin
- Arg := ParamStr(I);
+ Arg := AArgs[I];
if Copy(Arg, 1, Length(LONG_FLAG_PREFIX)) = LONG_FLAG_PREFIX then
begin
@@ -87,18 +99,16 @@ function ParseCommandLine(const AOptions: TGocciaOptionArray): TStringList;
SplitFlag(Arg, Name, Value);
Option := FindOption(AOptions, Name);
if Option = nil then
- raise TGocciaParseError.CreateFmt('Unknown option: --%s', [Name]);
+ raise TParseError.CreateFmt('Unknown option: --%s', [Name]);
if (Value = '') and (not HasEquals) and
- not (Option is TGocciaFlagOption) and
- (Option is TGocciaRepeatableOption) then
+ Option.ConsumesSeparateValue then
begin
- if (I >= Count) or
- (Copy(ParamStr(I + 1), 1, 1) = SHORT_FLAG_CHAR) then
- raise TGocciaParseError.CreateFmt(
+ if (I >= High(AArgs)) or LooksLikeOptionToken(AArgs[I + 1]) then
+ raise TParseError.CreateFmt(
'--%s requires a value', [Name]);
Inc(I);
- Value := ParamStr(I);
+ Value := AArgs[I];
end;
Option.Apply(Value);
@@ -109,7 +119,7 @@ function ParseCommandLine(const AOptions: TGocciaOptionArray): TStringList;
begin
Option := FindOptionShort(AOptions, Arg[2]);
if Option = nil then
- raise TGocciaParseError.CreateFmt('Unknown option: %s', [Arg]);
+ raise TParseError.CreateFmt('Unknown option: %s', [Arg]);
Option.Apply('');
end
else
@@ -123,4 +133,15 @@ function ParseCommandLine(const AOptions: TGocciaOptionArray): TStringList;
end;
end;
+function ParseCommandLine(const AOptions: TOptionArray): TStringList;
+var
+ Args: array of string;
+ I: Integer;
+begin
+ SetLength(Args, ParamCount);
+ for I := 0 to High(Args) do
+ Args[I] := ParamStr(I + 1);
+ Result := ParseArguments(Args, AOptions);
+end;
+
end.
diff --git a/source/units/Goccia.Engine.pas b/source/units/Goccia.Engine.pas
index 05efed74..7ff1d83a 100644
--- a/source/units/Goccia.Engine.pas
+++ b/source/units/Goccia.Engine.pas
@@ -43,10 +43,10 @@ interface
Goccia.Modules.Resolver,
Goccia.ObjectModel,
Goccia.ObjectModel.Engine,
- Goccia.Parser,
Goccia.Realm,
Goccia.Scope,
Goccia.SourceMap,
+ Goccia.SourcePipeline,
Goccia.Values.BigIntValue,
Goccia.Values.ClassValue,
Goccia.Values.FunctionBase,
@@ -57,14 +57,29 @@ interface
Goccia.Values.TypedArrayValue;
type
- TGocciaPreprocessor = (ppJSX);
- TGocciaPreprocessors = set of TGocciaPreprocessor;
+ TGocciaPreprocessor = Goccia.SourcePipeline.TGocciaPreprocessor;
+ TGocciaPreprocessors = Goccia.SourcePipeline.TGocciaPreprocessors;
- TGocciaCompatibility = (cfASI, cfVar, cfFunction, cfTraditionalFor,
- cfWhileLoops, cfLooseEquality, cfNonStrictMode);
- TGocciaCompatibilityFlags = set of TGocciaCompatibility;
+ TGocciaCompatibility = Goccia.SourcePipeline.TGocciaCompatibility;
+ TGocciaCompatibilityFlags = Goccia.SourcePipeline.TGocciaCompatibilityFlags;
- TGocciaSourceType = (stScript, stModule);
+ TGocciaSourceType = Goccia.SourcePipeline.TGocciaSourceType;
+
+const
+ ppJSX = Goccia.SourcePipeline.ppJSX;
+
+ cfASI = Goccia.SourcePipeline.cfASI;
+ cfVar = Goccia.SourcePipeline.cfVar;
+ cfFunction = Goccia.SourcePipeline.cfFunction;
+ cfTraditionalFor = Goccia.SourcePipeline.cfTraditionalFor;
+ cfWhileLoops = Goccia.SourcePipeline.cfWhileLoops;
+ cfLooseEquality = Goccia.SourcePipeline.cfLooseEquality;
+ cfNonStrictMode = Goccia.SourcePipeline.cfNonStrictMode;
+
+ stScript = Goccia.SourcePipeline.stScript;
+ stModule = Goccia.SourcePipeline.stModule;
+
+type
TGocciaScriptResult = record
Result: TGocciaValue;
@@ -144,20 +159,6 @@ TGocciaEngine = class
FSuppressWarnings: Boolean;
FLastTiming: TGocciaScriptResult;
FLastSourceMap: TGocciaSourceMap;
- function GetASIEnabled: Boolean;
- function GetVarEnabled: Boolean;
- function GetFunctionEnabled: Boolean;
- function GetTraditionalForLoopsEnabled: Boolean;
- function GetWhileLoopsEnabled: Boolean;
- function GetLooseEqualityEnabled: Boolean;
- function GetNonStrictModeEnabled: Boolean;
- procedure SetASIEnabled(const AValue: Boolean);
- procedure SetVarEnabled(const AValue: Boolean);
- procedure SetFunctionEnabled(const AValue: Boolean);
- procedure SetTraditionalForLoopsEnabled(const AValue: Boolean);
- procedure SetWhileLoopsEnabled(const AValue: Boolean);
- procedure SetLooseEqualityEnabled(const AValue: Boolean);
- procedure SetNonStrictModeEnabled(const AValue: Boolean);
procedure SetStrictTypes(const AValue: Boolean);
function GetContentProvider: TGocciaModuleContentProvider;
function GetModuleResolver: TGocciaModuleResolver;
@@ -182,7 +183,8 @@ TGocciaEngine = class
function GocciaGCBytesAllocatedGetter(const AArgs: TGocciaArgumentsCollection; const AThisValue: TGocciaValue): TGocciaValue;
procedure DoRetainModule(const AModule: TObject);
procedure DiscardRuntimePending;
- procedure PrintParserWarnings(const AParser: TGocciaParser; const ASourceMap: TGocciaSourceMap = nil);
+ procedure PrintSourcePipelineWarnings(
+ const APipelineResult: TGocciaSourcePipelineResult);
function CompileDynamicFunction(const AParamsSources: array of string;
const ABodySource: string): TGocciaFunctionBase;
public
@@ -243,17 +245,6 @@ TGocciaEngine = class
property ContentProvider: TGocciaModuleContentProvider read GetContentProvider;
property ModuleResolver: TGocciaModuleResolver read GetModuleResolver;
property ModuleLoader: TGocciaModuleLoader read FModuleLoader;
- property ASIEnabled: Boolean read GetASIEnabled write SetASIEnabled;
- property VarEnabled: Boolean read GetVarEnabled write SetVarEnabled;
- property FunctionEnabled: Boolean read GetFunctionEnabled write SetFunctionEnabled;
- property TraditionalForLoopsEnabled: Boolean
- read GetTraditionalForLoopsEnabled write SetTraditionalForLoopsEnabled;
- property WhileLoopsEnabled: Boolean
- read GetWhileLoopsEnabled write SetWhileLoopsEnabled;
- property LooseEqualityEnabled: Boolean
- read GetLooseEqualityEnabled write SetLooseEqualityEnabled;
- property NonStrictModeEnabled: Boolean
- read GetNonStrictModeEnabled write SetNonStrictModeEnabled;
property FunctionConstructor: TGocciaFunctionConstructorClassValue read FFunctionConstructor;
property ObjectConstructor: TGocciaClassValue read FObjectConstructor;
property Preprocessors: TGocciaPreprocessors read FPreprocessors write SetPreprocessors;
@@ -281,7 +272,7 @@ TGocciaEngine = class
property GocciaGlobal: TGocciaObjectValue read FGocciaGlobal;
property SuppressWarnings: Boolean read FSuppressWarnings write FSuppressWarnings;
property LastTiming: TGocciaScriptResult read FLastTiming;
- // Source map from the most recent JSX transform, if any.
+ // Source map from the most recent source pipeline run, if any.
// Ownership transfers to the caller when read (set to nil after access).
function TakeLastSourceMap: TGocciaSourceMap;
end;
@@ -296,8 +287,6 @@ implementation
TextSemantics,
TimingUtils,
- Goccia.AST.Expressions,
- Goccia.AST.Statements,
Goccia.CallStack,
Goccia.Constants.ConstructorNames,
Goccia.Constants.PropertyNames,
@@ -305,17 +294,15 @@ implementation
Goccia.Error,
Goccia.Executor.Bytecode,
Goccia.Executor.Interpreter,
+ Goccia.FileExtensions,
Goccia.GarbageCollector,
Goccia.ImportMeta,
- Goccia.JSX.Transformer,
- Goccia.Lexer,
Goccia.MicrotaskQueue,
Goccia.Platform,
Goccia.Scope.Redeclaration,
Goccia.Shims,
Goccia.Spec,
Goccia.Threading,
- Goccia.Token,
Goccia.Values.ArrayBufferValue,
Goccia.Values.ArrayValue,
Goccia.Values.BooleanObjectValue,
@@ -368,11 +355,6 @@ function TGocciaEngineExtension.InjectGlobalsFromYAML(
{ TGocciaEngine }
-function TGocciaEngine.GetASIEnabled: Boolean;
-begin
- Result := cfASI in FCompatibility;
-end;
-
function TGocciaEngine.GetContentProvider: TGocciaModuleContentProvider;
begin
Result := FModuleLoader.ContentProvider;
@@ -578,7 +560,10 @@ procedure TGocciaEngine.Initialize(const AFileName: string;
FPreprocessors := DefaultPreprocessors;
FCompatibility := DefaultCompatibility;
- FSourceType := DefaultSourceType;
+ if IsModuleSourceFileName(AFileName) then
+ FSourceType := stModule
+ else
+ FSourceType := DefaultSourceType;
FStrictTypes := False;
FShims := TStringList.Create;
FExtensions := TGocciaEngineExtensionList.Create(True);
@@ -1247,134 +1232,110 @@ procedure TGocciaEngine.RegisterGlobalModule(const AName: string; const AModule:
function TGocciaEngine.Execute: TGocciaScriptResult;
var
- Lexer: TGocciaLexer;
- Parser: TGocciaParser;
- ProgramNode: TGocciaProgram;
- Tokens: TObjectList;
- StartTime, LexEnd, ParseEnd, ExecStart, ExecEnd: Int64;
- SourceText: string;
- JSXResult: TGocciaJSXTransformResult;
- SourceMap: TGocciaSourceMap;
- OrigLine, OrigCol: Integer;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ ActiveOptionsScope: TGocciaSourcePipelineOptionsScope;
+ PipelineResult: TGocciaSourcePipelineResult;
+ StartTime, ExecStart, ExecEnd: Int64;
ModuleScope: TGocciaScope;
ModuleContext: TGocciaEvaluationContext;
+ ModuleResult: TGocciaValue;
+ GC: TGarbageCollector;
begin
FillChar(FLastTiming, SizeOf(FLastTiming), 0);
FLastTiming.FileName := FSourcePath;
StartTime := GetNanoseconds;
-
- if Assigned(FSourceLines) then
- SourceText := StringListToLFText(FSourceLines)
- else
- SourceText := '';
- SourceMap := nil;
-
- if ppJSX in FPreprocessors then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(SourceText);
- SourceText := JSXResult.Source;
- SourceMap := JSXResult.SourceMap;
- if Assigned(SourceMap) then
- WarnIfJSXExtensionMismatch(FSourcePath);
- end;
+ PipelineResult := nil;
try
+ PipelineOptions.Preprocessors := FPreprocessors;
+ PipelineOptions.Compatibility := FCompatibility;
+ PipelineOptions.SourceType := FSourceType;
+ PipelineResult := TGocciaSourcePipeline.Parse(FSourceLines, FSourcePath,
+ PipelineOptions);
+ FLastTiming.LexTimeNanoseconds := PipelineResult.LexTimeNanoseconds;
+ FLastTiming.ParseTimeNanoseconds := PipelineResult.ParseTimeNanoseconds;
+ PrintSourcePipelineWarnings(PipelineResult);
+
+ if Assigned(TGocciaCoverageTracker.Instance) and
+ TGocciaCoverageTracker.Instance.Enabled then
+ begin
+ TGocciaCoverageTracker.Instance.RegisterSourceFile(
+ FSourcePath, CountExecutableLines(PipelineResult.GeneratedSourceLines));
+ if Assigned(PipelineResult.SourceMap) then
+ TGocciaCoverageTracker.Instance.RegisterSourceMap(
+ FSourcePath, PipelineResult.SourceMap.Clone);
+ end;
+
+ ActiveOptionsScope := TGocciaSourcePipeline.ActivateOptions(PipelineOptions);
try
- Lexer := TGocciaLexer.Create(SourceText, FSourcePath);
- try
- Tokens := Lexer.ScanTokens;
- LexEnd := GetNanoseconds;
- FLastTiming.LexTimeNanoseconds := LexEnd - StartTime;
-
- Parser := TGocciaParser.Create(Tokens, FSourcePath, Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := cfASI in FCompatibility;
- Parser.VarDeclarationsEnabled := cfVar in FCompatibility;
- Parser.FunctionDeclarationsEnabled := cfFunction in FCompatibility;
- Parser.TraditionalForLoopsEnabled := cfTraditionalFor in FCompatibility;
- Parser.WhileLoopsEnabled := cfWhileLoops in FCompatibility;
- Parser.LooseEqualityEnabled := cfLooseEquality in FCompatibility;
- Parser.NonStrictModeEnabled := (cfNonStrictMode in FCompatibility) or
- (FSourceType = stModule);
+ if FSourceType = stModule then
+ begin
+ // ES2026 §16.2.1.6.4: a Module Environment Record's
+ // [[ThisValue]] is undefined. Run the entry program in a
+ // fresh module scope so import.meta resolves and top-level
+ // `this` is undefined, matching the semantics imported
+ // modules already receive via TGocciaModuleLoader.
+ ModuleScope := FInterpreter.GlobalScope.CreateChild(skModule,
+ 'Module:' + FSourcePath);
+ ModuleScope.ThisValue :=
+ TGocciaUndefinedLiteralValue.UndefinedValue;
+ ModuleScope.NonStrictMode := False;
+ ModuleContext := FInterpreter.CreateEvaluationContext;
+ ModuleContext.Scope := ModuleScope;
+ ModuleContext.CurrentFilePath := FSourcePath;
+ ModuleContext.NonStrictMode := False;
+ ExecStart := GetNanoseconds;
+ ModuleResult := nil;
+ GC := TGarbageCollector.Instance;
+ if Assigned(GC) then
+ GC.AddTempRoot(ModuleScope);
try
- ProgramNode := Parser.Parse;
- PrintParserWarnings(Parser, SourceMap);
- ParseEnd := GetNanoseconds;
- FLastTiming.ParseTimeNanoseconds := ParseEnd - LexEnd;
-
- if Assigned(TGocciaCoverageTracker.Instance) and
- TGocciaCoverageTracker.Instance.Enabled then
- begin
- TGocciaCoverageTracker.Instance.RegisterSourceFile(
- FSourcePath, CountExecutableLines(Lexer.SourceLines));
- if Assigned(SourceMap) then
- TGocciaCoverageTracker.Instance.RegisterSourceMap(
- FSourcePath, SourceMap.Clone);
- end;
-
+ ModuleResult := FExecutor.EvaluateModuleBody(
+ PipelineResult.ProgramNode, ModuleContext);
+ if Assigned(ModuleResult) and Assigned(GC) then
+ GC.AddTempRoot(ModuleResult);
try
- if FSourceType = stModule then
- begin
- // ES2026 §16.2.1.6.4: a Module Environment Record's
- // [[ThisValue]] is undefined. Run the entry program in a
- // fresh module scope so import.meta resolves and top-level
- // `this` is undefined, matching the semantics imported
- // modules already receive via TGocciaModuleLoader.
- ModuleScope := FInterpreter.GlobalScope.CreateChild(skModule,
- 'Module:' + FSourcePath);
- ModuleScope.ThisValue :=
- TGocciaUndefinedLiteralValue.UndefinedValue;
- ModuleScope.NonStrictMode := False;
- ModuleContext := FInterpreter.CreateEvaluationContext;
- ModuleContext.Scope := ModuleScope;
- ModuleContext.CurrentFilePath := FSourcePath;
- ModuleContext.NonStrictMode := False;
- ExecStart := GetNanoseconds;
- FLastTiming.Result :=
- FExecutor.EvaluateModuleBody(ProgramNode, ModuleContext);
- WaitForRuntimeIdle;
- ExecEnd := GetNanoseconds;
- FLastTiming.CompileTimeNanoseconds := 0;
- FLastTiming.ExecuteTimeNanoseconds := ExecEnd - ExecStart;
- end
- else
- begin
- CheckTopLevelRedeclarations(ProgramNode,
- FInterpreter.GlobalScope, FSourcePath);
- FLastTiming.Result := FExecutor.ExecuteProgram(ProgramNode);
- WaitForRuntimeIdle;
- ExecEnd := GetNanoseconds;
- FLastTiming.CompileTimeNanoseconds :=
- FExecutor.CompileTimeNanoseconds;
- FLastTiming.ExecuteTimeNanoseconds :=
- FExecutor.ExecuteTimeNanoseconds;
- end;
- FLastTiming.TotalTimeNanoseconds := ExecEnd - StartTime;
+ WaitForRuntimeIdle;
+ FLastTiming.Result := ModuleResult;
finally
- if Assigned(TGocciaMicrotaskQueue.Instance) then
- TGocciaMicrotaskQueue.Instance.ClearQueue;
- DiscardRuntimePending;
- ProgramNode.Free;
+ if Assigned(ModuleResult) and Assigned(GC) then
+ GC.RemoveTempRoot(ModuleResult);
end;
finally
- Parser.Free;
+ if Assigned(GC) then
+ GC.RemoveTempRoot(ModuleScope);
end;
- finally
- Lexer.Free;
- end;
- except
- on E: TGocciaError do
+ ExecEnd := GetNanoseconds;
+ FLastTiming.CompileTimeNanoseconds := 0;
+ FLastTiming.ExecuteTimeNanoseconds := ExecEnd - ExecStart;
+ end
+ else
begin
- if Assigned(SourceMap) and
- SourceMap.Translate(E.Line, E.Column, OrigLine, OrigCol) then
- E.TranslatePosition(OrigLine, OrigCol, FSourceLines);
- raise;
+ CheckTopLevelRedeclarations(PipelineResult.ProgramNode,
+ FInterpreter.GlobalScope, FSourcePath);
+ FLastTiming.Result := ExecuteProgram(PipelineResult.ProgramNode);
+ ExecEnd := GetNanoseconds;
+ FLastTiming.CompileTimeNanoseconds :=
+ FExecutor.CompileTimeNanoseconds;
+ FLastTiming.ExecuteTimeNanoseconds :=
+ FExecutor.ExecuteTimeNanoseconds;
end;
+ FLastTiming.TotalTimeNanoseconds := ExecEnd - StartTime;
+ finally
+ ActiveOptionsScope.Free;
+ if Assigned(TGocciaMicrotaskQueue.Instance) then
+ TGocciaMicrotaskQueue.Instance.ClearQueue;
+ DiscardRuntimePending;
end;
finally
if FLastTiming.TotalTimeNanoseconds = 0 then
FLastTiming.TotalTimeNanoseconds := GetNanoseconds - StartTime;
FLastSourceMap.Free;
- FLastSourceMap := SourceMap;
+ if Assigned(PipelineResult) then
+ FLastSourceMap := PipelineResult.TakeSourceMap
+ else
+ FLastSourceMap := nil;
+ PipelineResult.Free;
end;
Result := FLastTiming;
@@ -1387,14 +1348,18 @@ function TGocciaEngine.TakeLastSourceMap: TGocciaSourceMap;
end;
function TGocciaEngine.ExecuteProgram(const AProgram: TGocciaProgram): TGocciaValue;
+var
+ GC: TGarbageCollector;
begin
+ Result := FExecutor.ExecuteProgram(AProgram);
+ GC := TGarbageCollector.Instance;
+ if Assigned(Result) and Assigned(GC) then
+ GC.AddTempRoot(Result);
try
- Result := FExecutor.ExecuteProgram(AProgram);
WaitForRuntimeIdle;
finally
- if Assigned(TGocciaMicrotaskQueue.Instance) then
- TGocciaMicrotaskQueue.Instance.ClearQueue;
- DiscardRuntimePending;
+ if Assigned(Result) and Assigned(GC) then
+ GC.RemoveTempRoot(Result);
end;
end;
@@ -1430,23 +1395,24 @@ class function TGocciaEngine.RunScriptFromStringList(
end;
end;
-procedure TGocciaEngine.PrintParserWarnings(const AParser: TGocciaParser; const ASourceMap: TGocciaSourceMap);
+procedure TGocciaEngine.PrintSourcePipelineWarnings(
+ const APipelineResult: TGocciaSourcePipelineResult);
var
- Warning: TGocciaParserWarning;
- I, OrigLine, OrigCol: Integer;
+ Warning: TGocciaSourcePipelineWarning;
+ I: Integer;
begin
if FSuppressWarnings then
Exit;
- for I := 0 to AParser.WarningCount - 1 do
+ if not Assigned(APipelineResult) then
+ Exit;
+ for I := 0 to APipelineResult.WarningCount - 1 do
begin
- Warning := AParser.GetWarning(I);
+ Warning := APipelineResult.Warnings[I];
WriteLn(Format('Warning: %s', [Warning.Message]));
if Warning.Suggestion <> '' then
WriteLn(Format(' Suggestion: %s', [Warning.Suggestion]));
- if Assigned(ASourceMap) and ASourceMap.Translate(Warning.Line, Warning.Column, OrigLine, OrigCol) then
- WriteLn(Format(' --> %s:%d:%d', [FSourcePath, OrigLine, OrigCol]))
- else
- WriteLn(Format(' --> %s:%d:%d', [FSourcePath, Warning.Line, Warning.Column]));
+ WriteLn(Format(' --> %s:%d:%d', [FSourcePath, Warning.Line,
+ Warning.Column]));
end;
end;
@@ -1534,101 +1500,6 @@ function TGocciaEngine.GocciaGCBytesAllocatedGetter(
Result := TGocciaNumberLiteralValue.ZeroValue;
end;
-procedure TGocciaEngine.SetASIEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfASI)
- else
- Exclude(FCompatibility, cfASI);
- FInterpreter.ASIEnabled := AValue;
-end;
-
-function TGocciaEngine.GetVarEnabled: Boolean;
-begin
- Result := cfVar in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetVarEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfVar)
- else
- Exclude(FCompatibility, cfVar);
- FInterpreter.VarEnabled := AValue;
-end;
-
-function TGocciaEngine.GetFunctionEnabled: Boolean;
-begin
- Result := cfFunction in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetFunctionEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfFunction)
- else
- Exclude(FCompatibility, cfFunction);
- FInterpreter.FunctionEnabled := AValue;
-end;
-
-function TGocciaEngine.GetTraditionalForLoopsEnabled: Boolean;
-begin
- Result := cfTraditionalFor in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetTraditionalForLoopsEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfTraditionalFor)
- else
- Exclude(FCompatibility, cfTraditionalFor);
- FInterpreter.TraditionalForLoopsEnabled := AValue;
-end;
-
-function TGocciaEngine.GetWhileLoopsEnabled: Boolean;
-begin
- Result := cfWhileLoops in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetWhileLoopsEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfWhileLoops)
- else
- Exclude(FCompatibility, cfWhileLoops);
- FInterpreter.WhileLoopsEnabled := AValue;
-end;
-
-function TGocciaEngine.GetLooseEqualityEnabled: Boolean;
-begin
- Result := cfLooseEquality in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetLooseEqualityEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfLooseEquality)
- else
- Exclude(FCompatibility, cfLooseEquality);
- FInterpreter.LooseEqualityEnabled := AValue;
-end;
-
-function TGocciaEngine.GetNonStrictModeEnabled: Boolean;
-begin
- Result := cfNonStrictMode in FCompatibility;
-end;
-
-procedure TGocciaEngine.SetNonStrictModeEnabled(const AValue: Boolean);
-begin
- if AValue then
- Include(FCompatibility, cfNonStrictMode)
- else
- Exclude(FCompatibility, cfNonStrictMode);
- FInterpreter.NonStrictModeEnabled := AValue;
- if FExecutor is TGocciaBytecodeExecutor then
- TGocciaBytecodeExecutor(FExecutor).NonStrictMode := AValue;
-end;
-
procedure TGocciaEngine.SetStrictTypes(const AValue: Boolean);
begin
FStrictTypes := AValue;
@@ -1672,12 +1543,10 @@ function TGocciaEngine.CompileDynamicFunction(
const AParamsSources: array of string;
const ABodySource: string): TGocciaFunctionBase;
var
- ParamStr, Source: string;
+ ParamStr: string;
I: Integer;
- BodyHasUseStrictDirective: Boolean;
- Lexer: TGocciaLexer;
- Tokens: TObjectList;
- Parser: TGocciaParser;
+ BodyParseResult: TGocciaFunctionBodyParseResult;
+ PipelineOptions: TGocciaSourcePipelineOptions;
ProgramNode: TGocciaProgram;
ResultValue: TGocciaValue;
begin
@@ -1690,7 +1559,6 @@ function TGocciaEngine.CompileDynamicFunction(
// wrapper will fail validation because it will have unmatched braces when
// parsed as a standalone function body.
ParamStr := '';
- BodyHasUseStrictDirective := False;
for I := 0 to High(AParamsSources) do
begin
if I > 0 then
@@ -1700,114 +1568,38 @@ function TGocciaEngine.CompileDynamicFunction(
// Validate params: must parse as a valid parameter list.
// If params contain tokens that escape the signature, this will throw.
- if ParamStr <> '' then
- begin
- Source := '(' + ParamStr + ') => {}';
- Lexer := TGocciaLexer.Create(Source, '');
- try
- Tokens := Lexer.ScanTokens;
- Parser := TGocciaParser.Create(Tokens, '', Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := cfASI in FCompatibility;
- Parser.VarDeclarationsEnabled := cfVar in FCompatibility;
- Parser.FunctionDeclarationsEnabled := cfFunction in FCompatibility;
- Parser.TraditionalForLoopsEnabled := cfTraditionalFor in FCompatibility;
- Parser.WhileLoopsEnabled := cfWhileLoops in FCompatibility;
- Parser.LooseEqualityEnabled := cfLooseEquality in FCompatibility;
- Parser.NonStrictModeEnabled := cfNonStrictMode in FCompatibility;
- try
- ProgramNode := Parser.Parse;
- try
- if (ProgramNode.Body.Count <> 1) or
- not (ProgramNode.Body[0] is TGocciaExpressionStatement) or
- not (TGocciaExpressionStatement(ProgramNode.Body[0]).Expression
- is TGocciaArrowFunctionExpression) then
- ThrowSyntaxError('Invalid parameter list for Function constructor');
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
- finally
- Lexer.Free;
- end;
- end;
+ PipelineOptions.Preprocessors := [];
+ PipelineOptions.Compatibility := FCompatibility;
+ PipelineOptions.SourceType := stScript;
+ if not TGocciaSourcePipeline.ParseFunctionParameters(ParamStr,
+ '', PipelineOptions) then
+ ThrowSyntaxError('Invalid parameter list for Function constructor');
// Validate body: must parse as a valid function body.
// An arrow wrapper ensures the body is enclosed in matching braces.
- if ABodySource <> '' then
- begin
- Source := '() => {' + #10 + ABodySource + #10 + '}';
- Lexer := TGocciaLexer.Create(Source, '');
- try
- Tokens := Lexer.ScanTokens;
- Parser := TGocciaParser.Create(Tokens, '', Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := cfASI in FCompatibility;
- Parser.VarDeclarationsEnabled := cfVar in FCompatibility;
- Parser.FunctionDeclarationsEnabled := cfFunction in FCompatibility;
- Parser.TraditionalForLoopsEnabled := cfTraditionalFor in FCompatibility;
- Parser.WhileLoopsEnabled := cfWhileLoops in FCompatibility;
- Parser.LooseEqualityEnabled := cfLooseEquality in FCompatibility;
- Parser.NonStrictModeEnabled := cfNonStrictMode in FCompatibility;
- try
- ProgramNode := Parser.Parse;
- try
- if (ProgramNode.Body.Count <> 1) or
- not (ProgramNode.Body[0] is TGocciaExpressionStatement) or
- not (TGocciaExpressionStatement(ProgramNode.Body[0]).Expression
- is TGocciaArrowFunctionExpression) then
- ThrowSyntaxError('Invalid body for Function constructor');
- BodyHasUseStrictDirective := HasUseStrictDirective(
- TGocciaArrowFunctionExpression(
- TGocciaExpressionStatement(ProgramNode.Body[0]).Expression).Body);
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
- end;
- finally
- Lexer.Free;
- end;
- end;
+ BodyParseResult := TGocciaSourcePipeline.ParseFunctionBodyWrapper(
+ ABodySource, '', PipelineOptions);
+ if not BodyParseResult.IsValid then
+ ThrowSyntaxError('Invalid body for Function constructor');
// Both pieces validated — safe to assemble the wrapper
- Source := '({ anonymous(' + ParamStr + ') {' + #10 + ABodySource + #10 + '} }).anonymous';
-
- Lexer := TGocciaLexer.Create(Source, '');
+ ProgramNode := TGocciaSourcePipeline.ParseDynamicFunctionWrapper(ParamStr,
+ ABodySource, '', PipelineOptions);
try
- Tokens := Lexer.ScanTokens;
- Parser := TGocciaParser.Create(Tokens, '', Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := cfASI in FCompatibility;
- Parser.VarDeclarationsEnabled := cfVar in FCompatibility;
- Parser.FunctionDeclarationsEnabled := cfFunction in FCompatibility;
- Parser.TraditionalForLoopsEnabled := cfTraditionalFor in FCompatibility;
- Parser.WhileLoopsEnabled := cfWhileLoops in FCompatibility;
- Parser.LooseEqualityEnabled := cfLooseEquality in FCompatibility;
- Parser.NonStrictModeEnabled := cfNonStrictMode in FCompatibility;
- try
- ProgramNode := Parser.ParseUnchecked;
- try
- ResultValue := FExecutor.ExecuteDynamicFunction(ProgramNode);
- Result := TGocciaFunctionBase(ResultValue);
- // ES2026 §20.2.1.1.1: the function's name is 'anonymous'
- if Result is TGocciaFunctionValue then
- TGocciaFunctionValue(Result).Name := 'anonymous';
- // ES2026 §15.2.2.4: Function-constructor bodies are non-strict
- // unless the parsed body contains a Use Strict Directive (§11.2.2).
- if not BodyHasUseStrictDirective then
- begin
- Result.StrictThis := False;
- Result.StrictCode := False;
- end;
- finally
- ProgramNode.Free;
- end;
- finally
- Parser.Free;
+ ResultValue := FExecutor.ExecuteDynamicFunction(ProgramNode);
+ Result := TGocciaFunctionBase(ResultValue);
+ // ES2026 §20.2.1.1.1: the function's name is 'anonymous'
+ if Result is TGocciaFunctionValue then
+ TGocciaFunctionValue(Result).Name := 'anonymous';
+ // ES2026 §15.2.2.4: Function-constructor bodies are non-strict
+ // unless the parsed body contains a Use Strict Directive (§11.2.2).
+ if not BodyParseResult.HasUseStrictDirective then
+ begin
+ Result.StrictThis := False;
+ Result.StrictCode := False;
end;
finally
- Lexer.Free;
+ ProgramNode.Free;
end;
end;
diff --git a/source/units/Goccia.Evaluator.pas b/source/units/Goccia.Evaluator.pas
index d35e88bc..cc86d557 100644
--- a/source/units/Goccia.Evaluator.pas
+++ b/source/units/Goccia.Evaluator.pas
@@ -121,8 +121,7 @@ implementation
Goccia.Generator.Continuation,
Goccia.InstructionLimit,
Goccia.Keywords.Reserved,
- Goccia.Lexer,
- Goccia.Parser,
+ Goccia.SourcePipeline,
Goccia.StackLimit,
Goccia.Timeout,
Goccia.Token,
@@ -6154,12 +6153,10 @@ function EvaluateTemplateExpression(const AExpressionText: string; const AContex
PlusPos, MinusPos, StarPos, SlashPos, DotPos: Integer;
Left, Right, PropName: string;
LeftVal, RightVal, ObjVal: TGocciaValue;
- Lexer: TGocciaLexer;
- Parser: TGocciaParser;
Expression: TGocciaExpression;
- Tokens: TObjectList;
- SourceLines: TStringList;
DeclaredPrivateNames: TStringList;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ SourceName: string;
I: Integer;
IsSimpleIdentifier: Boolean;
begin
@@ -6364,35 +6361,22 @@ function EvaluateTemplateExpression(const AExpressionText: string; const AContex
// Fall back to full parsing for complex expressions
// This handles complex cases like nested expressions, function calls, string literals, etc.
- Lexer := nil;
- Parser := nil;
- Tokens := nil;
- SourceLines := nil;
Expression := nil;
DeclaredPrivateNames := nil;
try
- SourceLines := TStringList.Create;
- SourceLines.Add(AExpressionText);
-
- Lexer := TGocciaLexer.Create(AExpressionText, 'template-expression');
- Tokens := Lexer.ScanTokens;
- if Tokens = nil then
- begin
- Result := TGocciaUndefinedLiteralValue.UndefinedValue;
- Exit;
- end;
-
- Parser := TGocciaParser.Create(Tokens, 'template-expression', SourceLines);
- Tokens := nil; // Parser owns it
-
+ PipelineOptions := TGocciaSourcePipeline.CurrentOptionsOrDefault;
+ SourceName := Format('%s:%d:%d', [AContext.CurrentFilePath, ALine,
+ AColumn]);
if Pos('#', Trimmed) > 0 then
begin
DeclaredPrivateNames := CollectDeclaredPrivateNames(AContext);
- Expression := Parser.ParseExpressionWithPrivateNames(DeclaredPrivateNames);
+ Expression := TGocciaSourcePipeline.ParseExpression(AExpressionText,
+ SourceName, PipelineOptions, DeclaredPrivateNames);
end
else
- Expression := Parser.Expression;
+ Expression := TGocciaSourcePipeline.ParseExpression(AExpressionText,
+ SourceName, PipelineOptions);
if Expression = nil then
begin
@@ -6408,10 +6392,6 @@ function EvaluateTemplateExpression(const AExpressionText: string; const AContex
// Cleanup
if Assigned(Expression) then Expression.Free;
- if Assigned(Parser) then Parser.Free;
- if Assigned(Tokens) then Tokens.Free;
- if Assigned(Lexer) then Lexer.Free;
- if Assigned(SourceLines) then SourceLines.Free;
if Assigned(DeclaredPrivateNames) then DeclaredPrivateNames.Free;
end;
diff --git a/source/units/Goccia.FileExtensions.pas b/source/units/Goccia.FileExtensions.pas
index c90d7f0f..83e837f2 100644
--- a/source/units/Goccia.FileExtensions.pas
+++ b/source/units/Goccia.FileExtensions.pas
@@ -48,6 +48,8 @@ function IsCSVExtension(const AExtension: string): Boolean;
function IsJSON5Extension(const AExtension: string): Boolean;
function IsJSONLExtension(const AExtension: string): Boolean;
function IsJSXNativeExtension(const AExtension: string): Boolean;
+function IsModuleSourceExtension(const AExtension: string): Boolean;
+function IsModuleSourceFileName(const AFileName: string): Boolean;
function IsTextAssetExtension(const AExtension: string): Boolean;
function IsTOMLExtension(const AExtension: string): Boolean;
function IsTSVExtension(const AExtension: string): Boolean;
@@ -84,6 +86,19 @@ function IsJSXNativeExtension(const AExtension: string): Boolean;
Result := False;
end;
+function IsModuleSourceExtension(const AExtension: string): Boolean;
+var
+ Ext: string;
+begin
+ Ext := LowerCase(AExtension);
+ Result := Ext = EXT_MJS;
+end;
+
+function IsModuleSourceFileName(const AFileName: string): Boolean;
+begin
+ Result := IsModuleSourceExtension(ExtractFileExt(AFileName));
+end;
+
function IsCSVExtension(const AExtension: string): Boolean;
var
Ext: string;
diff --git a/source/units/Goccia.Modules.Loader.pas b/source/units/Goccia.Modules.Loader.pas
index ee0a6ed9..f03f46ba 100644
--- a/source/units/Goccia.Modules.Loader.pas
+++ b/source/units/Goccia.Modules.Loader.pas
@@ -16,6 +16,7 @@ interface
Goccia.Modules.ContentProvider,
Goccia.Modules.Resolver,
Goccia.Scope,
+ Goccia.SourcePipeline,
Goccia.Values.Primitives;
type
@@ -31,20 +32,14 @@ interface
TGocciaModuleLoader = class
private
- FASIEnabled: Boolean;
- FVarEnabled: Boolean;
- FFunctionEnabled: Boolean;
- FTraditionalForLoopsEnabled: Boolean;
- FWhileLoopsEnabled: Boolean;
- FLooseEqualityEnabled: Boolean;
- FNonStrictModeEnabled: Boolean;
+ FPreprocessors: TGocciaPreprocessors;
+ FCompatibility: TGocciaCompatibilityFlags;
FStrictTypesEnabled: Boolean;
FContentProvider: TGocciaModuleContentProvider;
FEvaluateModuleBody: TGocciaModuleBodyEvaluator;
FEntryFileName: string;
FGlobalModules: TOrderedStringMap;
FGlobalScope: TGocciaGlobalScope;
- FJSXEnabled: Boolean;
FLoadingModules: TOrderedStringMap;
FModules: TOrderedStringMap;
FOnError: TGocciaThrowErrorCallback;
@@ -56,6 +51,22 @@ TGocciaModuleLoader = class
procedure CopyModuleContents(const ASourceModule,
ATargetModule: TGocciaModule);
function LoadJSONModule(const AResolvedPath: string): TGocciaModule;
+ function GetASIEnabled: Boolean;
+ function GetJSXEnabled: Boolean;
+ function GetVarEnabled: Boolean;
+ function GetFunctionEnabled: Boolean;
+ function GetTraditionalForLoopsEnabled: Boolean;
+ function GetWhileLoopsEnabled: Boolean;
+ function GetLooseEqualityEnabled: Boolean;
+ function GetNonStrictModeEnabled: Boolean;
+ procedure SetASIEnabled(const AValue: Boolean);
+ procedure SetJSXEnabled(const AValue: Boolean);
+ procedure SetVarEnabled(const AValue: Boolean);
+ procedure SetFunctionEnabled(const AValue: Boolean);
+ procedure SetTraditionalForLoopsEnabled(const AValue: Boolean);
+ procedure SetWhileLoopsEnabled(const AValue: Boolean);
+ procedure SetLooseEqualityEnabled(const AValue: Boolean);
+ procedure SetNonStrictModeEnabled(const AValue: Boolean);
public
constructor Create(const AEntryFileName: string;
const AResolver: TGocciaModuleResolver = nil;
@@ -77,18 +88,22 @@ TGocciaModuleLoader = class
read FEvaluateModuleBody write FEvaluateModuleBody;
property GlobalModules: TOrderedStringMap
read FGlobalModules;
- property ASIEnabled: Boolean read FASIEnabled write FASIEnabled;
- property JSXEnabled: Boolean read FJSXEnabled write FJSXEnabled;
- property VarEnabled: Boolean read FVarEnabled write FVarEnabled;
- property FunctionEnabled: Boolean read FFunctionEnabled write FFunctionEnabled;
+ property Preprocessors: TGocciaPreprocessors
+ read FPreprocessors write FPreprocessors;
+ property Compatibility: TGocciaCompatibilityFlags
+ read FCompatibility write FCompatibility;
+ property ASIEnabled: Boolean read GetASIEnabled write SetASIEnabled;
+ property JSXEnabled: Boolean read GetJSXEnabled write SetJSXEnabled;
+ property VarEnabled: Boolean read GetVarEnabled write SetVarEnabled;
+ property FunctionEnabled: Boolean read GetFunctionEnabled write SetFunctionEnabled;
property TraditionalForLoopsEnabled: Boolean
- read FTraditionalForLoopsEnabled write FTraditionalForLoopsEnabled;
+ read GetTraditionalForLoopsEnabled write SetTraditionalForLoopsEnabled;
property WhileLoopsEnabled: Boolean
- read FWhileLoopsEnabled write FWhileLoopsEnabled;
+ read GetWhileLoopsEnabled write SetWhileLoopsEnabled;
property LooseEqualityEnabled: Boolean
- read FLooseEqualityEnabled write FLooseEqualityEnabled;
+ read GetLooseEqualityEnabled write SetLooseEqualityEnabled;
property NonStrictModeEnabled: Boolean
- read FNonStrictModeEnabled write FNonStrictModeEnabled;
+ read GetNonStrictModeEnabled write SetNonStrictModeEnabled;
property StrictTypesEnabled: Boolean read FStrictTypesEnabled
write FStrictTypesEnabled;
property Resolver: TGocciaModuleResolver read FResolver;
@@ -99,19 +114,13 @@ TGocciaModuleLoader = class
implementation
uses
- TextSemantics,
-
Goccia.AST.Expressions,
Goccia.AST.Statements,
Goccia.Error,
Goccia.FileExtensions,
Goccia.GarbageCollector,
Goccia.JSON,
- Goccia.JSX.Transformer,
Goccia.Keywords.Reserved,
- Goccia.Lexer,
- Goccia.Parser,
- Goccia.SourceMap,
Goccia.Values.ObjectValue;
constructor TGocciaModuleLoader.Create(const AEntryFileName: string;
@@ -160,6 +169,111 @@ destructor TGocciaModuleLoader.Destroy;
inherited;
end;
+function TGocciaModuleLoader.GetASIEnabled: Boolean;
+begin
+ Result := cfASI in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetJSXEnabled: Boolean;
+begin
+ Result := ppJSX in FPreprocessors;
+end;
+
+function TGocciaModuleLoader.GetVarEnabled: Boolean;
+begin
+ Result := cfVar in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetFunctionEnabled: Boolean;
+begin
+ Result := cfFunction in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetTraditionalForLoopsEnabled: Boolean;
+begin
+ Result := cfTraditionalFor in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetWhileLoopsEnabled: Boolean;
+begin
+ Result := cfWhileLoops in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetLooseEqualityEnabled: Boolean;
+begin
+ Result := cfLooseEquality in FCompatibility;
+end;
+
+function TGocciaModuleLoader.GetNonStrictModeEnabled: Boolean;
+begin
+ Result := cfNonStrictMode in FCompatibility;
+end;
+
+procedure TGocciaModuleLoader.SetASIEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfASI)
+ else
+ Exclude(FCompatibility, cfASI);
+end;
+
+procedure TGocciaModuleLoader.SetJSXEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FPreprocessors, ppJSX)
+ else
+ Exclude(FPreprocessors, ppJSX);
+end;
+
+procedure TGocciaModuleLoader.SetVarEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfVar)
+ else
+ Exclude(FCompatibility, cfVar);
+end;
+
+procedure TGocciaModuleLoader.SetFunctionEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfFunction)
+ else
+ Exclude(FCompatibility, cfFunction);
+end;
+
+procedure TGocciaModuleLoader.SetTraditionalForLoopsEnabled(
+ const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfTraditionalFor)
+ else
+ Exclude(FCompatibility, cfTraditionalFor);
+end;
+
+procedure TGocciaModuleLoader.SetWhileLoopsEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfWhileLoops)
+ else
+ Exclude(FCompatibility, cfWhileLoops);
+end;
+
+procedure TGocciaModuleLoader.SetLooseEqualityEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfLooseEquality)
+ else
+ Exclude(FCompatibility, cfLooseEquality);
+end;
+
+procedure TGocciaModuleLoader.SetNonStrictModeEnabled(const AValue: Boolean);
+begin
+ if AValue then
+ Include(FCompatibility, cfNonStrictMode)
+ else
+ Exclude(FCompatibility, cfNonStrictMode);
+end;
+
procedure TGocciaModuleLoader.SetContentProvider(
const AContentProvider: TGocciaModuleContentProvider;
const AOwnsContentProvider: Boolean);
@@ -213,19 +327,16 @@ function TGocciaModuleLoader.LoadModule(const AModulePath,
ExportPair: TStringStringMap.TKeyValuePair;
ExportVarDecl: TGocciaExportVariableDeclaration;
I: Integer;
- JSXResult: TGocciaJSXTransformResult;
- JSXSourceMap: TGocciaSourceMap;
- Lexer: TGocciaLexer;
Module: TGocciaModule;
+ ModuleParseResult: TGocciaSourcePipelineModuleResult;
+ ModuleWarning: TGocciaSourcePipelineWarning;
ModuleScope: TGocciaScope;
- OrigLine: Integer;
- OrigCol: Integer;
- Parser: TGocciaParser;
+ PipelineOptions: TGocciaSourcePipelineOptions;
+ ActiveOptionsScope: TGocciaSourcePipelineOptionsScope;
ProgramNode: TGocciaProgram;
ReExportDecl: TGocciaReExportDeclaration;
ResolvedPath: string;
SourceModule: TGocciaModule;
- SourceText: UTF8String;
Stmt: TGocciaStatement;
Value: TGocciaValue;
VarInfo: TGocciaVariableInfo;
@@ -282,149 +393,131 @@ function TGocciaModuleLoader.LoadModule(const AModulePath,
Content := FContentProvider.LoadContent(ResolvedPath);
try
- SourceText := NormalizeUTF8NewlinesToLF(Content.Text);
- JSXSourceMap := nil;
- if FJSXEnabled then
- begin
- JSXResult := TGocciaJSXTransformer.Transform(string(SourceText));
- SourceText := UTF8String(JSXResult.Source);
- JSXSourceMap := JSXResult.SourceMap;
- if Assigned(JSXSourceMap) then
- WarnIfJSXExtensionMismatch(ResolvedPath);
- end;
-
+ PipelineOptions.Preprocessors := FPreprocessors;
+ PipelineOptions.Compatibility := FCompatibility;
+ PipelineOptions.SourceType := stModule;
+ ModuleParseResult := TGocciaSourcePipeline.ParseModuleSource(Content.Text,
+ ResolvedPath, PipelineOptions);
try
+ for I := 0 to ModuleParseResult.WarningCount - 1 do
+ begin
+ ModuleWarning := ModuleParseResult.Warnings[I];
+ WriteLn(Format('Warning: %s', [ModuleWarning.Message]));
+ if ModuleWarning.Suggestion <> '' then
+ WriteLn(Format(' Suggestion: %s', [ModuleWarning.Suggestion]));
+ WriteLn(Format(' --> %s:%d:%d', [ResolvedPath, ModuleWarning.Line,
+ ModuleWarning.Column]));
+ end;
+
+ ProgramNode := ModuleParseResult.TakeProgramNode;
try
- Lexer := TGocciaLexer.Create(string(SourceText), ResolvedPath);
+ Module := TGocciaModule.Create(ResolvedPath);
+ Module.LastModified := Content.LastModified;
+ FModules.Add(ResolvedPath, Module);
+ FLoadingModules.Add(ResolvedPath, True);
+ LoadSucceeded := False;
try
- Parser := TGocciaParser.Create(Lexer.ScanTokens, ResolvedPath,
- Lexer.SourceLines);
- Parser.AutomaticSemicolonInsertion := FASIEnabled;
- Parser.VarDeclarationsEnabled := FVarEnabled;
- Parser.FunctionDeclarationsEnabled := FFunctionEnabled;
- Parser.TraditionalForLoopsEnabled := FTraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := FWhileLoopsEnabled;
- Parser.LooseEqualityEnabled := FLooseEqualityEnabled;
- Parser.NonStrictModeEnabled := True;
+ ModuleScope := FGlobalScope.CreateChild(skModule,
+ 'Module:' + ResolvedPath);
+ // ES2026 §16.2.1.6.4 InitializeEnvironment: a Module
+ // Environment Record's [[ThisValue]] is undefined.
+ ModuleScope.ThisValue := TGocciaUndefinedLiteralValue.UndefinedValue;
+ ModuleScope.StrictTypes := FStrictTypesEnabled;
+ ModuleScope.NonStrictMode := False;
+ Context.Scope := ModuleScope;
+ Context.OnError := FOnError;
+ Context.LoadModule := LoadModule;
+ Context.CurrentFilePath := ResolvedPath;
+ Context.CoverageEnabled := False;
+ Context.StrictTypes := FStrictTypesEnabled;
+ Context.NonStrictMode := False;
+ Context.DisposalTracker := nil;
+
+ ActiveOptionsScope := TGocciaSourcePipeline.ActivateOptions(
+ PipelineOptions);
try
- ProgramNode := Parser.Parse;
- try
- Module := TGocciaModule.Create(ResolvedPath);
- Module.LastModified := Content.LastModified;
- FModules.Add(ResolvedPath, Module);
- FLoadingModules.Add(ResolvedPath, True);
- LoadSucceeded := False;
- try
- ModuleScope := FGlobalScope.CreateChild(skModule,
- 'Module:' + ResolvedPath);
- // ES2026 §16.2.1.6.4 InitializeEnvironment: a Module
- // Environment Record's [[ThisValue]] is undefined.
- ModuleScope.ThisValue := TGocciaUndefinedLiteralValue.UndefinedValue;
- ModuleScope.StrictTypes := FStrictTypesEnabled;
- ModuleScope.NonStrictMode := False;
- Context.Scope := ModuleScope;
- Context.OnError := FOnError;
- Context.LoadModule := LoadModule;
- Context.CurrentFilePath := ResolvedPath;
- Context.CoverageEnabled := False;
- Context.StrictTypes := FStrictTypesEnabled;
- Context.NonStrictMode := False;
- Context.DisposalTracker := nil;
-
- FEvaluateModuleBody(ProgramNode, Context);
-
- for I := 0 to ProgramNode.Body.Count - 1 do
- begin
- Stmt := ProgramNode.Body[I];
-
- if Stmt is TGocciaExportDeclaration then
- begin
- ExportDecl := TGocciaExportDeclaration(Stmt);
- for ExportPair in ExportDecl.ExportsTable do
- begin
- Value := ModuleScope.GetValue(ExportPair.Value);
- if Assigned(Value) then
- Module.ExportsTable.AddOrSetValue(ExportPair.Key, Value);
- end;
- end
- else if Stmt is TGocciaExportDefaultDeclaration then
- begin
- ExportDefaultDecl := TGocciaExportDefaultDeclaration(Stmt);
- Value := ModuleScope.GetValue(ExportDefaultDecl.LocalName);
- if Assigned(Value) then
- Module.ExportsTable.AddOrSetValue(KEYWORD_DEFAULT, Value);
- end
- else if Stmt is TGocciaExportVariableDeclaration then
- begin
- ExportVarDecl := TGocciaExportVariableDeclaration(Stmt);
- for VarInfo in ExportVarDecl.Declaration.Variables do
- begin
- Value := ModuleScope.GetValue(VarInfo.Name);
- if Assigned(Value) then
- Module.ExportsTable.AddOrSetValue(VarInfo.Name, Value);
- end;
- end
- else if Stmt is TGocciaExportFunctionDeclaration then
- begin
- ExportFuncDecl := TGocciaExportFunctionDeclaration(Stmt);
- Value := ModuleScope.GetValue(ExportFuncDecl.Declaration.Name);
- if Assigned(Value) then
- Module.ExportsTable.AddOrSetValue(
- ExportFuncDecl.Declaration.Name, Value);
- end
- else if Stmt is TGocciaExportEnumDeclaration then
- begin
- Value := ModuleScope.GetValue(
- TGocciaExportEnumDeclaration(Stmt).Declaration.Name);
- if Assigned(Value) then
- Module.ExportsTable.AddOrSetValue(
- TGocciaExportEnumDeclaration(Stmt).Declaration.Name,
- Value);
- end
- else if Stmt is TGocciaReExportDeclaration then
- begin
- ReExportDecl := TGocciaReExportDeclaration(Stmt);
- SourceModule := LoadModule(ReExportDecl.ModulePath,
- ResolvedPath);
- for ExportPair in ReExportDecl.ExportsTable do
- begin
- if SourceModule.ExportsTable.TryGetValue(ExportPair.Value,
- Value) then
- Module.ExportsTable.AddOrSetValue(ExportPair.Key, Value);
- end;
- end;
- end;
-
- Result := Module;
- LoadSucceeded := True;
- finally
- FLoadingModules.Remove(ResolvedPath);
- if not LoadSucceeded then
- begin
- FModules.Remove(ResolvedPath);
- Module.Free;
- end;
+ FEvaluateModuleBody(ProgramNode, Context);
+ finally
+ ActiveOptionsScope.Free;
+ end;
+
+ for I := 0 to ProgramNode.Body.Count - 1 do
+ begin
+ Stmt := ProgramNode.Body[I];
+
+ if Stmt is TGocciaExportDeclaration then
+ begin
+ ExportDecl := TGocciaExportDeclaration(Stmt);
+ for ExportPair in ExportDecl.ExportsTable do
+ begin
+ Value := ModuleScope.GetValue(ExportPair.Value);
+ if Assigned(Value) then
+ Module.ExportsTable.AddOrSetValue(ExportPair.Key, Value);
+ end;
+ end
+ else if Stmt is TGocciaExportDefaultDeclaration then
+ begin
+ ExportDefaultDecl := TGocciaExportDefaultDeclaration(Stmt);
+ Value := ModuleScope.GetValue(ExportDefaultDecl.LocalName);
+ if Assigned(Value) then
+ Module.ExportsTable.AddOrSetValue(KEYWORD_DEFAULT, Value);
+ end
+ else if Stmt is TGocciaExportVariableDeclaration then
+ begin
+ ExportVarDecl := TGocciaExportVariableDeclaration(Stmt);
+ for VarInfo in ExportVarDecl.Declaration.Variables do
+ begin
+ Value := ModuleScope.GetValue(VarInfo.Name);
+ if Assigned(Value) then
+ Module.ExportsTable.AddOrSetValue(VarInfo.Name, Value);
+ end;
+ end
+ else if Stmt is TGocciaExportFunctionDeclaration then
+ begin
+ ExportFuncDecl := TGocciaExportFunctionDeclaration(Stmt);
+ Value := ModuleScope.GetValue(ExportFuncDecl.Declaration.Name);
+ if Assigned(Value) then
+ Module.ExportsTable.AddOrSetValue(
+ ExportFuncDecl.Declaration.Name, Value);
+ end
+ else if Stmt is TGocciaExportEnumDeclaration then
+ begin
+ Value := ModuleScope.GetValue(
+ TGocciaExportEnumDeclaration(Stmt).Declaration.Name);
+ if Assigned(Value) then
+ Module.ExportsTable.AddOrSetValue(
+ TGocciaExportEnumDeclaration(Stmt).Declaration.Name,
+ Value);
+ end
+ else if Stmt is TGocciaReExportDeclaration then
+ begin
+ ReExportDecl := TGocciaReExportDeclaration(Stmt);
+ SourceModule := LoadModule(ReExportDecl.ModulePath,
+ ResolvedPath);
+ for ExportPair in ReExportDecl.ExportsTable do
+ begin
+ if SourceModule.ExportsTable.TryGetValue(ExportPair.Value,
+ Value) then
+ Module.ExportsTable.AddOrSetValue(ExportPair.Key, Value);
end;
- finally
- ProgramNode.Free;
end;
- finally
- Parser.Free;
end;
+
+ Result := Module;
+ LoadSucceeded := True;
finally
- Lexer.Free;
- end;
- except
- on E: TGocciaError do
- begin
- if Assigned(JSXSourceMap) and
- JSXSourceMap.Translate(E.Line, E.Column, OrigLine, OrigCol) then
- E.TranslatePosition(OrigLine, OrigCol, Content.SourceLines);
- raise;
+ FLoadingModules.Remove(ResolvedPath);
+ if not LoadSucceeded then
+ begin
+ FModules.Remove(ResolvedPath);
+ Module.Free;
+ end;
end;
+ finally
+ ProgramNode.Free;
end;
finally
- JSXSourceMap.Free;
+ ModuleParseResult.Free;
end;
finally
Content.Free;
diff --git a/source/units/Goccia.Parser.pas b/source/units/Goccia.Parser.pas
index 635c890d..8796b470 100644
--- a/source/units/Goccia.Parser.pas
+++ b/source/units/Goccia.Parser.pas
@@ -25,6 +25,16 @@ TGocciaParserWarning = record
Column: Integer;
end;
+ TGocciaParserOptions = record
+ AutomaticSemicolonInsertion: Boolean;
+ VarDeclarationsEnabled: Boolean;
+ FunctionDeclarationsEnabled: Boolean;
+ TraditionalForLoopsEnabled: Boolean;
+ WhileLoopsEnabled: Boolean;
+ LooseEqualityEnabled: Boolean;
+ NonStrictModeEnabled: Boolean;
+ end;
+
TGocciaPrivateNameReference = record
Name: string;
Line: Integer;
@@ -234,21 +244,10 @@ TGocciaParser = class
function ParseExpressionWithPrivateNames(const ADeclaredNames: TStrings): TGocciaExpression;
function ParseExpressionUnchecked: TGocciaExpression;
function Expression: TGocciaExpression;
+ function AtEnd: Boolean;
function GetWarning(const AIndex: Integer): TGocciaParserWarning; inline;
- property AutomaticSemicolonInsertion: Boolean
- read FAutomaticSemicolonInsertion write FAutomaticSemicolonInsertion;
- property VarDeclarationsEnabled: Boolean
- read FVarDeclarationsEnabled write FVarDeclarationsEnabled;
- property FunctionDeclarationsEnabled: Boolean
- read FFunctionDeclarationsEnabled write FFunctionDeclarationsEnabled;
- property TraditionalForLoopsEnabled: Boolean
- read FTraditionalForLoopsEnabled write FTraditionalForLoopsEnabled;
- property WhileLoopsEnabled: Boolean
- read FWhileLoopsEnabled write FWhileLoopsEnabled;
- property LooseEqualityEnabled: Boolean
- read FLooseEqualityEnabled write FLooseEqualityEnabled;
- property NonStrictModeEnabled: Boolean
- read FNonStrictModeEnabled write FNonStrictModeEnabled;
+ procedure ApplyOptions(const AOptions: TGocciaParserOptions);
+ function Options: TGocciaParserOptions;
property WarningCount: Integer read FWarningCount;
end;
@@ -330,6 +329,28 @@ constructor TGocciaParser.Create(const ATokens: TObjectList;
FPrivateClassContexts := TObjectList.Create(True);
end;
+procedure TGocciaParser.ApplyOptions(const AOptions: TGocciaParserOptions);
+begin
+ FAutomaticSemicolonInsertion := AOptions.AutomaticSemicolonInsertion;
+ FVarDeclarationsEnabled := AOptions.VarDeclarationsEnabled;
+ FFunctionDeclarationsEnabled := AOptions.FunctionDeclarationsEnabled;
+ FTraditionalForLoopsEnabled := AOptions.TraditionalForLoopsEnabled;
+ FWhileLoopsEnabled := AOptions.WhileLoopsEnabled;
+ FLooseEqualityEnabled := AOptions.LooseEqualityEnabled;
+ FNonStrictModeEnabled := AOptions.NonStrictModeEnabled;
+end;
+
+function TGocciaParser.Options: TGocciaParserOptions;
+begin
+ Result.AutomaticSemicolonInsertion := FAutomaticSemicolonInsertion;
+ Result.VarDeclarationsEnabled := FVarDeclarationsEnabled;
+ Result.FunctionDeclarationsEnabled := FFunctionDeclarationsEnabled;
+ Result.TraditionalForLoopsEnabled := FTraditionalForLoopsEnabled;
+ Result.WhileLoopsEnabled := FWhileLoopsEnabled;
+ Result.LooseEqualityEnabled := FLooseEqualityEnabled;
+ Result.NonStrictModeEnabled := FNonStrictModeEnabled;
+end;
+
destructor TGocciaParser.Destroy;
begin
FPrivateClassContexts.Free;
@@ -503,6 +524,11 @@ function TGocciaParser.IsAtEnd: Boolean;
Result := Peek.TokenType = gttEOF;
end;
+function TGocciaParser.AtEnd: Boolean;
+begin
+ Result := IsAtEnd;
+end;
+
function TGocciaParser.Peek: TGocciaToken;
begin
Result := FTokens[FCurrent];
@@ -1539,12 +1565,7 @@ function CookRawSegment(const ARawSegment: string; out ACooked: string): Boolean
// Note: Tokens are owned by the Lexer (FTokens with OwnsObjects=True) and freed
// when the Lexer is destroyed — they must not be freed separately.
function ParseInterpolationExpression(const AExprText, AFileName: string;
- const AASI: Boolean = False; const AVarEnabled: Boolean = False;
- const AFunctionEnabled: Boolean = False;
- const ATraditionalForLoopsEnabled: Boolean = False;
- const AWhileLoopsEnabled: Boolean = False;
- const ALooseEqualityEnabled: Boolean = False;
- const ANonStrictModeEnabled: Boolean = False): TGocciaExpression;
+ const AOptions: TGocciaParserOptions): TGocciaExpression;
var
Lexer: TGocciaLexer;
Parser: TGocciaParser;
@@ -1563,13 +1584,7 @@ function ParseInterpolationExpression(const AExprText, AFileName: string;
SourceLines.Text := AExprText;
try
Parser := TGocciaParser.Create(Tokens, AFileName, SourceLines);
- Parser.AutomaticSemicolonInsertion := AASI;
- Parser.VarDeclarationsEnabled := AVarEnabled;
- Parser.FunctionDeclarationsEnabled := AFunctionEnabled;
- Parser.TraditionalForLoopsEnabled := ATraditionalForLoopsEnabled;
- Parser.WhileLoopsEnabled := AWhileLoopsEnabled;
- Parser.LooseEqualityEnabled := ALooseEqualityEnabled;
- Parser.NonStrictModeEnabled := ANonStrictModeEnabled;
+ Parser.ApplyOptions(AOptions);
try
ProgramNode := Parser.ParseUnchecked;
try
@@ -1632,10 +1647,7 @@ function TGocciaParser.ParseTaggedTemplate(const ATag: TGocciaExpression;
Expressions := TObjectList.Create(True);
for I := 0 to Length(ExprTexts) - 1 do
begin
- ParsedExpr := ParseInterpolationExpression(ExprTexts[I], FFileName,
- FAutomaticSemicolonInsertion, FVarDeclarationsEnabled,
- FFunctionDeclarationsEnabled, FTraditionalForLoopsEnabled,
- FWhileLoopsEnabled, FLooseEqualityEnabled, FNonStrictModeEnabled);
+ ParsedExpr := ParseInterpolationExpression(ExprTexts[I], FFileName, Options);
if Assigned(ParsedExpr) then
Expressions.Add(ParsedExpr);
end;
@@ -1695,10 +1707,7 @@ function TGocciaParser.ParseTemplateLiteral(const AToken: TGocciaToken): TGoccia
AToken.Line, AToken.Column));
// Parse and add the interpolation expression
- ParsedExpr := ParseInterpolationExpression(ExprTexts[I], FFileName,
- FAutomaticSemicolonInsertion, FVarDeclarationsEnabled,
- FFunctionDeclarationsEnabled, FTraditionalForLoopsEnabled,
- FWhileLoopsEnabled, FLooseEqualityEnabled, FNonStrictModeEnabled);
+ ParsedExpr := ParseInterpolationExpression(ExprTexts[I], FFileName, Options);
if Assigned(ParsedExpr) then
Parts.Add(ParsedExpr);
end;
diff --git a/source/units/Goccia.Shims.pas b/source/units/Goccia.Shims.pas
index 3d0e6109..ee58aad4 100644
--- a/source/units/Goccia.Shims.pas
+++ b/source/units/Goccia.Shims.pas
@@ -43,15 +43,11 @@ function LoadShimValue(const AInterpreter: TGocciaInterpreter;
implementation
uses
- Generics.Collections,
-
Goccia.AST.Node,
Goccia.Evaluator,
Goccia.Evaluator.Context,
- Goccia.Lexer,
- Goccia.Parser,
Goccia.Scope,
- Goccia.Token;
+ Goccia.SourcePipeline;
const
DEFAULT_SHIMS: array[0..7] of TGocciaShimDefinition = (
@@ -285,38 +281,36 @@ procedure RegisterDefaultShimNames(const AShims: TStringList);
function LoadShimValue(const AInterpreter: TGocciaInterpreter;
const AShim: TGocciaShimDefinition): TGocciaValue;
var
- Lexer: TGocciaLexer;
- Parser: TGocciaParser;
+ ModuleParseResult: TGocciaSourcePipelineModuleResult;
+ PipelineOptions: TGocciaSourcePipelineOptions;
ProgramNode: TGocciaProgram;
ModuleScope: TGocciaScope;
Context: TGocciaEvaluationContext;
I: Integer;
begin
- Lexer := TGocciaLexer.Create(AShim.Source, AShim.FileName);
+ PipelineOptions.Preprocessors := [];
+ PipelineOptions.Compatibility := [];
+ PipelineOptions.SourceType := stModule;
+ ModuleParseResult := TGocciaSourcePipeline.ParseModuleSource(
+ UTF8String(AShim.Source), AShim.FileName, PipelineOptions);
try
- Parser := TGocciaParser.Create(Lexer.ScanTokens, AShim.FileName,
- Lexer.SourceLines);
+ ProgramNode := ModuleParseResult.TakeProgramNode;
try
- ProgramNode := Parser.Parse;
- try
- ModuleScope := AInterpreter.GlobalScope.CreateChild(skModule,
- 'Shim:' + AShim.Name);
- // ES2026 §16.2.1.6.4 InitializeEnvironment: a Module
- // Environment Record's [[ThisValue]] is undefined.
- ModuleScope.ThisValue := TGocciaUndefinedLiteralValue.UndefinedValue;
- Context := AInterpreter.CreateEvaluationContext;
- Context.Scope := ModuleScope;
- for I := 0 to ProgramNode.Body.Count - 1 do
- EvaluateStatement(ProgramNode.Body[I], Context);
- Result := ModuleScope.GetValue(AShim.Name);
- finally
- ProgramNode.Free;
- end;
+ ModuleScope := AInterpreter.GlobalScope.CreateChild(skModule,
+ 'Shim:' + AShim.Name);
+ // ES2026 §16.2.1.6.4 InitializeEnvironment: a Module
+ // Environment Record's [[ThisValue]] is undefined.
+ ModuleScope.ThisValue := TGocciaUndefinedLiteralValue.UndefinedValue;
+ Context := AInterpreter.CreateEvaluationContext;
+ Context.Scope := ModuleScope;
+ for I := 0 to ProgramNode.Body.Count - 1 do
+ EvaluateStatement(ProgramNode.Body[I], Context);
+ Result := ModuleScope.GetValue(AShim.Name);
finally
- Parser.Free;
+ ProgramNode.Free;
end;
finally
- Lexer.Free;
+ ModuleParseResult.Free;
end;
end;
diff --git a/source/units/Goccia.SourcePipeline.pas b/source/units/Goccia.SourcePipeline.pas
new file mode 100644
index 00000000..6bce75cc
--- /dev/null
+++ b/source/units/Goccia.SourcePipeline.pas
@@ -0,0 +1,600 @@
+unit Goccia.SourcePipeline;
+
+{$I Goccia.inc}
+
+interface
+
+uses
+ Classes,
+ Generics.Collections,
+
+ Goccia.AST.Expressions,
+ Goccia.AST.Node,
+ Goccia.SourceMap;
+
+type
+ TGocciaPreprocessor = (ppJSX);
+ TGocciaPreprocessors = set of TGocciaPreprocessor;
+
+ TGocciaCompatibility = (cfASI, cfVar, cfFunction, cfTraditionalFor,
+ cfWhileLoops, cfLooseEquality, cfNonStrictMode);
+ TGocciaCompatibilityFlags = set of TGocciaCompatibility;
+
+ TGocciaSourceType = (stScript, stModule);
+
+ TGocciaSourcePipelineOptions = record
+ Preprocessors: TGocciaPreprocessors;
+ Compatibility: TGocciaCompatibilityFlags;
+ SourceType: TGocciaSourceType;
+ end;
+
+ TGocciaFunctionBodyParseResult = record
+ IsValid: Boolean;
+ HasUseStrictDirective: Boolean;
+ end;
+
+ TGocciaSourcePipelineWarning = record
+ Message: string;
+ Suggestion: string;
+ Line: Integer;
+ Column: Integer;
+ GeneratedLine: Integer;
+ GeneratedColumn: Integer;
+ end;
+
+ TGocciaSourcePipelineResult = class
+ private
+ FProgramNode: TGocciaProgram;
+ FSourceMap: TGocciaSourceMap;
+ FGeneratedSourceLines: TStringList;
+ FLexTimeNanoseconds: Int64;
+ FParseTimeNanoseconds: Int64;
+ FWarnings: array of TGocciaSourcePipelineWarning;
+ FWarningCount: Integer;
+
+ procedure AddWarning(const AMessage, ASuggestion: string;
+ const ALine, AColumn, AGeneratedLine, AGeneratedColumn: Integer);
+ function GetWarning(const AIndex: Integer): TGocciaSourcePipelineWarning;
+ public
+ destructor Destroy; override;
+
+ function TakeProgramNode: TGocciaProgram;
+ function TakeSourceMap: TGocciaSourceMap;
+
+ property ProgramNode: TGocciaProgram read FProgramNode;
+ property SourceMap: TGocciaSourceMap read FSourceMap;
+ property GeneratedSourceLines: TStringList read FGeneratedSourceLines;
+ property LexTimeNanoseconds: Int64 read FLexTimeNanoseconds;
+ property ParseTimeNanoseconds: Int64 read FParseTimeNanoseconds;
+ property WarningCount: Integer read FWarningCount;
+ property Warnings[const AIndex: Integer]: TGocciaSourcePipelineWarning
+ read GetWarning;
+ end;
+
+ TGocciaSourcePipelineModuleResult = class
+ private
+ FProgramNode: TGocciaProgram;
+ FWarnings: array of TGocciaSourcePipelineWarning;
+ FWarningCount: Integer;
+
+ procedure AddWarning(const AWarning: TGocciaSourcePipelineWarning);
+ function GetWarning(const AIndex: Integer): TGocciaSourcePipelineWarning;
+ public
+ destructor Destroy; override;
+
+ function TakeProgramNode: TGocciaProgram;
+
+ property ProgramNode: TGocciaProgram read FProgramNode;
+ property WarningCount: Integer read FWarningCount;
+ property Warnings[const AIndex: Integer]: TGocciaSourcePipelineWarning
+ read GetWarning;
+ end;
+
+ TGocciaSourcePipelineOptionsScope = class
+ private
+ FOptions: TGocciaSourcePipelineOptions;
+ FPrevious: TGocciaSourcePipelineOptionsScope;
+ FNext: TGocciaSourcePipelineOptionsScope;
+
+ constructor Create(const AOptions: TGocciaSourcePipelineOptions);
+ public
+ destructor Destroy; override;
+ end;
+
+ TGocciaSourcePipeline = class
+ public
+ class function DefaultOptions: TGocciaSourcePipelineOptions; static;
+ class function CurrentOptionsOrDefault: TGocciaSourcePipelineOptions; static;
+ class function ActivateOptions(
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineOptionsScope; static;
+ class function Parse(const ASource: TStringList; const AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineResult; static;
+ class function ParseModuleSource(const ASource: UTF8String;
+ const AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineModuleResult; static;
+ class function ParseExpression(const AExpressionText,
+ AFileName: string; const AOptions: TGocciaSourcePipelineOptions;
+ const ADeclaredPrivateNames: TStrings = nil): TGocciaExpression; static;
+ class function ParseFunctionParameters(const AParametersSource,
+ AFileName: string; const AOptions: TGocciaSourcePipelineOptions): Boolean; static;
+ class function ParseFunctionBodyWrapper(const ABodySource,
+ AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaFunctionBodyParseResult; static;
+ class function ParseDynamicFunctionWrapper(const AParametersSource,
+ ABodySource, AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaProgram; static;
+ end;
+
+implementation
+
+uses
+ SysUtils,
+
+ TextSemantics,
+ TimingUtils,
+
+ Goccia.AST.Statements,
+ Goccia.Error,
+ Goccia.FileExtensions,
+ Goccia.JSX.Transformer,
+ Goccia.Lexer,
+ Goccia.Parser,
+ Goccia.Token;
+
+threadvar
+ GActiveSourcePipelineOptionsScope: TGocciaSourcePipelineOptionsScope;
+
+function SourceTextToLines(const ASource: UTF8String): TStringList;
+begin
+ Result := CreateUTF8FileTextLines(NormalizeUTF8NewlinesToLF(ASource));
+end;
+
+function CloneStringList(const ASource: TStrings): TStringList;
+begin
+ Result := TStringList.Create;
+ if Assigned(ASource) then
+ Result.Assign(ASource);
+end;
+
+function ApplyPreprocessors(const ASource: string;
+ const AOptions: TGocciaSourcePipelineOptions;
+ out ASourceMap: TGocciaSourceMap): string;
+var
+ JSXResult: TGocciaJSXTransformResult;
+begin
+ Result := ASource;
+ ASourceMap := nil;
+
+ if ppJSX in AOptions.Preprocessors then
+ begin
+ JSXResult := TGocciaJSXTransformer.Transform(Result);
+ Result := JSXResult.Source;
+ ASourceMap := JSXResult.SourceMap;
+ end;
+end;
+
+function ParserOptionsForSourcePipeline(
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaParserOptions;
+begin
+ Result.AutomaticSemicolonInsertion := cfASI in AOptions.Compatibility;
+ Result.VarDeclarationsEnabled := cfVar in AOptions.Compatibility;
+ Result.FunctionDeclarationsEnabled := cfFunction in AOptions.Compatibility;
+ Result.TraditionalForLoopsEnabled := cfTraditionalFor in AOptions.Compatibility;
+ Result.WhileLoopsEnabled := cfWhileLoops in AOptions.Compatibility;
+ Result.LooseEqualityEnabled := cfLooseEquality in AOptions.Compatibility;
+ Result.NonStrictModeEnabled := (cfNonStrictMode in AOptions.Compatibility) and
+ (AOptions.SourceType <> stModule);
+end;
+
+procedure ConfigureParser(const AParser: TGocciaParser;
+ const AOptions: TGocciaSourcePipelineOptions);
+begin
+ AParser.ApplyOptions(ParserOptionsForSourcePipeline(AOptions));
+end;
+
+function HasSingleArrowFunctionProgram(const AProgramNode: TGocciaProgram;
+ out AArrowFunction: TGocciaArrowFunctionExpression): Boolean;
+var
+ ExpressionStatement: TGocciaExpressionStatement;
+begin
+ AArrowFunction := nil;
+ Result := Assigned(AProgramNode) and (AProgramNode.Body.Count = 1) and
+ (AProgramNode.Body[0] is TGocciaExpressionStatement);
+ if not Result then
+ Exit;
+
+ ExpressionStatement := TGocciaExpressionStatement(AProgramNode.Body[0]);
+ Result := ExpressionStatement.Expression is TGocciaArrowFunctionExpression;
+ if Result then
+ AArrowFunction := TGocciaArrowFunctionExpression(
+ ExpressionStatement.Expression);
+end;
+
+{ TGocciaSourcePipelineOptionsScope }
+
+constructor TGocciaSourcePipelineOptionsScope.Create(
+ const AOptions: TGocciaSourcePipelineOptions);
+begin
+ inherited Create;
+ FOptions := AOptions;
+ FPrevious := GActiveSourcePipelineOptionsScope;
+ if Assigned(FPrevious) then
+ FPrevious.FNext := Self;
+ GActiveSourcePipelineOptionsScope := Self;
+end;
+
+destructor TGocciaSourcePipelineOptionsScope.Destroy;
+begin
+ if GActiveSourcePipelineOptionsScope = Self then
+ GActiveSourcePipelineOptionsScope := FPrevious;
+ if Assigned(FPrevious) then
+ FPrevious.FNext := FNext;
+ if Assigned(FNext) then
+ FNext.FPrevious := FPrevious;
+ inherited Destroy;
+end;
+
+{ TGocciaSourcePipelineResult }
+
+destructor TGocciaSourcePipelineResult.Destroy;
+begin
+ FProgramNode.Free;
+ FSourceMap.Free;
+ FGeneratedSourceLines.Free;
+ inherited;
+end;
+
+procedure TGocciaSourcePipelineResult.AddWarning(const AMessage,
+ ASuggestion: string; const ALine, AColumn, AGeneratedLine,
+ AGeneratedColumn: Integer);
+begin
+ Inc(FWarningCount);
+ SetLength(FWarnings, FWarningCount);
+ FWarnings[FWarningCount - 1].Message := AMessage;
+ FWarnings[FWarningCount - 1].Suggestion := ASuggestion;
+ FWarnings[FWarningCount - 1].Line := ALine;
+ FWarnings[FWarningCount - 1].Column := AColumn;
+ FWarnings[FWarningCount - 1].GeneratedLine := AGeneratedLine;
+ FWarnings[FWarningCount - 1].GeneratedColumn := AGeneratedColumn;
+end;
+
+function TGocciaSourcePipelineResult.GetWarning(
+ const AIndex: Integer): TGocciaSourcePipelineWarning;
+begin
+ if (AIndex < 0) or (AIndex >= FWarningCount) then
+ raise ERangeError.CreateFmt('Source pipeline warning index out of range: %d',
+ [AIndex]);
+ Result := FWarnings[AIndex];
+end;
+
+function TGocciaSourcePipelineResult.TakeProgramNode: TGocciaProgram;
+begin
+ Result := FProgramNode;
+ FProgramNode := nil;
+end;
+
+function TGocciaSourcePipelineResult.TakeSourceMap: TGocciaSourceMap;
+begin
+ Result := FSourceMap;
+ FSourceMap := nil;
+end;
+
+{ TGocciaSourcePipelineModuleResult }
+
+destructor TGocciaSourcePipelineModuleResult.Destroy;
+begin
+ FProgramNode.Free;
+ inherited;
+end;
+
+procedure TGocciaSourcePipelineModuleResult.AddWarning(
+ const AWarning: TGocciaSourcePipelineWarning);
+begin
+ Inc(FWarningCount);
+ SetLength(FWarnings, FWarningCount);
+ FWarnings[FWarningCount - 1] := AWarning;
+end;
+
+function TGocciaSourcePipelineModuleResult.GetWarning(
+ const AIndex: Integer): TGocciaSourcePipelineWarning;
+begin
+ if (AIndex < 0) or (AIndex >= FWarningCount) then
+ raise ERangeError.CreateFmt('Source pipeline module warning index out of range: %d',
+ [AIndex]);
+ Result := FWarnings[AIndex];
+end;
+
+function TGocciaSourcePipelineModuleResult.TakeProgramNode: TGocciaProgram;
+begin
+ Result := FProgramNode;
+ FProgramNode := nil;
+end;
+
+{ TGocciaSourcePipeline }
+
+class function TGocciaSourcePipeline.DefaultOptions: TGocciaSourcePipelineOptions;
+begin
+ Result.Preprocessors := [];
+ Result.Compatibility := [];
+ Result.SourceType := stScript;
+end;
+
+class function TGocciaSourcePipeline.CurrentOptionsOrDefault: TGocciaSourcePipelineOptions;
+begin
+ if Assigned(GActiveSourcePipelineOptionsScope) then
+ Result := GActiveSourcePipelineOptionsScope.FOptions
+ else
+ Result := DefaultOptions;
+end;
+
+class function TGocciaSourcePipeline.ActivateOptions(
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineOptionsScope;
+begin
+ Result := TGocciaSourcePipelineOptionsScope.Create(AOptions);
+end;
+
+class function TGocciaSourcePipeline.Parse(const ASource: TStringList;
+ const AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineResult;
+var
+ SourceText, OriginalSourceText: string;
+ Lexer: TGocciaLexer;
+ Tokens: TObjectList;
+ Parser: TGocciaParser;
+ ParserWarning: TGocciaParserWarning;
+ PreprocessorSourceMap: TGocciaSourceMap;
+ StartTime, LexEnd, ParseEnd: Int64;
+ OrigLine, OrigCol, I: Integer;
+begin
+ Result := TGocciaSourcePipelineResult.Create;
+ try
+ StartTime := GetNanoseconds;
+ if Assigned(ASource) then
+ SourceText := StringListToLFText(ASource)
+ else
+ SourceText := '';
+ OriginalSourceText := SourceText;
+
+ SourceText := ApplyPreprocessors(SourceText, AOptions, PreprocessorSourceMap);
+ Result.FSourceMap := PreprocessorSourceMap;
+ if Assigned(Result.FSourceMap) then
+ begin
+ Result.FSourceMap.SetSourceContent(0, OriginalSourceText);
+ if not IsJSXNativeExtension(ExtractFileExt(AFileName)) then
+ Result.AddWarning(
+ 'JSX syntax found in source with a non-JSX extension',
+ 'Use a .jsx or .tsx extension for JSX source',
+ 1, 1, 1, 1);
+ end;
+
+ try
+ Lexer := TGocciaLexer.Create(SourceText, AFileName);
+ try
+ Tokens := Lexer.ScanTokens;
+ LexEnd := GetNanoseconds;
+ Result.FLexTimeNanoseconds := LexEnd - StartTime;
+ Result.FGeneratedSourceLines := CloneStringList(Lexer.SourceLines);
+
+ Parser := TGocciaParser.Create(Tokens, AFileName, Lexer.SourceLines);
+ ConfigureParser(Parser, AOptions);
+ try
+ Result.FProgramNode := Parser.Parse;
+ ParseEnd := GetNanoseconds;
+ Result.FParseTimeNanoseconds := ParseEnd - LexEnd;
+
+ for I := 0 to Parser.WarningCount - 1 do
+ begin
+ ParserWarning := Parser.GetWarning(I);
+ if (AOptions.SourceType = stModule) and
+ (ParserWarning.Message =
+ '''with'' statements require --compat-non-strict-mode') then
+ raise TGocciaSyntaxError.Create(
+ '''with'' statements are not allowed in strict mode',
+ ParserWarning.Line, ParserWarning.Column, AFileName,
+ Lexer.SourceLines);
+
+ OrigLine := ParserWarning.Line;
+ OrigCol := ParserWarning.Column;
+ if Assigned(Result.FSourceMap) then
+ Result.FSourceMap.Translate(ParserWarning.Line,
+ ParserWarning.Column, OrigLine, OrigCol);
+ Result.AddWarning(ParserWarning.Message, ParserWarning.Suggestion,
+ OrigLine, OrigCol, ParserWarning.Line, ParserWarning.Column);
+ end;
+ finally
+ Parser.Free;
+ end;
+ finally
+ Lexer.Free;
+ end;
+ except
+ on E: TGocciaError do
+ begin
+ if Assigned(Result.FSourceMap) and
+ Result.FSourceMap.Translate(E.Line, E.Column, OrigLine, OrigCol) then
+ E.TranslatePosition(OrigLine, OrigCol, ASource);
+ raise;
+ end;
+ end;
+ except
+ Result.Free;
+ raise;
+ end;
+end;
+
+class function TGocciaSourcePipeline.ParseModuleSource(const ASource: UTF8String;
+ const AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaSourcePipelineModuleResult;
+var
+ ModuleOptions: TGocciaSourcePipelineOptions;
+ PipelineResult: TGocciaSourcePipelineResult;
+ SourceLines: TStringList;
+ I: Integer;
+begin
+ ModuleOptions := AOptions;
+ ModuleOptions.SourceType := stModule;
+ SourceLines := SourceTextToLines(ASource);
+ try
+ PipelineResult := Parse(SourceLines, AFileName, ModuleOptions);
+ try
+ Result := TGocciaSourcePipelineModuleResult.Create;
+ try
+ Result.FProgramNode := PipelineResult.TakeProgramNode;
+ for I := 0 to PipelineResult.WarningCount - 1 do
+ Result.AddWarning(PipelineResult.Warnings[I]);
+ except
+ Result.Free;
+ raise;
+ end;
+ finally
+ PipelineResult.Free;
+ end;
+ finally
+ SourceLines.Free;
+ end;
+end;
+
+class function TGocciaSourcePipeline.ParseExpression(const AExpressionText,
+ AFileName: string; const AOptions: TGocciaSourcePipelineOptions;
+ const ADeclaredPrivateNames: TStrings): TGocciaExpression;
+var
+ Lexer: TGocciaLexer;
+ Parser: TGocciaParser;
+ SourceLines: TStringList;
+ Tokens: TObjectList;
+begin
+ Result := nil;
+ if AExpressionText = '' then
+ Exit;
+
+ SourceLines := CreateECMAScriptSourceLines(AExpressionText);
+ try
+ Lexer := TGocciaLexer.Create(AExpressionText, AFileName);
+ try
+ Tokens := Lexer.ScanTokens;
+ if not Assigned(Tokens) then
+ Exit;
+ Parser := TGocciaParser.Create(Tokens, AFileName, SourceLines);
+ ConfigureParser(Parser, AOptions);
+ try
+ if Assigned(ADeclaredPrivateNames) then
+ Result := Parser.ParseExpressionWithPrivateNames(ADeclaredPrivateNames)
+ else
+ Result := Parser.Expression;
+ if not Parser.AtEnd then
+ begin
+ Result.Free;
+ Result := nil;
+ end;
+ finally
+ Parser.Free;
+ end;
+ finally
+ Lexer.Free;
+ end;
+ finally
+ SourceLines.Free;
+ end;
+end;
+
+class function TGocciaSourcePipeline.ParseFunctionParameters(
+ const AParametersSource, AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): Boolean;
+var
+ ArrowFunction: TGocciaArrowFunctionExpression;
+ PipelineResult: TGocciaSourcePipelineResult;
+ Source: TStringList;
+begin
+ Source := TStringList.Create;
+ try
+ Source.Text := '(' + AParametersSource + ') => {}';
+ PipelineResult := Parse(Source, AFileName, AOptions);
+ try
+ Result := HasSingleArrowFunctionProgram(PipelineResult.ProgramNode,
+ ArrowFunction);
+ finally
+ PipelineResult.Free;
+ end;
+ finally
+ Source.Free;
+ end;
+end;
+
+class function TGocciaSourcePipeline.ParseFunctionBodyWrapper(
+ const ABodySource, AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaFunctionBodyParseResult;
+var
+ ArrowFunction: TGocciaArrowFunctionExpression;
+ PipelineResult: TGocciaSourcePipelineResult;
+ Source: TStringList;
+begin
+ Result.IsValid := False;
+ Result.HasUseStrictDirective := False;
+ Source := TStringList.Create;
+ try
+ Source.Text := '() => {' + #10 + ABodySource + #10 + '}';
+ PipelineResult := Parse(Source, AFileName, AOptions);
+ try
+ Result.IsValid := HasSingleArrowFunctionProgram(PipelineResult.ProgramNode,
+ ArrowFunction);
+ if Result.IsValid then
+ Result.HasUseStrictDirective := HasUseStrictDirective(
+ ArrowFunction.Body);
+ finally
+ PipelineResult.Free;
+ end;
+ finally
+ Source.Free;
+ end;
+end;
+
+class function TGocciaSourcePipeline.ParseDynamicFunctionWrapper(
+ const AParametersSource, ABodySource, AFileName: string;
+ const AOptions: TGocciaSourcePipelineOptions): TGocciaProgram;
+var
+ Lexer: TGocciaLexer;
+ Parser: TGocciaParser;
+ Source: string;
+ OriginalSourceLines: TStringList;
+ SourceMap: TGocciaSourceMap;
+ OrigLine, OrigCol: Integer;
+begin
+ Source := '({ anonymous(' + AParametersSource + ') {' + #10 + ABodySource +
+ #10 + '} }).anonymous';
+
+ OriginalSourceLines := CreateECMAScriptSourceLines(Source);
+ try
+ Source := ApplyPreprocessors(Source, AOptions, SourceMap);
+ try
+ Lexer := TGocciaLexer.Create(Source, AFileName);
+ try
+ Parser := TGocciaParser.Create(Lexer.ScanTokens, AFileName,
+ Lexer.SourceLines);
+ ConfigureParser(Parser, AOptions);
+ try
+ try
+ Result := Parser.ParseUnchecked;
+ except
+ on E: TGocciaError do
+ begin
+ if Assigned(SourceMap) and
+ SourceMap.Translate(E.Line, E.Column, OrigLine, OrigCol) then
+ E.TranslatePosition(OrigLine, OrigCol, OriginalSourceLines);
+ raise;
+ end;
+ end;
+ finally
+ Parser.Free;
+ end;
+ finally
+ Lexer.Free;
+ end;
+ finally
+ SourceMap.Free;
+ end;
+ finally
+ OriginalSourceLines.Free;
+ end;
+end;
+
+end.
diff --git a/tests/language/asi/goccia.json b/tests/language/asi/goccia.json
index 3757b734..314cbf3d 100644
--- a/tests/language/asi/goccia.json
+++ b/tests/language/asi/goccia.json
@@ -1,3 +1,3 @@
{
- "asi": true
+ "compat-asi": true
}
diff --git a/tests/language/modules/mjs-entry-source-type.mjs b/tests/language/modules/mjs-entry-source-type.mjs
new file mode 100644
index 00000000..2cc40559
--- /dev/null
+++ b/tests/language/modules/mjs-entry-source-type.mjs
@@ -0,0 +1,13 @@
+const topLevelThis = this;
+const metaUrl = import.meta.url;
+
+describe(".mjs entry source type", () => {
+ test(".mjs entries default to module source", () => {
+ expect(topLevelThis).toBeUndefined();
+ });
+
+ test("import.meta resolves for .mjs entries without source-type config", () => {
+ expect(typeof metaUrl).toBe("string");
+ expect(metaUrl.endsWith("/mjs-entry-source-type.mjs")).toBe(true);
+ });
+});
diff --git a/tests/language/with/asi/goccia.json b/tests/language/with/asi/goccia.json
index ce83bbff..8b07681c 100644
--- a/tests/language/with/asi/goccia.json
+++ b/tests/language/with/asi/goccia.json
@@ -1,4 +1,4 @@
{
"extends": "../goccia.json",
- "asi": true
+ "compat-asi": true
}
diff --git a/tmp/logo-detail/cut.png b/tmp/logo-detail/cut.png
new file mode 100644
index 00000000..f5ec63c9
Binary files /dev/null and b/tmp/logo-detail/cut.png differ
diff --git a/tmp/logo-detail/final-balanced.png b/tmp/logo-detail/final-balanced.png
new file mode 100644
index 00000000..da10dd53
Binary files /dev/null and b/tmp/logo-detail/final-balanced.png differ
diff --git a/tmp/logo-detail/manual-balanced.png b/tmp/logo-detail/manual-balanced.png
new file mode 100644
index 00000000..3f6aa97f
Binary files /dev/null and b/tmp/logo-detail/manual-balanced.png differ
diff --git a/tmp/logo-detail/manual-balanced.svg b/tmp/logo-detail/manual-balanced.svg
new file mode 100644
index 00000000..b91f637d
--- /dev/null
+++ b/tmp/logo-detail/manual-balanced.svg
@@ -0,0 +1,3164 @@
+
+
+
diff --git a/tmp/logo-detail/manual-max.png b/tmp/logo-detail/manual-max.png
new file mode 100644
index 00000000..d4b56a25
Binary files /dev/null and b/tmp/logo-detail/manual-max.png differ
diff --git a/tmp/logo-detail/manual-max.svg b/tmp/logo-detail/manual-max.svg
new file mode 100644
index 00000000..903326b5
--- /dev/null
+++ b/tmp/logo-detail/manual-max.svg
@@ -0,0 +1,136196 @@
+
+
+
diff --git a/tmp/logo-detail/photo-preset.png b/tmp/logo-detail/photo-preset.png
new file mode 100644
index 00000000..496b0a87
Binary files /dev/null and b/tmp/logo-detail/photo-preset.png differ
diff --git a/tmp/logo-detail/photo-preset.svg b/tmp/logo-detail/photo-preset.svg
new file mode 100644
index 00000000..3f98dccd
--- /dev/null
+++ b/tmp/logo-detail/photo-preset.svg
@@ -0,0 +1,543 @@
+
+
+
diff --git a/tmp/logo-large.svg b/tmp/logo-large.svg
new file mode 100644
index 00000000..71fec342
--- /dev/null
+++ b/tmp/logo-large.svg
@@ -0,0 +1,1143 @@
+
+
+
diff --git a/tmp/logo-medium.svg b/tmp/logo-medium.svg
new file mode 100644
index 00000000..b3b223b7
--- /dev/null
+++ b/tmp/logo-medium.svg
@@ -0,0 +1,548 @@
+
+
+
diff --git a/tmp/logo-poster.svg b/tmp/logo-poster.svg
new file mode 100644
index 00000000..b90248a7
--- /dev/null
+++ b/tmp/logo-poster.svg
@@ -0,0 +1,2226 @@
+
+
+
diff --git a/tmp/logo-small.svg b/tmp/logo-small.svg
new file mode 100644
index 00000000..7abb259f
--- /dev/null
+++ b/tmp/logo-small.svg
@@ -0,0 +1,61 @@
+
+
+
diff --git a/tmp/logo-tune/current-script-output.png b/tmp/logo-tune/current-script-output.png
new file mode 100644
index 00000000..1349a37a
Binary files /dev/null and b/tmp/logo-tune/current-script-output.png differ
diff --git a/tmp/logo-tune/cut-detail-no-blur.png b/tmp/logo-tune/cut-detail-no-blur.png
new file mode 100644
index 00000000..2cb33d93
Binary files /dev/null and b/tmp/logo-tune/cut-detail-no-blur.png differ
diff --git a/tmp/logo-tune/cut-detail-soft.png b/tmp/logo-tune/cut-detail-soft.png
new file mode 100644
index 00000000..36e53f93
Binary files /dev/null and b/tmp/logo-tune/cut-detail-soft.png differ
diff --git a/tmp/logo-tune/cut-floodfill.png b/tmp/logo-tune/cut-floodfill.png
new file mode 100644
index 00000000..15c51183
Binary files /dev/null and b/tmp/logo-tune/cut-floodfill.png differ
diff --git a/tmp/logo-tune/cut-max-detail.png b/tmp/logo-tune/cut-max-detail.png
new file mode 100644
index 00000000..2d983f9f
Binary files /dev/null and b/tmp/logo-tune/cut-max-detail.png differ
diff --git a/tmp/logo-tune/cut-no-blur.png b/tmp/logo-tune/cut-no-blur.png
new file mode 100644
index 00000000..4082c02f
Binary files /dev/null and b/tmp/logo-tune/cut-no-blur.png differ
diff --git a/tmp/logo-tune/cut-preserve-alpha.png b/tmp/logo-tune/cut-preserve-alpha.png
new file mode 100644
index 00000000..6801807f
Binary files /dev/null and b/tmp/logo-tune/cut-preserve-alpha.png differ
diff --git a/tmp/logo-tune/detail-no-blur.png b/tmp/logo-tune/detail-no-blur.png
new file mode 100644
index 00000000..8e47fbd2
Binary files /dev/null and b/tmp/logo-tune/detail-no-blur.png differ
diff --git a/tmp/logo-tune/detail-no-blur.svg b/tmp/logo-tune/detail-no-blur.svg
new file mode 100644
index 00000000..ff667865
--- /dev/null
+++ b/tmp/logo-tune/detail-no-blur.svg
@@ -0,0 +1,857 @@
+
+
+
diff --git a/tmp/logo-tune/detail-soft.png b/tmp/logo-tune/detail-soft.png
new file mode 100644
index 00000000..8e47fbd2
Binary files /dev/null and b/tmp/logo-tune/detail-soft.png differ
diff --git a/tmp/logo-tune/detail-soft.svg b/tmp/logo-tune/detail-soft.svg
new file mode 100644
index 00000000..ff667865
--- /dev/null
+++ b/tmp/logo-tune/detail-soft.svg
@@ -0,0 +1,857 @@
+
+
+
diff --git a/tmp/logo-tune/final-logo-svg-render.png b/tmp/logo-tune/final-logo-svg-render.png
new file mode 100644
index 00000000..fc390c11
Binary files /dev/null and b/tmp/logo-tune/final-logo-svg-render.png differ
diff --git a/tmp/logo-tune/floodfill.png b/tmp/logo-tune/floodfill.png
new file mode 100644
index 00000000..b8b48d4e
Binary files /dev/null and b/tmp/logo-tune/floodfill.png differ
diff --git a/tmp/logo-tune/floodfill.svg b/tmp/logo-tune/floodfill.svg
new file mode 100644
index 00000000..38b8ed53
--- /dev/null
+++ b/tmp/logo-tune/floodfill.svg
@@ -0,0 +1,306 @@
+
+
+
diff --git a/tmp/logo-tune/max-detail.png b/tmp/logo-tune/max-detail.png
new file mode 100644
index 00000000..6bfa43d5
Binary files /dev/null and b/tmp/logo-tune/max-detail.png differ
diff --git a/tmp/logo-tune/max-detail.svg b/tmp/logo-tune/max-detail.svg
new file mode 100644
index 00000000..4bf1193a
--- /dev/null
+++ b/tmp/logo-tune/max-detail.svg
@@ -0,0 +1,1796 @@
+
+
+
diff --git a/tmp/logo-tune/no-blur.png b/tmp/logo-tune/no-blur.png
new file mode 100644
index 00000000..de198a97
Binary files /dev/null and b/tmp/logo-tune/no-blur.png differ
diff --git a/tmp/logo-tune/no-blur.svg b/tmp/logo-tune/no-blur.svg
new file mode 100644
index 00000000..48c7e22a
--- /dev/null
+++ b/tmp/logo-tune/no-blur.svg
@@ -0,0 +1,273 @@
+
+
+
diff --git a/tmp/logo-tune/preserve-alpha.png b/tmp/logo-tune/preserve-alpha.png
new file mode 100644
index 00000000..3e9e00e9
Binary files /dev/null and b/tmp/logo-tune/preserve-alpha.png differ
diff --git a/tmp/logo-tune/preserve-alpha.svg b/tmp/logo-tune/preserve-alpha.svg
new file mode 100644
index 00000000..c74304a1
--- /dev/null
+++ b/tmp/logo-tune/preserve-alpha.svg
@@ -0,0 +1,346 @@
+
+
+
diff --git a/website/public/logo.png b/website/public/logo.png
index 587a273c..bbe42c73 100644
Binary files a/website/public/logo.png and b/website/public/logo.png differ