Compare commits

..
23 Commits
Author SHA1 Message Date
sergeych 580256d520 Add decimal module and operator interop registry 2026-03-27 21:31:37 +03:00
sergeych 4269310beb Use canonical class identity for delegate checks 2026-03-27 19:19:38 +03:00
sergeych 7c059b4741 Fix lazy delegate type resolution across modules 2026-03-27 18:57:27 +03:00
sergeych 217787e17a Temporary lazy builtin baseline 2026-03-27 18:46:53 +03:00
sergeych 9ddc7dbee6 Fix remaining compiler and VM review findings 2026-03-27 16:10:49 +03:00
sergeych 24937c7cf5 some commercial proposals and clarifications 2026-03-27 15:53:12 +03:00
sergeych ecc4d8b9ed Add explicit script import prep APIs and VM regression tests 2026-03-27 15:51:17 +03:00
sergeych 3d8bfe8863 Add Lyng string interpolation with docs/tests and refresh changelog 2026-03-25 18:43:23 +03:00
sergeych 3b83439788 Rewrite Lyng common-platform proposal with validated samples 2026-03-25 17:53:57 +03:00
sergeych 0af0f31e48 site version fix 2026-03-22 03:11:34 +03:00
sergeych d17ad9ef0d 1.5.0 release; console stability fix; tetris sample rewritten to be RC-free 2026-03-22 03:11:08 +03:00
sergeych 222a653040 pause for tetris ;) 2026-03-21 01:44:28 +03:00
sergeych f24c7d2715 some docs tweaks 2026-03-20 23:44:18 +03:00
sergeych 2546a5327f better tetris ;) 2026-03-20 23:04:01 +03:00
sergeych 4df6612eca 1.5.0-RC2: build fixes 2026-03-19 22:45:08 +03:00
sergeych 2a79c718ba 1.5.0-RC2: improved lyngio.console, some polishing 2026-03-19 22:41:06 +03:00
sergeych d92309d76c fixed version for site badge 2026-03-19 01:34:23 +03:00
sergeych 767e995a96 RC version bump 2026-03-19 01:33:08 +03:00
sergeych 794553d81d Add stdlib Random API and migrate tetris RNG 2026-03-19 01:30:35 +03:00
sergeych d9d7cafec8 +added console spport for lyngio
+added console support to lyng/jlyng CLI
+added unicode escapes
+created tetris console sample
2026-03-19 01:09:32 +03:00
sergeych 1a080bc53e added AI coding data for Lyng 2026-03-17 14:05:26 +03:00
sergeych a6492bb750 Add support for symbol inclusion via directive and refactor extern classes handling 2026-03-15 09:13:33 +03:00
sergeych d2a47d34a3 fixed extending extern classes (extension methods) 2026-03-15 05:35:29 +03:00
93 changed files with 8285 additions and 593 deletions

No files matched your search

+14
View File
@@ -1,5 +1,19 @@
# AI Agent Notes # AI Agent Notes
## Canonical AI References
- Use `docs/ai_language_reference.md` as the primary, compiler-verified Lyng language reference for code generation.
- For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`.
- Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface.
- Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above.
- Prefer the shortest clear loop: use `for` for straightforward iteration/ranges; use `while` only when loop state/condition is irregular or changes in ways `for` cannot express cleanly.
- In Lyng code, slice strings with range indexing (`text[a..<b]`, `text[..<n]`, `text[n..]`) and avoid Java/Kotlin-style `substring(...)`.
## Lyng-First API Declarations
- Use `.lyng` declarations as the single source of truth for Lyng-facing API docs and types (especially module extern declarations).
- Prefer defining Lyng entities (enums/classes/type shapes) in `.lyng` files; only define them in Kotlin when there is Kotlin/platform-specific implementation detail that cannot be expressed in Lyng.
- Avoid hardcoding Lyng API documentation in Kotlin registrars when it can be declared in `.lyng`; Kotlin-side docs should be fallback/bridge only.
- For mixed pluggable modules (Lyng + Kotlin), embed module `.lyng` sources as generated Kotlin string literals, evaluate them into module scope during registration, then attach Kotlin implementations/bindings.
## Kotlin/Wasm generation guardrails ## Kotlin/Wasm generation guardrails
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`. - Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
- Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks). - Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks).
+73 -141
View File
@@ -1,156 +1,88 @@
## 1.5.0-SNAPSHOT # Changelog
### Language Features This file tracks user-visible Lyng language/runtime/tooling changes.
- Added `return` statement with local and non-local exit support (`return@label`).
- Support for `abstract` classes, methods, and variables.
- Introduced `interface` as a synonym for `abstract class`.
- Multiple Inheritance (MI) completed and enabled by default (C3 MRO).
- Class properties with custom accessors (`get`, `set`).
- Restricted setter visibility (`private set`, `protected set`).
- Late-initialized `val` fields in classes with `Unset` protection.
- Named arguments (`name: value`) and named splats (`...Map`).
- Assign-if-null operator `?=`.
- Refined `protected` visibility rules and `closed` modifier.
- Transient attribute `@Transient` for serialization and equality.
- Unified Delegation model for `val`, `var`, and `fun`.
- Singleton objects (`object`) and object expressions.
### Standard Library History note:
- Added `with(self, block)` for scoped execution. - The project had periods where changelog maintenance lagged behind commits.
- Added `clamp()` function and extension. - Entries below are synchronized and curated for `1.5.x`.
- Improved `Exception` and `StackTraceEntry` reporting. - Earlier history may be incomplete and should be cross-checked with git tags/commits when needed.
### Tooling and IDE ## 1.5.1 (2026-03-25)
- **CLI**: Added `fmt` as a first-class subcommand for code formatting.
- **IDEA Plugin**: Lightweight autocompletion (experimental), improved docs, and Grazie integration.
- **Highlighters**: Updated TextMate bundle and website highlighters for new syntax.
### Detailed Changes: ### Language
- Added string interpolation:
- `"$name"` identifier interpolation.
- `"${expr}"` expression interpolation.
- Added literal-dollar forms in strings:
- `"\$"` -> `$`
- `"$$"` -> `$`
- `\\$x` is parsed as backslash + interpolation of `x`.
- Added per-file interpolation opt-out via leading directive comment:
- `// feature: interpolation: off`
- Language: Refined `protected` visibility rules ### Docs and AI references
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor). - Updated compiler-accurate AI language docs:
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass. - interpolation syntax and escaping
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic. - per-file feature switch behavior
- Refreshed tutorial examples and doctests to reflect new interpolation semantics.
- Added/reworked current proposal/reference materials for Lyng common-platform guidance.
- Language: Added `return` statement ### Compatibility notes
- `return [expression]` exits the innermost enclosing callable (function or lambda). - Interpolation is enabled by default for normal string literals.
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`). - Existing code that intentionally used `$name` as literal text should use `\$name`, `$$name`, or the file directive `// feature: interpolation: off`.
- Named functions automatically provide their name as a label for non-local returns.
- Labeled lambdas: lambdas can be explicitly labeled using `@label { ... }`.
- Restriction: `return` is forbidden in shorthand function definitions (e.g., `fun f(x) = return x` is a syntax error).
- Control Flow: `return` and `break` are now protected from being caught by user-defined `try-catch` blocks in Lyng.
- Documentation: New `docs/return_statement.md` and updated `tutorial.md`.
- Language: stdlib improvements ## 1.5.0 (2026-03-22)
- Added `with(self, block)` function to `root.lyng` which executes a block with `this` set to the provided object.
- Language: Abstract Classes and Interfaces
- Support for `abstract` modifier on classes, methods, and variables.
- Introduced `interface` as a synonym for `abstract class`, supporting full state (constructors, fields, `init` blocks) and implementation by parts via MI.
- New `closed` modifier (antonym to `open`) to prevent overriding class members.
- Refined `override` logic: mandatory keyword when re-declaring members that exist in the ancestor chain (MRO).
- MI Satisfaction: Abstract requirements are automatically satisfied by matching concrete members found later in the C3 MRO chain without requiring explicit proxy methods.
- Integration: Updated highlighters (lynglib, lyngweb, IDEA plugin), IDEA completion, and Grazie grammar checking.
- Documentation: Updated `docs/OOP.md` with sections on "Abstract Classes and Members", "Interfaces", and "Overriding and Virtual Dispatch".
- IDEA plugin: Improved natural language support and spellchecking
- Disabled the limited built-in English and Technical dictionaries.
- Enforced usage of the platform's standard Natural Languages (Grazie) and Spellchecker components.
- Integrated `SpellCheckerManager` for word suggestions and validation, respecting users' personal and project dictionaries.
- Added project-specific "learned words" support via `Lyng Formatter` settings and quick-fixes.
- Enhanced fallback spellchecker for technical terms and Lyng-specific vocabulary.
- Language: Class properties with accessors ### Major runtime/compiler direction
- Support for `val` (read-only) and `var` (read-write) properties in classes. - Completed migration to bytecode-first/bytecode-only execution paths.
- Syntax: `val name [ : Type ] get() { body }` or `var name [ : Type ] get() { body } set(value) { body }`. - Removed interpreter fallback behavior in core execution hot paths.
- Laconic Expression Shorthand: `val prop get() = expression` and `var prop get() = read set(v) = write`. - Continued frame-slot-first local/capture model improvements and related diagnostics.
- Properties are pure accessors and do **not** have automatic backing fields.
- Validation: `var` properties must have both accessors; `val` must have only a getter.
- Integration: Updated TextMate grammar and IntelliJ plugin (highlighting + keywords).
- Documentation: New "Properties" section in `docs/OOP.md`.
- Language: Restricted Setter Visibility ### Language features and semantics
- Support for `private set` and `protected set` modifiers on `var` fields and properties. - Added/finished `return` semantics including labeled non-local forms (`return@label`).
- Allows members to be publicly readable but only writable from within the declaring class or its subclasses. - Added abstract classes/members and `interface` support (as abstract-class-style construct).
- Enforcement at runtime: throws `AccessException` on unauthorized writes. - Completed and enabled multiple inheritance with C3 MRO by default.
- Supported only for declarations in class bodies (fields and properties). - Added class properties with accessors (`get`/`set`) and restricted setter visibility (`private set`, `protected set`).
- Documentation: New "Restricted Setter Visibility" section in `docs/OOP.md`. - Added late-initialized class `val` support with `Unset` protection rules.
- Added named arguments (`name: value`) and named splats (`...map`) with stricter validation.
- Added assign-if-null operator `?=`.
- Improved nullable/type-checking behavior (including `T is nullable` and related type checks).
- Added variadic function types (`...` in function type declarations) and tighter lambda type checks.
- Language: Late-initialized `val` fields in classes ### Type system and collections
- Support for declaring `val` without an immediate initializer in class bodies. - Added immutable collections hierarchy (`ImmutableList`, `ImmutableSet`, `ImmutableMap`).
- Compulsory initialization: every late-init `val` must be assigned at least once within the class body or an `init` block. - Improved generic runtime binding/checking for explicit type arguments and bounds.
- Write-once enforcement: assigning to a `val` is allowed only if its current value is `Unset`. - Added smarter type-aware collection ops (`+=`, `-=`) and stronger declared-member type checks.
- Access protection: reading a late-init `val` before it is assigned returns the `Unset` singleton; using `Unset` for most operations throws an `UnsetException`.
- Extension properties do not support late-init.
- Documentation: New "Late-initialized `val` fields" and "The `Unset` singleton" sections in `docs/OOP.md`.
- Docs: OOP improvements ### Extern/Kotlin bridge
- New page: `docs/scopes_and_closures.md` detailing `ClosureScope` resolution order, recursion‑safe helpers (`chainLookupIgnoreClosure`, `chainLookupWithMembers`, `baseGetIgnoreClosure`), cycle prevention, and capturing lexical environments for callbacks (`snapshotForClosure`). - Tightened extern declaration rules:
- Updated: `docs/advanced_topics.md` (link to the new page), `docs/parallelism.md` (closures in `launch`/`flow`), `docs/OOP.md` (visibility from closures with preserved `currentClassCtx`), `docs/exceptions_handling.md` (compatibility alias `SymbolNotFound`). - explicit extern members are required for extern class/object declarations.
- Tutorial: added quick link to Scopes and Closures. - Improved extern generic class behavior and diagnostics.
- Extended bridge APIs for binding global functions/variables and object/member interop scenarios.
- IDEA plugin: Lightweight autocompletion (experimental) ### Standard library and modules
- Global completion: local declarations, in‑scope parameters, imported modules, and stdlib symbols. - Added `lyng.observable` improvements (`ObservableList` hooks/events).
- Member completion: after a dot, suggests only members of the inferred receiver type (incl. chained calls like `Path(".." ).lines().` → `Iterator` methods). No global identifiers appear after a dot. - Added `Random` stdlib API used by updated samples.
- Inheritance-aware: direct class members first, then inherited (e.g., `List` includes `Collection`/`Iterable` methods). - Added/extended `lyngio.console` support and CLI integration for console interaction.
- Heuristics: handles literals (`"…"` → `String`, numbers → `Int/Real`, `[...]` → `List`, `{...}` → `Dict`) and static `Namespace.` members. - Migrated time APIs to `kotlin.time` (`Instant` migration and related docs/tests).
- Performance: capped results, early prefix filtering, per‑document MiniAst cache, cancellation checks.
- Toggle: Settings | Lyng Formatter → "Enable Lyng autocompletion (experimental)" (default ON).
- Stabilization: DEBUG completion/Quick Doc logs are OFF by default; behavior aligned between IDE and isolated engine tests.
- Language: Named arguments and named splats ### CLI, IDE, and docs/tooling
- New call-site syntax for named arguments using colon: `name: value`. - CLI:
- Positional arguments must come before named; positionals after a named argument inside parentheses are rejected. - added first-class `fmt` command
- Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal. - preserved direct script fast-path invocation
- Named splats: `...` can now expand a Map into named arguments. - improved command help/dispatch behavior
- Only string keys are allowed; non-string keys raise a clear error. - IntelliJ plugin:
- Duplicate assignment across named args and named splats is an error. - improved lightweight completion and documentation/inspection behavior
- Ellipsis (variadic) parameters remain positional-only and cannot be named. - continued highlighter and Grazie/spellchecking integration work
- Rationale: `=` is assignment and an expression in Lyng; `:` at call sites avoids ambiguity. Declarations keep `name: Type`; call-site casts continue to use `as` / `as?`. - Docs:
- Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases. - substantial updates across tutorial/OOP/type/runtime references
- Tests added covering success cases and errors for named args/splats and trailing-lambda interactions. - expanded bytecode and advanced topics coverage
- Tooling: Highlighters and TextMate bundle updated for named args ## Migration checklist for 1.5.x
- Website/editor highlighter (lyngweb + site) works with `name: value` and `...Map("k" => v)`; added JS tests covering punctuation/operator spans for `:` and `...`.
- TextMate grammar updated to recognize named call arguments: `name: value` after `(` or `,` with `name` highlighted as `variable.parameter.named.lyng` and `:` as punctuation; excludes `::`.
- TextMate bundle version bumped to 0.0.3; README updated with details and guidance.
- Multiple Inheritance (MI) completed and enabled by default: - If you rely on literal `$...` strings:
- Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds. - replace with `\$...` or `$$...`, or
- Qualified dispatch: - add `// feature: interpolation: off` at file top.
- `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor. - Review any code relying on interpreter-era fallback behavior; 1.5.x assumes bytecode-first execution.
- Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`). - For extern declarations, ensure members are explicitly declared where required.
- Field inheritance (`val`/`var`) under MI: - For named arguments/splats, verify call sites follow stricter ordering/duplication rules.
- Instance storage is disambiguated per declaring class; unqualified read/write resolves to the first match in MRO.
- Qualified read/write targets the chosen ancestor’s storage.
- Constructors and initialization:
- Direct bases are initialized left-to-right; each ancestor is initialized at most once (diamond-safe de-duplication).
- Header-specified constructor arguments are passed to direct bases.
- Visibility enforcement under MI:
- `private` visible only inside the declaring class body.
- `protected` visible inside the declaring class and its transitive subclasses. Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Unrelated contexts cannot access it (qualification/casts do not bypass).
- Diagnostics improvements:
- Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
- Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
- `as`/`as?` cast errors include actual and target type names.
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
- CLI: Added `fmt` as a first-class Clikt subcommand.
- Default behavior: formats files to stdout (no in-place edits by default).
- Options:
- `--check`: check only; print files that would change; exit with code 2 if any changes are needed.
- `-i, --in-place`: write formatted result back to files.
- `--spacing`: apply spacing normalization.
- `--wrap`, `--wrapping`: enable line wrapping.
- Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1.
- Multi-file stdout prints headers `--- <path> ---` per file.
- `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help.
- Fix: Property accessors (`get`, `set`, `private set`, `protected set`) are now correctly indented relative to the property declaration.
- Fix: Indentation now correctly carries over into blocks that start on extra‑indented lines (e.g., nested `if` statements or property accessor bodies).
- Fix: Formatting Markdown files no longer deletes content in `.lyng` code fences and works correctly with injected files (resolves clobbering, `StringIndexOutOfBoundsException`, and `nonempty text is not covered by block` errors).
- CLI: Preserved legacy script invocation fast-paths:
- `lyng script.lyng [args...]` executes the script directly.
- `lyng -- -file.lyng [args...]` executes a script whose name begins with `-`.
- CLI: Fixed a regression where the root help banner could print before subcommands.
- Root command no longer prints help when a subcommand (e.g., `fmt`) is invoked.
+250
View File
@@ -0,0 +1,250 @@
# Decimal (`lyng.decimal`)
`lyng.decimal` adds an arbitrary-precision decimal type to Lyng as a normal library module.
Import it when you need decimal arithmetic that should not inherit `Real`'s binary floating-point behavior:
```lyng
import lyng.decimal
```
## What `BigDecimal` Is For
Use `BigDecimal` when values are fundamentally decimal:
- money
- human-entered quantities
- exact decimal text
- predictable decimal rounding
- user-facing formatting and tests
Do not use it just because a number has a fractional part. `Real` is still the right type for ordinary double-precision numeric work.
## Creating Decimal Values
There are three supported conversions:
```lyng
import lyng.decimal
val a = 1.d
val b = 2.2.d
val c = "2.2".d
assertEquals("1", a.toStringExpanded())
assertEquals("2.2", b.toStringExpanded())
assertEquals("2.2", c.toStringExpanded())
```
The three forms mean different things:
- `1.d`: convert `Int -> BigDecimal`
- `2.2.d`: convert `Real -> BigDecimal`
- `"2.2".d`: parse exact decimal text
That distinction is intentional.
### `Real.d` vs `"..." .d`
`Real.d` preserves the current `Real` value. It does not pretend the source code was exact decimal text.
```lyng
import lyng.decimal
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
assertEquals("0.3", "0.3".d.toStringExpanded())
```
This follows the "minimal confusion" rule:
- if you start from a `Real`, you get a decimal representation of that `Real`
- if you want exact decimal source text, use a `String`
## Factory Functions
The explicit factory methods are:
```lyng
import lyng.decimal
BigDecimal.fromInt(10)
BigDecimal.fromReal(2.5)
BigDecimal.fromString("12.34")
```
These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code.
## Core Operations
`BigDecimal` supports:
- `+`
- `-`
- `*`
- `/`
- `%`
- unary `-`
- comparison operators
- equality operators
Examples:
```lyng
import lyng.decimal
assertEquals("3.75", ("1.5".d + "2.25".d).toStringExpanded())
assertEquals("1.25", ("2.5".d - "1.25".d).toStringExpanded())
assertEquals("3.0", ("1.5".d * 2.d).toStringExpanded())
assertEquals("0.5", (1.d / 2.d).toStringExpanded())
assert("2.0".d > "1.5".d)
assert("2.0".d == 2.d)
```
## Interoperability With `Int` and `Real`
The decimal module registers mixed-operand operator bridges so both sides read naturally:
```lyng
import lyng.decimal
assertEquals(3.d, 1 + 2.d)
assertEquals(3.d, 2.d + 1)
assertEquals(1.5.d, 1.d + 0.5)
assertEquals(1.5.d, 0.5 + 1.d)
assert(2 == 2.d)
assert(3 > 2.d)
```
Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + BigDecimal` and `Real + BigDecimal`.
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
## String Representation
Use `toStringExpanded()` when you want plain decimal output without scientific notation:
```lyng
import lyng.decimal
assertEquals("12.34", "12.34".d.toStringExpanded())
```
This is the recommended representation for:
- tests
- user-visible diagnostics
- decimal formatting checks
## Conversions Back To Built-ins
```lyng
import lyng.decimal
assertEquals(2, "2.9".d.toInt())
assertEquals(2.9, "2.9".d.toReal())
```
Use `toReal()` only when you are willing to return to binary floating-point semantics.
## Division Context
Division is the operation where precision and rounding matter most.
By default, decimal division uses:
- precision: `34` significant digits
- rounding: `HalfEven`
Example:
```lyng
import lyng.decimal
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
```
## `withDecimalContext(...)`
Use `withDecimalContext(...)` to override decimal division rules inside a block:
```lyng
import lyng.decimal
assertEquals(
"0.3333333333",
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
)
```
You can also pass an explicit context object:
```lyng
import lyng.decimal
val ctx = DecimalContext(6, DecimalRounding.HalfAwayFromZero)
assertEquals("0.666667", withDecimalContext(ctx) { ("2".d / 3.d).toStringExpanded() })
```
The context is dynamic and local to the block. After the block exits, the previous context is restored.
## Rounding Modes
Available rounding modes:
- `HalfEven`
- `HalfAwayFromZero`
- `HalfTowardsZero`
- `Ceiling`
- `Floor`
- `AwayFromZero`
- `TowardsZero`
Tie example at precision `2`:
```lyng
import lyng.decimal
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.Ceiling) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.Floor) { (1.d / 8.d).toStringExpanded() })
```
Negative values follow the same named policy in the obvious direction:
```lyng
import lyng.decimal
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
```
## Recommended Usage Rules
If you care about exact decimal source text:
```lyng
"12.34".d
```
If you intentionally convert an existing binary floating-point value:
```lyng
someReal.d
```
If you want local control over division:
```lyng
withDecimalContext(precision, rounding) { ... }
```
If you want custom mixed operators for your own type, follow the same pattern as Decimal and use the operator registry:
- define the operators on your own class
- choose a common class
- register mixed operand bridges
See [OperatorInterop.md](OperatorInterop.md).
+309
View File
@@ -0,0 +1,309 @@
# Operator Interop Registry
`lyng.operators` provides a runtime registry for mixed-class binary operators.
Import it when you want expressions such as:
- `1 + MyType(...)`
- `2 < MyType(...)`
- `3 == MyType(...)`
to work without modifying the built-in `Int` or `Real` classes.
```lyng
import lyng.operators
```
## Why This Exists
If your class defines:
```lyng
class Amount(val value: Int) {
fun plus(other: Amount) = Amount(value + other.value)
}
```
then:
```lyng
Amount(1) + Amount(2)
```
works, because the left operand already knows how to add another `Amount`.
But:
```lyng
1 + Amount(2)
```
does not naturally work, because `Int` has not been rewritten to know about `Amount`.
The operator interop registry solves exactly that problem.
## Mental Model
Registration describes a mixed pair:
- left class `L`
- right class `R`
- common class `C`
When Lyng sees `L op R`, it:
1. converts `L -> C`
2. converts `R -> C`
3. evaluates the operator as `C op C`
So the registry is a bridge, not a separate arithmetic engine.
## API
```lyng
OperatorInterop.register(
leftClass,
rightClass,
commonClass,
operators,
leftToCommon,
rightToCommon
)
```
Parameters:
- `leftClass`: original left operand class
- `rightClass`: original right operand class
- `commonClass`: class that will actually execute the operator methods
- `operators`: list of operators enabled for this pair
- `leftToCommon`: conversion from left operand to common class
- `rightToCommon`: conversion from right operand to common class
## Supported Operators
`BinaryOperator` values:
- `Plus`
- `Minus`
- `Mul`
- `Div`
- `Mod`
- `Compare`
- `Equals`
Meaning:
- `Compare` enables `<`, `<=`, `>`, `>=`, and `<=>`
- `Equals` enables `==` and `!=`
## Minimal Working Example
```lyng
package test.decimalbox
import lyng.operators
class DecimalBox(val value: Int) {
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
fun minus(other: DecimalBox) = DecimalBox(value - other.value)
fun mul(other: DecimalBox) = DecimalBox(value * other.value)
fun div(other: DecimalBox) = DecimalBox(value / other.value)
fun mod(other: DecimalBox) = DecimalBox(value % other.value)
fun compareTo(other: DecimalBox) = value <=> other.value
}
OperatorInterop.register(
Int,
DecimalBox,
DecimalBox,
[
BinaryOperator.Plus,
BinaryOperator.Minus,
BinaryOperator.Mul,
BinaryOperator.Div,
BinaryOperator.Mod,
BinaryOperator.Compare,
BinaryOperator.Equals
],
{ x: Int -> DecimalBox(x) },
{ x: DecimalBox -> x }
)
```
Then:
```lyng
import test.decimalbox
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
assertEquals(DecimalBox(1), 3 - DecimalBox(2))
assertEquals(DecimalBox(8), 4 * DecimalBox(2))
assertEquals(DecimalBox(4), 8 / DecimalBox(2))
assertEquals(DecimalBox(1), 7 % DecimalBox(2))
assert(1 < DecimalBox(2))
assert(2 <= DecimalBox(2))
assert(3 > DecimalBox(2))
assert(2 == DecimalBox(2))
assert(2 != DecimalBox(3))
```
## How Decimal Uses It
`lyng.decimal` uses this same mechanism so that:
```lyng
import lyng.decimal
1 + 2.d
0.5 + 1.d
2 == 2.d
3 > 2.d
```
work naturally even though `Int` and `Real` themselves were not edited to know `BigDecimal`.
The shape is:
- `leftClass = Int` or `Real`
- `rightClass = BigDecimal`
- `commonClass = BigDecimal`
- convert built-ins into `BigDecimal`
- leave `BigDecimal` values unchanged
## Step-By-Step Pattern For Your Own Type
### 1. Pick the common class
Choose one class that will be the actual arithmetic domain.
For numeric-like types, that is usually your own class:
```lyng
class Rational(...)
```
### 2. Implement operators on that class
The common class should define the operations you plan to register.
Example:
```lyng
class Rational(val num: Int, val den: Int) {
fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
fun minus(other: Rational) = Rational(num * other.den - other.num * den, den * other.den)
fun mul(other: Rational) = Rational(num * other.num, den * other.den)
fun div(other: Rational) = Rational(num * other.den, den * other.num)
fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
static fun fromInt(value: Int) = Rational(value, 1)
}
```
### 3. Register the mixed pair
```lyng
import lyng.operators
OperatorInterop.register(
Int,
Rational,
Rational,
[
BinaryOperator.Plus,
BinaryOperator.Minus,
BinaryOperator.Mul,
BinaryOperator.Div,
BinaryOperator.Compare,
BinaryOperator.Equals
],
{ x: Int -> Rational.fromInt(x) },
{ x: Rational -> x }
)
```
### 4. Use it
```lyng
assertEquals(Rational(3, 2), 1 + Rational(1, 2))
assert(Rational(3, 2) == Rational(3, 2))
assert(2 > Rational(3, 2))
```
## Registering More Than One Built-in Type
If you want both `Int + MyType` and `Real + MyType`, register both pairs explicitly:
```lyng
OperatorInterop.register(
Int,
MyType,
MyType,
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Int -> MyType.fromInt(x) },
{ x: MyType -> x }
)
OperatorInterop.register(
Real,
MyType,
MyType,
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Real -> MyType.fromReal(x) },
{ x: MyType -> x }
)
```
Each mixed pair is independent.
## Pure Lyng Registration
This mechanism is intentionally useful from pure Lyng code, not only from Kotlin-backed modules.
That means you can:
- declare a class in Lyng
- define its operators in Lyng
- register mixed operand bridges in Lyng
without touching compiler internals.
## Where To Register
Register once during module initialization.
Top-level module code is a good place:
```lyng
package my.rational
import lyng.operators
class Rational(...)
OperatorInterop.register(...)
```
That keeps registration close to the type declaration and makes importing the module enough to activate the interop.
## What Registration Does Not Do
The registry does not:
- invent operators your common class does not implement
- change the original `Int`, `Real`, or other built-ins
- automatically cover every class pair
- replace normal method overload resolution when the left-hand class already knows what to do
It only teaches Lyng how to bridge a specific mixed pair into a common class for the listed operators.
## Recommended Design Rules
If you want interop to feel natural:
- choose one obvious common class
- make conversions explicit and unsurprising
- implement `compareTo` if you want ordering operators
- register `Equals` whenever mixed equality should work
- keep the registered operator list minimal and accurate
For decimal-like semantics, also read [Decimal.md](Decimal.md).
+227
View File
@@ -0,0 +1,227 @@
# Lyng Language Reference for AI Agents (Current Compiler State)
Purpose: dense, implementation-first reference for generating valid Lyng code.
Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,Token,Compiler,Script,TypeDecl}.kt`, `lynglib/stdlib/lyng/root.lyng`, tests in `lynglib/src/commonTest` and `lynglib/src/jvmTest`.
## 1. Ground Rules
- Resolution is compile-time-first. Avoid runtime name/member lookup assumptions.
- `lyng.stdlib` is auto-seeded for normal scripts (default import manager).
- Use explicit casts when receiver type is unknown (`Object`/`Obj`).
- Prefer modern null-safe operators (`?.`, `?:`/`??`, `?=`, `as?`, `!!`).
- Do not rely on fallback opcodes or dynamic member fallback semantics.
## 2. Lexical Syntax
- Comments: `// line`, `/* block */`.
- Strings: `"..."` (supports escapes). Multiline string content is normalized by indentation logic.
- Supported escapes: `\n`, `\r`, `\t`, `\"`, `\\`, `\uXXXX` (4 hex digits).
- Unicode escapes use exactly 4 hex digits (for example: `"\u0416"` -> `Ж`).
- Unknown `\x` escapes in strings are preserved literally as two characters (`\` and `x`).
- String interpolation is supported:
- identifier form: `"$name"`
- expression form: `"${expr}"`
- escaped dollar: `"\$"` and `"$$"` both produce literal `$`.
- `\\$x` means backslash + interpolated `x`.
- Per-file opt-out is supported via leading comment directive:
- `// feature: interpolation: off`
- with this directive, `$...` stays literal text.
- Numbers: `Int` (`123`, `1_000`), `Real` (`1.2`, `1e3`), hex (`0xFF`).
- Char: `'a'`, escaped chars supported.
- Supported escapes: `\n`, `\r`, `\t`, `\'`, `\\`, `\uXXXX` (4 hex digits).
- Backslash character in a char literal must be written as `'\\'` (forms like `'\'` are invalid).
- Labels:
- statement label: `loop@ for (...) { ... }`
- label reference: `break@loop`, `continue@loop`, `return@fnLabel`
- Keywords/tokens include (contextual in many places):
- declarations: `fun`/`fn`, `val`, `var`, `class`, `object`, `interface`, `enum`, `type`, `init`
- modifiers: `private`, `protected`, `static`, `abstract`, `closed`, `override`, `extern`, `open`
- flow: `if`, `else`, `when`, `for`, `while`, `do`, `try`, `catch`, `finally`, `throw`, `return`, `break`, `continue`
## 3. Literals and Core Expressions
- Scalars: `null`, `true`, `false`, `void`.
- List literal: `[a, b, c]`, spreads with `...`.
- Spread positions: beginning, middle, end are all valid: `[...a]`, `[0, ...a, 4]`, `[head, ...mid, tail]`.
- Spread source must be a `List` at runtime (non-list spread raises an error).
- Map literal: `{ key: value, x:, ...otherMap }`.
- `x:` means shorthand `x: x`.
- Map spread source must be a `Map`.
- Range literals:
- inclusive: `a..b`
- exclusive end: `a..<b`
- open-ended forms are supported (`a..`, `..b`, `..`).
- optional step: `a..b step 2`
- Lambda literal:
- with params: `{ x, y -> x + y }`
- implicit `it`: `{ it + 1 }`
- Ternary conditional is supported: `cond ? thenExpr : elseExpr`.
## 3.1 Splats in Calls and Lambdas
- Declaration-side variadic parameters use ellipsis suffix:
- functions: `fun f(head, tail...) { ... }`
- lambdas: `{ x, rest... -> ... }`
- Call-side splats use `...expr` and are expanded by argument kind:
- positional splat: `f(...[1,2,3])`
- named splat: `f(...{ a: 1, b: 2 })` (map-style)
- Runtime acceptance for splats:
- positional splat accepts `List` and general `Iterable` (iterable is converted to list first).
- named splat accepts `Map` with string keys only.
- Ordering/validation rules (enforced):
- positional argument cannot follow named arguments (except trailing-block parsing case).
- positional splat cannot follow named arguments.
- duplicate named arguments are errors (including duplicates introduced via named splat).
- unknown named parameters are errors.
- variadic parameter itself cannot be passed as a named argument (`fun g(args..., tail)` then `g(args: ...)` is invalid).
- Trailing block + named arguments:
- if the last callable parameter is already provided by name in parentheses, adding a trailing block is invalid.
## 4. Operators (implemented)
- Assignment: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `?=`.
- Logical: `||`, `&&`, unary `!`.
- Bitwise: `|`, `^`, `&`, `~`, shifts `<<`, `>>`.
- Equality/comparison: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, `>=`, `<=>`, `=~`, `!~`.
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family:
- member access: `?.`
- safe index: `?[i]`
- safe invoke: `?(...)`
- safe block invoke: `?{ ... }`
- elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`.
## 5. Declarations
- Variables:
- `val` immutable, `var` mutable.
- top-level/local `val` must be initialized.
- class `val` may be late-initialized, but must be assigned in class body/init before class parse ends.
- destructuring declaration: `val [a, b, rest...] = expr`.
- destructuring declaration details:
- allowed in `val` and `var` declarations.
- supports nested patterns: `val [a, [b, c...], d] = rhs`.
- supports at most one splat (`...`) per pattern level.
- RHS must be a `List`.
- without splat: RHS must have at least as many elements as pattern arity.
- with splat: head/tail elements are bound directly, splat receives a `List`.
- Functions:
- `fun` and `fn` are equivalent.
- full body: `fun f(x) { ... }`
- shorthand: `fun f(x) = expr`.
- generics: `fun f<T>(x: T): T`.
- extension functions: `fun Type.name(...) { ... }`.
- delegated callable: `fun f(...) by delegate`.
- Type aliases:
- `type Name = TypeExpr`
- generic: `type Box<T> = List<T>`
- aliases are expanded structurally.
- Classes/objects/enums/interfaces:
- `interface` is parsed as abstract class synonym.
- `object` supports named singleton and anonymous object expression forms.
- enums support lifted entries: `enum E* { A, B }`.
- multiple inheritance is supported; override is enforced when overriding base members.
- Properties/accessors in class body:
- accessor form supports `get`/`set`, including `private set`/`protected set`.
## 6. Control Flow
- `if` is expression-like.
- `when(value) { ... }` supported.
- branch conditions support equality, `in`, `!in`, `is`, `!is`, and `nullable` predicate.
- `when { ... }` (subject-less) is currently not implemented.
- Loops: `for`, `while`, `do ... while`.
- loop `else` blocks are supported.
- `break value` can return a loop result.
- Exceptions: `try/catch/finally`, `throw`.
## 6.1 Destructuring Assignment (implemented)
- Reassignment form is supported (not only declaration):
- `[x, y] = [y, x]`
- Semantics match destructuring declaration:
- nested patterns allowed.
- at most one splat per pattern level.
- RHS must be a `List`.
- too few RHS elements raises runtime error.
- Targets in pattern are variables parsed from identifier patterns.
## 7. Type System (current behavior)
- Non-null by default (`T`), nullable with `T?`.
- `as` (checked cast), `as?` (safe cast returning `null`), `!!` non-null assertion.
- Type expressions support:
- unions `A | B`
- intersections `A & B`
- function types `(A, B)->R` and receiver form `Receiver.(A)->R`
- variadics in function type via ellipsis (`T...`)
- Generics:
- type params on classes/functions/type aliases
- bounds via `:` with union/intersection expressions
- declaration-site variance via `in` / `out`
- Generic function/class/type syntax examples:
- function: `fun choose<T>(a: T, b: T): T = a`
- class: `class Box<T>(val value: T)`
- alias: `type PairList<T> = List<List<T>>`
- Untyped params default to `Object` (`x`) or `Object?` (`x?` shorthand).
- Untyped `var x` starts as `Unset`; first assignment fixes type tracking in compiler.
## 7.1 Generics Runtime Model and Bounds (AI-critical)
- Lyng generic type information is operational in script execution contexts; do not assume JVM-style full erasure.
- Generic call type arguments can be:
- explicit at call site (`f<Int>(1)` style),
- inferred from runtime values/declared arg types,
- defaulted from type parameter defaults (or `Any` fallback).
- At function execution, generic type parameters are runtime-bound as constants in scope:
- simple non-null class-like types are bound as `ObjClass`,
- complex/nullable/union/intersection forms are bound as `ObjTypeExpr`.
- Practical implication for generated code:
- inside generic code, treat type params as usable type objects in `is`/`in`/type-expression logic (not as purely compile-time placeholders).
- example pattern: `if (value is T) { ... }`.
- Bound syntax (implemented):
- intersection bound: `fun f<T: A & B>(x: T) { ... }`
- union bound: `fun g<T: A | B>(x: T) { ... }`
- Bound checks happen at two points:
- compile-time call checking for resolvable generic calls,
- runtime re-check while binding type params for actual invocation.
- Bound satisfaction is currently class-hierarchy based for class-resolvable parts (including union/intersection combination rules).
- Keep expectations realistic:
- extern-generic runtime ABI for full instance-level generic metadata is still proposal-level (`proposals/extern_generic_runtime_abi.md`), so avoid assuming fully materialized generic-instance metadata everywhere.
## 7.2 Differences vs Java / Kotlin / Scala
- Java:
- Java generics are erased at runtime (except reflection metadata and raw `Class` tokens).
- Lyng generic params in script execution are runtime-bound type objects, so generated code can reason about `T` directly.
- Kotlin:
- Kotlin on JVM is mostly erased; full runtime type access usually needs `inline reified`.
- Lyng generic function execution binds `T` without requiring an inline/reified escape hatch.
- Scala:
- Scala has richer static typing but still runs on JVM erasure model unless carrying explicit runtime evidence (`TypeTag`, etc.).
- Lyng exposes runtime-bound type expressions/classes directly in generic execution scope.
- AI generation rule:
- do not port JVM-language assumptions like “`T` unavailable at runtime unless reified/tagged”.
- in Lyng, prefer direct type-expression-driven branching when useful, but avoid assuming extern object generic args are always introspectable today.
## 8. OOP, Members, and Dispatch
- Multiple inheritance with C3-style linearization behavior is implemented in class machinery.
- Disambiguation helpers are supported:
- qualified this: `this@Base.member()`
- cast view: `(obj as Base).member()`
- On unknown receiver types, compiler allows only Object-safe members:
- `toString`, `toInspectString`, `let`, `also`, `apply`, `run`
- Other members require known receiver type or explicit cast.
## 9. Delegation (`by`)
- Works for `val`, `var`, and `fun`.
- Expected delegate hooks in practice:
- `getValue(thisRef, name)`
- `setValue(thisRef, name, newValue)`
- `invoke(thisRef, name, args...)` for delegated callables
- optional `bind(name, access, thisRef)`
- `@Transient` is recognized for declarations/params and affects serialization/equality behavior.
## 10. Modules and Imports
- `package` and `import module.name` are supported.
- Import form is module-only (no aliasing/selective import syntax in parser).
- Default module ecosystem includes:
- auto-seeded: `lyng.stdlib`
- available by import: `lyng.observable`, `lyng.buffer`, `lyng.serialization`, `lyng.time`
- extra module (when installed): `lyng.io.fs`, `lyng.io.process`
## 11. Current Limitations / Avoid
- No subject-less `when { ... }` yet.
- No regex literal tokenization (`/.../`); use `Regex("...")` or `"...".re`.
- Do not generate runtime name fallback patterns from legacy docs.
+75
View File
@@ -0,0 +1,75 @@
# Lyng Stdlib Reference for AI Agents (Compact)
Purpose: fast overview of what is available by default and what must be imported.
Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/stdlib/lyng/root.lyng`, `lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/observable_lyng.kt`.
## 1. Default Availability
- Normal scripts are auto-seeded with `lyng.stdlib` (default import manager path).
- Root runtime scope also exposes global constants/functions directly.
## 2. Core Global Functions (Root Scope)
- IO/debug: `print`, `println`, `traceScope`.
- Invocation/util: `call`, `run`, `dynamic`, `cached`, `lazy`.
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
- Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
## 3. Core Global Constants/Types
- Values: `Unset`, `π`.
- Primitive/class symbols: `Object`, `Int`, `Real`, `Bool`, `Char`, `String`, `Class`, `Callable`.
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
- Random: singleton `Random` and class `SeededRandom`.
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
- Delegation types: `Delegate`, `DelegateContext`.
- Regex types: `Regex`, `RegexMatch`.
- Also present: `Math.PI` namespace constant.
## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
### 4.1 Extern class declarations
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
- Host iterator bridge: `KotlinIterator<T>`.
- Random APIs: `extern object Random`, `extern class SeededRandom`.
### 4.2 High-use extension APIs
- Iteration/filtering: `forEach`, `filter`, `filterFlow`, `filterNotNull`, `filterFlowNotNull`, `drop`, `dropLast`, `takeLast`.
- Search/predicates: `findFirst`, `findFirstOrNull`, `any`, `all`, `count`, `first`, `last`.
- Mapping/aggregation: `map`, `flatMap`, `flatten`, `sum`, `sumOf`, `minOf`, `maxOf`.
- Ordering: `sorted`, `sortedBy`, `shuffled`, `List.sort`, `List.sortBy`.
- String helper: `joinToString`, `String.re`.
### 4.3 Delegation helpers
- `enum DelegateAccess { Val, Var, Callable }`
- `interface Delegate<T,ThisRefType=void>` with `getValue`, `setValue`, `invoke`, `bind`.
- `class lazy<T,...>` delegate implementation.
- `fun with(self, block)` helper.
### 4.4 Other module-level symbols
- `$~` (last regex match object).
- `TODO(message?)` utility.
- `StackTraceEntry` class.
- `Random.nextInt()`, `Random.nextFloat()`, `Random.next(range)`, `Random.seeded(seed)`.
- `SeededRandom.nextInt()`, `SeededRandom.nextFloat()`, `SeededRandom.next(range)`.
## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.buffer`
- `Buffer`, `MutableBuffer`.
- `import lyng.serialization`
- `Lynon` serialization utilities.
- `import lyng.time`
- `Instant`, `DateTime`, `Duration`, and module `delay`.
## 6. Optional (lyngio) Modules
Requires installing `lyngio` into the import manager from host code.
- `import lyng.io.fs` (filesystem `Path` API)
- `import lyng.io.process` (process execution API)
- `import lyng.io.console` (console capabilities, geometry, ANSI/output, events)
## 7. AI Generation Tips
- Assume `lyng.stdlib` APIs exist in regular script contexts.
- For platform-sensitive code (`fs`, `process`, `console`), gate assumptions and mention required module install.
- Prefer extension-method style (`items.filter { ... }`) and standard scope helpers (`let`/`also`/`apply`/`run`).
+22
View File
@@ -72,6 +72,14 @@ For module-level APIs, the default workflow is:
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`; 1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
2. bind Kotlin implementation via `ModuleScope.globalBinder()`. 2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
This is also the recommended way to expose a Kotlin-backed value that should behave like a true
Lyng global variable/property. If you need `x` to read/write through Kotlin on every access, use
`extern var` / `extern val` plus `bindGlobalVar(...)`.
Do not use `addConst(...)` for this case: `addConst(...)` installs a value, not a Kotlin-backed
property accessor. It is appropriate for fixed values and objects, but not for a global that should
delegate reads/writes back into Kotlin state.
```kotlin ```kotlin
import net.sergeych.lyng.bridge.* import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
@@ -117,6 +125,12 @@ assertEquals("changed", globalProp)
assertEquals("1.0.0", globalVersion) assertEquals("1.0.0", globalVersion)
``` ```
Minimal rule of thumb:
- use `bindGlobalFun(...)` for global functions
- use `bindGlobalVar(...)` for Kotlin-backed global variables/properties
- use `addConst(...)` only for fixed values/objects that do not need getter/setter behavior
For custom argument handling and full runtime access: For custom argument handling and full runtime access:
```kotlin ```kotlin
@@ -462,14 +476,21 @@ im.addPackage("my.tools") { module: ModuleScope ->
module.eval( module.eval(
""" """
extern val version: String extern val version: String
extern var status: String
extern fun triple(x: Int): Int extern fun triple(x: Int): Int
""".trimIndent() """.trimIndent()
) )
val binder = module.globalBinder() val binder = module.globalBinder()
var status = "ready"
binder.bindGlobalVar( binder.bindGlobalVar(
name = "version", name = "version",
get = { "1.0" } get = { "1.0" }
) )
binder.bindGlobalVar(
name = "status",
get = { status },
set = { status = it }
)
binder.bindGlobalFun1<Int>("triple") { x -> binder.bindGlobalFun1<Int>("triple") { x ->
ObjInt.of((x * 3).toLong()) ObjInt.of((x * 3).toLong())
} }
@@ -479,6 +500,7 @@ im.addPackage("my.tools") { module: ModuleScope ->
scope.eval(""" scope.eval("""
import my.tools.* import my.tools.*
val v = triple(14) val v = triple(14)
status = "busy"
""") """)
val v = scope.eval("v").toKotlin(scope) // -> 42 val v = scope.eval("v").toKotlin(scope) // -> 42
``` ```
+112
View File
@@ -0,0 +1,112 @@
### lyng.io.console
`lyng.io.console` provides optional rich console support for terminal applications.
> **Note:** this module is part of `lyngio`. It must be explicitly installed into the import manager by host code.
>
> **CLI note:** the `lyng` CLI now installs `lyng.io.console` in its base scope by default, so scripts can simply `import lyng.io.console`.
#### Install in host
```kotlin
import net.sergeych.lyng.Script
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun initScope() {
val scope = Script.newScope()
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
}
```
#### Use in Lyng script
```lyng
import lyng.io.console
println("supported = " + Console.isSupported())
println("tty = " + Console.isTty())
println("ansi = " + Console.ansiLevel())
println("geometry = " + Console.geometry())
Console.write("hello\n")
Console.home()
Console.clear()
Console.moveTo(1, 1)
Console.clearLine()
Console.enterAltScreen()
Console.leaveAltScreen()
Console.setCursorVisible(true)
Console.flush()
```
#### Tetris sample
The repository includes a full interactive Tetris sample that demonstrates:
- alternate screen rendering
- raw keyboard input
- resize handling
- typed console events
![Lyng Tetris sample](/tetris.png)
Run it from the project root in a real TTY:
```bash
lyng examples/tetris_console.lyng
```
#### API
- `Console.isSupported(): Bool` — whether console control is available on this platform/runtime.
- `Console.isTty(): Bool` — whether output is attached to a TTY.
- `Console.ansiLevel(): ConsoleAnsiLevel` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`.
- `Console.geometry(): ConsoleGeometry?` — `{columns, rows}` as typed object or `null`.
- `Console.details(): ConsoleDetails` — consolidated capability object.
- `Console.write(text: String)` — writes to console output.
- `Console.flush()` — flushes buffered output.
- `Console.home()` — moves cursor to top-left.
- `Console.clear()` — clears visible screen.
- `Console.moveTo(row: Int, column: Int)` — moves cursor to 1-based row/column.
- `Console.clearLine()` — clears current line.
- `Console.enterAltScreen()` — switch to alternate screen buffer.
- `Console.leaveAltScreen()` — return to normal screen buffer.
- `Console.setCursorVisible(visible: Bool)` — shows/hides cursor.
- `Console.events(): ConsoleEventStream` — endless iterable source of typed events: `ConsoleResizeEvent`, `ConsoleKeyEvent`.
- `Console.setRawMode(enabled: Bool): Bool` — requests raw input mode, returns `true` if changed.
#### Event Iteration
Use events from a loop, typically in a separate coroutine:
```lyng
launch {
for (ev in Console.events()) {
if (ev is ConsoleKeyEvent) {
// handle key
}
}
}
```
#### Event format
`Console.events()` emits `ConsoleEvent` with:
- `type: ConsoleEventType` — `UNKNOWN`, `RESIZE`, `KEY_DOWN`, `KEY_UP`
Additional fields:
- `ConsoleResizeEvent`: `columns`, `rows`
- `ConsoleKeyEvent`: `key`, `code`, `ctrl`, `alt`, `shift`, `meta`
#### Security policy
The module uses `ConsoleAccessPolicy` with operations:
- `WriteText(length)`
- `ReadEvents`
- `SetRawMode(enabled)`
For permissive mode, use `PermitAllConsoleAccessPolicy`.
+17 -9
View File
@@ -6,12 +6,13 @@
1. **Security:** I/O and process execution are sensitive operations. By keeping them in a separate module, we ensure that the Lyng core remains 100% safe by default. You only enable what you explicitly need. 1. **Security:** I/O and process execution are sensitive operations. By keeping them in a separate module, we ensure that the Lyng core remains 100% safe by default. You only enable what you explicitly need.
2. **Footprint:** Not every script needs filesystem or process access. Keeping these as a separate module helps minimize the dependency footprint for small embedded projects. 2. **Footprint:** Not every script needs filesystem or process access. Keeping these as a separate module helps minimize the dependency footprint for small embedded projects.
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`) that allow you to control exactly what a script can do. 3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`, `ConsoleAccessPolicy`) that allow you to control exactly what a script can do.
#### Included Modules #### Included Modules
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing. - **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information. - **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
- **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events.
--- ---
@@ -39,8 +40,10 @@ To use `lyngio` modules in your scripts, you must install them into your Lyng sc
import net.sergeych.lyng.Script import net.sergeych.lyng.Script
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.io.process.createProcessModule import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun runMyScript() { suspend fun runMyScript() {
val scope = Script.newScope() val scope = Script.newScope()
@@ -48,14 +51,17 @@ suspend fun runMyScript() {
// Install modules with policies // Install modules with policies
createFs(PermitAllAccessPolicy, scope) createFs(PermitAllAccessPolicy, scope)
createProcessModule(PermitAllProcessAccessPolicy, scope) createProcessModule(PermitAllProcessAccessPolicy, scope)
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
// Now scripts can import them // Now scripts can import them
scope.eval(""" scope.eval("""
import lyng.io.fs import lyng.io.fs
import lyng.io.process import lyng.io.process
import lyng.io.console
println("Working dir: " + Path(".").readUtf8()) println("Working dir: " + Path(".").readUtf8())
println("OS: " + Platform.details().name) println("OS: " + Platform.details().name)
println("TTY: " + Console.isTty())
""") """)
} }
``` ```
@@ -68,20 +74,22 @@ suspend fun runMyScript() {
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory). - **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely. - **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
- **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching.
For more details, see the specific module documentation: For more details, see the specific module documentation:
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security) - [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
- [Process Security Details](lyng.io.process.md#security-policy) - [Process Security Details](lyng.io.process.md#security-policy)
- [Console Module Details](lyng.io.console.md)
--- ---
#### Platform Support Overview #### Platform Support Overview
| Platform | lyng.io.fs | lyng.io.process | | Platform | lyng.io.fs | lyng.io.process | lyng.io.console |
| :--- | :---: | :---: | | :--- | :---: | :---: | :---: |
| **JVM** | ✅ | ✅ | | **JVM** | ✅ | ✅ | ✅ (baseline) |
| **Native (Linux/macOS)** | ✅ | ✅ | | **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
| **Native (Windows)** | ✅ | 🚧 (Planned) | | **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
| **Android** | ✅ | ❌ | | **Android** | ✅ | ❌ | ❌ |
| **NodeJS** | ✅ | ❌ | | **NodeJS** | ✅ | ❌ | ❌ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ | | **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
+23
View File
@@ -110,6 +110,29 @@ For example:
assert( 5.clamp(0..10) == 5 ) assert( 5.clamp(0..10) == 5 )
>>> void >>> void
## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators:
| name | meaning |
|--------------------------|---------|
| Random.nextInt() | random `Int` from full platform range |
| Random.nextFloat() | random `Real` in `[0,1)` |
| Random.next(range) | random value from the given finite range |
| Random.seeded(seed) | creates deterministic generator |
| SeededRandom.nextInt() | deterministic random `Int` |
| SeededRandom.nextFloat() | deterministic random `Real` in `[0,1)` |
| SeededRandom.next(range) | deterministic random value from range |
Examples:
val rng = Random.seeded(1234)
assert( rng.next(1..10) in 1..10 )
assert( rng.next('a'..<'f') in 'a'..<'f' )
assert( rng.next(0.0..<1.0) >= 0.0 )
assert( rng.next(0.0..<1.0) < 1.0 )
>>> void
## Scientific constant ## Scientific constant
| name | meaning | | name | meaning |
+54 -2
View File
@@ -1555,21 +1555,70 @@ The type for the character objects is `Char`.
| \t | 0x07, tabulation | | \t | 0x07, tabulation |
| \\ | \ slash character | | \\ | \ slash character |
| \" | " double quote | | \" | " double quote |
| \uXXXX | unicode code point |
Unicode escape form is exactly 4 hex digits, e.g. `"\u263A"` -> `☺`.
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.: Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
val s = "\a" val s = "\a"
assert(s[0] == '\') assert(s[0] == '\\')
assert(s[1] == 'a') assert(s[1] == 'a')
>>> void >>> void
same as: same as:
val s = "\\a" val s = "\\a"
assert(s[0] == '\') assert(s[0] == '\\')
assert(s[1] == 'a') assert(s[1] == 'a')
>>> void >>> void
### String interpolation
Supported forms:
- `$name`
- `${expr}`
Literal dollar forms:
- `\$` -> `$`
- `$$` -> `$`
Example:
val name = "Lyng"
assertEquals("hello, Lyng!", "hello, $name!")
assertEquals("sum=3", "sum=${1+2}")
assertEquals("\$name", "\$name")
assertEquals("\$name", "$$name")
assertEquals("\\Lyng", "\\$name")
>>> void
Interpolation and `printf`-style formatting can be combined when needed:
val method = "transfer"
val argc = 2
val compact = "%s:%d"(method, argc)
assertEquals("call=transfer:2", "call=$compact")
assertEquals("[transfer:2] ok", "[${"%s:%d"(method, argc)}] ok")
>>> void
Interpolation also works well with regex patterns. To keep a literal `$` in the
regex, escape it in the resulting pattern:
val currency = "USD"
val amount = 15
val escapedDollar = "\\$"
val re = Regex("^${currency}${escapedDollar}${amount}$")
assert("USD$15" =~ re)
assert("USD15" !~ re)
>>> void
If you need old literal behavior in a file, add a leading directive comment:
// feature: interpolation: off
### Char literal escapes ### Char literal escapes
Are the same as in string literals with little difference: Are the same as in string literals with little difference:
@@ -1581,6 +1630,9 @@ Are the same as in string literals with little difference:
| \t | 0x07, tabulation | | \t | 0x07, tabulation |
| \\ | \ slash character | | \\ | \ slash character |
| \' | ' apostrophe | | \' | ' apostrophe |
| \uXXXX | unicode code point |
For char literals, use `'\\'` to represent a single backslash character; `'\'` is invalid.
### Char instance members ### Char instance members
+67
View File
@@ -5,6 +5,73 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## Language Features
### Decimal Arithmetic Module (`lyng.decimal`)
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
It provides:
- `BigDecimal`
- convenient `.d` conversions from `Int`, `Real`, and `String`
- mixed arithmetic with `Int` and `Real`
- local division precision and rounding control via `withDecimalContext(...)`
```lyng
import lyng.decimal
assertEquals("3", (1 + 2.d).toStringExpanded())
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
assertEquals("0.3", "0.3".d.toStringExpanded())
assertEquals(
"0.3333333333",
withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
)
```
The distinction between `Real -> Decimal` and exact decimal parsing is explicit by design:
- `2.2.d` converts the current `Real` value
- `"2.2".d` parses exact decimal text
See [Decimal](Decimal.md).
### Binary Operator Interop Registry
Lyng now provides a general mechanism for mixed binary operators through `lyng.operators`.
This solves cases like:
- `Int + MyType`
- `Real < MyType`
- `Int == MyType`
without requiring changes to built-in classes.
```lyng
import lyng.operators
class DecimalBox(val value: Int) {
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
fun compareTo(other: DecimalBox) = value <=> other.value
}
OperatorInterop.register(
Int,
DecimalBox,
DecimalBox,
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Int -> DecimalBox(x) },
{ x: DecimalBox -> x }
)
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
assert(1 < DecimalBox(2))
assert(2 == DecimalBox(2))
```
`lyng.decimal` uses this same mechanism internally to interoperate with `Int` and `Real`.
See [Operator Interop Registry](OperatorInterop.md).
### Class Properties with Accessors ### Class Properties with Accessors
Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors. Classes now support properties with custom `get()` and `set()` accessors. Properties in Lyng do **not** have automatic backing fields; they are pure accessors.
+814
View File
@@ -0,0 +1,814 @@
#!/usr/bin/env lyng
/*
* Lyng Console Tetris (interactive sample)
*
* Controls:
* - Left/Right arrows or A/D: move
* - Up arrow or W: rotate
* - Down arrow or S: soft drop
* - Space: hard drop
* - P or Escape: pause
* - Q: quit
Tsted to score:
sergeych@sergeych-XPS-17-9720:~$ ~/dev/lyng/examples/tetris_console.lyng
Bye.
Score: 435480
Lines: 271
Level: 28
Ssergeych@sergeych-XPS-17-9720:~$
*/
import lyng.io.console
import lyng.io.fs
val MIN_COLS = 56
val MIN_ROWS = 24
val PANEL_WIDTH = 24
val BOARD_MARGIN_ROWS = 5
val BOARD_MIN_W = 10
val BOARD_MAX_W = 16
val BOARD_MIN_H = 16
val BOARD_MAX_H = 28
val LEVEL_LINES_STEP = 10
val DROP_FRAMES_BASE = 15
val DROP_FRAMES_MIN = 3
val FRAME_DELAY_MS = 35
val RESIZE_WAIT_MS = 250
val MAX_PENDING_INPUTS = 64
val ROTATION_KICKS = [0, -1, 1, -2, 2]
val ANSI_ESC = "\u001b["
val ANSI_RESET = ANSI_ESC + "0m"
val ERROR_LOG_PATH = "/tmp/lyng_tetris_errors.log"
val UNICODE_BLOCK = "██"
val UNICODE_TOP_LEFT = "┌"
val UNICODE_TOP_RIGHT = "┐"
val UNICODE_BOTTOM_LEFT = "└"
val UNICODE_BOTTOM_RIGHT = "┘"
val UNICODE_HORIZONTAL = "──"
val UNICODE_VERTICAL = "│"
val UNICODE_DOT = "· "
type Cell = List<Int>
type Rotation = List<Cell>
type Rotations = List<Rotation>
type Row = List<Int>
type Board = List<Row>
class Piece(val name: String, val rotations: Rotations) {}
class RotateResult(val ok: Bool, val rot: Int, val px: Int) {}
class GameState(
pieceId0: Int,
nextId0: Int,
next2Id0: Int,
px0: Int,
py0: Int,
) {
var pieceId = pieceId0
var nextId = nextId0
var next2Id = next2Id0
var rot = 0
var px = px0
var py = py0
var score = 0
var totalLines = 0
var level = 1
var running = true
var gameOver = false
var paused = false
}
class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {}
fun clearAndHome() {
Console.clear()
Console.home()
}
fun logError(message: String, err: Object?): Void {
try {
var details = ""
if (err != null) {
try {
details = ": " + err
} catch (_: Object) {
details = ": <error-format-failed>"
}
}
Path(ERROR_LOG_PATH).appendUtf8(message + details + "\n")
} catch (_: Object) {
// Never let logging errors affect gameplay.
}
}
fun repeatText(s: String, n: Int): String {
var out: String = ""
for (i in 0..<n) {
out += s
}
out
}
fun max<T>(a: T, b: T): T = if (a > b) a else b
fun emptyRow(width: Int): Row {
val r: Row = []
for (x in 0..<width) {
r.add(0)
}
r
}
fun createBoard(width: Int, height: Int): Board {
val b: Board = []
for (y in 0..<height) {
b.add(emptyRow(width))
}
b
}
fun colorize(text: String, sgr: String, useColor: Bool): String {
if (!useColor) return text
ANSI_ESC + sgr + "m" + text + ANSI_RESET
}
fun blockText(pieceId: Int, useColor: Bool): String {
if (pieceId <= 0) return " "
val sgr = when (pieceId) {
1 -> "36" // I
2 -> "33" // O
3 -> "35" // T
4 -> "32" // S
5 -> "31" // Z
6 -> "34" // J
7 -> "93" // L
else -> "37"
}
colorize(UNICODE_BLOCK, sgr, useColor)
}
fun emptyCellText(useColor: Bool): String {
colorize(UNICODE_DOT, "90", useColor)
}
fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): Bool {
try {
if (pieceId < 1 || pieceId > 7) return false
val piece: Piece = PIECES[pieceId - 1]
if (rot < 0 || rot >= piece.rotations.size) return false
val cells = piece.rotations[rot]
for (cell in cells) {
val x = px + cell[0]
val y = py + cell[1]
if (x < 0 || x >= boardW) return false
if (y >= boardH) return false
if (y >= 0) {
if (y >= board.size) return false
val row = board[y]
if (row == null) return false
if (row[x] != 0) return false
}
}
true
} catch (_: Object) {
false
}
}
fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
val piece: Piece = PIECES[pieceId - 1]
val cells = piece.rotations[rot]
for (cell in cells) {
val x = px + cell[0]
val y = py + cell[1]
if (y >= 0 && y < board.size) {
val row = board[y]
if (row != null) {
row[x] = pieceId
}
}
}
}
fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int {
val b = board
var y = boardH - 1
var cleared = 0
while (y >= 0) {
if (y >= b.size) {
y--
continue
}
val row = b[y]
if (row == null) {
b.removeAt(y)
b.insertAt(0, emptyRow(boardW))
cleared++
continue
}
var full = true
for (x in 0..<boardW) {
if (row[x] == 0) {
full = false
break
}
}
if (full) {
b.removeAt(y)
b.insertAt(0, emptyRow(boardW))
cleared++
} else {
y--
}
}
cleared
}
fun activeCellId(pieceId: Int, rot: Int, px: Int, py: Int, x: Int, y: Int): Int {
val piece: Piece = PIECES[pieceId - 1]
val cells = piece.rotations[rot]
for (cell in cells) {
val ax = px + cell[0]
val ay = py + cell[1]
if (ax == x && ay == y) return pieceId
}
0
}
fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): RotateResult {
val piece: Piece = PIECES[pieceId - 1]
val rotations = piece.rotations.size
val nr = (rot + 1) % rotations
for (kx in ROTATION_KICKS) {
val nx = px + kx
if (canPlace(board, boardW, boardH, pieceId, nr, nx, py) == true) {
return RotateResult(true, nr, nx)
}
}
RotateResult(false, rot, px)
}
fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
val out: List<String> = []
if (pieceId <= 0) {
for (i in 0..<4) {
out.add(" ")
}
return out
}
val piece: Piece = PIECES[pieceId - 1]
val cells = piece.rotations[0]
for (y in 0..<4) {
var line = ""
for (x in 0..<4) {
var filled = false
for (cell in cells) {
if (cell[0] == x && cell[1] == y) {
filled = true
break
}
}
line += if (filled) blockText(pieceId, useColor) else " "
}
out.add(line)
}
out
}
fun render(
state: GameState,
board: Board,
boardW: Int,
boardH: Int,
prevFrameLines: List<String>,
originRow: Int,
originCol: Int,
useColor: Bool,
): List<String> {
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, boardW) + UNICODE_BOTTOM_RIGHT
val panel: List<String> = []
val nextPiece: Piece = PIECES[state.nextId - 1]
val next2Piece: Piece = PIECES[state.next2Id - 1]
val nextName = nextPiece.name
val next2Name = next2Piece.name
val preview = nextPreviewLines(state.nextId, useColor)
panel.add("Lyng Tetris")
panel.add("")
panel.add("Score: " + state.score)
panel.add("Lines: " + state.totalLines)
panel.add("Level: " + state.level)
panel.add("")
panel.add("Next: " + nextName)
panel.add("")
for (pl in preview) panel.add(pl)
panel.add("After: " + next2Name)
panel.add("")
panel.add("Keys:")
panel.add("A/D or arrows")
panel.add("W/Up: rotate")
panel.add("S/Down: drop")
panel.add("Space: hard drop")
panel.add("P/Esc: pause")
panel.add("Q: quit")
val frameLines: List<String> = []
for (y in 0..<boardH) {
var line = UNICODE_VERTICAL
for (x in 0..<boardW) {
val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y)
val row = if (y < board.size) board[y] else null
val b = if (row == null) 0 else row[x]
val id = if (a > 0) a else b
line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor)
}
line += UNICODE_VERTICAL
if (y < panel.size) {
line += " " + panel[y]
}
frameLines.add(line)
}
frameLines.add(bottomBorder)
for (i in 0..<frameLines.size) {
val line = frameLines[i]
val old = if (i < prevFrameLines.size) prevFrameLines[i] else null
if (old != line) {
Console.moveTo(originRow + i, originCol)
Console.clearLine()
Console.write(line)
}
}
frameLines
}
fun fitLine(line: String, width: Int): String {
val maxLen = if (width > 0) width else 0
if (maxLen <= 0) return ""
if (line.size >= maxLen) return line[..<maxLen]
line + repeatText(" ", maxLen - line.size)
}
fun renderPauseOverlay(
originRow: Int,
originCol: Int,
boardW: Int,
boardH: Int,
): Void {
val contentWidth = boardW * 2 + 2 + 3 + PANEL_WIDTH
val contentHeight = boardH + 1
val lines: List<String> = []
lines.add("PAUSED")
lines.add("")
lines.add("Any key: continue game")
lines.add("Esc: exit game")
lines.add("")
lines.add("Move: A/D or arrows")
lines.add("Rotate: W or Up")
lines.add("Drop: S/Down, Space hard drop")
var innerWidth = 0
for (line in lines) {
if (line.size > innerWidth) innerWidth = line.size
}
innerWidth += 4
val maxInner = max(12, contentWidth - 2)
if (innerWidth > maxInner) innerWidth = maxInner
if (innerWidth % 2 != 0) innerWidth--
val boxWidth = innerWidth + 2
val boxHeight = lines.size + 2
val left = originCol + max(0, (contentWidth - boxWidth) / 2)
val top = originRow + max(0, (contentHeight - boxHeight) / 2)
val topBorder = UNICODE_TOP_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_TOP_RIGHT
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_BOTTOM_RIGHT
Console.moveTo(top, left)
Console.write(topBorder)
for (i in 0..<lines.size) {
Console.moveTo(top + 1 + i, left)
Console.write(UNICODE_VERTICAL + fitLine(" " + lines[i], innerWidth) + UNICODE_VERTICAL)
}
Console.moveTo(top + boxHeight - 1, left)
Console.write(bottomBorder)
}
fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
while (true) {
val g = Console.geometry()
val cols = g?.columns ?: 0
val rows = g?.rows ?: 0
if (cols >= minCols && rows >= minRows) return g
clearAndHome()
val lines: List<String> = []
lines.add("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
lines.add("Current: %sx%s"(cols, rows))
lines.add("Resize the console window to continue.")
val visibleLines = if (rows < lines.size) rows else lines.size
if (visibleLines > 0) {
val startRow = max(1, ((rows - visibleLines) / 2) + 1)
for (i in 0..<visibleLines) {
val line = lines[i]
val startCol = max(1, ((cols - line.size) / 2) + 1)
Console.moveTo(startRow + i, startCol)
Console.clearLine()
Console.write(line)
}
Console.flush()
}
delay(RESIZE_WAIT_MS)
}
}
fun scoreForLines(cleared: Int, level: Int): Int {
when (cleared) {
1 -> 100 * level
2 -> 300 * level
3 -> 500 * level
4 -> 800 * level
else -> 0
}
}
// Classic 7 tetrominoes, minimal rotations per piece.
fun cell(x: Int, y: Int): Cell { [x, y] }
fun rot(a: Cell, b: Cell, c: Cell, d: Cell): Rotation {
val r: Rotation = []
r.add(a)
r.add(b)
r.add(c)
r.add(d)
r
}
val PIECES: List<Piece> = []
val iRots: Rotations = []
iRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(3,1)))
iRots.add(rot(cell(2,0), cell(2,1), cell(2,2), cell(2,3)))
PIECES.add(Piece("I", iRots))
val oRots: Rotations = []
oRots.add(rot(cell(1,0), cell(2,0), cell(1,1), cell(2,1)))
PIECES.add(Piece("O", oRots))
val tRots: Rotations = []
tRots.add(rot(cell(1,0), cell(0,1), cell(1,1), cell(2,1)))
tRots.add(rot(cell(1,0), cell(1,1), cell(2,1), cell(1,2)))
tRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(1,2)))
tRots.add(rot(cell(1,0), cell(0,1), cell(1,1), cell(1,2)))
PIECES.add(Piece("T", tRots))
val sRots: Rotations = []
sRots.add(rot(cell(1,0), cell(2,0), cell(0,1), cell(1,1)))
sRots.add(rot(cell(1,0), cell(1,1), cell(2,1), cell(2,2)))
PIECES.add(Piece("S", sRots))
val zRots: Rotations = []
zRots.add(rot(cell(0,0), cell(1,0), cell(1,1), cell(2,1)))
zRots.add(rot(cell(2,0), cell(1,1), cell(2,1), cell(1,2)))
PIECES.add(Piece("Z", zRots))
val jRots: Rotations = []
jRots.add(rot(cell(0,0), cell(0,1), cell(1,1), cell(2,1)))
jRots.add(rot(cell(1,0), cell(2,0), cell(1,1), cell(1,2)))
jRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(2,2)))
jRots.add(rot(cell(1,0), cell(1,1), cell(0,2), cell(1,2)))
PIECES.add(Piece("J", jRots))
val lRots: Rotations = []
lRots.add(rot(cell(2,0), cell(0,1), cell(1,1), cell(2,1)))
lRots.add(rot(cell(1,0), cell(1,1), cell(1,2), cell(2,2)))
lRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(0,2)))
lRots.add(rot(cell(0,0), cell(1,0), cell(1,1), cell(1,2)))
PIECES.add(Piece("L", lRots))
if (!Console.isSupported()) {
println("Console API is not supported in this runtime.")
void
} else if (!Console.isTty()) {
println("This sample needs an interactive terminal (TTY).")
void
} else {
waitForMinimumSize(MIN_COLS, MIN_ROWS)
val g0 = Console.geometry()
val cols = g0?.columns ?: MIN_COLS
val rows = g0?.rows ?: MIN_ROWS
val boardW = clamp((cols - PANEL_WIDTH) / 2, BOARD_MIN_W..BOARD_MAX_W)
val boardH = clamp(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H..BOARD_MAX_H)
val board: Board = createBoard(boardW, boardH)
fun nextPieceId() {
Random.next(1..7)
}
val state: GameState = GameState(
nextPieceId(),
nextPieceId(),
nextPieceId(),
(boardW / 2) - 2,
-1,
)
var prevFrameLines: List<String> = []
val gameMutex: Mutex = Mutex()
var forceRedraw = false
val pendingInputs: List<String> = []
val rawModeEnabled = Console.setRawMode(true)
if (!rawModeEnabled) {
println("Raw keyboard mode is not available in this terminal/runtime.")
println("Use jlyng in an interactive terminal with raw input support.")
void
} else {
val useColor = Console.ansiLevel() != ConsoleAnsiLevel.NONE
Console.enterAltScreen()
Console.setCursorVisible(false)
clearAndHome()
fun resetActivePiece(s: GameState): Void {
s.pieceId = nextPieceId()
s.rot = 0
s.px = (boardW / 2) - 2
s.py = -1
}
fun applyKeyInput(s: GameState, key: String): Void {
try {
if (key == "__CTRL_C__") {
s.running = false
}
else if (s.paused) {
if (key == "Escape") {
s.running = false
} else {
s.paused = false
forceRedraw = true
}
}
else if (key == "p" || key == "P" || key == "Escape") {
s.paused = true
forceRedraw = true
}
else if (key == "q" || key == "Q") {
s.running = false
}
else if (key == "ArrowLeft" || key == "a" || key == "A") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py) == true) s.px--
}
else if (key == "ArrowRight" || key == "d" || key == "D") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py) == true) s.px++
}
else if (key == "ArrowUp" || key == "w" || key == "W") {
val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)
if (rr.ok) {
s.rot = rr.rot
s.px = rr.px
}
}
else if (key == "ArrowDown" || key == "s" || key == "S") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py++
s.score++
}
}
else if (key == " ") {
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py++
s.score += 2
}
}
} catch (inputErr: Object) {
logError("applyKeyInput recovered after error", inputErr)
resetActivePiece(s)
}
}
var inputRunning = true
launch {
while (inputRunning) {
try {
for (ev in Console.events()) {
if (!inputRunning) break
// Isolate per-event failures so one bad event does not unwind the stream.
try {
if (ev is ConsoleKeyEvent) {
val ke = ev as ConsoleKeyEvent
if (ke.type == ConsoleEventType.KEY_DOWN) {
var key = ""
var ctrl = false
try {
key = ke.key
} catch (keyErr: Object) {
logError("Input key read error", keyErr)
}
try {
ctrl = ke.ctrl == true
} catch (_: Object) {
ctrl = false
}
if (key == "") {
logError("Dropped key event with empty/null key", null)
continue
}
val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key
val mm: Mutex = gameMutex
mm.withLock {
if (pendingInputs.size >= MAX_PENDING_INPUTS) {
pendingInputs.removeAt(0)
}
pendingInputs.add(mapped)
}
}
}
} catch (eventErr: Object) {
// Keep the input stream alive; report for diagnostics.
logError("Input event error", eventErr)
}
}
} catch (err: Object) {
// Recover stream-level failures by recreating event stream in next loop turn.
if (!inputRunning) break
logError("Input stream recovered after error", err)
Console.setRawMode(true)
delay(50)
}
}
}
fun pollLoopFrame(): LoopFrame? {
val g = Console.geometry()
val c = g?.columns ?: 0
val r = g?.rows ?: 0
if (c < MIN_COLS || r < MIN_ROWS) {
waitForMinimumSize(MIN_COLS, MIN_ROWS)
clearAndHome()
prevFrameLines = []
return null
}
val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH
val contentRows = boardH + 1
val requiredCols = max(MIN_COLS, contentCols)
val requiredRows = max(MIN_ROWS, contentRows)
if (c < requiredCols || r < requiredRows) {
waitForMinimumSize(requiredCols, requiredRows)
clearAndHome()
prevFrameLines = []
return null
}
val originCol = max(1, ((c - contentCols) / 2) + 1)
val originRow = max(1, ((r - contentRows) / 2) + 1)
LoopFrame(false, originRow, originCol)
}
fun advanceGravity(s: GameState, frame: Int): Int {
s.level = 1 + (s.totalLines / LEVEL_LINES_STEP)
val dropEvery = max(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level)
var nextFrame = frame + 1
if (nextFrame < dropEvery) return nextFrame
nextFrame = 0
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
s.py++
return nextFrame
}
lockPiece(board, s.pieceId, s.rot, s.px, s.py)
val cleared = clearCompletedLines(board, boardW, boardH)
if (cleared > 0) {
s.totalLines += cleared
s.score += scoreForLines(cleared, s.level)
}
s.pieceId = s.nextId
s.nextId = s.next2Id
s.next2Id = nextPieceId()
s.rot = 0
s.px = (boardW / 2) - 2
s.py = -1
if (!canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)) {
s.gameOver = true
}
nextFrame
}
try {
if (!canPlace(board, boardW, boardH, state.pieceId, state.rot, state.px, state.py)) {
state.gameOver = true
}
var frame = 0
var shouldStop = false
var prevOriginRow = -1
var prevOriginCol = -1
var prevPaused = false
while (!shouldStop) {
val frameData = pollLoopFrame()
if (frameData == null) {
frame = 0
prevPaused = false
continue
}
val mm: Mutex = gameMutex
mm.withLock {
if (pendingInputs.size > 0) {
val toApply: List<String> = []
while (pendingInputs.size > 0) {
val k = pendingInputs[0]
pendingInputs.removeAt(0)
toApply.add(k)
}
for (k in toApply) {
applyKeyInput(state, k)
if (!state.running || state.gameOver) break
}
}
}
if (!state.running || state.gameOver) {
shouldStop = true
} else {
val localForceRedraw = forceRedraw
forceRedraw = false
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
if (frameData.resized || movedOrigin || localForceRedraw) {
clearAndHome()
prevFrameLines = []
}
prevOriginRow = frameData.originRow
prevOriginCol = frameData.originCol
if (!state.paused) {
frame = advanceGravity(state, frame)
}
prevFrameLines = render(
state,
board,
boardW,
boardH,
prevFrameLines,
frameData.originRow,
frameData.originCol,
useColor
)
if (state.paused && (!prevPaused || frameData.resized || movedOrigin)) {
renderPauseOverlay(frameData.originRow, frameData.originCol, boardW, boardH)
}
prevPaused = state.paused
}
Console.flush()
delay(FRAME_DELAY_MS)
}
} finally {
inputRunning = false
Console.setRawMode(false)
Console.setCursorVisible(true)
Console.leaveAltScreen()
Console.flush()
}
if (state.gameOver) {
println("Game over.")
} else {
println("Bye.")
}
println("Score: %s"(state.score))
println("Lines: %s"(state.totalLines))
println("Level: %s"(state.level))
}
}
+5
View File
@@ -1,12 +1,14 @@
[versions] [versions]
agp = "8.5.2" agp = "8.5.2"
clikt = "5.0.3" clikt = "5.0.3"
mordant = "3.0.2"
kotlin = "2.3.0" kotlin = "2.3.0"
android-minSdk = "24" android-minSdk = "24"
android-compileSdk = "34" android-compileSdk = "34"
kotlinx-coroutines = "1.10.2" kotlinx-coroutines = "1.10.2"
kotlinx-datetime = "0.6.1" kotlinx-datetime = "0.6.1"
mp_bintools = "0.3.2" mp_bintools = "0.3.2"
ionspin-bignum = "0.3.10"
firebaseCrashlyticsBuildtools = "3.0.3" firebaseCrashlyticsBuildtools = "3.0.3"
okioVersion = "3.10.2" okioVersion = "3.10.2"
compiler = "3.2.0-alpha11" compiler = "3.2.0-alpha11"
@@ -14,11 +16,14 @@ compiler = "3.2.0-alpha11"
[libraries] [libraries]
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" } clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref = "clikt" } clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref = "clikt" }
mordant-core = { module = "com.github.ajalt.mordant:mordant-core", version.ref = "mordant" }
mordant-jvm-jna = { module = "com.github.ajalt.mordant:mordant-jvm-jna", version.ref = "mordant" }
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" } kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" } kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" } kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" } kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" } mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" } firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" } okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" } okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
@@ -36,6 +36,7 @@ object LyngAstManager {
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp") private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache") private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
private val implicitBuiltinNames = setOf("void") private val implicitBuiltinNames = setOf("void")
private val includeSymbolsDirective = Regex("""(?im)^\s*//\s*include\s+symbols\s*:\s*(.+?)\s*$""")
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction { fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
getAnalysis(file)?.mini getAnalysis(file)?.mini
@@ -44,8 +45,8 @@ object LyngAstManager {
fun getCombinedStamp(file: PsiFile): Long = runReadAction { fun getCombinedStamp(file: PsiFile): Long = runReadAction {
var combinedStamp = file.viewProvider.modificationStamp var combinedStamp = file.viewProvider.modificationStamp
if (!file.name.endsWith(".lyng.d")) { if (!file.name.endsWith(".lyng.d")) {
collectDeclarationFiles(file).forEach { df -> collectDeclarationFiles(file).forEach { symbolsFile ->
combinedStamp += df.viewProvider.modificationStamp combinedStamp += symbolsFile.viewProvider.modificationStamp
} }
} }
combinedStamp combinedStamp
@@ -66,6 +67,22 @@ object LyngAstManager {
currentDir = currentDir.parentDirectory currentDir = currentDir.parentDirectory
} }
val includeSpecs = includeSymbolsDirective.findAll(file.viewProvider.contents)
.flatMap { it.groupValues[1].split(',').asSequence() }
.map { it.trim() }
.filter { it.isNotEmpty() }
.toList()
val baseDir = file.virtualFile?.parent
if (baseDir != null) {
for (spec in includeSpecs) {
val included = baseDir.findFileByRelativePath(spec) ?: continue
if (included.path == file.virtualFile?.path) continue
if (seen.add(included.path)) {
psiManager.findFile(included)?.let { result.add(it) }
}
}
}
if (result.isNotEmpty()) return@runReadAction result if (result.isNotEmpty()) return@runReadAction result
// Fallback for virtual/light files without a stable parent chain (e.g., tests) // Fallback for virtual/light files without a stable parent chain (e.g., tests)
@@ -50,6 +50,18 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
myFixture.addFileToProject("api.lyng.d", defs) myFixture.addFileToProject("api.lyng.d", defs)
} }
private fun addPlainSymbolsFile() {
val defs = """
/** Symbols exposed via include directive */
class PlainDeclared(val name: String) {
fun hello(): String = "ok"
}
fun plainTopFun(x: Int): Int = x + 2
""".trimIndent()
myFixture.addFileToProject("plain_symbols.lyng", defs)
}
fun test_CompletionsIncludeDefinitions() { fun test_CompletionsIncludeDefinitions() {
addDefinitionsFile() addDefinitionsFile()
enableCompletion() enableCompletion()
@@ -136,4 +148,35 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList() val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
assertTrue("Should not report unresolved name for void, got=$messages", messages.none { it.contains("unresolved name: void") }) assertTrue("Should not report unresolved name for void, got=$messages", messages.none { it.contains("unresolved name: void") })
} }
fun test_CompletionsIncludePlainLyngViaDirective() {
addPlainSymbolsFile()
enableCompletion()
val code = """
// include symbols: plain_symbols.lyng
val v = plainTop<caret>
""".trimIndent()
myFixture.configureByText("main.lyng", code)
val text = myFixture.editor.document.text
val caret = myFixture.caretOffset
val analysis = LyngAstManager.getAnalysis(myFixture.file)
val engine = runBlocking { CompletionEngineLight.completeSuspend(text, caret, analysis?.mini, analysis?.binding).map { it.name } }
assertTrue("Expected plainTopFun from included .lyng; got=$engine", engine.contains("plainTopFun"))
}
fun test_DiagnosticsIgnorePlainLyngSymbolsViaDirective() {
addPlainSymbolsFile()
val code = """
// include symbols: plain_symbols.lyng
val x = plainTopFun(1)
val y = PlainDeclared("x")
y.hello()
""".trimIndent()
myFixture.configureByText("main.lyng", code)
val analysis = LyngAstManager.getAnalysis(myFixture.file)
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
assertTrue("Should not report unresolved name for plainTopFun", messages.none { it.contains("unresolved name: plainTopFun") })
assertTrue("Should not report unresolved name for PlainDeclared", messages.none { it.contains("unresolved name: PlainDeclared") })
assertTrue("Should not report unresolved member for hello", messages.none { it.contains("unresolved member: hello") })
}
} }
+6 -1
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -32,8 +32,10 @@ import net.sergeych.lyng.LyngVersion
import net.sergeych.lyng.Script import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source import net.sergeych.lyng.Source
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.mp_tools.globalDefer import net.sergeych.mp_tools.globalDefer
import okio.FileSystem import okio.FileSystem
@@ -69,6 +71,9 @@ val baseScopeDefer = globalDefer {
// Install lyng.io.fs module with full access by default for the CLI tool's Scope. // Install lyng.io.fs module with full access by default for the CLI tool's Scope.
// Scripts still need to `import lyng.io.fs` to use Path API. // Scripts still need to `import lyng.io.fs` to use Path API.
createFs(PermitAllAccessPolicy, this) createFs(PermitAllAccessPolicy, this)
// Install console access by default for interactive CLI scripts.
// Scripts still need to `import lyng.io.console` to use it.
createConsoleModule(PermitAllConsoleAccessPolicy, this)
} }
} }
+66
View File
@@ -78,6 +78,7 @@ kotlin {
api(project(":lynglib")) api(project(":lynglib"))
api(libs.okio) api(libs.okio)
api(libs.kotlinx.coroutines.core) api(libs.kotlinx.coroutines.core)
api(libs.mordant.core)
} }
} }
val commonTest by getting { val commonTest by getting {
@@ -94,6 +95,13 @@ kotlin {
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}") implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
} }
} }
val jvmMain by getting {
dependencies {
implementation(libs.mordant.jvm.jna)
implementation("org.jline:jline-reader:3.29.0")
implementation("org.jline:jline-terminal:3.29.0")
}
}
// // For Wasm we use in-memory VFS for now // // For Wasm we use in-memory VFS for now
// val wasmJsMain by getting { // val wasmJsMain by getting {
// dependencies { // dependencies {
@@ -104,6 +112,64 @@ kotlin {
} }
} }
abstract class GenerateLyngioConsoleDecls : DefaultTask() {
@get:InputFile
@get:PathSensitive(PathSensitivity.RELATIVE)
abstract val sourceFile: RegularFileProperty
@get:OutputDirectory
abstract val outputDir: DirectoryProperty
@TaskAction
fun generate() {
val targetPkg = "net.sergeych.lyngio.stdlib_included"
val pkgPath = targetPkg.replace('.', '/')
val targetDir = outputDir.get().asFile.resolve(pkgPath)
targetDir.mkdirs()
val text = sourceFile.get().asFile.readText()
fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) {
'\\' -> append("\\\\")
'"' -> append("\\\"")
'\n' -> append("\\n")
'\r' -> {}
'\t' -> append("\\t")
else -> append(ch)
}
}
val out = buildString {
append("package ").append(targetPkg).append("\n\n")
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
append("internal val consoleLyng = \"")
append(escapeForQuoted(text))
append("\"\n")
}
targetDir.resolve("console_types_lyng.generated.kt").writeText(out)
}
}
val lyngioConsoleDeclsFile = layout.projectDirectory.file("stdlib/lyng/io/console.lyng")
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
val generateLyngioConsoleDecls by tasks.registering(GenerateLyngioConsoleDecls::class) {
sourceFile.set(lyngioConsoleDeclsFile)
outputDir.set(generatedLyngioDeclsDir)
}
kotlin.sourceSets.named("commonMain") {
kotlin.srcDir(generateLyngioConsoleDecls)
}
kotlin.targets.configureEach {
compilations.configureEach {
compileTaskProvider.configure {
dependsOn(generateLyngioConsoleDecls)
}
}
}
android { android {
namespace = "net.sergeych.lyngio" namespace = "net.sergeych.lyngio"
compileSdk = libs.versions.android.compileSdk.get().toInt() compileSdk = libs.versions.android.compileSdk.get().toInt()
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
// no-op on Android
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
actual fun getSystemConsole(): LyngConsole = MordantLyngConsole
@@ -0,0 +1,494 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.io.console
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjEnumClass
import net.sergeych.lyng.obj.ObjEnumEntry
import net.sergeych.lyng.obj.ObjIterable
import net.sergeych.lyng.obj.ObjIterationFinishedException
import net.sergeych.lyng.obj.ObjIterator
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.requiredArg
import net.sergeych.lyng.obj.thisAs
import net.sergeych.lyng.obj.toObj
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.raiseIllegalOperation
import net.sergeych.lyng.requireScope
import net.sergeych.lyngio.console.*
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
import net.sergeych.lyngio.console.security.LyngConsoleSecured
import net.sergeych.lyngio.stdlib_included.consoleLyng
private const val CONSOLE_MODULE_NAME = "lyng.io.console"
/**
* Install Lyng module `lyng.io.console` into the given scope's ImportManager.
*/
fun createConsoleModule(policy: ConsoleAccessPolicy, scope: Scope): Boolean =
createConsoleModule(policy, scope.importManager)
fun createConsole(policy: ConsoleAccessPolicy, scope: Scope): Boolean = createConsoleModule(policy, scope)
/** Same as [createConsoleModule] but with explicit [ImportManager]. */
fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean {
if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
manager.addPackage(CONSOLE_MODULE_NAME) { module ->
buildConsoleModule(module, policy)
}
return true
}
fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager)
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) {
// Load Lyng declarations for console enums/types first (module-local source of truth).
module.eval(Source(CONSOLE_MODULE_NAME, consoleLyng))
ConsoleEnums.initialize(module)
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
consoleType.apply {
addClassFn("isSupported") {
ObjBool(console.isSupported)
}
addClassFn("isTty") {
consoleGuard {
ObjBool(console.isTty())
}
}
addClassFn("ansiLevel") {
consoleGuard {
ConsoleEnums.ansiLevel(console.ansiLevel().name)
}
}
addClassFn("geometry") {
consoleGuard {
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
}
}
addClassFn("details") {
consoleGuard {
val tty = console.isTty()
val ansi = console.ansiLevel()
val geometry = console.geometry()
ObjConsoleDetails(
supported = console.isSupported,
isTty = tty,
ansiLevel = ConsoleEnums.ansiLevel(ansi.name),
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
)
}
}
addClassFn("write") {
consoleGuard {
val text = requiredArg<ObjString>(0).value
console.write(text)
ObjVoid
}
}
addClassFn("flush") {
consoleGuard {
console.flush()
ObjVoid
}
}
addClassFn("home") {
consoleGuard {
console.write("\u001B[H")
ObjVoid
}
}
addClassFn("clear") {
consoleGuard {
console.write("\u001B[2J")
ObjVoid
}
}
addClassFn("moveTo") {
consoleGuard {
val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value
val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value
console.write("\u001B[${row};${col}H")
ObjVoid
}
}
addClassFn("clearLine") {
consoleGuard {
console.write("\u001B[2K")
ObjVoid
}
}
addClassFn("enterAltScreen") {
consoleGuard {
console.write("\u001B[?1049h")
ObjVoid
}
}
addClassFn("leaveAltScreen") {
consoleGuard {
console.write("\u001B[?1049l")
ObjVoid
}
}
addClassFn("setCursorVisible") {
consoleGuard {
val visible = requiredArg<ObjBool>(0).value
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
ObjVoid
}
}
addClassFn("events") {
consoleGuard {
console.events().toConsoleEventStream()
}
}
addClassFn("setRawMode") {
consoleGuard {
val enabled = requiredArg<ObjBool>(0).value
ObjBool(console.setRawMode(enabled))
}
}
}
module.addConst("Console", consoleType)
module.addConst("ConsoleGeometry", ObjConsoleGeometry.type)
module.addConst("ConsoleDetails", ObjConsoleDetails.type)
module.addConst("ConsoleEvent", ObjConsoleEvent.type)
module.addConst("ConsoleResizeEvent", ObjConsoleResizeEvent.type)
module.addConst("ConsoleKeyEvent", ObjConsoleKeyEvent.typeObj)
module.addConst("ConsoleEventStream", ObjConsoleEventStream.type)
}
private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj {
return try {
block()
} catch (e: ConsoleAccessDeniedException) {
raiseIllegalOperation(e.reasonDetail ?: "console access denied")
} catch (e: Exception) {
raiseIllegalOperation(e.message ?: "console error")
}
}
private fun ConsoleEventSource.toConsoleEventStream(): ObjConsoleEventStream {
return ObjConsoleEventStream(this)
}
private class ObjConsoleEventStream(
private val source: ConsoleEventSource,
) : Obj() {
override val objClass: net.sergeych.lyng.obj.ObjClass
get() = type
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply {
addFn("iterator") {
val stream = thisAs<ObjConsoleEventStream>()
ObjConsoleEventIterator(stream.source)
}
}
}
}
private class ObjConsoleEventIterator(
private val source: ConsoleEventSource,
) : Obj() {
private var cached: Obj? = null
private var closed = false
override val objClass: net.sergeych.lyng.obj.ObjClass
get() = type
private suspend fun ensureCached(): Boolean {
if (closed) return false
if (cached != null) return true
while (!closed && cached == null) {
val event = try {
source.nextEvent()
} catch (e: Throwable) {
// Consumer loops must survive source/read failures: report and keep polling.
consoleFlowDebug("console-bridge: nextEvent failed; dropping failure and continuing", e)
continue
}
if (event == null) {
closeSource()
return false
}
cached = try {
event.toObjEvent()
} catch (e: Throwable) {
// Malformed/native event payload must not terminate consumer iteration.
consoleFlowDebug("console-bridge: malformed event dropped: $event", e)
null
}
}
return cached != null
}
private suspend fun closeSource() {
if (closed) return
closed = true
// Do not close the underlying console source from VM iterator cancellation.
// CmdFrame.cancelIterators() may call cancelIteration() while user code is still
// expected to keep processing input (e.g. recover from app-level exceptions).
// The source lifecycle is managed by the console runtime.
}
suspend fun hasNext(): Boolean = ensureCached()
suspend fun next(scope: Scope): Obj {
if (!ensureCached()) {
scope.raiseError(ObjIterationFinishedException(scope))
}
val out = cached ?: scope.raiseError("console iterator internal error: missing cached event")
cached = null
return out
}
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply {
addFn("hasNext") {
thisAs<ObjConsoleEventIterator>().hasNext().toObj()
}
addFn("next") {
thisAs<ObjConsoleEventIterator>().next(requireScope())
}
addFn("cancelIteration") {
thisAs<ObjConsoleEventIterator>().closeSource()
ObjVoid
}
}
}
}
private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_DOWN, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_UP, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
}
private fun sanitizedKeyOrFallback(key: String): String {
if (key.isNotEmpty()) return key
consoleFlowDebug("console-bridge: empty key value received; using fallback key name")
return "Unknown"
}
private object ConsoleEnums {
lateinit var eventTypeClass: ObjEnumClass
private set
lateinit var keyCodeClass: ObjEnumClass
private set
lateinit var ansiLevelClass: ObjEnumClass
private set
private lateinit var eventEntries: Map<String, ObjEnumEntry>
private lateinit var keyCodeEntries: Map<String, ObjEnumEntry>
private lateinit var ansiLevelEntries: Map<String, ObjEnumEntry>
val UNKNOWN: ObjEnumEntry get() = event("UNKNOWN")
val RESIZE: ObjEnumEntry get() = event("RESIZE")
val KEY_DOWN: ObjEnumEntry get() = event("KEY_DOWN")
val KEY_UP: ObjEnumEntry get() = event("KEY_UP")
val CODE_UNKNOWN: ObjEnumEntry get() = code("UNKNOWN")
val CHARACTER: ObjEnumEntry get() = code("CHARACTER")
fun initialize(module: ModuleScope) {
eventTypeClass = resolveEnum(module, "ConsoleEventType")
keyCodeClass = resolveEnum(module, "ConsoleKeyCode")
ansiLevelClass = resolveEnum(module, "ConsoleAnsiLevel")
eventEntries = resolveEntries(
eventTypeClass,
listOf("UNKNOWN", "RESIZE", "KEY_DOWN", "KEY_UP")
)
keyCodeEntries = resolveEntries(
keyCodeClass,
listOf(
"UNKNOWN", "CHARACTER", "ARROW_UP", "ARROW_DOWN", "ARROW_LEFT", "ARROW_RIGHT",
"HOME", "END", "INSERT", "DELETE", "PAGE_UP", "PAGE_DOWN",
"ESCAPE", "ENTER", "TAB", "BACKSPACE", "SPACE"
)
)
ansiLevelEntries = resolveEntries(
ansiLevelClass,
listOf("NONE", "BASIC16", "ANSI256", "TRUECOLOR")
)
}
private fun resolveEnum(module: ModuleScope, enumName: String): ObjEnumClass {
val local = module.get(enumName)?.value as? ObjEnumClass
if (local != null) return local
val root = module.importProvider.rootScope.get(enumName)?.value as? ObjEnumClass
return root ?: error("lyng.io.console declaration enum is missing: $enumName")
}
private fun resolveEntries(enumClass: ObjEnumClass, names: List<String>): Map<String, ObjEnumEntry> {
return names.associateWith { name ->
(enumClass.byName[ObjString(name)] as? ObjEnumEntry)
?: error("lyng.io.console enum entry is missing: ${enumClass.className}.$name")
}
}
fun event(name: String): ObjEnumEntry = eventEntries[name]
?: error("lyng.io.console enum entry is missing: ${eventTypeClass.className}.$name")
fun code(name: String): ObjEnumEntry = keyCodeEntries[name]
?: error("lyng.io.console enum entry is missing: ${keyCodeClass.className}.$name")
fun ansiLevel(name: String): ObjEnumEntry = ansiLevelEntries[name]
?: error("lyng.io.console enum entry is missing: ${ansiLevelClass.className}.$name")
}
private val KEY_CODE_BY_KEY_NAME = mapOf(
"ArrowUp" to "ARROW_UP",
"ArrowDown" to "ARROW_DOWN",
"ArrowLeft" to "ARROW_LEFT",
"ArrowRight" to "ARROW_RIGHT",
"Home" to "HOME",
"End" to "END",
"Insert" to "INSERT",
"Delete" to "DELETE",
"PageUp" to "PAGE_UP",
"PageDown" to "PAGE_DOWN",
"Escape" to "ESCAPE",
"Enter" to "ENTER",
"Tab" to "TAB",
"Backspace" to "BACKSPACE",
" " to "SPACE",
)
private fun codeFrom(key: String, codeName: String?): ObjEnumEntry {
val resolved = KEY_CODE_BY_KEY_NAME[codeName ?: key]
return when {
resolved != null -> ConsoleEnums.code(resolved)
key.length == 1 -> ConsoleEnums.CHARACTER
else -> ConsoleEnums.CODE_UNKNOWN
}
}
private abstract class ObjConsoleEventBase(
private val type: ObjEnumEntry,
final override val objClass: net.sergeych.lyng.obj.ObjClass,
) : Obj() {
fun type(): ObjEnumEntry = type
}
private class ObjConsoleEvent : ObjConsoleEventBase(ConsoleEnums.UNKNOWN, type) {
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
addProperty(name = "type", getter = { (this.thisObj as ObjConsoleEventBase).type() })
}
}
}
private class ObjConsoleResizeEvent(
val columns: Int,
val rows: Int,
) : ObjConsoleEventBase(ConsoleEnums.RESIZE, type) {
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() })
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() })
}
}
}
private class ObjConsoleKeyEvent(
type: ObjEnumEntry,
val key: String,
val codeName: String?,
val ctrl: Boolean,
val alt: Boolean,
val shift: Boolean,
val meta: Boolean,
) : ObjConsoleEventBase(type, typeObj) {
init {
require(key.isNotEmpty()) { "ConsoleKeyEvent.key must never be empty" }
}
companion object {
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
addProperty(name = "key", getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) })
addProperty(name = "code", getter = { codeFrom((this.thisObj as ObjConsoleKeyEvent).key, (this.thisObj as ObjConsoleKeyEvent).codeName) })
addProperty(name = "codeName", getter = {
val code = (this.thisObj as ObjConsoleKeyEvent).codeName
code?.let(::ObjString) ?: ObjNull
})
addProperty(name = "ctrl", getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() })
addProperty(name = "alt", getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() })
addProperty(name = "shift", getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() })
addProperty(name = "meta", getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() })
}
}
}
private class ObjConsoleGeometry(
val columns: Int,
val rows: Int,
) : Obj() {
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply {
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() })
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() })
}
}
}
private class ObjConsoleDetails(
val supported: Boolean,
val isTty: Boolean,
val ansiLevel: ObjEnumEntry,
val geometry: ObjConsoleGeometry?,
) : Obj() {
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply {
addProperty(name = "supported", getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() })
addProperty(name = "isTty", getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() })
addProperty(name = "ansiLevel", getter = { (this.thisObj as ObjConsoleDetails).ansiLevel })
addProperty(name = "geometry", getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull })
}
}
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal expect fun consoleFlowDebug(message: String, error: Throwable? = null)
@@ -0,0 +1,132 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
/**
* ANSI color support level detected for the active console.
*/
enum class ConsoleAnsiLevel {
NONE,
BASIC16,
ANSI256,
TRUECOLOR,
}
/**
* Console geometry in character cells.
*/
data class ConsoleGeometry(
val columns: Int,
val rows: Int,
)
/**
* Input/terminal events emitted by the console runtime.
*/
sealed interface ConsoleEvent {
data class Resize(
val columns: Int,
val rows: Int,
) : ConsoleEvent
data class KeyDown(
val key: String,
val code: String? = null,
val ctrl: Boolean = false,
val alt: Boolean = false,
val shift: Boolean = false,
val meta: Boolean = false,
) : ConsoleEvent
data class KeyUp(
val key: String,
val code: String? = null,
val ctrl: Boolean = false,
val alt: Boolean = false,
val shift: Boolean = false,
val meta: Boolean = false,
) : ConsoleEvent
}
/**
* Pull-based console event source.
*
* `nextEvent(timeoutMs)` returns:
* - next event when available,
* - `null` on timeout,
* - `null` after close.
*/
interface ConsoleEventSource {
suspend fun nextEvent(timeoutMs: Long = 0L): ConsoleEvent?
suspend fun close()
}
private object EmptyConsoleEventSource : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
override suspend fun close() {
// no-op
}
}
/**
* Platform-independent console runtime surface.
*/
interface LyngConsole {
val isSupported: Boolean
suspend fun isTty(): Boolean
suspend fun geometry(): ConsoleGeometry?
suspend fun ansiLevel(): ConsoleAnsiLevel
suspend fun write(text: String)
suspend fun flush()
fun events(): ConsoleEventSource
/**
* Set terminal raw input mode. Returns true when mode was changed.
*/
suspend fun setRawMode(enabled: Boolean): Boolean
}
object UnsupportedLyngConsole : LyngConsole {
override val isSupported: Boolean = false
override suspend fun isTty(): Boolean = false
override suspend fun geometry(): ConsoleGeometry? = null
override suspend fun ansiLevel(): ConsoleAnsiLevel = ConsoleAnsiLevel.NONE
override suspend fun write(text: String) {
// no-op
}
override suspend fun flush() {
// no-op
}
override fun events(): ConsoleEventSource = EmptyConsoleEventSource
override suspend fun setRawMode(enabled: Boolean): Boolean = false
}
@@ -0,0 +1,292 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import com.github.ajalt.mordant.input.KeyboardEvent
import com.github.ajalt.mordant.input.RawModeScope
import com.github.ajalt.mordant.input.enterRawModeOrNull
import com.github.ajalt.mordant.rendering.AnsiLevel
import com.github.ajalt.mordant.terminal.Terminal
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
import net.sergeych.mp_tools.globalLaunch
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeSource
/**
* Mordant-backed console runtime implementation.
*/
object MordantLyngConsole : LyngConsole {
private val terminal: Terminal? by lazy {
runCatching { Terminal() }.getOrNull()
}
private val stateMutex = Mutex()
private var rawModeRequested: Boolean = false
private var rawModeScope: RawModeScope? = null
private suspend fun forceRawModeReset(t: Terminal): Boolean = stateMutex.withLock {
if (!rawModeRequested) return@withLock false
runCatching { rawModeScope?.close() }
.onFailure { consoleFlowDebug("forceRawModeReset: close failed", it) }
rawModeScope = null
rawModeRequested = false
if (!t.terminalInfo.inputInteractive) return@withLock false
val reopened = t.enterRawModeOrNull()
rawModeScope = reopened
rawModeRequested = reopened != null
reopened != null
}
override val isSupported: Boolean
get() = terminal != null
override suspend fun isTty(): Boolean {
val t = terminal ?: return false
return t.terminalInfo.outputInteractive
}
override suspend fun geometry(): ConsoleGeometry? {
val t = terminal ?: return null
val size = t.updateSize()
return ConsoleGeometry(size.width, size.height)
}
override suspend fun ansiLevel(): ConsoleAnsiLevel {
val t = terminal ?: return ConsoleAnsiLevel.NONE
return when (t.terminalInfo.ansiLevel) {
AnsiLevel.NONE -> ConsoleAnsiLevel.NONE
AnsiLevel.ANSI16 -> ConsoleAnsiLevel.BASIC16
AnsiLevel.ANSI256 -> ConsoleAnsiLevel.ANSI256
AnsiLevel.TRUECOLOR -> ConsoleAnsiLevel.TRUECOLOR
}
}
override suspend fun write(text: String) {
terminal?.rawPrint(text)
}
override suspend fun flush() {
// Mordant prints via platform streams immediately.
}
override fun events(): ConsoleEventSource {
val t = terminal ?: return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
override suspend fun close() {}
}
val out = Channel<ConsoleEvent>(Channel.UNLIMITED)
val sourceState = Mutex()
var running = true
globalLaunch {
val initialSize = runCatching { t.updateSize() }.getOrNull()
var lastWidth = initialSize?.width ?: 0
var lastHeight = initialSize?.height ?: 0
val startMark = TimeSource.Monotonic.markNow()
var lastHeartbeatMark = startMark
var loops = 0L
var readAttempts = 0L
var readFailures = 0L
var keyEvents = 0L
var resizeEvents = 0L
var rawNullLoops = 0L
var lastKeyMark = startMark
var lastRawRecoveryMark = startMark
fun tryEmitResize(width: Int, height: Int) {
if (width < 1 || height < 1) {
consoleFlowDebug("events: ignored invalid resize width=$width height=$height")
return
}
if (width == lastWidth && height == lastHeight) return
out.trySend(ConsoleEvent.Resize(width, height))
lastWidth = width
lastHeight = height
resizeEvents += 1
}
consoleFlowDebug("events: collector started")
try {
while (currentCoroutineContext().isActive && sourceState.withLock { running }) {
loops += 1
val currentSize = runCatching { t.updateSize() }.getOrNull()
if (currentSize == null) {
delay(150)
continue
}
tryEmitResize(currentSize.width, currentSize.height)
val raw = stateMutex.withLock {
if (!rawModeRequested) {
null
} else {
// Recover raw scope lazily if it was dropped due to an earlier read failure.
if (rawModeScope == null) {
rawModeScope = t.enterRawModeOrNull()
if (rawModeScope == null) {
consoleFlowDebug("events: failed to reopen raw mode scope")
} else {
consoleFlowDebug("events: raw mode scope reopened")
}
}
rawModeScope
}
}
if (raw == null || !t.terminalInfo.inputInteractive) {
rawNullLoops += 1
delay(150)
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
consoleFlowDebug(
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
)
lastHeartbeatMark = TimeSource.Monotonic.markNow()
}
continue
}
readAttempts += 1
val readResult = runCatching { raw.readEventOrNull(150.milliseconds) }
if (readResult.isFailure) {
readFailures += 1
consoleFlowDebug("events: readEventOrNull failed; resetting raw scope", readResult.exceptionOrNull())
// Raw scope became invalid; close and force reopen on next iteration.
stateMutex.withLock {
runCatching { rawModeScope?.close() }
rawModeScope = null
}
delay(50)
continue
}
val ev = readResult.getOrNull()
val resized = runCatching { t.updateSize() }.getOrNull()
if (resized != null) {
tryEmitResize(resized.width, resized.height)
}
when (ev) {
is KeyboardEvent -> {
keyEvents += 1
lastKeyMark = TimeSource.Monotonic.markNow()
out.trySend(
ConsoleEvent.KeyDown(
key = ev.key,
code = null,
ctrl = ev.ctrl,
alt = ev.alt,
shift = ev.shift,
meta = false,
)
)
}
else -> {
// Mouse/other events are ignored in Lyng console v1.
}
}
// Some terminals silently stop delivering keyboard events while raw reads keep succeeding.
// If we had keys before and then prolonged key inactivity, proactively recycle raw scope.
if (keyEvents > 0L &&
lastKeyMark.elapsedNow() >= 4.seconds &&
lastRawRecoveryMark.elapsedNow() >= 4.seconds
) {
if (rawModeRequested) {
consoleFlowDebug("events: key inactivity detected; forcing raw reset")
val resetOk = forceRawModeReset(t)
if (resetOk) {
consoleFlowDebug("events: raw reset succeeded during inactivity recovery")
lastKeyMark = TimeSource.Monotonic.markNow()
} else {
consoleFlowDebug("events: raw reset failed during inactivity recovery")
}
lastRawRecoveryMark = TimeSource.Monotonic.markNow()
}
}
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
consoleFlowDebug(
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
)
lastHeartbeatMark = TimeSource.Monotonic.markNow()
}
}
} catch (e: CancellationException) {
consoleFlowDebug("events: collector cancelled (normal)")
// normal
} catch (e: ScriptFlowIsNoMoreCollected) {
consoleFlowDebug("events: collector stopped by flow consumer (normal)")
// normal
} catch (e: Exception) {
consoleFlowDebug("events: collector loop failed", e)
// terminate event source loop
} finally {
consoleFlowDebug(
"events: collector ended uptime=${startMark.elapsedNow().inWholeMilliseconds}ms loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested"
)
out.close()
}
}
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
if (timeoutMs <= 0L) {
return out.receiveCatching().getOrNull()
}
return withTimeoutOrNull(timeoutMs.milliseconds) {
out.receiveCatching().getOrNull()
}
}
override suspend fun close() {
sourceState.withLock { running = false }
out.close()
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
val t = terminal ?: return false
return stateMutex.withLock {
if (enabled) {
if (!t.terminalInfo.inputInteractive) return@withLock false
if (rawModeRequested) return@withLock false
val scope = t.enterRawModeOrNull() ?: return@withLock false
rawModeScope = scope
rawModeRequested = true
consoleFlowDebug("setRawMode(true): enabled")
true
} else {
val hadRaw = rawModeRequested || rawModeScope != null
rawModeRequested = false
val scope = rawModeScope
rawModeScope = null
runCatching { scope?.close() }
.onFailure { consoleFlowDebug("setRawMode(false): close failed", it) }
consoleFlowDebug("setRawMode(false): disabled hadRaw=$hadRaw")
hadRaw
}
}
}
}
@@ -0,0 +1,23 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
/**
* Get the system default console implementation.
*/
expect fun getSystemConsole(): LyngConsole
@@ -0,0 +1,55 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console.security
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
/**
* Primitive console operations for access control decisions.
*/
sealed interface ConsoleAccessOp {
data class WriteText(val length: Int) : ConsoleAccessOp
data object ReadEvents : ConsoleAccessOp
data class SetRawMode(val enabled: Boolean) : ConsoleAccessOp
}
class ConsoleAccessDeniedException(
val op: ConsoleAccessOp,
val reasonDetail: String? = null,
) : IllegalStateException("Console access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
/**
* Policy interface that decides whether a specific console operation is allowed.
*/
interface ConsoleAccessPolicy {
suspend fun check(op: ConsoleAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
suspend fun require(op: ConsoleAccessOp, ctx: AccessContext = AccessContext()) {
val res = check(op, ctx)
if (!res.isAllowed()) throw ConsoleAccessDeniedException(op, res.reason)
}
}
object PermitAllConsoleAccessPolicy : ConsoleAccessPolicy {
override suspend fun check(op: ConsoleAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Allow)
}
@@ -0,0 +1,68 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console.security
import net.sergeych.lyngio.console.*
import net.sergeych.lyngio.fs.security.AccessContext
/**
* Decorator that applies a [ConsoleAccessPolicy] to a delegate [LyngConsole].
*/
class LyngConsoleSecured(
private val delegate: LyngConsole,
private val policy: ConsoleAccessPolicy,
private val ctx: AccessContext = AccessContext(),
) : LyngConsole {
override val isSupported: Boolean
get() = delegate.isSupported
override suspend fun isTty(): Boolean = delegate.isTty()
override suspend fun geometry(): ConsoleGeometry? = delegate.geometry()
override suspend fun ansiLevel(): ConsoleAnsiLevel = delegate.ansiLevel()
override suspend fun write(text: String) {
policy.require(ConsoleAccessOp.WriteText(text.length), ctx)
delegate.write(text)
}
override suspend fun flush() {
delegate.flush()
}
override fun events(): ConsoleEventSource {
val source = delegate.events()
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
policy.require(ConsoleAccessOp.ReadEvents, ctx)
return source.nextEvent(timeoutMs)
}
override suspend fun close() {
source.close()
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
policy.require(ConsoleAccessOp.SetRawMode(enabled), ctx)
return delegate.setRawMode(enabled)
}
}
@@ -0,0 +1,28 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.docs
/**
* Console docs are declared in `lyngio/stdlib/lyng/io/console.lyng`.
* Keep this shim for compatibility with reflective loaders.
*/
object ConsoleBuiltinDocs {
fun ensure() {
// No Kotlin-side doc registration: console.lyng is the source of truth.
}
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
// no-op on JS
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
actual fun getSystemConsole(): LyngConsole = MordantLyngConsole
@@ -0,0 +1,46 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import java.io.File
import java.time.Instant
private val flowDebugLogFilePath: String =
System.getenv("LYNG_CONSOLE_DEBUG_LOG")
?.takeIf { it.isNotBlank() }
?: "/tmp/lyng_console_flow_debug.log"
private val flowDebugLogLock = Any()
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
runCatching {
val line = buildString {
append(Instant.now().toString())
append(" [console-flow] ")
append(message)
append('\n')
if (error != null) {
append(error.stackTraceToString())
append('\n')
}
}
synchronized(flowDebugLogLock) {
File(flowDebugLogFilePath).appendText(line)
}
}
}
@@ -0,0 +1,602 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.withTimeoutOrNull
import org.jline.terminal.Attributes
import org.jline.terminal.Terminal
import org.jline.terminal.TerminalBuilder
import org.jline.utils.NonBlockingReader
import java.io.EOFException
import java.io.InterruptedIOException
import java.util.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicLong
import java.util.concurrent.atomic.AtomicReference
import kotlin.concurrent.thread
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.seconds
import kotlin.time.TimeSource
/**
* JVM console implementation:
* - output/capabilities/input use a single JLine terminal instance
* to avoid dual-terminal contention.
*/
object JvmLyngConsole : LyngConsole {
private const val DEBUG_REVISION = "jline-r27-no-close-on-vm-iterator-cancel-2026-03-19"
private val codeSourceLocation: String by lazy {
runCatching {
JvmLyngConsole::class.java.protectionDomain?.codeSource?.location?.toString()
}.getOrNull() ?: "<unknown>"
}
private val terminalRef = AtomicReference<Terminal?>(null)
private val terminalInitLock = Any()
private val shutdownHook = Thread(
{
restoreTerminalStateOnShutdown()
},
"lyng-console-shutdown"
).apply { isDaemon = true }
init {
runCatching { Runtime.getRuntime().addShutdownHook(shutdownHook) }
.onFailure { consoleFlowDebug("jline-events: shutdown hook install failed", it) }
}
private fun restoreTerminalStateOnShutdown() {
val term = terminalRef.get() ?: return
runCatching {
term.writer().print("\u001B[?25h")
term.writer().print("\u001B[?1049l")
term.writer().flush()
}.onFailure {
consoleFlowDebug("jline-events: shutdown visual restore failed", it)
}
val saved = if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
try {
rawModeRequested = false
val s = rawSavedAttributes
rawSavedAttributes = null
s
} finally {
stateMutex.unlock()
}
} else {
null
}
if (saved != null) {
runCatching { term.setAttributes(saved) }
.onFailure { consoleFlowDebug("jline-events: shutdown raw attrs restore failed", it) }
}
}
private fun currentTerminal(): Terminal? {
val existing = terminalRef.get()
if (existing != null) return existing
synchronized(terminalInitLock) {
val already = terminalRef.get()
if (already != null) return already
val created = buildTerminal()
if (created != null) terminalRef.set(created)
return created
}
}
private fun buildTerminal(): Terminal? {
System.setProperty(TerminalBuilder.PROP_DISABLE_DEPRECATED_PROVIDER_WARNING, "true")
val providerOrders = listOf(
"exec",
"exec,ffm",
null,
)
for (providers in providerOrders) {
val terminal = runCatching {
val builder = TerminalBuilder.builder().system(true)
if (providers != null) builder.providers(providers)
builder.build()
}.onFailure {
if (providers != null) {
consoleFlowDebug("jline-events: terminal build failed providers=$providers", it)
} else {
consoleFlowDebug("jline-events: terminal build failed default providers", it)
}
}.getOrNull()
if (terminal != null) {
val termType = terminal.type.lowercase(Locale.getDefault())
if (termType.contains("dumb")) {
consoleFlowDebug("jline-events: terminal rejected providers=${providers ?: "<default>"} type=${terminal.type}")
runCatching { terminal.close() }
continue
}
consoleFlowDebug("jline-events: terminal built providers=${providers ?: "<default>"} type=${terminal.type}")
consoleFlowDebug("jline-events: runtime-marker rev=$DEBUG_REVISION codeSource=$codeSourceLocation")
return terminal
}
}
return null
}
private val stateMutex = Mutex()
private var rawModeRequested: Boolean = false
private var rawSavedAttributes: Attributes? = null
private fun enforceRawReadAttrs(term: Terminal) {
runCatching {
val attrs = term.attributes
attrs.setLocalFlag(Attributes.LocalFlag.ICANON, false)
attrs.setLocalFlag(Attributes.LocalFlag.ECHO, false)
attrs.setControlChar(Attributes.ControlChar.VMIN, 0)
attrs.setControlChar(Attributes.ControlChar.VTIME, 1)
term.setAttributes(attrs)
}.onFailure {
consoleFlowDebug("jline-events: enforceRawReadAttrs failed", it)
}
}
override val isSupported: Boolean
get() = currentTerminal() != null
override suspend fun isTty(): Boolean {
val term = currentTerminal() ?: return false
return !term.type.lowercase(Locale.getDefault()).contains("dumb")
}
override suspend fun geometry(): ConsoleGeometry? {
val term = currentTerminal() ?: return null
val size = runCatching { term.size }.getOrNull() ?: return null
if (size.columns <= 0 || size.rows <= 0) return null
return ConsoleGeometry(size.columns, size.rows)
}
override suspend fun ansiLevel(): ConsoleAnsiLevel {
val colorTerm = (System.getenv("COLORTERM") ?: "").lowercase(Locale.getDefault())
val term = (System.getenv("TERM") ?: "").lowercase(Locale.getDefault())
return when {
colorTerm.contains("truecolor") || colorTerm.contains("24bit") -> ConsoleAnsiLevel.TRUECOLOR
term.contains("256color") -> ConsoleAnsiLevel.ANSI256
term.isNotBlank() && term != "dumb" -> ConsoleAnsiLevel.BASIC16
else -> ConsoleAnsiLevel.NONE
}
}
override suspend fun write(text: String) {
val term = currentTerminal() ?: return
term.writer().print(text)
}
override suspend fun flush() {
val term = currentTerminal() ?: return
term.writer().flush()
}
override fun events(): ConsoleEventSource {
var activeTerm = currentTerminal() ?: return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
override suspend fun close() {}
}
val out = Channel<ConsoleEvent>(Channel.UNLIMITED)
val keyEvents = AtomicLong(0L)
val keyCodesRead = AtomicLong(0L)
val keySendFailures = AtomicLong(0L)
val readFailures = AtomicLong(0L)
val readerRecoveries = AtomicLong(0L)
var lastHeartbeat = TimeSource.Monotonic.markNow()
val keyLoopRunning = AtomicBoolean(true)
val keyLoopCount = AtomicLong(0L)
val keyReadStartNs = AtomicLong(0L)
val keyReadEndNs = AtomicLong(0L)
val lastKeyReadNs = AtomicLong(System.nanoTime())
val lastRecoveryNs = AtomicLong(0L)
val recoveryRequested = AtomicBoolean(false)
val running = AtomicBoolean(true)
var winchHandler: Terminal.SignalHandler? = null
var reader = activeTerm.reader()
var keyThread: Thread? = null
var heartbeatThread: Thread? = null
val resizeEmitMutex = Any()
var lastResizeCols = Int.MIN_VALUE
var lastResizeRows = Int.MIN_VALUE
fun emitResize() {
val size = runCatching { activeTerm.size }.getOrNull() ?: return
val cols = size.columns
val rows = size.rows
if (cols < 1 || rows < 1) {
consoleFlowDebug("jline-events: ignored invalid resize columns=$cols rows=$rows")
return
}
val shouldEmit = synchronized(resizeEmitMutex) {
if (cols == lastResizeCols && rows == lastResizeRows) {
false
} else {
lastResizeCols = cols
lastResizeRows = rows
true
}
}
if (!shouldEmit) return
out.trySend(ConsoleEvent.Resize(cols, rows))
}
fun cleanup() {
running.set(false)
keyLoopRunning.set(false)
runCatching { reader.shutdown() }
runCatching {
if (winchHandler != null) {
activeTerm.handle(Terminal.Signal.WINCH, winchHandler)
}
}.onFailure {
consoleFlowDebug("jline-events: WINCH handler restore failed", it)
}
runCatching { keyThread?.interrupt() }
runCatching { heartbeatThread?.interrupt() }
out.close()
}
fun installWinchHandler() {
winchHandler = runCatching {
activeTerm.handle(Terminal.Signal.WINCH) {
emitResize()
}
}.onFailure {
consoleFlowDebug("jline-events: WINCH handler install failed", it)
}.getOrNull()
}
fun tryRebuildTerminal(): Boolean {
val oldTerm = activeTerm
val rebuilt = runCatching {
synchronized(terminalInitLock) {
if (terminalRef.get() === oldTerm) {
terminalRef.set(null)
}
}
runCatching { oldTerm.close() }
.onFailure { consoleFlowDebug("jline-events: old terminal close failed during rebuild", it) }
currentTerminal()
}.onFailure {
consoleFlowDebug("jline-events: terminal rebuild failed", it)
}.getOrNull() ?: return false
if (rebuilt === oldTerm) {
consoleFlowDebug("jline-events: terminal rebuild returned same terminal instance")
return false
}
activeTerm = rebuilt
reader = activeTerm.reader()
val rawRequestedNow = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
rawModeRequested
} finally {
stateMutex.unlock()
}
if (rawRequestedNow) {
val saved = runCatching { activeTerm.enterRawMode() }.getOrNull()
if (saved != null) {
enforceRawReadAttrs(activeTerm)
if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
try {
rawSavedAttributes = saved
} finally {
stateMutex.unlock()
}
}
} else {
consoleFlowDebug("jline-events: terminal rebuild succeeded but enterRawMode failed")
}
}
installWinchHandler()
emitResize()
consoleFlowDebug("jline-events: terminal rebuilt and rebound")
return true
}
consoleFlowDebug("jline-events: collector started rev=$DEBUG_REVISION")
emitResize()
installWinchHandler()
keyThread = thread(start = true, isDaemon = true, name = "lyng-jline-key-reader") {
consoleFlowDebug("jline-events: key-reader thread started")
consoleFlowDebug("jline-events: using NonBlockingReader key path")
while (running.get() && keyLoopRunning.get()) {
keyLoopCount.incrementAndGet()
try {
if (recoveryRequested.compareAndSet(true, false)) {
val prevReader = reader
runCatching { prevReader.shutdown() }
.onFailure { consoleFlowDebug("jline-events: reader shutdown failed during recovery", it) }
reader = activeTerm.reader()
if (reader === prevReader) {
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)} -> forcing terminal rebuild")
if (!tryRebuildTerminal()) {
consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader")
}
} else {
consoleFlowDebug("jline-events: reader recovered oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)}")
}
readerRecoveries.incrementAndGet()
lastRecoveryNs.set(System.nanoTime())
}
val isRaw = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
rawModeRequested
} finally {
stateMutex.unlock()
}
if (!isRaw) {
Thread.sleep(20)
continue
}
keyReadStartNs.set(System.nanoTime())
val event = readKeyEvent(reader)
keyReadEndNs.set(System.nanoTime())
if (event == null) {
continue
}
keyCodesRead.incrementAndGet()
lastKeyReadNs.set(System.nanoTime())
if (out.trySend(event).isSuccess) {
keyEvents.incrementAndGet()
} else {
keySendFailures.incrementAndGet()
}
} catch (e: InterruptedException) {
// Keep input alive if this is a transient interrupt while still running.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: key-reader interrupted; scheduling reader recovery", e)
Thread.interrupted()
continue
} catch (e: InterruptedIOException) {
// Common during reader shutdown/rebind. Recover silently and keep input flowing.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: read interrupted; scheduling reader recovery", e)
try {
Thread.sleep(10)
} catch (ie: InterruptedException) {
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during recovery backoff; continuing", ie)
Thread.interrupted()
}
} catch (e: EOFException) {
// EOF from reader should trigger rebind/rebuild rather than ending input stream.
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: reader EOF; scheduling reader recovery", e)
try {
Thread.sleep(20)
} catch (ie: InterruptedException) {
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during EOF backoff; continuing", ie)
Thread.interrupted()
}
} catch (e: Throwable) {
readFailures.incrementAndGet()
recoveryRequested.set(true)
consoleFlowDebug("jline-events: blocking read failed", e)
try {
Thread.sleep(50)
} catch (ie: InterruptedException) {
if (!running.get() || !keyLoopRunning.get()) break
recoveryRequested.set(true)
consoleFlowDebug("jline-events: interrupted during error backoff; continuing", ie)
Thread.interrupted()
}
}
}
consoleFlowDebug(
"jline-events: key-reader thread stopped running=${running.get()} keyLoopRunning=${keyLoopRunning.get()} loops=${keyLoopCount.get()} keys=${keyEvents.get()} readFailures=${readFailures.get()}"
)
}
heartbeatThread = thread(start = true, isDaemon = true, name = "lyng-jline-heartbeat") {
while (running.get()) {
if (lastHeartbeat.elapsedNow() >= 2.seconds) {
val requested = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
rawModeRequested
} finally {
stateMutex.unlock()
}
val readStartNs = keyReadStartNs.get()
val readEndNs = keyReadEndNs.get()
val lastKeyNs = lastKeyReadNs.get()
val idleMs = if (lastKeyNs > 0L) (System.nanoTime() - lastKeyNs) / 1_000_000L else 0L
val readBlockedMs = if (readStartNs > 0L && readEndNs < readStartNs) {
(System.nanoTime() - readStartNs) / 1_000_000L
} else 0L
val streamIdle = requested && keyCodesRead.get() > 0L && idleMs >= 1400L
val readStalled = requested && readBlockedMs >= 1600L
if (streamIdle || readStalled) {
val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L
if (sinceRecoveryMs >= 1200L) {
recoveryRequested.set(true)
if (readStalled) {
consoleFlowDebug("jline-events: key read blocked ${readBlockedMs}ms; scheduling reader recovery")
} else {
consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery")
}
}
}
consoleFlowDebug(
"jline-events: heartbeat keyCodes=${keyCodesRead.get()} keysSent=${keyEvents.get()} sendFailures=${keySendFailures.get()} readFailures=${readFailures.get()} recoveries=${readerRecoveries.get()} rawRequested=$requested keyLoop=${keyLoopCount.get()} readBlockedMs=$readBlockedMs keyIdleMs=$idleMs keyPath=reader"
)
lastHeartbeat = TimeSource.Monotonic.markNow()
}
try {
Thread.sleep(200)
} catch (_: InterruptedException) {
break
}
}
}
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
if (!running.get()) return null
if (timeoutMs <= 0L) {
return out.receiveCatching().getOrNull()
}
return withTimeoutOrNull(timeoutMs.milliseconds) {
out.receiveCatching().getOrNull()
}
}
override suspend fun close() {
consoleFlowDebug("jline-events: collector close requested", Throwable("collector close caller"))
cleanup()
consoleFlowDebug(
"jline-events: collector ended keys=${keyEvents.get()} readFailures=${readFailures.get()}"
)
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
val term = currentTerminal() ?: return false
return stateMutex.withLock {
if (enabled) {
if (rawModeRequested) return@withLock false
val saved = runCatching { term.enterRawMode() }.getOrNull() ?: return@withLock false
enforceRawReadAttrs(term)
rawSavedAttributes = saved
rawModeRequested = true
consoleFlowDebug("jline-events: setRawMode(true): enabled")
true
} else {
val hadRaw = rawModeRequested
rawModeRequested = false
val saved = rawSavedAttributes
rawSavedAttributes = null
runCatching {
if (saved != null) term.setAttributes(saved)
}.onFailure {
consoleFlowDebug("jline-events: setRawMode(false): restore failed", it)
}
consoleFlowDebug("jline-events: setRawMode(false): disabled hadRaw=$hadRaw")
hadRaw
}
}
}
private fun readKeyEvent(reader: NonBlockingReader): ConsoleEvent.KeyDown? {
val code = reader.read(120L)
if (code == NonBlockingReader.READ_EXPIRED) return null
if (code < 0) throw EOFException("non-blocking reader returned EOF")
return decodeKey(code) { timeout -> readNextCode(reader, timeout) }
}
private fun decodeKey(code: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
if (code == 27) {
val next = nextCode(25L)
if (next == null || next < 0) {
return key("Escape")
}
if (next == '['.code || next == 'O'.code) {
val sb = StringBuilder()
sb.append(next.toChar())
var i = 0
while (i < 6) {
val c = nextCode(25L) ?: break
if (c < 0) break
sb.append(c.toChar())
if (c.toChar().isLetter() || c == '~'.code) break
i += 1
}
return keyFromAnsiSequence(sb.toString()) ?: key("Escape")
}
// Alt+key
val base = decodePlainKey(next)
return ConsoleEvent.KeyDown(
key = base.key,
code = base.code,
ctrl = base.ctrl,
alt = true,
shift = base.shift,
meta = false
)
}
return decodePlainKey(code)
}
private fun readNextCode(reader: NonBlockingReader, timeoutMs: Long): Int? {
val c = reader.read(timeoutMs)
if (c == NonBlockingReader.READ_EXPIRED) return null
if (c < 0) throw EOFException("non-blocking reader returned EOF while decoding key sequence")
return c
}
private fun decodePlainKey(code: Int): ConsoleEvent.KeyDown = when (code) {
3 -> key("c", ctrl = true)
9 -> key("Tab")
10, 13 -> key("Enter")
127, 8 -> key("Backspace")
32 -> key(" ")
else -> {
if (code in 1..26) {
val ch = ('a'.code + code - 1).toChar().toString()
key(ch, ctrl = true)
} else {
val ch = code.toChar().toString()
key(ch, shift = ch.length == 1 && ch[0].isLetter() && ch[0].isUpperCase())
}
}
}
private fun keyFromAnsiSequence(seq: String): ConsoleEvent.KeyDown? = when (seq) {
"[A", "OA" -> key("ArrowUp")
"[B", "OB" -> key("ArrowDown")
"[C", "OC" -> key("ArrowRight")
"[D", "OD" -> key("ArrowLeft")
"[H", "OH" -> key("Home")
"[F", "OF" -> key("End")
"[2~" -> key("Insert")
"[3~" -> key("Delete")
"[5~" -> key("PageUp")
"[6~" -> key("PageDown")
else -> null
}
private fun key(
value: String,
ctrl: Boolean = false,
alt: Boolean = false,
shift: Boolean = false,
): ConsoleEvent.KeyDown {
require(value.isNotEmpty()) { "ConsoleEvent.KeyDown.key must never be empty" }
return ConsoleEvent.KeyDown(
key = value,
code = null,
ctrl = ctrl,
alt = alt,
shift = shift,
meta = false
)
}
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
actual fun getSystemConsole(): LyngConsole = JvmLyngConsole
@@ -0,0 +1,115 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.io.console
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Scope
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjIllegalOperationException
import net.sergeych.lyngio.console.security.ConsoleAccessOp
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import kotlin.test.Test
import kotlin.test.assertFalse
import kotlin.test.assertIs
import kotlin.test.assertTrue
class LyngConsoleModuleTest {
private fun newScope(): Scope = Scope.new()
@Test
fun installIsIdempotent() = runBlocking {
val scope = newScope()
assertTrue(createConsoleModule(PermitAllConsoleAccessPolicy, scope))
assertFalse(createConsoleModule(PermitAllConsoleAccessPolicy, scope))
}
@Test
fun moduleSmokeScript() = runBlocking {
val scope = newScope()
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
val code = """
import lyng.io.console
import lyng.stdlib
val d = Console.details()
assert(d.supported is Bool)
assert(d.isTty is Bool)
assert(d.ansiLevel is ConsoleAnsiLevel)
val g = Console.geometry()
if (g != null) {
assert(g.columns is Int)
assert(g.rows is Int)
assert(g.columns > 0)
assert(g.rows > 0)
}
assert(Console.events() is Iterable)
Console.write("")
Console.flush()
Console.home()
Console.clear()
Console.moveTo(1, 1)
Console.clearLine()
Console.enterAltScreen()
Console.leaveAltScreen()
Console.setCursorVisible(true)
val changed = Console.setRawMode(false)
assert(changed is Bool)
true
""".trimIndent()
val result = scope.eval(code)
assertIs<ObjBool>(result)
assertTrue(result.value)
}
@Test
fun denyWritePolicyMapsToIllegalOperation() {
runBlocking {
val denyWritePolicy = object : ConsoleAccessPolicy {
override suspend fun check(op: ConsoleAccessOp, ctx: AccessContext): AccessDecision = when (op) {
is ConsoleAccessOp.WriteText -> AccessDecision(Decision.Deny, "denied by test policy")
else -> AccessDecision(Decision.Allow)
}
}
val scope = newScope()
createConsoleModule(denyWritePolicy, scope)
val error = kotlin.test.assertFailsWith<ExecutionError> {
scope.eval(
"""
import lyng.io.console
Console.write("x")
""".trimIndent()
)
}
assertIs<ObjIllegalOperationException>(error.errorObject)
}
}
}
@@ -0,0 +1,77 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import kotlinx.coroutines.runBlocking
import kotlin.test.Test
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
class MordantLyngConsoleJvmTest {
@Test
fun basicCapabilitiesSmoke() = runBlocking {
val console = getSystemConsole()
assertNotNull(console)
// Must be callable in any environment (interactive or redirected output).
val tty = console.isTty()
val ansi = console.ansiLevel()
val geometry = console.geometry()
if (geometry != null) {
assertTrue(geometry.columns > 0, "columns must be positive when geometry is present")
assertTrue(geometry.rows > 0, "rows must be positive when geometry is present")
}
// no-op smoke checks
console.write("")
console.flush()
// Keep values live so compiler doesn't optimize away calls in future changes
assertNotNull(ansi)
assertTrue(tty || !tty)
}
@Test
fun setRawModeContract() = runBlocking {
val console = getSystemConsole()
val enabledChanged = console.setRawMode(true)
val disabledChanged = console.setRawMode(false)
// If enabling changed state, disabling should also change it back.
if (enabledChanged) {
assertTrue(disabledChanged, "raw mode disable should report changed after enable")
}
}
@Test
fun eventsSourceDoesNotCrash() = runBlocking {
val console = getSystemConsole()
val source = console.events()
val event = source.nextEvent(350)
source.close()
// Any event kind is acceptable in this smoke test; null is also valid when idle.
if (event != null) {
assertTrue(
event is ConsoleEvent.Resize || event is ConsoleEvent.KeyDown || event is ConsoleEvent.KeyUp,
"unexpected event type: ${event::class.simpleName}"
)
}
}
}
@@ -0,0 +1,243 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import kotlinx.cinterop.*
import kotlinx.coroutines.delay
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import platform.posix.*
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.TimeSource
internal actual fun getNativeSystemConsole(): LyngConsole = LinuxPosixLyngConsole
internal object LinuxConsoleKeyDecoder {
fun decode(firstCode: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
if (firstCode == 27) {
val next = nextCode(25L)
if (next == null || next < 0) return key("Escape")
if (next == '['.code || next == 'O'.code) {
val sb = StringBuilder()
sb.append(next.toChar())
var i = 0
while (i < 8) {
val c = nextCode(25L) ?: break
if (c < 0) break
sb.append(c.toChar())
if (c.toChar().isLetter() || c == '~'.code) break
i += 1
}
return keyFromAnsiSequence(sb.toString()) ?: key("Escape")
}
val base = decodePlain(next)
return ConsoleEvent.KeyDown(
key = base.key,
code = base.code,
ctrl = base.ctrl,
alt = true,
shift = base.shift,
meta = false,
)
}
return decodePlain(firstCode)
}
private fun decodePlain(code: Int): ConsoleEvent.KeyDown {
if (code == 3) return ConsoleEvent.KeyDown(key = "c", ctrl = true)
if (code == 9) return key("Tab")
if (code == 10 || code == 13) return key("Enter")
if (code == 32) return key(" ")
if (code == 127 || code == 8) return key("Backspace")
val c = code.toChar()
return if (c in 'A'..'Z') {
ConsoleEvent.KeyDown(key = c.toString(), shift = true)
} else {
key(c.toString())
}
}
private fun keyFromAnsiSequence(seq: String): ConsoleEvent.KeyDown? {
val letter = seq.lastOrNull() ?: return null
val shift = seq.contains(";2")
val alt = seq.contains(";3")
val ctrl = seq.contains(";5")
val key = when (letter) {
'A' -> "ArrowUp"
'B' -> "ArrowDown"
'C' -> "ArrowRight"
'D' -> "ArrowLeft"
'H' -> "Home"
'F' -> "End"
else -> return null
}
return ConsoleEvent.KeyDown(key = key, ctrl = ctrl, alt = alt, shift = shift)
}
private fun key(name: String): ConsoleEvent.KeyDown = ConsoleEvent.KeyDown(key = name)
}
@OptIn(ExperimentalForeignApi::class)
object LinuxPosixLyngConsole : LyngConsole {
private val stateMutex = Mutex()
private var rawModeRequested = false
private var savedAttrsBlob: ByteArray? = null
override val isSupported: Boolean
get() = isatty(STDIN_FILENO) == 1 && isatty(STDOUT_FILENO) == 1
override suspend fun isTty(): Boolean = isSupported
override suspend fun geometry(): ConsoleGeometry? = readGeometry()
override suspend fun ansiLevel(): ConsoleAnsiLevel {
val colorTerm = (getenv("COLORTERM")?.toKString() ?: "").lowercase()
val term = (getenv("TERM")?.toKString() ?: "").lowercase()
return when {
colorTerm.contains("truecolor") || colorTerm.contains("24bit") -> ConsoleAnsiLevel.TRUECOLOR
term.contains("256color") -> ConsoleAnsiLevel.ANSI256
term.isNotBlank() && term != "dumb" -> ConsoleAnsiLevel.BASIC16
else -> ConsoleAnsiLevel.NONE
}
}
override suspend fun write(text: String) {
kotlin.io.print(text)
}
override suspend fun flush() {
fflush(null)
}
override fun events(): ConsoleEventSource {
if (!isSupported) {
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
override suspend fun close() {}
}
}
return object : ConsoleEventSource {
var closed = false
var lastGeometry: ConsoleGeometry? = null
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
if (closed) return null
val started = TimeSource.Monotonic.markNow()
while (!closed) {
val g = readGeometry()
if (g != null && (lastGeometry == null || g.columns != lastGeometry?.columns || g.rows != lastGeometry?.rows)) {
lastGeometry = g
return ConsoleEvent.Resize(g.columns, g.rows)
}
val rawRequested = stateMutex.withLock { rawModeRequested }
val pollSliceMs = if (timeoutMs <= 0L) 250L else minOf(250L, timeoutMs)
if (rawRequested) {
val ev = readKeyEvent(pollSliceMs)
if (ev != null) return ev
} else {
delay(25)
}
if (timeoutMs > 0L && started.elapsedNow() >= timeoutMs.milliseconds) {
return null
}
}
return null
}
override suspend fun close() {
closed = true
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
if (!isSupported) return false
return stateMutex.withLock {
if (enabled) {
if (rawModeRequested) return@withLock false
memScoped {
val attrs = alloc<termios>()
if (tcgetattr(STDIN_FILENO, attrs.ptr) != 0) return@withLock false
val saved = ByteArray(sizeOf<termios>().toInt())
saved.usePinned { pinned ->
memcpy(pinned.addressOf(0), attrs.ptr, sizeOf<termios>().convert())
}
savedAttrsBlob = saved
attrs.c_lflag = attrs.c_lflag and ICANON.convert<UInt>().inv() and ECHO.convert<UInt>().inv()
attrs.c_iflag = attrs.c_iflag and IXON.convert<UInt>().inv() and ISTRIP.convert<UInt>().inv()
attrs.c_oflag = attrs.c_oflag and OPOST.convert<UInt>().inv()
if (tcsetattr(STDIN_FILENO, TCSANOW, attrs.ptr) != 0) return@withLock false
}
rawModeRequested = true
true
} else {
val hadRaw = rawModeRequested
rawModeRequested = false
val saved = savedAttrsBlob
if (saved != null) {
memScoped {
val attrs = alloc<termios>()
saved.usePinned { pinned ->
memcpy(attrs.ptr, pinned.addressOf(0), sizeOf<termios>().convert())
}
tcsetattr(STDIN_FILENO, TCSANOW, attrs.ptr)
}
}
hadRaw
}
}
}
private fun readGeometry(): ConsoleGeometry? = memScoped {
val ws = alloc<winsize>()
if (ioctl(STDOUT_FILENO, TIOCGWINSZ.convert(), ws.ptr) != 0) return null
val cols = ws.ws_col.toInt()
val rows = ws.ws_row.toInt()
if (cols <= 0 || rows <= 0) return null
ConsoleGeometry(columns = cols, rows = rows)
}
private fun readByte(timeoutMs: Long): Int? = memScoped {
val pfd = alloc<pollfd>()
pfd.fd = STDIN_FILENO
pfd.events = POLLIN.convert()
pfd.revents = 0
val ready = poll(pfd.ptr, 1.convert(), timeoutMs.toInt())
if (ready <= 0) return null
val buf = ByteArray(1)
val count = buf.usePinned { pinned ->
read(STDIN_FILENO, pinned.addressOf(0), 1.convert())
}
if (count <= 0) return null
val b = buf[0].toInt()
if (b < 0) b + 256 else b
}
private fun readKeyEvent(timeoutMs: Long): ConsoleEvent.KeyDown? {
val first = readByte(timeoutMs) ?: return null
return LinuxConsoleKeyDecoder.decode(first) { timeout ->
readByte(timeout)
}
}
}
@@ -0,0 +1,67 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
class LinuxPosixLyngConsoleTest {
private fun decode(vararg bytes: Int): ConsoleEvent.KeyDown {
var i = 1
return LinuxConsoleKeyDecoder.decode(bytes[0]) { _ ->
if (i >= bytes.size) null else bytes[i++]
}
}
@Test
fun decodesArrowLeft() {
val ev = decode(27, '['.code, 'D'.code)
assertEquals("ArrowLeft", ev.key)
assertFalse(ev.ctrl)
}
@Test
fun decodesArrowRightCtrlModifier() {
val ev = decode(27, '['.code, '1'.code, ';'.code, '5'.code, 'C'.code)
assertEquals("ArrowRight", ev.key)
assertTrue(ev.ctrl)
}
@Test
fun decodesEscape() {
val ev = decode(27)
assertEquals("Escape", ev.key)
}
@Test
fun decodesCtrlC() {
val ev = decode(3)
assertEquals("c", ev.key)
assertTrue(ev.ctrl)
}
@Test
fun decodesUppercaseShift() {
val ev = decode('A'.code)
assertEquals("A", ev.key)
assertTrue(ev.shift)
}
}
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
// no-op on Native
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
actual fun getSystemConsole(): LyngConsole = getNativeSystemConsole()
internal expect fun getNativeSystemConsole(): LyngConsole
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
// no-op on wasmJs
}
+157
View File
@@ -0,0 +1,157 @@
package lyng.io.console
/* Console event kinds used by `ConsoleEvent.type`. */
enum ConsoleEventType {
UNKNOWN,
RESIZE,
KEY_DOWN,
KEY_UP
}
/* Normalized key codes used by `ConsoleKeyEvent.code`. */
enum ConsoleKeyCode {
UNKNOWN,
CHARACTER,
ARROW_UP,
ARROW_DOWN,
ARROW_LEFT,
ARROW_RIGHT,
HOME,
END,
INSERT,
DELETE,
PAGE_UP,
PAGE_DOWN,
ESCAPE,
ENTER,
TAB,
BACKSPACE,
SPACE
}
/* Detected ANSI terminal capability level. */
enum ConsoleAnsiLevel {
NONE,
BASIC16,
ANSI256,
TRUECOLOR
}
/* Base class for console events. */
extern class ConsoleEvent {
/* Event kind for stable matching/switching. */
val type: ConsoleEventType
}
/* Terminal resize event. */
extern class ConsoleResizeEvent : ConsoleEvent {
/* Current terminal width in character cells. */
val columns: Int
/* Current terminal height in character cells. */
val rows: Int
}
/* Keyboard event. */
extern class ConsoleKeyEvent : ConsoleEvent {
/*
Logical key name normalized for app-level handling, for example:
"a", "A", "ArrowLeft", "Escape", "Enter".
*/
val key: String
/* Normalized key code enum for robust matching independent of backend specifics. */
val code: ConsoleKeyCode
/*
Optional backend-specific raw identifier (if available).
Not guaranteed to be present or stable across platforms.
*/
val codeName: String?
/* True when Ctrl was pressed during the key event. */
val ctrl: Bool
/* True when Alt/Option was pressed during the key event. */
val alt: Bool
/* True when Shift was pressed during the key event. */
val shift: Bool
/* True when Meta/Super/Command was pressed during the key event. */
val meta: Bool
}
/* Pull iterator over console events. */
extern class ConsoleEventIterator : Iterator<ConsoleEvent> {
/* Whether another event is currently available from the stream. */
override fun hasNext(): Bool
/* Returns next event or throws iteration-finished when exhausted/cancelled. */
override fun next(): ConsoleEvent
/* Stops this iterator. The underlying console service remains managed by runtime. */
override fun cancelIteration(): void
}
/* Endless iterable console event stream. */
extern class ConsoleEventStream : Iterable<ConsoleEvent> {
/* Creates a fresh event iterator bound to the current console input stream. */
override fun iterator(): ConsoleEventIterator
}
/* Terminal geometry in character cells. */
extern class ConsoleGeometry {
val columns: Int
val rows: Int
}
/* Snapshot of console support/capabilities. */
extern class ConsoleDetails {
/* True when current runtime has console control implementation. */
val supported: Bool
/* True when output/input are attached to an interactive terminal. */
val isTty: Bool
/* Detected terminal color capability level. */
val ansiLevel: ConsoleAnsiLevel
/* Current terminal size if available, otherwise null. */
val geometry: ConsoleGeometry?
}
/* Console API singleton object. */
extern object Console {
/* Returns true when console control API is implemented in this runtime. */
fun isSupported(): Bool
/* Returns true when process is attached to interactive TTY. */
fun isTty(): Bool
/* Returns detected color capability level. */
fun ansiLevel(): ConsoleAnsiLevel
/* Returns current terminal geometry, or null when unavailable. */
fun geometry(): ConsoleGeometry?
/* Returns combined capability snapshot in one call. */
fun details(): ConsoleDetails
/* Writes raw text to console output buffer (no implicit newline). */
fun write(text: String): void
/* Flushes pending console output. Call after batched writes. */
fun flush(): void
/* Moves cursor to home position (row 1, column 1). */
fun home(): void
/* Clears visible screen buffer. Cursor position is backend-dependent after clear. */
fun clear(): void
/* Moves cursor to 1-based row/column. Values outside viewport are backend-defined. */
fun moveTo(row: Int, column: Int): void
/* Clears current line content. Cursor stays on the same line. */
fun clearLine(): void
/* Switches terminal into alternate screen buffer (useful for TUIs). */
fun enterAltScreen(): void
/* Returns from alternate screen buffer to the normal terminal screen. */
fun leaveAltScreen(): void
/* Shows or hides the cursor. Prefer restoring visibility in finally blocks. */
fun setCursorVisible(visible: Bool): void
/*
Returns endless event stream (resize + key events).
Typical usage is consuming in a launched loop.
*/
fun events(): ConsoleEventStream
/*
Enables/disables raw keyboard mode.
Returns true when state was actually changed.
*/
fun setRawMode(enabled: Bool): Bool
}
+2 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.5.0-SNAPSHOT" version = "1.5.1"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -101,6 +101,7 @@ kotlin {
//put your multiplatform dependencies here //put your multiplatform dependencies here
api(libs.kotlinx.coroutines.core) api(libs.kotlinx.coroutines.core)
api(libs.mp.bintools) api(libs.mp.bintools)
implementation(libs.ionspin.bignum)
} }
} }
val commonTest by getting { val commonTest by getting {
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on Android
}
@@ -184,6 +184,7 @@ class Compiler(
private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf() private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val objectDeclNames: MutableSet<String> = mutableSetOf() private val objectDeclNames: MutableSet<String> = mutableSetOf()
private val externCallableNames: MutableSet<String> = mutableSetOf() private val externCallableNames: MutableSet<String> = mutableSetOf()
private val externBindingNames: MutableSet<String> = mutableSetOf()
private val moduleDeclaredNames: MutableSet<String> = mutableSetOf() private val moduleDeclaredNames: MutableSet<String> = mutableSetOf()
private var seedingSlotPlan: Boolean = false private var seedingSlotPlan: Boolean = false
@@ -192,6 +193,7 @@ class Compiler(
if (plan.slots.isEmpty()) return emptyMap() if (plan.slots.isEmpty()) return emptyMap()
val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size) val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size)
for ((name, entry) in plan.slots) { for ((name, entry) in plan.slots) {
if (externBindingNames.contains(name)) continue
result[name] = ForcedLocalSlotInfo( result[name] = ForcedLocalSlotInfo(
index = entry.index, index = entry.index,
isMutable = entry.isMutable, isMutable = entry.isMutable,
@@ -581,7 +583,7 @@ class Compiler(
val baseNames = cls.directParents.map { it.className } val baseNames = cls.directParents.map { it.className }
val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1 val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1
val nextMethodId = (methodIds.values.maxOrNull() ?: -1) + 1 val nextMethodId = (methodIds.values.maxOrNull() ?: -1) + 1
return CompileClassInfo(name, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames) return CompileClassInfo(name, cls.logicalPackageName, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames)
} }
private data class BaseMemberIds( private data class BaseMemberIds(
@@ -885,6 +887,7 @@ class Compiler(
name = declaredName, name = declaredName,
isMutable = false, isMutable = false,
visibility = Visibility.Public, visibility = Visibility.Public,
actualExtern = false,
initializer = initStmt, initializer = initStmt,
isTransient = false, isTransient = false,
typeDecl = null, typeDecl = null,
@@ -1120,7 +1123,16 @@ class Compiler(
if (implicitType != null) { if (implicitType != null) {
resolutionSink?.referenceMember(name, pos, implicitType) resolutionSink?.referenceMember(name, pos, implicitType)
val ids = resolveImplicitThisMemberIds(name, pos, implicitType) val ids = resolveImplicitThisMemberIds(name, pos, implicitType)
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, implicitType) val inClassContext = codeContexts.any { ctx -> ctx is CodeContext.ClassBody }
val currentImplicitType = currentImplicitThisTypeName()
val preferredType = when {
inClassContext -> implicitType
// Extension receiver aliases (extern class name -> host runtime class) can fail strict
// variant casts; keep current receiver untyped but preserve non-current receivers.
implicitType == currentImplicitType -> null
else -> implicitType
}
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, preferredType)
} }
if (classCtx != null && classCtx.classScopeMembers.contains(name)) { if (classCtx != null && classCtx.classScopeMembers.contains(name)) {
resolutionSink?.referenceMember(name, pos, classCtx.name) resolutionSink?.referenceMember(name, pos, classCtx.name)
@@ -1541,6 +1553,7 @@ class Compiler(
private data class CompileClassInfo( private data class CompileClassInfo(
val name: String, val name: String,
val packageName: String?,
val fieldIds: Map<String, Int>, val fieldIds: Map<String, Int>,
val methodIds: Map<String, Int>, val methodIds: Map<String, Int>,
val nextFieldId: Int, val nextFieldId: Int,
@@ -1742,6 +1755,7 @@ class Compiler(
enumEntriesByName = enumEntriesByName, enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) as BytecodeStatement ) as BytecodeStatement
unwrapped to bytecodeStmt.bytecodeFunction() unwrapped to bytecodeStmt.bytecodeFunction()
@@ -1948,6 +1962,9 @@ class Compiler(
val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId } val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId }
if (functionIndex >= 0 && scopeIndex >= functionIndex) return null if (functionIndex >= 0 && scopeIndex >= functionIndex) return null
val modulePlan = moduleSlotPlan() val modulePlan = moduleSlotPlan()
if (modulePlan != null && slotLoc.scopeId == modulePlan.id && externBindingNames.contains(name)) {
return null
}
if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) { if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) {
return null return null
} }
@@ -2066,6 +2083,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2096,6 +2114,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2151,6 +2170,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2334,6 +2354,7 @@ class Compiler(
stmt.name, stmt.name,
stmt.isMutable, stmt.isMutable,
stmt.visibility, stmt.visibility,
stmt.actualExtern,
init, init,
stmt.isTransient, stmt.isTransient,
stmt.typeDecl, stmt.typeDecl,
@@ -4646,6 +4667,7 @@ class Compiler(
} }
is MethodCallRef -> methodReturnTypeDeclByRef[ref] is MethodCallRef -> methodReturnTypeDeclByRef[ref]
is CallRef -> callReturnTypeDeclByRef[ref] is CallRef -> callReturnTypeDeclByRef[ref]
is BinaryOpRef -> inferBinaryOpReturnTypeDecl(ref)
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) } is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
else -> null else -> null
} }
@@ -4709,6 +4731,7 @@ class Compiler(
is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is CallRef -> inferCallReturnClass(ref) is CallRef -> inferCallReturnClass(ref)
is BinaryOpRef -> inferBinaryOpReturnClass(ref)
is FieldRef -> { is FieldRef -> {
val targetClass = resolveReceiverClassForMember(ref.target) val targetClass = resolveReceiverClassForMember(ref.target)
inferFieldReturnClass(targetClass, ref.name) inferFieldReturnClass(targetClass, ref.name)
@@ -4723,10 +4746,105 @@ class Compiler(
} }
} }
private fun typeDeclOfClass(objClass: ObjClass): TypeDecl = TypeDecl.Simple(objClass.className, false)
private fun binaryOpMethodName(op: BinOp): String? = when (op) {
BinOp.PLUS -> "plus"
BinOp.MINUS -> "minus"
BinOp.STAR -> "mul"
BinOp.SLASH -> "div"
BinOp.PERCENT -> "mod"
else -> null
}
private fun interopOperatorFor(op: BinOp): InteropOperator? = when (op) {
BinOp.PLUS -> InteropOperator.Plus
BinOp.MINUS -> InteropOperator.Minus
BinOp.STAR -> InteropOperator.Mul
BinOp.SLASH -> InteropOperator.Div
BinOp.PERCENT -> InteropOperator.Mod
BinOp.LT, BinOp.LTE, BinOp.GT, BinOp.GTE -> InteropOperator.Compare
BinOp.EQ, BinOp.NEQ -> InteropOperator.Equals
else -> null
}
private fun sameClassArithmeticFallback(leftClass: ObjClass, rightClass: ObjClass, op: BinOp): TypeDecl? {
if (leftClass !== rightClass) return null
val methodName = binaryOpMethodName(op) ?: return null
if (leftClass.getInstanceMemberOrNull(methodName, includeAbstract = true) == null) return null
return typeDeclOfClass(leftClass)
}
private fun inferBinaryOpReturnTypeDecl(ref: BinaryOpRef): TypeDecl? {
val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left)
val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right)
val boolType = typeDeclOfClass(ObjBool.type)
val intType = typeDeclOfClass(ObjInt.type)
val realType = typeDeclOfClass(ObjReal.type)
val stringType = typeDeclOfClass(ObjString.type)
when (ref.op) {
BinOp.OR, BinOp.AND,
BinOp.EQARROW, BinOp.EQ, BinOp.NEQ, BinOp.REF_EQ, BinOp.REF_NEQ, BinOp.MATCH, BinOp.NOTMATCH,
BinOp.LTE, BinOp.LT, BinOp.GTE, BinOp.GT,
BinOp.IN, BinOp.NOTIN,
BinOp.IS, BinOp.NOTIS -> return boolType
else -> {}
}
if (leftClass == null || rightClass == null) return null
val leftIsInt = leftClass == ObjInt.type
val rightIsInt = rightClass == ObjInt.type
val leftIsReal = leftClass == ObjReal.type
val rightIsReal = rightClass == ObjReal.type
val leftIsNumeric = leftIsInt || leftIsReal
val rightIsNumeric = rightIsInt || rightIsReal
return when (ref.op) {
BinOp.PLUS -> when {
leftIsInt && rightIsInt -> intType
leftIsNumeric && rightIsNumeric -> realType
leftClass == ObjString.type -> stringType
interopOperatorFor(ref.op)?.let {
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, it)
} != null -> typeDeclOfClass(
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, interopOperatorFor(ref.op)!!)!!
)
else -> binaryOpMethodName(ref.op)?.let { classMethodReturnTypeDecl(leftClass, it) }
?: sameClassArithmeticFallback(leftClass, rightClass, ref.op)
}
BinOp.MINUS, BinOp.STAR, BinOp.SLASH, BinOp.PERCENT -> when {
leftIsInt && rightIsInt -> intType
leftIsNumeric && rightIsNumeric -> realType
ref.op == BinOp.STAR && leftClass == ObjString.type && rightIsNumeric -> stringType
interopOperatorFor(ref.op)?.let {
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, it)
} != null -> typeDeclOfClass(
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, interopOperatorFor(ref.op)!!)!!
)
else -> binaryOpMethodName(ref.op)?.let { classMethodReturnTypeDecl(leftClass, it) }
?: sameClassArithmeticFallback(leftClass, rightClass, ref.op)
}
BinOp.BAND, BinOp.BOR, BinOp.BXOR, BinOp.SHL, BinOp.SHR ->
if (leftIsInt && rightIsInt) intType else null
else -> null
}
}
private fun inferBinaryOpReturnClass(ref: BinaryOpRef): ObjClass? { private fun inferBinaryOpReturnClass(ref: BinaryOpRef): ObjClass? {
inferBinaryOpReturnTypeDecl(ref)?.let { declared ->
resolveTypeDeclObjClass(declared)?.let { return it }
}
val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left) val leftClass = resolveReceiverClassForMember(ref.left) ?: inferObjClassFromRef(ref.left)
val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right) val rightClass = resolveReceiverClassForMember(ref.right) ?: inferObjClassFromRef(ref.right)
if (leftClass == null || rightClass == null) return null if (leftClass == null || rightClass == null) return null
interopOperatorFor(ref.op)?.let { op ->
OperatorInteropRegistry.commonClassFor(leftClass, rightClass, op)?.let { return it }
}
sameClassArithmeticFallback(leftClass, rightClass, ref.op)?.let { declared ->
resolveTypeDeclObjClass(declared)?.let { return it }
}
return when (ref.op) { return when (ref.op) {
BinOp.PLUS, BinOp.MINUS -> when { BinOp.PLUS, BinOp.MINUS -> when {
leftClass == ObjInstant.type && rightClass == ObjInstant.type && ref.op == BinOp.MINUS -> ObjDuration.type leftClass == ObjInstant.type && rightClass == ObjInstant.type && ref.op == BinOp.MINUS -> ObjDuration.type
@@ -4779,6 +4897,11 @@ class Compiler(
if (payload != null) return payload if (payload != null) return payload
} }
val receiverClass = resolveReceiverClassForMember(ref.receiver) val receiverClass = resolveReceiverClassForMember(ref.receiver)
classMethodReturnClass(receiverClass, ref.name)?.let { return it }
inferFieldReturnClass(receiverClass, ref.name)?.let { return it }
if (receiverClass != null && isClassScopeCallableMember(receiverClass.className, ref.name)) {
resolveClassByName("${receiverClass.className}.${ref.name}")?.let { return it }
}
return inferMethodCallReturnClass(ref.name) return inferMethodCallReturnClass(ref.name)
} }
@@ -6432,7 +6555,7 @@ class Compiler(
WhenStatement(value, cases, elseCase, whenPos) WhenStatement(value, cases, elseCase, whenPos)
} else { } else {
// when { cond -> ... } // when { cond -> ... }
TODO("when without object is not yet implemented") throw ScriptError(t.pos, "when without subject is not implemented")
} }
return wrapBytecode(stmt) return wrapBytecode(stmt)
} }
@@ -6685,6 +6808,7 @@ class Compiler(
) )
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = fieldIds, fieldIds = fieldIds,
methodIds = methodIds, methodIds = methodIds,
nextFieldId = fieldIds.size, nextFieldId = fieldIds.size,
@@ -6807,6 +6931,7 @@ class Compiler(
classCtx?.let { ctx -> classCtx?.let { ctx ->
compileClassInfos[className] = CompileClassInfo( compileClassInfos[className] = CompileClassInfo(
name = className, name = className,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -6848,6 +6973,7 @@ class Compiler(
val baseIds = collectBaseMemberIds(baseSpecs.map { it.name }) val baseIds = collectBaseMemberIds(baseSpecs.map { it.name })
compileClassInfos[className] = CompileClassInfo( compileClassInfos[className] = CompileClassInfo(
name = className, name = className,
packageName = packageName,
fieldIds = baseIds.fieldIds, fieldIds = baseIds.fieldIds,
methodIds = baseIds.methodIds, methodIds = baseIds.methodIds,
nextFieldId = baseIds.nextFieldId, nextFieldId = baseIds.nextFieldId,
@@ -7096,6 +7222,7 @@ class Compiler(
} }
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -7111,6 +7238,7 @@ class Compiler(
classCtx?.let { ctx -> classCtx?.let { ctx ->
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -7197,6 +7325,7 @@ class Compiler(
} }
compileClassInfos[qualifiedName] = CompileClassInfo( compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName, name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(), fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(), methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId, nextFieldId = ctx.nextFieldId,
@@ -8376,7 +8505,7 @@ class Compiler(
is ImplicitThisMethodCallRef -> { is ImplicitThisMethodCallRef -> {
when (directRef.methodName()) { when (directRef.methodName()) {
"iterator" -> ObjIterator "iterator" -> ObjIterator
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy") ?: inferMethodCallReturnClass(directRef.methodName())
else -> inferMethodCallReturnClass(directRef.methodName()) else -> inferMethodCallReturnClass(directRef.methodName())
} }
} }
@@ -8395,7 +8524,7 @@ class Compiler(
when { when {
target is LocalSlotRef -> { target is LocalSlotRef -> {
when (target.name) { when (target.name) {
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator "iterator" -> ObjIterator
"flow" -> ObjFlow.type "flow" -> ObjFlow.type
"launch" -> ObjDeferred.type "launch" -> ObjDeferred.type
@@ -8406,7 +8535,7 @@ class Compiler(
} }
target is LocalVarRef -> { target is LocalVarRef -> {
when (target.name) { when (target.name) {
"lazy" -> ObjLazyDelegate.type "lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator "iterator" -> ObjIterator
"flow" -> ObjFlow.type "flow" -> ObjFlow.type
"launch" -> ObjDeferred.type "launch" -> ObjDeferred.type
@@ -8445,7 +8574,9 @@ class Compiler(
?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) } ?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) }
?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time") ?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time")
if (initClass !== delegateClass && if (initClass !== delegateClass &&
initClass.logicalName != delegateClass.logicalName &&
!initClass.allParentsSet.contains(delegateClass) && !initClass.allParentsSet.contains(delegateClass) &&
!initClass.allParentsSet.any { it.logicalName == delegateClass.logicalName } &&
!initClass.allImplementingNames.contains(delegateClass.className) !initClass.allImplementingNames.contains(delegateClass.className)
) { ) {
throw ScriptError( throw ScriptError(
@@ -8535,7 +8666,9 @@ class Compiler(
if (closedParent != null) { if (closedParent != null) {
throw ScriptError(Pos.builtIn, "can't inherit from closed class ${closedParent.className}") throw ScriptError(Pos.builtIn, "can't inherit from closed class ${closedParent.className}")
} }
ObjInstanceClass(info.name, *parents.toTypedArray()) ObjInstanceClass(info.name, *parents.toTypedArray()).apply {
logicalPackageNameOverride = info.packageName
}
} }
if (stub is ObjInstanceClass) { if (stub is ObjInstanceClass) {
for ((fieldName, fieldId) in info.fieldIds) { for ((fieldName, fieldId) in info.fieldIds) {
@@ -8879,7 +9012,7 @@ class Compiler(
val effectiveEqToken = if (isProperty) null else eqToken val effectiveEqToken = if (isProperty) null else eqToken
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals // Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
if (!isStatic && declaringClassNameCaptured == null) declareLocalName(name, isMutable) if (!isStatic && declaringClassNameCaptured == null && !actualExtern) declareLocalName(name, isMutable)
val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) { val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) {
SymbolKind.MEMBER SymbolKind.MEMBER
} else { } else {
@@ -8888,6 +9021,8 @@ class Compiler(
resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride) resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride)
if (declKind == SymbolKind.MEMBER && extTypeName == null) { if (declKind == SymbolKind.MEMBER && extTypeName == null) {
(codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name) (codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name)
} else if (actualExtern) {
externBindingNames.add(name)
} }
val isDelegate = if (isAbstract || actualExtern) { val isDelegate = if (isAbstract || actualExtern) {
@@ -8953,7 +9088,11 @@ class Compiler(
if (isDelegate && initialExpression != null) { if (isDelegate && initialExpression != null) {
ensureDelegateType(initialExpression) ensureDelegateType(initialExpression)
if (isMutable && resolveInitializerObjClass(initialExpression) == ObjLazyDelegate.type) { val lazyClass = resolveClassByName("lazy")
if (isMutable &&
lazyClass != null &&
resolveInitializerObjClass(initialExpression)?.logicalName == lazyClass.logicalName
) {
throw ScriptError(initialExpression.pos, "lazy delegate is read-only") throw ScriptError(initialExpression.pos, "lazy delegate is read-only")
} }
} }
@@ -9045,6 +9184,7 @@ class Compiler(
name, name,
isMutable, isMutable,
visibility, visibility,
actualExtern,
initialExpression, initialExpression,
isTransient, isTransient,
declaredType, declaredType,
@@ -0,0 +1,109 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjVoid
internal enum class InteropOperator(val memberName: String?) {
Plus("plus"),
Minus("minus"),
Mul("mul"),
Div("div"),
Mod("mod"),
Compare("compareTo"),
Equals("equals");
companion object {
fun fromName(name: String): InteropOperator =
entries.firstOrNull { it.name == name }
?: throw IllegalArgumentException("unknown interop operator: $name")
}
}
private data class InteropRule(
val commonClass: ObjClass,
val operators: Set<InteropOperator>,
val leftToCommon: Obj,
val rightToCommon: Obj
)
internal data class PromotedOperands(val left: Obj, val right: Obj)
internal object OperatorInteropRegistry {
private val rules = mutableMapOf<Pair<ObjClass, ObjClass>, InteropRule>()
fun register(
leftClass: ObjClass,
rightClass: ObjClass,
commonClass: ObjClass,
operatorNames: List<String>,
leftToCommon: Obj,
rightToCommon: Obj
) {
val operators = operatorNames.mapTo(linkedSetOf(), InteropOperator::fromName)
rules[leftClass to rightClass] = InteropRule(commonClass, operators, leftToCommon, rightToCommon)
if (leftClass !== rightClass) {
rules[rightClass to leftClass] = InteropRule(commonClass, operators, rightToCommon, leftToCommon)
}
}
suspend fun promote(scope: Scope, left: Obj, right: Obj, operator: InteropOperator): PromotedOperands? {
val leftValue = unwrap(left)
val rightValue = unwrap(right)
val rule = rules[leftValue.objClass to rightValue.objClass] ?: return null
if (operator !in rule.operators) return null
val promotedLeft = rule.leftToCommon.invoke(scope, ObjVoid, Arguments(leftValue))
val promotedRight = rule.rightToCommon.invoke(scope, ObjVoid, Arguments(rightValue))
if (promotedLeft.objClass !== rule.commonClass || promotedRight.objClass !== rule.commonClass) {
scope.raiseIllegalState(
"Operator interop promotion must return ${rule.commonClass.className}, " +
"got ${promotedLeft.objClass.className} and ${promotedRight.objClass.className}"
)
}
return PromotedOperands(promotedLeft, promotedRight)
}
suspend fun invokeBinary(scope: Scope, left: Obj, right: Obj, operator: InteropOperator): Obj? {
val promoted = promote(scope, left, right, operator) ?: return null
val memberName = operator.memberName ?: return null
return promoted.left.invokeInstanceMethod(scope, memberName, Arguments(promoted.right))
}
suspend fun invokeCompare(scope: Scope, left: Obj, right: Obj): Int? {
val promoted = promote(scope, left, right, InteropOperator.Compare) ?: return null
return promoted.left.invokeInstanceMethod(scope, "compareTo", Arguments(promoted.right))
.cast<ObjInt>(scope)
.value
.toInt()
}
fun commonClassFor(leftClass: ObjClass, rightClass: ObjClass, operator: InteropOperator): ObjClass? {
val rule = rules[leftClass to rightClass] ?: return null
if (operator !in rule.operators) return null
return rule.commonClass
}
private suspend fun unwrap(obj: Obj): Obj = when (obj) {
is FrameSlotRef -> obj.read()
is RecordSlotRef -> obj.read()
else -> obj
}
}
@@ -26,7 +26,10 @@ val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' } val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
fun parseLyng(source: Source): List<Token> { fun parseLyng(source: Source): List<Token> {
val p = Parser(fromPos = source.startPos) val p = Parser(
fromPos = source.startPos,
interpolationEnabled = detectInterpolationEnabled(source.text)
)
val tokens = mutableListOf<Token>() val tokens = mutableListOf<Token>()
do { do {
val t = p.nextToken() val t = p.nextToken()
@@ -35,9 +38,70 @@ fun parseLyng(source: Source): List<Token> {
return tokens return tokens
} }
private class Parser(fromPos: Pos) { private fun parseLyng(source: Source, interpolationEnabled: Boolean): List<Token> {
val p = Parser(
fromPos = source.startPos,
interpolationEnabled = interpolationEnabled
)
val tokens = mutableListOf<Token>()
do {
val t = p.nextToken()
tokens += t
} while (t.type != Token.Type.EOF)
return tokens
}
private fun detectInterpolationEnabled(text: String): Boolean {
// Per-file feature switch in leading comments:
// // feature: interpolation: off
// // feature: interpolation: on
var enabled = true
val lines = text.split('\n')
var i = 0
while (i < lines.size) {
val line = lines[i]
val trimmed = line.trim()
if (trimmed.isBlank()) {
i++
continue
}
if (i == 0 && trimmed.startsWith("#!")) {
i++
continue
}
if (trimmed.startsWith("//")) {
val m = Regex("^//\\s*feature\\s*:\\s*interpolation\\s*:\\s*(on|off)\\s*$", RegexOption.IGNORE_CASE)
.matchEntire(trimmed)
if (m != null) {
enabled = m.groupValues[1].equals("on", ignoreCase = true)
}
i++
continue
}
if (trimmed.startsWith("/*")) {
// Skip leading block comment(s); directives are intentionally line-comment based.
var j = i
var closed = false
while (j < lines.size) {
if (lines[j].contains("*/")) {
closed = true
break
}
j++
}
if (!closed) break
i = j + 1
continue
}
break
}
return enabled
}
private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = true) {
private val pos = MutablePos(fromPos) private val pos = MutablePos(fromPos)
private val bufferedTokens = ArrayDeque<Token>()
/** /**
* Immutable copy of current position * Immutable copy of current position
@@ -47,6 +111,7 @@ private class Parser(fromPos: Pos) {
private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg) private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg)
fun nextToken(): Token { fun nextToken(): Token {
if (bufferedTokens.isNotEmpty()) return bufferedTokens.removeFirst()
skipws() skipws()
if (pos.end) return Token("", currentPos, Token.Type.EOF) if (pos.end) return Token("", currentPos, Token.Type.EOF)
val from = currentPos val from = currentPos
@@ -296,7 +361,7 @@ private class Parser(fromPos: Pos) {
Token(":", from, Token.Type.COLON) Token(":", from, Token.Type.COLON)
} }
'"' -> loadStringToken() '"' -> loadStringTokens(from)
in digitsSet -> { in digitsSet -> {
pos.back() pos.back()
@@ -306,17 +371,41 @@ private class Parser(fromPos: Pos) {
'\'' -> { '\'' -> {
val start = pos.toPos() val start = pos.toPos()
var value = currentChar var value = currentChar
pos.advance()
if (currentChar == '\\') { if (currentChar == '\\') {
value = currentChar
pos.advance() pos.advance()
value = when (value) { if (pos.end) throw ScriptError(start, "unterminated character literal")
'n' -> '\n' value = when (currentChar) {
'r' -> '\r' 'n' -> {
't' -> '\t' pos.advance()
'\'', '\\' -> value '\n'
else -> throw ScriptError(currentPos, "unsupported escape character: $value")
} }
'r' -> {
pos.advance()
'\r'
}
't' -> {
pos.advance()
'\t'
}
'\'' -> {
pos.advance()
'\''
}
'\\' -> {
pos.advance()
'\\'
}
'u' -> loadUnicodeEscape(start)
else -> throw ScriptError(currentPos, "unsupported escape character: $currentChar")
}
} else {
pos.advance()
} }
if (currentChar != '\'') throw ScriptError(currentPos, "expected end of character literal: '") if (currentChar != '\'') throw ScriptError(currentPos, "expected end of character literal: '")
pos.advance() pos.advance()
@@ -461,11 +550,6 @@ private class Parser(fromPos: Pos) {
private fun loadStringToken(): Token { private fun loadStringToken(): Token {
val start = currentPos val start = currentPos
// if (currentChar == '"') pos.advance()
// else start = start.back()
// start = start.back()
val sb = StringBuilder() val sb = StringBuilder()
var newlineDetected = false var newlineDetected = false
while (currentChar != '"') { while (currentChar != '"') {
@@ -494,6 +578,10 @@ private class Parser(fromPos: Pos) {
sb.append('\\'); pos.advance() sb.append('\\'); pos.advance()
} }
'u' -> {
sb.append(loadUnicodeEscape(start))
}
else -> { else -> {
sb.append('\\').append(currentChar) sb.append('\\').append(currentChar)
pos.advance() pos.advance()
@@ -520,6 +608,279 @@ private class Parser(fromPos: Pos) {
return Token(result, start, Token.Type.STRING) return Token(result, start, Token.Type.STRING)
} }
private sealed interface StringChunk {
data class Literal(val text: String, val pos: Pos) : StringChunk
data class Expr(val tokens: List<Token>, val pos: Pos) : StringChunk
}
private fun loadStringTokens(startQuotePos: Pos): Token {
if (!interpolationEnabled) return loadStringToken()
val tokenPos = currentPos
val chunks = mutableListOf<StringChunk>()
val literal = StringBuilder()
var newlineDetected = false
var hasInterpolation = false
fun flushLiteralChunk() {
if (literal.isNotEmpty()) {
chunks += StringChunk.Literal(literal.toString(), tokenPos)
literal.clear()
}
}
while (currentChar != '"') {
if (pos.end) throw ScriptError(startQuotePos, "unterminated string started there")
when (currentChar) {
'\\' -> {
pos.advance() ?: raise("unterminated string")
when (currentChar) {
'n' -> {
literal.append('\n'); pos.advance()
}
'r' -> {
literal.append('\r'); pos.advance()
}
't' -> {
literal.append('\t'); pos.advance()
}
'"' -> {
literal.append('"'); pos.advance()
}
'\\' -> {
literal.append('\\'); pos.advance()
}
'u' -> {
literal.append(loadUnicodeEscape(tokenPos))
}
'$' -> {
// Backslash-escaped dollar is always literal.
literal.append('$')
pos.advance()
}
else -> {
literal.append('\\').append(currentChar)
pos.advance()
}
}
}
'$' -> {
pos.advance()
when {
currentChar == '$' -> {
// $$ -> literal '$'
literal.append('$')
pos.advance()
}
currentChar == '{' -> {
hasInterpolation = true
flushLiteralChunk()
val exprStart = pos.toPos()
pos.advance() // consume '{'
val exprText = readInterpolationExprText(startQuotePos)
val exprTokens = parseEmbeddedExpressionTokens(exprText, exprStart)
chunks += StringChunk.Expr(exprTokens, exprStart)
}
idFirstChars(currentChar) -> {
hasInterpolation = true
flushLiteralChunk()
val idPos = pos.toPos()
val id = loadChars(idNextChars)
val idToken = Token(id, idPos, Token.Type.ID)
chunks += StringChunk.Expr(listOf(idToken), idPos)
}
else -> {
// Bare '$' before non-interpolation text stays literal.
literal.append('$')
}
}
}
'\n', '\r' -> {
newlineDetected = true
literal.append(currentChar)
pos.advance()
}
else -> {
literal.append(currentChar)
pos.advance()
}
}
}
pos.advance() // closing quote
if (!hasInterpolation) {
val result = literal.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
return Token(result, tokenPos, Token.Type.STRING)
}
flushLiteralChunk()
if (chunks.isEmpty()) {
return Token("", tokenPos, Token.Type.STRING)
}
val expanded = mutableListOf<Token>()
expanded += Token("(", tokenPos, Token.Type.LPAREN)
var emittedPieces = 0
for (chunk in chunks) {
val pieceTokens = when (chunk) {
is StringChunk.Literal -> {
if (chunk.text.isEmpty()) emptyList()
else listOf(Token(chunk.text, chunk.pos, Token.Type.STRING))
}
is StringChunk.Expr -> {
if (chunk.tokens.isEmpty()) throw ScriptError(chunk.pos, "empty interpolation expression")
if (chunk.tokens.size == 1) {
chunk.tokens
} else {
listOf(Token("(", chunk.pos, Token.Type.LPAREN)) +
chunk.tokens +
listOf(Token(")", chunk.pos, Token.Type.RPAREN))
}
}
}
if (pieceTokens.isEmpty()) continue
if (emittedPieces > 0) expanded += Token("+", tokenPos, Token.Type.PLUS)
expanded += pieceTokens
emittedPieces++
}
if (emittedPieces == 0) {
expanded += Token("", tokenPos, Token.Type.STRING)
}
expanded += Token(")", tokenPos, Token.Type.RPAREN)
val first = expanded.first()
for (i in 1 until expanded.size) bufferedTokens.addLast(expanded[i])
return first
}
private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> {
val tokens = parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled)
if (tokens.isEmpty()) return emptyList()
val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens
return withoutEof
}
private fun readInterpolationExprText(start: Pos): String {
val out = StringBuilder()
var depth = 1
while (!pos.end) {
val ch = currentChar
if (ch == '"') {
appendQuoted(out, '"')
continue
}
if (ch == '\'') {
appendQuoted(out, '\'')
continue
}
if (ch == '/' && peekChar() == '/') {
out.append('/').append('/')
pos.advance()
pos.advance()
while (!pos.end && currentChar != '\n') {
out.append(currentChar)
pos.advance()
}
continue
}
if (ch == '/' && peekChar() == '*') {
out.append('/').append('*')
pos.advance()
pos.advance()
var closed = false
while (!pos.end) {
val c = currentChar
if (c == '*' && peekChar() == '/') {
out.append('*').append('/')
pos.advance()
pos.advance()
closed = true
break
}
out.append(c)
pos.advance()
}
if (!closed) throw ScriptError(start, "unterminated block comment in interpolation")
continue
}
if (ch == '{') {
depth++
out.append(ch)
pos.advance()
continue
}
if (ch == '}') {
depth--
if (depth == 0) {
pos.advance() // consume closing '}'
return out.toString()
}
out.append(ch)
pos.advance()
continue
}
out.append(ch)
pos.advance()
}
throw ScriptError(start, "unterminated interpolation expression")
}
private fun appendQuoted(out: StringBuilder, quote: Char) {
out.append(quote)
pos.advance()
while (!pos.end) {
val c = currentChar
out.append(c)
pos.advance()
if (c == '\\') {
if (!pos.end) {
out.append(currentChar)
pos.advance()
}
continue
}
if (c == quote) return
}
}
private fun peekChar(): Char {
if (pos.end) return 0.toChar()
val mark = pos.toPos()
pos.advance()
val result = currentChar
pos.resetTo(mark)
return result
}
private fun loadUnicodeEscape(start: Pos): Char {
// Called when currentChar points to 'u' right after a backslash.
if (currentChar != 'u') throw ScriptError(currentPos, "expected unicode escape marker: u")
pos.advance() ?: throw ScriptError(start, "unterminated unicode escape")
var code = 0
repeat(4) {
val ch = currentChar
if (ch !in hexDigits) {
throw ScriptError(currentPos, "invalid unicode escape sequence, expected 4 hex digits")
}
code = (code shl 4) + ch.digitToInt(16)
pos.advance()
}
return code.toChar()
}
/** /**
* Load characters from the set until it reaches EOF or invalid character found. * Load characters from the set until it reaches EOF or invalid character found.
* stop at EOF on character filtered by [isValidChar]. * stop at EOF on character filtered by [isValidChar].
@@ -20,16 +20,21 @@ package net.sergeych.lyng
import kotlinx.coroutines.delay import kotlinx.coroutines.delay
import kotlinx.coroutines.yield import kotlinx.coroutines.yield
import net.sergeych.lyng.Script.Companion.defaultImportManager import net.sergeych.lyng.Script.Companion.defaultImportManager
import net.sergeych.lyng.bridge.bind
import net.sergeych.lyng.bridge.bindObject
import net.sergeych.lyng.bytecode.CmdFunction import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.decimalLyng
import net.sergeych.lyng.stdlib_included.observableLyng import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.operatorsLyng
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lynon.ObjLynonClass import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer import net.sergeych.mp_tools.globalDefer
import kotlin.math.* import kotlin.math.*
import kotlin.random.Random as KRandom
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING") @Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
class Script( class Script(
@@ -43,6 +48,28 @@ class Script(
// private val catchReturn: Boolean = false, // private val catchReturn: Boolean = false,
) : Statement() { ) : Statement() {
fun statements(): List<Statement> = statements fun statements(): List<Statement> = statements
/**
* Explicitly apply this script's import/module bindings to [scope] without executing the script.
* This is intended for embedding scenarios where the host owns scope lifecycle and wants
* script-specific imports to be a separate, opt-in preparation step.
*/
suspend fun importInto(scope: Scope, seedScope: Scope = scope): Scope {
prepareScriptScope(scope, seedScope)
return scope
}
/**
* Create a fresh raw module scope and apply this script's import/module bindings to it.
* If [seedScope] is provided, its import provider is reused and seed-bound imports resolve from it.
*/
suspend fun instantiateModule(seedScope: Scope? = null, pos: Pos = this.pos): ModuleScope {
val provider = seedScope?.currentImportProvider ?: defaultImportManager
val module = provider.newModuleAt(pos)
prepareScriptScope(module, seedScope ?: module)
return module
}
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
scope.pos = pos scope.pos = pos
val execScope = resolveModuleScope(scope) ?: scope val execScope = resolveModuleScope(scope) ?: scope
@@ -72,6 +99,19 @@ class Script(
return ObjVoid return ObjVoid
} }
private suspend fun prepareScriptScope(scope: Scope, seedScope: Scope) {
if (importBindings.isNotEmpty() || importedModules.isNotEmpty()) {
seedImportBindings(scope, seedScope)
}
if (moduleSlotPlan.isNotEmpty()) {
scope.applySlotPlan(moduleSlotPlan)
for (name in moduleSlotPlan.keys) {
val record = scope.objects[name] ?: scope.localBindings[name] ?: continue
scope.updateSlotFor(name, record)
}
}
}
private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) { private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) {
if (importBindings.isEmpty() && importedModules.isEmpty()) return if (importBindings.isEmpty() && importedModules.isEmpty()) return
seedImportBindings(scope, seedScope) seedImportBindings(scope, seedScope)
@@ -502,10 +542,6 @@ class Script(
cachedValue cachedValue
} }
} }
addFn("lazy") {
val builder = requireOnlyArg<Obj>()
ObjLazyDelegate(builder, requireScope())
}
addVoidFn("delay") { addVoidFn("delay") {
val a = args.firstAndOnly() val a = args.firstAndOnly()
when (a) { when (a) {
@@ -588,11 +624,97 @@ class Script(
} }
} }
private fun seededRandomFromThis(scope: Scope, thisObj: Obj): KRandom {
val instance = thisObj as? ObjInstance
?: scope.raiseIllegalState("SeededRandom method requires instance receiver")
val stored = instance.kotlinInstanceData
if (stored is KRandom) return stored
return KRandom.Default.also { instance.kotlinInstanceData = it }
}
private suspend fun sampleRangeValue(scope: Scope, random: KRandom, range: ObjRange): Obj {
if (range.start == null || range.start.isNull || range.end == null || range.end.isNull) {
scope.raiseIllegalArgument("Random.next(range) requires a finite range")
}
val start = range.start
val end = range.end
// Real ranges without explicit step are sampled continuously.
if (!range.hasExplicitStep &&
start is Numeric &&
end is Numeric &&
(start !is ObjInt || end !is ObjInt)
) {
val from = start.doubleValue
val to = end.doubleValue
if (from > to || (!range.isEndInclusive && from == to)) {
scope.raiseIllegalArgument("Random.next(range) got an empty numeric range")
}
if (from == to) return ObjReal(from)
val upperExclusive = if (range.isEndInclusive) to.nextUp() else to
if (upperExclusive <= from) {
scope.raiseIllegalArgument("Random.next(range) got an empty numeric range")
}
return ObjReal(random.nextDouble(from, upperExclusive))
}
// Discrete sampling for stepped ranges and integer/char ranges.
var picked: Obj? = null
var count = 0L
range.enumerate(scope) { value ->
count += 1
if (random.nextLong(count) == 0L) {
picked = value
}
true
}
if (count <= 0L || picked == null) {
scope.raiseIllegalArgument("Random.next(range) got an empty range")
}
return picked
}
val defaultImportManager: ImportManager by lazy { val defaultImportManager: ImportManager by lazy {
ImportManager(rootScope, SecurityManager.allowAll).apply { ImportManager(rootScope, SecurityManager.allowAll).apply {
addPackage("lyng.stdlib") { module -> addPackage("lyng.stdlib") { module ->
module.eval(Source("lyng.stdlib", rootLyng)) module.eval(Source("lyng.stdlib", rootLyng))
ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator")) ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator"))
val seededRandomClass = module.requireClass("SeededRandom")
module.bind("SeededRandom") {
init { data = KRandom.Default }
addFun("nextInt") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
ObjInt.of(rnd.nextInt().toLong())
}
addFun("nextFloat") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
ObjReal(rnd.nextDouble())
}
addFun("next") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
val range = requiredArg<ObjRange>(0)
sampleRangeValue(requireScope(), rnd, range)
}
}
module.bindObject("Random") {
addFun("nextInt") {
ObjInt.of(KRandom.Default.nextInt().toLong())
}
addFun("nextFloat") {
ObjReal(KRandom.Default.nextDouble())
}
addFun("next") {
val range = requiredArg<ObjRange>(0)
sampleRangeValue(requireScope(), KRandom.Default, range)
}
addFun("seeded") {
val seed = requiredArg<ObjInt>(0).value.toInt()
val instance = call(seededRandomClass) as? ObjInstance
?: requireScope().raiseIllegalState("SeededRandom() did not return an object instance")
instance.kotlinInstanceData = KRandom(seed)
instance
}
}
} }
addPackage("lyng.observable") { module -> addPackage("lyng.observable") { module ->
module.addConst("Observable", ObjObservable) module.addConst("Observable", ObjObservable)
@@ -607,6 +729,36 @@ class Script(
module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass) module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass)
module.eval(Source("lyng.observable", observableLyng)) module.eval(Source("lyng.observable", observableLyng))
} }
addPackage("lyng.operators") { module ->
module.eval(Source("lyng.operators", operatorsLyng))
module.bindObject("OperatorInterop") {
addFun("register") {
val leftClass = requiredArg<ObjClass>(0)
val rightClass = requiredArg<ObjClass>(1)
val commonClass = requiredArg<ObjClass>(2)
val operators = requiredArg<ObjList>(3).list.map { value ->
val entry = value as? ObjEnumEntry
?: requireScope().raiseIllegalArgument(
"OperatorInterop.register expects BinaryOperator enum entries"
)
entry.name.value
}
OperatorInteropRegistry.register(
leftClass = leftClass,
rightClass = rightClass,
commonClass = commonClass,
operatorNames = operators,
leftToCommon = args[4],
rightToCommon = args[5]
)
ObjVoid
}
}
}
addPackage("lyng.decimal") { module ->
module.eval(Source("lyng.decimal", decimalLyng))
ObjBigDecimalSupport.bindTo(module)
}
addPackage("lyng.buffer") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
name = "Buffer", name = "Buffer",
@@ -24,6 +24,7 @@ class VarDeclStatement(
val name: String, val name: String,
val isMutable: Boolean, val isMutable: Boolean,
val visibility: Visibility, val visibility: Visibility,
val actualExtern: Boolean,
val initializer: Statement?, val initializer: Statement?,
val isTransient: Boolean, val isTransient: Boolean,
val typeDecl: TypeDecl?, val typeDecl: TypeDecl?,
@@ -42,6 +42,7 @@ class BytecodeCompiler(
private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(), private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
private val externCallableNames: Set<String> = emptySet(), private val externCallableNames: Set<String> = emptySet(),
private val externBindingNames: Set<String> = emptySet(),
private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
) { ) {
private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
@@ -1067,18 +1068,9 @@ class BytecodeCompiler(
updateSlotType(dst, SlotType.OBJ) updateSlotType(dst, SlotType.OBJ)
return CompiledValue(dst, SlotType.OBJ) return CompiledValue(dst, SlotType.OBJ)
} }
if (receiverClass == null && memberName == "negate") { if (memberName == "negate" &&
val zeroId = builder.addConst(BytecodeConst.IntVal(0)) (receiverClass == null || isDelegateClass(receiverClass) || receiverClass in setOf(ObjInt.type, ObjReal.type))
val zeroSlot = allocSlot() ) {
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
updateSlotType(zeroSlot, SlotType.INT)
val obj = ensureObjSlot(value)
val dst = allocSlot()
builder.emit(Opcode.SUB_OBJ, zeroSlot, obj.slot, dst)
updateSlotType(dst, SlotType.OBJ)
return CompiledValue(dst, SlotType.OBJ)
}
if (memberName == "negate" && receiverClass in setOf(ObjInt.type, ObjReal.type)) {
val zeroId = builder.addConst(BytecodeConst.IntVal(0)) val zeroId = builder.addConst(BytecodeConst.IntVal(0))
val zeroSlot = allocSlot() val zeroSlot = allocSlot()
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot) builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
@@ -1095,6 +1087,10 @@ class BytecodeCompiler(
) )
} }
private fun isDelegateClass(receiverClass: ObjClass): Boolean =
receiverClass.className == "Delegate" ||
receiverClass.implementingNames.contains("Delegate")
private fun operatorMemberName(op: BinOp): String? = when (op) { private fun operatorMemberName(op: BinOp): String? = when (op) {
BinOp.PLUS -> "plus" BinOp.PLUS -> "plus"
BinOp.MINUS -> "minus" BinOp.MINUS -> "minus"
@@ -1142,11 +1138,7 @@ class BytecodeCompiler(
): CompiledValue? { ): CompiledValue? {
val memberName = operatorMemberName(op) ?: return null val memberName = operatorMemberName(op) ?: return null
val receiverClass = resolveReceiverClass(leftRef) val receiverClass = resolveReceiverClass(leftRef)
if (receiverClass == null || if (receiverClass == null || isDelegateClass(receiverClass)) {
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
) {
val objOpcode = when (op) { val objOpcode = when (op) {
BinOp.PLUS -> Opcode.ADD_OBJ BinOp.PLUS -> Opcode.ADD_OBJ
BinOp.MINUS -> Opcode.SUB_OBJ BinOp.MINUS -> Opcode.SUB_OBJ
@@ -4516,7 +4508,7 @@ class BytecodeCompiler(
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
if (useScopeSlots && allowedScopeNames?.contains(name) == true) { if (useScopeSlots && isPreparedScopeName(name)) {
scopeSlotIndexByName[name]?.let { slot -> scopeSlotIndexByName[name]?.let { slot ->
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
@@ -4821,9 +4813,26 @@ class BytecodeCompiler(
private data class CallArgs(val base: Int, val count: Int, val planId: Int?) private data class CallArgs(val base: Int, val count: Int, val planId: Int?)
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? { private fun extensionReceiverTypeNames(receiverClass: ObjClass): Set<String> {
val names = LinkedHashSet<String>()
for (cls in receiverClass.mro) { for (cls in receiverClass.mro) {
val candidate = extensionCallableName(cls.className, memberName) names.add(cls.className)
for ((knownName, knownClass) in nameObjClass) {
if (knownClass !== cls && knownClass.className != cls.className) continue
names.add(knownName)
names.add(knownName.substringAfterLast('.'))
}
}
return names
}
private fun resolveExtensionSlotByReceiverNames(
receiverClass: ObjClass,
memberName: String,
wrapperName: (String, String) -> String
): CompiledValue? {
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val candidate = wrapperName(receiverName, memberName)
if (allowedScopeNames != null && if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) && !allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate) !localSlotIndexByName.containsKey(candidate)
@@ -4835,32 +4844,39 @@ class BytecodeCompiler(
return null return null
} }
private fun resolveUniqueExtensionWrapperSlot(
memberName: String,
wrapperPrefix: String
): CompiledValue? {
val suffix = "__$memberName"
val candidates = LinkedHashSet<String>()
for (name in localSlotIndexByName.keys) {
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
candidates.add(name)
}
}
for (name in scopeSlotIndexByName.keys) {
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
candidates.add(name)
}
}
if (candidates.size != 1) return null
return resolveDirectNameSlot(candidates.first())
}
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionCallableName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext__")
}
private fun resolveExtensionGetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? { private fun resolveExtensionGetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
for (cls in receiverClass.mro) { return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertyGetterName)
val candidate = extensionPropertyGetterName(cls.className, memberName) ?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_get__")
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
} }
private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? { private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
for (cls in receiverClass.mro) { return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertySetterName)
val candidate = extensionPropertySetterName(cls.className, memberName) ?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_set__")
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
} }
private fun compileCallArgsWithReceiver( private fun compileCallArgsWithReceiver(
@@ -7468,7 +7484,7 @@ class BytecodeCompiler(
if (targetClass == null) return null if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return ObjDynamic.type if (targetClass == ObjDynamic.type) return ObjDynamic.type
classFieldTypesByName[targetClass.className]?.get(name)?.let { cls -> classFieldTypesByName[targetClass.className]?.get(name)?.let { cls ->
if (cls.className == "Delegate" || cls.className == "LazyDelegate" || cls.implementingNames.contains("Delegate")) { if (isDelegateClass(cls)) {
return null return null
} }
return cls return cls
@@ -7555,8 +7571,8 @@ class BytecodeCompiler(
private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) { private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) { for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val name = extensionCallableName(cls.className, memberName) val name = extensionCallableName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(name)) { if (allowedScopeNames == null || allowedScopeNames.contains(name)) {
pendingScopeNameRefs.add(name) pendingScopeNameRefs.add(name)
} }
@@ -7565,12 +7581,12 @@ class BytecodeCompiler(
private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) { private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) { for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val getter = extensionPropertyGetterName(cls.className, memberName) val getter = extensionPropertyGetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(getter)) { if (allowedScopeNames == null || allowedScopeNames.contains(getter)) {
pendingScopeNameRefs.add(getter) pendingScopeNameRefs.add(getter)
} }
val setter = extensionPropertySetterName(cls.className, memberName) val setter = extensionPropertySetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(setter)) { if (allowedScopeNames == null || allowedScopeNames.contains(setter)) {
pendingScopeNameRefs.add(setter) pendingScopeNameRefs.add(setter)
} }
@@ -8057,7 +8073,7 @@ class BytecodeCompiler(
slotInitClassByKey[ScopeSlotKey(scopeId, slotIndex)] = cls slotInitClassByKey[ScopeSlotKey(scopeId, slotIndex)] = cls
} }
} }
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) { if (allowLocalSlots && slotIndex != null && (stmt.actualExtern || !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = false))) {
val key = ScopeSlotKey(scopeId, slotIndex) val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key) declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
@@ -8084,7 +8100,7 @@ class BytecodeCompiler(
val scopeId = stmt.spec.scopeId ?: 0 val scopeId = stmt.spec.scopeId ?: 0
if (slotIndex != null) { if (slotIndex != null) {
val key = ScopeSlotKey(scopeId, slotIndex) val key = ScopeSlotKey(scopeId, slotIndex)
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId)) { if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId, stmt.spec.name, isDelegated = false)) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false) localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false)
} }
@@ -8101,7 +8117,7 @@ class BytecodeCompiler(
is DelegatedVarDeclStatement -> { is DelegatedVarDeclStatement -> {
val slotIndex = stmt.slotIndex val slotIndex = stmt.slotIndex
val scopeId = stmt.scopeId ?: 0 val scopeId = stmt.scopeId ?: 0
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) { if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = true)) {
val key = ScopeSlotKey(scopeId, slotIndex) val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key) declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
@@ -8267,15 +8283,26 @@ class BytecodeCompiler(
private fun isModuleSlot(scopeId: Int, name: String?): Boolean { private fun isModuleSlot(scopeId: Int, name: String?): Boolean {
if (moduleScopeId != null && scopeId != moduleScopeId) return false if (moduleScopeId != null && scopeId != moduleScopeId) return false
val scopeNames = allowedScopeNames ?: scopeSlotNameSet return isPreparedScopeName(name)
if (scopeNames == null || name == null) return false
return scopeNames.contains(name)
} }
private fun shouldUseScopeSlotFor(scopeId: Int): Boolean { private fun shouldUseScopeSlotFor(scopeId: Int): Boolean {
return useScopeSlots && moduleScopeId != null && scopeId == moduleScopeId return useScopeSlots && moduleScopeId != null && scopeId == moduleScopeId
} }
private fun shouldUseScopeSlotFor(scopeId: Int, name: String, isDelegated: Boolean): Boolean {
if (moduleScopeId == null || scopeId != moduleScopeId) return false
if (isDelegated) return false
if (externBindingNames.contains(name)) return true
return useScopeSlots && isPreparedScopeName(name)
}
private fun isPreparedScopeName(name: String?): Boolean {
if (name == null) return false
if (scopeSlotNameSet?.contains(name) == true) return true
return allowedScopeNames?.contains(name) == true
}
private fun collectLoopVarNames(stmt: Statement) { private fun collectLoopVarNames(stmt: Statement) {
if (stmt is BytecodeStatement) { if (stmt is BytecodeStatement) {
collectLoopVarNames(stmt.original) collectLoopVarNames(stmt.original)
@@ -8384,8 +8411,9 @@ class BytecodeCompiler(
captureSlotKeys.add(key) captureSlotKeys.add(key)
return return
} }
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, ref.name, ref.isDelegated)
val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name) val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name)
if (allowLocalSlots && !isModuleSlot) { if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated) localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated)
} }
@@ -8432,8 +8460,9 @@ class BytecodeCompiler(
} }
captureSlotKeys.add(key) captureSlotKeys.add(key)
} else { } else {
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, target.name, target.isDelegated)
val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name) val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name)
if (allowLocalSlots && !isModuleSlot) { if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) { if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated) localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated)
} }
@@ -87,6 +87,7 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(), callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(), externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(), slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement { ): Statement {
@@ -122,6 +123,7 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
val compiled = compiler.compileStatement(nameHint, statement) val compiled = compiler.compileStatement(nameHint, statement)
@@ -236,6 +238,7 @@ class BytecodeStatement private constructor(
stmt.name, stmt.name,
stmt.isMutable, stmt.isMutable,
stmt.visibility, stmt.visibility,
stmt.actualExtern,
stmt.initializer?.let { unwrapDeep(it) }, stmt.initializer?.let { unwrapDeep(it) },
stmt.isTransient, stmt.isTransient,
stmt.typeDecl, stmt.typeDecl,
@@ -2392,8 +2392,13 @@ class CmdDeclLocal(internal val constId: Int, internal val slot: Int) : Cmd() {
?: error("DECL_LOCAL expects LocalDecl at $constId") ?: error("DECL_LOCAL expects LocalDecl at $constId")
if (slot < frame.fn.scopeSlotCount) { if (slot < frame.fn.scopeSlotCount) {
val target = frame.scopeTarget(slot) val target = frame.scopeTarget(slot)
frame.ensureScopeSlot(target, slot) val index = frame.ensureScopeSlot(target, slot)
val value = frame.slotToObj(slot).byValueCopy() val raw = target.getSlotRecord(index).value
val value = when (raw) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
else -> raw
}.byValueCopy()
target.updateSlotFor( target.updateSlotFor(
decl.name, decl.name,
ObjRecord( ObjRecord(
@@ -3784,6 +3789,7 @@ class CmdFrame(
val exceptionSlot: Int, val exceptionSlot: Int,
val catchIp: Int, val catchIp: Int,
val finallyIp: Int, val finallyIp: Int,
val iterDepthAtPush: Int,
var inCatch: Boolean = false var inCatch: Boolean = false
) )
internal val tryStack = ArrayDeque<TryHandler>() internal val tryStack = ArrayDeque<TryHandler>()
@@ -3929,7 +3935,7 @@ class CmdFrame(
} else { } else {
val raw = frame.getRawObj(localIndex) val raw = frame.getRawObj(localIndex)
if (raw == null && name != null) { if (raw == null && name != null) {
val record = scope.get(name) val record = findNamedExistingRecord(scope, name)
if (record != null) { if (record != null) {
val value = record.value val value = record.value
return@mapIndexed when (value) { return@mapIndexed when (value) {
@@ -3938,6 +3944,12 @@ class CmdFrame(
else -> ObjRecord(value, isMutable) else -> ObjRecord(value, isMutable)
} }
} }
if (hasNamedScopeBinding(scope, name)) {
throw ScriptError(
ensureScope().pos,
"captured binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
}
} }
when (raw) { when (raw) {
is FrameSlotRef -> ObjRecord(raw, isMutable) is FrameSlotRef -> ObjRecord(raw, isMutable)
@@ -3951,22 +3963,27 @@ class CmdFrame(
val target = moduleScope val target = moduleScope
val name = captureNames?.getOrNull(index) val name = captureNames?.getOrNull(index)
if (name != null) { if (name != null) {
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return@mapIndexed it } findNamedExistingRecord(target, name)?.let { return@mapIndexed it }
target.getSlotIndexOf(name)?.let { return@mapIndexed target.getSlotRecord(it) }
target.get(name)?.let { return@mapIndexed it }
// Fallback to current scope in case the module scope isn't in the parent chain // Fallback to current scope in case the module scope isn't in the parent chain
// or doesn't carry the imported symbol yet. // or doesn't carry the imported symbol yet.
scope.tryGetLocalRecord(scope, name, scope.currentClassCtx)?.let { return@mapIndexed it } findNamedExistingRecord(scope, name)?.let { return@mapIndexed it }
scope.get(name)?.let { return@mapIndexed it }
} }
if (slotId < target.slotCount) { if (slotId < target.slotCount) {
return@mapIndexed target.getSlotRecord(slotId) val existing = target.getSlotRecord(slotId)
if (name == null || existing.value !== ObjUnset || hasResolvedNamedScopeBinding(target, name)) {
return@mapIndexed existing
}
} }
if (name != null) { if (name != null) {
target.applySlotPlan(mapOf(name to slotId)) throw ScriptError(
return@mapIndexed target.getSlotRecord(slotId) ensureScope().pos,
"module capture '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
} }
error("Missing module capture slot $slotId") throw ScriptError(
ensureScope().pos,
"missing module capture slot $slotId"
)
} }
} }
} }
@@ -4069,11 +4086,15 @@ class CmdFrame(
return scope return scope
} }
fun handleException(t: Throwable): Boolean { suspend fun handleException(t: Throwable): Boolean {
val handler = tryStack.lastOrNull() ?: return false val handler = tryStack.lastOrNull() ?: return false
vmIterDebug(
"handleException fn=${fn.name} throwable=${t::class.simpleName} message=${t.message} catchIp=${handler.catchIp} finallyIp=${handler.finallyIp} iterDepth=${iterStack.size}"
)
val finallyIp = handler.finallyIp val finallyIp = handler.finallyIp
if (t is ReturnException || t is LoopBreakContinueException) { if (t is ReturnException || t is LoopBreakContinueException) {
if (finallyIp >= 0) { if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:returnOrLoop->finally")
pendingThrowable = t pendingThrowable = t
ip = finallyIp ip = finallyIp
return true return true
@@ -4082,6 +4103,7 @@ class CmdFrame(
} }
if (handler.inCatch) { if (handler.inCatch) {
if (finallyIp >= 0) { if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:inCatch->finally")
pendingThrowable = t pendingThrowable = t
ip = finallyIp ip = finallyIp
return true return true
@@ -4091,6 +4113,7 @@ class CmdFrame(
handler.inCatch = true handler.inCatch = true
pendingThrowable = t pendingThrowable = t
if (handler.catchIp >= 0) { if (handler.catchIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toCatch")
val caughtObj = when (t) { val caughtObj = when (t) {
is ExecutionError -> t.errorObject is ExecutionError -> t.errorObject
else -> ObjUnknownException(ensureScope(), t.message ?: t.toString()) else -> ObjUnknownException(ensureScope(), t.message ?: t.toString())
@@ -4100,6 +4123,7 @@ class CmdFrame(
return true return true
} }
if (finallyIp >= 0) { if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toFinallyNoCatch")
ip = finallyIp ip = finallyIp
return true return true
} }
@@ -4107,7 +4131,7 @@ class CmdFrame(
} }
fun pushTry(exceptionSlot: Int, catchIp: Int, finallyIp: Int) { fun pushTry(exceptionSlot: Int, catchIp: Int, finallyIp: Int) {
tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp)) tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp, iterDepthAtPush = iterStack.size))
} }
fun popTry() { fun popTry() {
@@ -4164,24 +4188,47 @@ class CmdFrame(
fun pushIterator(iter: Obj) { fun pushIterator(iter: Obj) {
iterStack.addLast(iter) iterStack.addLast(iter)
if (iter.objClass.className == "FlowIterator") {
vmIterDebug("pushIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
}
} }
fun popIterator() { fun popIterator() {
val iter = iterStack.lastOrNull()
if (iter != null && iter.objClass.className == "FlowIterator") {
vmIterDebug("popIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
}
iterStack.removeLastOrNull() iterStack.removeLastOrNull()
} }
suspend fun cancelTopIterator() { suspend fun cancelTopIterator() {
val iter = iterStack.removeLastOrNull() ?: return val iter = iterStack.removeLastOrNull() ?: return
vmIterDebug("cancelTopIterator fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid } iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
} }
suspend fun cancelIterators() { suspend fun cancelIterators() {
while (iterStack.isNotEmpty()) { while (iterStack.isNotEmpty()) {
val iter = iterStack.removeLast() val iter = iterStack.removeLast()
vmIterDebug("cancelIterators fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid } iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
} }
} }
private suspend fun cancelIteratorsToDepth(depth: Int, reason: String) {
while (iterStack.size > depth) {
val iter = iterStack.removeLast()
vmIterDebug(
"cancelIteratorsToDepth fn=${fn.name} reason=$reason targetDepth=$depth depthAfter=${iterStack.size} iterClass=${iter.objClass.className}"
)
try {
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
} catch (e: Throwable) {
vmIterDebug("cancelIteratorsToDepth: cancelIteration failed fn=${fn.name} reason=$reason", e)
}
}
}
fun pushSlotPlan(plan: Map<String, Int>) { fun pushSlotPlan(plan: Map<String, Int>) {
if (scope.hasSlotPlanConflict(plan)) { if (scope.hasSlotPlanConflict(plan)) {
scopeStack.addLast(scope) scopeStack.addLast(scope)
@@ -4515,7 +4562,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot) return getScopeSlotValueAtAddr(addrSlot)
} }
fun setAddrObj(addrSlot: Int, value: Obj) { suspend fun setAddrObj(addrSlot: Int, value: Obj) {
setScopeSlotValueAtAddr(addrSlot, value) setScopeSlotValueAtAddr(addrSlot, value)
} }
@@ -4523,7 +4570,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toLong() return getScopeSlotValueAtAddr(addrSlot).toLong()
} }
fun setAddrInt(addrSlot: Int, value: Long) { suspend fun setAddrInt(addrSlot: Int, value: Long) {
setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value)) setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value))
} }
@@ -4531,7 +4578,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toDouble() return getScopeSlotValueAtAddr(addrSlot).toDouble()
} }
fun setAddrReal(addrSlot: Int, value: Double) { suspend fun setAddrReal(addrSlot: Int, value: Double) {
setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value)) setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value))
} }
@@ -4539,7 +4586,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toBool() return getScopeSlotValueAtAddr(addrSlot).toBool()
} }
fun setAddrBool(addrSlot: Int, value: Boolean) { suspend fun setAddrBool(addrSlot: Int, value: Boolean) {
setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse) setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse)
} }
@@ -4745,12 +4792,13 @@ class CmdFrame(
private suspend fun getScopeSlotValue(slot: Int): Obj { private suspend fun getScopeSlotValue(slot: Int): Obj {
val target = scopeTarget(slot) val target = scopeTarget(slot)
val name = fn.scopeSlotNames[slot]
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val index = ensureScopeSlot(target, slot) val index = ensureScopeSlot(target, slot)
val record = target.getSlotRecord(index) val record = target.getSlotRecord(index)
val direct = record.value val direct = record.value
if (direct is FrameSlotRef) return direct.read() if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) return direct.read() if (direct is RecordSlotRef) return direct.read()
val name = fn.scopeSlotNames[slot]
if (name != null && record.memberName != null && record.memberName != name) { if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name) val resolved = target.get(name)
if (resolved != null) { if (resolved != null) {
@@ -4771,9 +4819,15 @@ class CmdFrame(
return direct return direct
} }
if (name == null) return record.value if (name == null) return record.value
val resolved = target.get(name) ?: return record.value val resolved = target.get(name)
if (resolved == null) {
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, record)
return record.value
}
if (resolved.value !== ObjUnset) { if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved) target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, resolved)
} }
return resolved.value return resolved.value
} }
@@ -4781,12 +4835,13 @@ class CmdFrame(
private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj { private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved") val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] val index = addrIndices[addrSlot]
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val record = target.getSlotRecord(index) val record = target.getSlotRecord(index)
val direct = record.value val direct = record.value
if (direct is FrameSlotRef) return direct.read() if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) return direct.read() if (direct is RecordSlotRef) return direct.read()
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
if (name != null && record.memberName != null && record.memberName != name) { if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name) val resolved = target.get(name)
if (resolved != null) { if (resolved != null) {
@@ -4807,16 +4862,29 @@ class CmdFrame(
return direct return direct
} }
if (name == null) return record.value if (name == null) return record.value
val resolved = target.get(name) ?: return record.value val resolved = target.get(name)
if (resolved == null) {
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, record)
return record.value
}
if (resolved.value !== ObjUnset) { if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved) target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, resolved)
} }
return resolved.value return resolved.value
} }
private fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) { private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved") val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot] val index = addrIndices[addrSlot]
val record = target.getSlotRecord(index)
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
target.assign(record, name, value)
return
}
target.setSlotValue(index, value) target.setSlotValue(index, value)
} }
@@ -4844,6 +4912,41 @@ class CmdFrame(
return index return index
} }
private fun hasNamedScopeBinding(target: Scope, name: String): Boolean {
if (target.tryGetLocalRecord(target, name, target.currentClassCtx) != null) return true
if (target.getSlotIndexOf(name) != null) return true
if (target.get(name) != null) return true
return false
}
private fun hasResolvedNamedScopeBinding(target: Scope, name: String): Boolean =
findNamedExistingRecord(target, name) != null
private fun findNamedExistingRecord(target: Scope, name: String): ObjRecord? {
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return it }
target.get(name)?.let { record ->
if (record.value !== ObjUnset || record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
return record
}
}
return null
}
private fun failMissingPreparedModuleBinding(
slot: Int,
name: String,
hadNamedBinding: Boolean,
record: ObjRecord
) {
if (hadNamedBinding) return
if (record.value !== ObjUnset) return
if (fn.scopeSlotIsModule.getOrNull(slot) != true) return
throw ScriptError(
ensureScope().pos,
"module binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
}
private fun ensureLocalMutable(localIndex: Int) { private fun ensureLocalMutable(localIndex: Int) {
val name = fn.localSlotNames.getOrNull(localIndex) ?: return val name = fn.localSlotNames.getOrNull(localIndex) ?: return
val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true
@@ -36,7 +36,7 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
} else { } else {
record.value record.value
} }
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, base + i)) { if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, i)) {
continue continue
} }
frame.setObjUnchecked(base + i, value) frame.setObjUnchecked(base + i, value)
@@ -0,0 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal expect fun vmIterDebug(message: String, error: Throwable? = null)
@@ -25,6 +25,8 @@ import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.serializer import kotlinx.serialization.serializer
import net.sergeych.lyng.* import net.sergeych.lyng.*
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
@@ -175,7 +177,8 @@ open class Obj {
if (other === this) return 0 if (other === this) return 0
if (other === ObjNull || other === ObjUnset || other === ObjVoid) return 2 if (other === ObjNull || other === ObjUnset || other === ObjVoid) return 2
return invokeInstanceMethod(scope, "compareTo", Arguments(other)) { return invokeInstanceMethod(scope, "compareTo", Arguments(other)) {
scope.raiseNotImplemented("compareTo for ${objClass.className}") OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { ObjInt.of(it.toLong()) }
?: scope.raiseNotImplemented("compareTo for ${objClass.className}")
}.cast<ObjInt>(scope).toInt() }.cast<ObjInt>(scope).toInt()
} }
@@ -284,7 +287,8 @@ open class Obj {
} }
if (self !== this) return self.plus(scope, otherValue) if (self !== this) return self.plus(scope, otherValue)
return invokeInstanceMethod(scope, "plus", Arguments(otherValue)) { return invokeInstanceMethod(scope, "plus", Arguments(otherValue)) {
scope.raiseNotImplemented("plus for ${objClass.className}") OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Plus)
?: scope.raiseNotImplemented("plus for ${objClass.className}")
} }
} }
@@ -301,7 +305,8 @@ open class Obj {
} }
if (self !== this) return self.minus(scope, otherValue) if (self !== this) return self.minus(scope, otherValue)
return invokeInstanceMethod(scope, "minus", Arguments(otherValue)) { return invokeInstanceMethod(scope, "minus", Arguments(otherValue)) {
scope.raiseNotImplemented("minus for ${objClass.className}") OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Minus)
?: scope.raiseNotImplemented("minus for ${objClass.className}")
} }
} }
@@ -324,7 +329,8 @@ open class Obj {
} }
if (self !== this) return self.mul(scope, otherValue) if (self !== this) return self.mul(scope, otherValue)
return invokeInstanceMethod(scope, "mul", Arguments(otherValue)) { return invokeInstanceMethod(scope, "mul", Arguments(otherValue)) {
scope.raiseNotImplemented("mul for ${objClass.className}") OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Mul)
?: scope.raiseNotImplemented("mul for ${objClass.className}")
} }
} }
@@ -341,7 +347,8 @@ open class Obj {
} }
if (self !== this) return self.div(scope, otherValue) if (self !== this) return self.div(scope, otherValue)
return invokeInstanceMethod(scope, "div", Arguments(otherValue)) { return invokeInstanceMethod(scope, "div", Arguments(otherValue)) {
scope.raiseNotImplemented("div for ${objClass.className}") OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Div)
?: scope.raiseNotImplemented("div for ${objClass.className}")
} }
} }
@@ -358,7 +365,8 @@ open class Obj {
} }
if (self !== this) return self.mod(scope, otherValue) if (self !== this) return self.mod(scope, otherValue)
return invokeInstanceMethod(scope, "mod", Arguments(otherValue)) { return invokeInstanceMethod(scope, "mod", Arguments(otherValue)) {
scope.raiseNotImplemented("mod for ${objClass.className}") OperatorInteropRegistry.invokeBinary(scope, self, otherValue, InteropOperator.Mod)
?: scope.raiseNotImplemented("mod for ${objClass.className}")
} }
} }
@@ -0,0 +1,313 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import com.ionspin.kotlin.bignum.decimal.BigDecimal as IonBigDecimal
import com.ionspin.kotlin.bignum.decimal.DecimalMode
import com.ionspin.kotlin.bignum.decimal.RoundingMode
import com.ionspin.kotlin.bignum.integer.BigInteger
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.RecordSlotRef
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.TypeDecl
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.requiredArg
object ObjBigDecimalSupport {
private const val decimalContextVar = "__lyng_decimal_context__"
// For Real -> BigDecimal, preserve the actual IEEE-754 Double value using a
// round-trip-safe precision. This intentionally does not try to recover source text.
private val realConversionMode = DecimalMode(17L, RoundingMode.ROUND_HALF_TO_EVEN)
// Division needs an explicit stopping rule for non-terminating results. Use a
// decimal128-like default context until Lyng exposes per-operation contexts.
private val defaultDivisionMode = DecimalMode(34L, RoundingMode.ROUND_HALF_TO_EVEN)
private val zero: IonBigDecimal = IonBigDecimal.ZERO
private val decimalTypeDecl = TypeDecl.Simple("lyng.decimal.BigDecimal", false)
private object BoundMarker
private data class DecimalRuntimeContext(
val precision: Long,
val rounding: RoundingMode
) : Obj()
suspend fun bindTo(module: ModuleScope) {
val decimalClass = module.requireClass("BigDecimal")
if (decimalClass.kotlinClassData === BoundMarker) return
decimalClass.kotlinClassData = BoundMarker
decimalClass.isAbstract = false
val hooks = decimalClass.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
decimalClass.bridgeInitHooks = it
}
hooks += { _, instance ->
instance.kotlinInstanceData = zero
}
decimalClass.addFn("plus") {
newInstance(decimalClass, valueOf(thisObj).plus(coerceArg(requireScope(), args.firstAndOnly())))
}
decimalClass.addFn("minus") {
newInstance(decimalClass, valueOf(thisObj).minus(coerceArg(requireScope(), args.firstAndOnly())))
}
decimalClass.addFn("mul") {
newInstance(decimalClass, valueOf(thisObj).times(coerceArg(requireScope(), args.firstAndOnly())))
}
decimalClass.addFn("div") {
newInstance(decimalClass, divideWithContext(valueOf(thisObj), coerceArg(requireScope(), args.firstAndOnly()), currentDivisionMode(requireScope())))
}
decimalClass.addFn("mod") {
newInstance(decimalClass, valueOf(thisObj).rem(coerceArg(requireScope(), args.firstAndOnly())))
}
decimalClass.addFn("compareTo") {
ObjInt.of(valueOf(thisObj).compareTo(coerceArg(requireScope(), args.firstAndOnly())).toLong())
}
decimalClass.addFn("negate") {
newInstance(decimalClass, valueOf(thisObj).unaryMinus())
}
decimalClass.addFn("toInt") {
ObjInt.of(valueOf(thisObj).longValue(false))
}
decimalClass.addFn("toReal") {
ObjReal.of(valueOf(thisObj).doubleValue(false))
}
decimalClass.addFn("toStringExpanded") {
ObjString(valueOf(thisObj).toStringExpanded())
}
decimalClass.addClassFn("fromInt") {
val value = requiredArg<ObjInt>(0).value
newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(value))
}
decimalClass.addClassFn("fromReal") {
val value = requiredArg<ObjReal>(0).value
newInstance(decimalClass, IonBigDecimal.fromDouble(value, realConversionMode))
}
decimalClass.addClassFn("fromString") {
val value = requiredArg<ObjString>(0).value
try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value")
}
}
module.addFn("withDecimalContext") {
val (context, block) = when (args.list.size) {
2 -> {
val first = args[0]
val block = args[1]
if (first is ObjInt) {
DecimalRuntimeContext(first.value, RoundingMode.ROUND_HALF_TO_EVEN) to block
} else {
normalizeContext(requireScope(), first) to block
}
}
3 -> {
val precision = requiredArg<ObjInt>(0).value
val rounding = roundingModeFromObj(requireScope(), args[1])
DecimalRuntimeContext(precision, rounding) to args[2]
}
else -> requireScope().raiseIllegalArgument("withDecimalContext expects (context, block), (precision, block), or (precision, rounding, block)")
}
val child = requireScope().createChildScope()
child.addConst(decimalContextVar, context)
block.callOn(child)
}
registerBuiltinConversions(decimalClass)
registerInterop(decimalClass)
}
private fun valueOf(obj: Obj): IonBigDecimal {
val instance = obj as? ObjInstance ?: error("BigDecimal receiver must be an object instance")
return instance.kotlinInstanceData as? IonBigDecimal ?: zero
}
private suspend fun currentDivisionMode(scope: Scope): DecimalMode {
val context = findContextObject(scope) ?: return defaultDivisionMode
return DecimalMode(context.precision, context.rounding)
}
private fun divideWithContext(left: IonBigDecimal, right: IonBigDecimal, mode: DecimalMode): IonBigDecimal {
if (mode.decimalPrecision <= 0L) {
return stripMode(left.divide(right, mode))
}
val exactLeft = stripMode(left)
val exactRight = stripMode(right)
val guardMode = DecimalMode(mode.decimalPrecision + 2, RoundingMode.TOWARDS_ZERO)
var guarded = stripMode(exactLeft.divide(exactRight, guardMode))
val hasMoreTail = !stripMode(exactLeft - stripMode(guarded * exactRight)).isZero()
if (hasMoreTail && isHalfRounding(mode.roundingMode) && looksLikeExactHalf(guarded, mode.decimalPrecision)) {
guarded = nudgeLastDigitAwayFromZero(guarded)
}
return stripMode(guarded.roundSignificand(mode))
}
private suspend fun ScopeFacade.newInstance(decimalClass: ObjClass, value: IonBigDecimal): ObjInstance {
val instance = call(decimalClass) as? ObjInstance
?: raiseIllegalState("BigDecimal() did not return an object instance")
instance.kotlinInstanceData = value
return instance
}
private fun coerceArg(scope: Scope, value: Obj): IonBigDecimal = when (value) {
is ObjInt -> IonBigDecimal.fromLongAsSignificand(value.value)
is ObjReal -> IonBigDecimal.fromDouble(value.value, realConversionMode)
is ObjInstance -> {
if (value.objClass.className != "BigDecimal") {
scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}")
}
value.kotlinInstanceData as? IonBigDecimal ?: zero
}
else -> scope.raiseIllegalArgument("expected BigDecimal-compatible value, got ${value.objClass.className}")
}
private suspend fun normalizeContext(scope: Scope, value: Obj): DecimalRuntimeContext {
val instance = value as? ObjInstance
?: scope.raiseClassCastError("withDecimalContext expects DecimalContext as the first argument")
if (instance.objClass.className != "DecimalContext") {
scope.raiseClassCastError("withDecimalContext expects DecimalContext as the first argument")
}
return decimalRuntimeContextFromInstance(scope, instance)
}
private fun findContextObject(scope: Scope): DecimalRuntimeContext? {
var current: Scope? = scope
while (current != null) {
val record = current.objects[decimalContextVar] ?: current.localBindings[decimalContextVar]
val value = when (val raw = record?.value) {
is FrameSlotRef -> raw.peekValue()
is RecordSlotRef -> raw.peekValue()
else -> raw
}
when (value) {
is DecimalRuntimeContext -> return value
}
current = current.parent
}
return null
}
private suspend fun decimalRuntimeContextFromInstance(scope: Scope, context: ObjInstance): DecimalRuntimeContext {
val precision = context.readField(scope, "precision").value as? ObjInt
?: scope.raiseClassCastError("DecimalContext.precision must be Int")
if (precision.value <= 0L) {
scope.raiseIllegalArgument("DecimalContext precision must be positive")
}
val rounding = roundingModeFromObj(scope, context.readField(scope, "rounding").value)
return DecimalRuntimeContext(precision.value, rounding)
}
private fun stripMode(value: IonBigDecimal): IonBigDecimal =
IonBigDecimal.fromBigIntegerWithExponent(value.significand, value.exponent)
private fun isHalfRounding(mode: RoundingMode): Boolean = when (mode) {
RoundingMode.ROUND_HALF_TO_EVEN,
RoundingMode.ROUND_HALF_AWAY_FROM_ZERO,
RoundingMode.ROUND_HALF_TOWARDS_ZERO,
RoundingMode.ROUND_HALF_CEILING,
RoundingMode.ROUND_HALF_FLOOR,
RoundingMode.ROUND_HALF_TO_ODD -> true
else -> false
}
private fun looksLikeExactHalf(value: IonBigDecimal, targetPrecision: Long): Boolean {
val digits = value.significand.abs().toString(10)
if (digits.length <= targetPrecision) return false
val discarded = digits.substring(targetPrecision.toInt())
return discarded[0] == '5' && discarded.drop(1).all { it == '0' }
}
private fun nudgeLastDigitAwayFromZero(value: IonBigDecimal): IonBigDecimal {
val ulpExponent = value.exponent - value.precision + 1
val ulp = IonBigDecimal.fromBigIntegerWithExponent(BigInteger.ONE, ulpExponent)
return if (value.significand.signum() < 0) value - ulp else value + ulp
}
private fun roundingModeFromObj(scope: Scope, value: Obj): RoundingMode {
val entry = value as? ObjEnumEntry ?: scope.raiseClassCastError("DecimalContext.rounding must be DecimalRounding")
return when (entry.name.value) {
"HalfEven" -> RoundingMode.ROUND_HALF_TO_EVEN
"HalfAwayFromZero" -> RoundingMode.ROUND_HALF_AWAY_FROM_ZERO
"HalfTowardsZero" -> RoundingMode.ROUND_HALF_TOWARDS_ZERO
"Ceiling" -> RoundingMode.CEILING
"Floor" -> RoundingMode.FLOOR
"AwayFromZero" -> RoundingMode.AWAY_FROM_ZERO
"TowardsZero" -> RoundingMode.TOWARDS_ZERO
else -> scope.raiseIllegalArgument("unsupported DecimalRounding: ${entry.name.value}")
}
}
private fun registerBuiltinConversions(decimalClass: ObjClass) {
ObjInt.type.addPropertyDoc(
name = "d",
doc = "Convert this integer to a BigDecimal.",
type = type("lyng.decimal.BigDecimal"),
moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(thisAs<ObjInt>().value)) }
)
ObjInt.type.members["d"] = ObjInt.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjReal.type.addPropertyDoc(
name = "d",
doc = "Convert this real number to a BigDecimal by preserving the current IEEE-754 value with 17 significant digits and half-even rounding.",
type = type("lyng.decimal.BigDecimal"),
moduleName = "lyng.decimal",
getter = { newInstance(decimalClass, IonBigDecimal.fromDouble(thisAs<ObjReal>().value, realConversionMode)) }
)
ObjReal.type.members["d"] = ObjReal.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
ObjString.type.addPropertyDoc(
name = "d",
doc = "Parse this string as a BigDecimal.",
type = type("lyng.decimal.BigDecimal"),
moduleName = "lyng.decimal",
getter = {
val value = thisAs<ObjString>().value
try {
newInstance(decimalClass, IonBigDecimal.parseStringWithMode(value))
} catch (e: Throwable) {
requireScope().raiseIllegalArgument("invalid BigDecimal string: $value")
}
}
)
ObjString.type.members["d"] = ObjString.type.members.getValue("d").copy(typeDecl = decimalTypeDecl)
}
private fun registerInterop(decimalClass: ObjClass) {
OperatorInteropRegistry.register(
leftClass = ObjInt.type,
rightClass = decimalClass,
commonClass = decimalClass,
operatorNames = listOf(
InteropOperator.Plus.name,
InteropOperator.Minus.name,
InteropOperator.Mul.name,
InteropOperator.Div.name,
InteropOperator.Mod.name,
InteropOperator.Compare.name,
InteropOperator.Equals.name
),
leftToCommon = ObjExternCallable.fromBridge {
val value = requiredArg<ObjInt>(0).value
newInstance(decimalClass, IonBigDecimal.fromLongAsSignificand(value))
},
rightToCommon = ObjExternCallable.fromBridge {
requiredArg<Obj>(0)
}
)
}
}
@@ -106,10 +106,20 @@ open class ObjClass(
vararg parents: ObjClass, vararg parents: ObjClass,
) : Obj() { ) : Obj() {
private fun declaringModulePackageName(scope: Scope?): String? {
var current = scope
while (current != null) {
if (current is ModuleScope) return current.packageName
current = current.parent
}
return null
}
var isAnonymous: Boolean = false var isAnonymous: Boolean = false
var isAbstract: Boolean = false var isAbstract: Boolean = false
var isClosed: Boolean = false var isClosed: Boolean = false
var logicalPackageNameOverride: String? = null
// Stable identity and simple structural version for PICs // Stable identity and simple structural version for PICs
val classId: Long = ClassIdGen.nextId() val classId: Long = ClassIdGen.nextId()
@@ -169,6 +179,16 @@ open class ObjClass(
*/ */
var classScope: Scope? = null var classScope: Scope? = null
/**
* Stable logical identity for class matching across separately instantiated modules.
* Uses declaring module package plus class name when available.
*/
val logicalPackageName: String?
get() = logicalPackageNameOverride ?: declaringModulePackageName(classScope)
val logicalName: String
get() = logicalPackageName?.let { "$it::$className" } ?: className
/** Direct parents in declaration order (kept deterministic). */ /** Direct parents in declaration order (kept deterministic). */
val directParents: List<ObjClass> = parents.toList() val directParents: List<ObjClass> = parents.toList()
@@ -129,6 +129,7 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
} }
val type = object : ObjClass("Delegate") {}.apply { val type = object : ObjClass("Delegate") {}.apply {
logicalPackageNameOverride = "lyng.stdlib"
addFn("getValue") { raiseError("Delegate.getValue is not implemented") } addFn("getValue") { raiseError("Delegate.getValue is not implemented") }
addFn("setValue") { raiseError("Delegate.setValue is not implemented") } addFn("setValue") { raiseError("Delegate.setValue is not implemented") }
addFn("invoke") { raiseError("Delegate.invoke is not implemented") } addFn("invoke") { raiseError("Delegate.invoke is not implemented") }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -24,7 +24,8 @@ import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.channels.SendChannel import kotlinx.coroutines.channels.SendChannel
import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.* import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.TypeGenericDoc import net.sergeych.lyng.miniast.TypeGenericDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
@@ -55,7 +56,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
else else
// Flow consumer is no longer collecting; signal producer to stop // Flow consumer is no longer collecting; signal producer to stop
throw ScriptFlowIsNoMoreCollected() throw ScriptFlowIsNoMoreCollected()
} catch (x: Exception) { } catch (x: Throwable) {
// Any failure to send (including closed channel) should gracefully stop the producer. // Any failure to send (including closed channel) should gracefully stop the producer.
if (x is CancellationException) { if (x is CancellationException) {
// Cancellation is a normal control-flow event // Cancellation is a normal control-flow event
@@ -80,7 +81,7 @@ private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj
producer.callOn(builderScope) producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) { } catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK // premature flow closing, OK
} catch (x: Exception) { } catch (x: Throwable) {
channel.close(x) channel.close(x)
return@globalLaunch return@globalLaunch
} }
@@ -364,6 +364,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
onNotFoundResult: (suspend () -> Obj?)? onNotFoundResult: (suspend () -> Obj?)?
): Obj { ): Obj {
val caller = scope.currentClassCtx val caller = scope.currentClassCtx
val methodScope = scope.applyClosure(instanceScope)
// Fast path for public members when outside any class context // Fast path for public members when outside any class context
if (caller == null) { if (caller == null) {
@@ -373,7 +374,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, decl) return rec.value.invoke(methodScope, this, args, decl)
} }
} }
} }
@@ -384,7 +385,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, decl) return rec.value.invoke(methodScope, this, args, decl)
} }
} }
} }
@@ -394,7 +395,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, decl) return rec.value.invoke(methodScope, this, args, decl)
} }
} }
} }
@@ -409,7 +410,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, c) return rec.value.invoke(methodScope, this, args, c)
} }
} }
} }
@@ -418,7 +419,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, c) return rec.value.invoke(methodScope, this, args, c)
} }
} }
} }
@@ -427,7 +428,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, c)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, c) return rec.value.invoke(methodScope, this, args, c)
} }
} }
} }
@@ -439,7 +440,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name) ?: objClass val decl = rec.declaringClass ?: objClass.findDeclaringClassOf(name) ?: objClass
val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null val effectiveCaller = caller ?: if (scope.thisObj === this) objClass else null
if (canAccessMember(rec.visibility, decl, effectiveCaller, name)) { if (canAccessMember(rec.visibility, decl, effectiveCaller, name)) {
return rec.value.invoke(instanceScope, this, args, decl) return rec.value.invoke(methodScope, this, args, decl)
} }
} }
} }
@@ -474,7 +475,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl) if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) { } else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke( return rec.value.invoke(
instanceScope, methodScope,
this, this,
args, args,
decl decl
@@ -586,8 +587,10 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is ObjInstance) return -1 if (other !is ObjInstance || other.objClass != objClass) {
if (other.objClass != objClass) return -1 OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
return -1
}
for (f in comparableVars) { for (f in comparableVars) {
val a = f.value.value val a = f.value.value
val b = other.instanceScope.objects[f.key]?.value ?: scope.raiseError("Internal error: field ${f.key} not found in other instance") val b = other.instanceScope.objects[f.key]?.value ?: scope.raiseError("Internal error: field ${f.key} not found in other instance")
@@ -19,6 +19,8 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
@@ -54,10 +56,11 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
} }
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other !is Numeric) return -2
return if (other is ObjInt) { return if (other is ObjInt) {
value.compareTo(other.value) value.compareTo(other.value)
} else { } else {
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
if (other !is Numeric) return -2
doubleValue.compareTo(other.doubleValue) doubleValue.compareTo(other.doubleValue)
} }
} }
@@ -70,28 +73,39 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
if (other is ObjInt) if (other is ObjInt)
of(this.value + other.value) of(this.value + other.value)
else else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
?:
ObjReal.of(this.doubleValue + other.toDouble()) ObjReal.of(this.doubleValue + other.toDouble())
override suspend fun minus(scope: Scope, other: Obj): Obj = override suspend fun minus(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value - other.value) of(this.value - other.value)
else else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
?:
ObjReal.of(this.doubleValue - other.toDouble()) ObjReal.of(this.doubleValue - other.toDouble())
override suspend fun mul(scope: Scope, other: Obj): Obj = override suspend fun mul(scope: Scope, other: Obj): Obj =
if (other is ObjInt) { if (other is ObjInt) {
of(this.value * other.value) of(this.value * other.value)
} else ObjReal.of(this.value * other.toDouble()) } else {
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul)
?: ObjReal.of(this.value * other.toDouble())
}
override suspend fun div(scope: Scope, other: Obj): Obj = override suspend fun div(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value / other.value) of(this.value / other.value)
else ObjReal.of(this.value / other.toDouble()) else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div)
?: ObjReal.of(this.value / other.toDouble())
override suspend fun mod(scope: Scope, other: Obj): Obj = override suspend fun mod(scope: Scope, other: Obj): Obj =
if (other is ObjInt) if (other is ObjInt)
of(this.value % other.value) of(this.value % other.value)
else ObjReal.of(this.value.toDouble() % other.toDouble()) else
OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod)
?: ObjReal.of(this.value.toDouble() % other.toDouble())
/** /**
* Numbers are now immutable, so we can't do in-place assignment. * Numbers are now immutable, so we can't do in-place assignment.
@@ -1,86 +0,0 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.Visibility
import net.sergeych.lyng.executeBytecodeWithSeed
/**
* Lazy delegate used by `val x by lazy { ... }`.
*/
class ObjLazyDelegate(
private val builder: Obj,
private val capturedScope: Scope,
) : Obj() {
override val objClass: ObjClass = type
private var calculated = false
private var cachedValue: Obj = ObjVoid
override suspend fun invokeInstanceMethod(
scope: Scope,
name: String,
args: Arguments,
onNotFoundResult: (suspend () -> Obj?)?,
): Obj {
return when (name) {
"getValue" -> {
if (!calculated) {
val callScope = capturedScope.createChildScope(capturedScope.pos, args = Arguments.EMPTY)
cachedValue = if (builder is Statement) {
executeBytecodeWithSeed(callScope, builder, "lazy delegate")
} else {
builder.callOn(callScope)
}
calculated = true
}
cachedValue
}
"setValue" -> scope.raiseIllegalAssignment("lazy delegate is read-only")
else -> super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
}
companion object {
val type = ObjClass("LazyDelegate").apply {
implementingNames.add("Delegate")
createField(
"getValue",
ObjNull,
isMutable = false,
visibility = Visibility.Public,
pos = Pos.builtIn,
declaringClass = this,
type = ObjRecord.Type.Fun
)
createField(
"setValue",
ObjNull,
isMutable = false,
visibility = Visibility.Public,
pos = Pos.builtIn,
declaringClass = this,
type = ObjRecord.Type.Fun
)
}
}
}
@@ -19,6 +19,8 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addConstDoc import net.sergeych.lyng.miniast.addConstDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
@@ -40,6 +42,8 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
override fun byValueCopy(): Obj = this override fun byValueCopy(): Obj = this
override suspend fun compareTo(scope: Scope, other: Obj): Int { override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjReal) return value.compareTo(other.value)
OperatorInteropRegistry.invokeCompare(scope, this, other)?.let { return it }
if (other !is Numeric) return -2 if (other !is Numeric) return -2
return value.compareTo(other.doubleValue) return value.compareTo(other.doubleValue)
} }
@@ -63,19 +67,24 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
} }
override suspend fun plus(scope: Scope, other: Obj): Obj = override suspend fun plus(scope: Scope, other: Obj): Obj =
of(this.value + other.toDouble()) OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Plus)
?: of(this.value + other.toDouble())
override suspend fun minus(scope: Scope, other: Obj): Obj = override suspend fun minus(scope: Scope, other: Obj): Obj =
of(this.value - other.toDouble()) OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Minus)
?: of(this.value - other.toDouble())
override suspend fun mul(scope: Scope, other: Obj): Obj = override suspend fun mul(scope: Scope, other: Obj): Obj =
of(this.value * other.toDouble()) OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mul)
?: of(this.value * other.toDouble())
override suspend fun div(scope: Scope, other: Obj): Obj = override suspend fun div(scope: Scope, other: Obj): Obj =
of(this.value / other.toDouble()) OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Div)
?: of(this.value / other.toDouble())
override suspend fun mod(scope: Scope, other: Obj): Obj = override suspend fun mod(scope: Scope, other: Obj): Obj =
of(this.value % other.toDouble()) OperatorInteropRegistry.invokeBinary(scope, this, other, InteropOperator.Mod)
?: of(this.value % other.toDouble())
/** /**
* Returns unboxed Double value * Returns unboxed Double value
@@ -0,0 +1,222 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.stdlib_included
@Suppress("Unused", "MemberVisibilityCanBePrivate")
internal val decimalLyng = """
package lyng.decimal
/**
* Rounding policies used by [DecimalContext] and `withDecimalContext(...)`.
*
* These modes currently affect decimal division. They are designed to be explicit and readable in Lyng code.
*
* Common examples at precision `2`:
* - `HalfEven`: `1.d / 8.d -> 0.12`
* - `HalfAwayFromZero`: `1.d / 8.d -> 0.13`, `-1.d / 8.d -> -0.13`
* - `HalfTowardsZero`: `1.d / 8.d -> 0.12`, `-1.d / 8.d -> -0.12`
* - `Ceiling`: rounds toward positive infinity
* - `Floor`: rounds toward negative infinity
* - `AwayFromZero`: always increases magnitude when rounding is needed
* - `TowardsZero`: always truncates toward zero
*/
enum DecimalRounding {
HalfEven,
HalfAwayFromZero,
HalfTowardsZero,
Ceiling,
Floor,
AwayFromZero,
TowardsZero
}
/**
* Dynamic decimal arithmetic settings.
*
* A decimal context is not attached permanently to a `BigDecimal` value. Instead, it is applied dynamically
* inside `withDecimalContext(...)`, which makes the rule local to a block of code.
*
* Default context:
* - precision: `34` significant digits
* - rounding: `DecimalRounding.HalfEven`
*
* Example:
*
* import lyng.decimal
*
* (1.d / 3.d).toStringExpanded()
* >>> "0.3333333333333333333333333333333333"
*
* withDecimalContext(10) { (1.d / 3.d).toStringExpanded() }
* >>> "0.3333333333"
*
* withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() }
* >>> "0.13"
*/
class DecimalContext(
val precision: Int = 34,
val rounding: DecimalRounding = DecimalRounding.HalfEven
)
/**
* Arbitrary-precision decimal value.
*
* `BigDecimal` is intended for decimal arithmetic where binary floating-point (`Real`) is the wrong tool:
* - money
* - human-entered decimal values
* - ratios that should round in decimal, not in binary
* - reproducible decimal formatting
*
* Creating values:
*
* - `1.d` converts `Int -> BigDecimal`
* - `2.2.d` converts `Real -> BigDecimal` by preserving the current IEEE-754 value
* - `"2.2".d` parses exact decimal text
* - `BigDecimal.fromInt(...)`, `fromReal(...)`, `fromString(...)` are explicit factory forms
*
* Important distinction:
*
* - `2.2.d` means "take the current `Real` value and convert it"
* - `"2.2".d` means "parse this exact decimal literal text"
*
* Therefore:
*
* import lyng.decimal
*
* 2.2.d.toStringExpanded()
* >>> "2.2"
*
* (0.1 + 0.2).d.toStringExpanded()
* >>> "0.30000000000000004"
*
* "0.3".d.toStringExpanded()
* >>> "0.3"
*
* Mixed arithmetic:
*
* `BigDecimal` defines its own operators against decimal-compatible values, and the decimal module also registers
* interop bridges so built-in left-hand operands work naturally:
*
* import lyng.decimal
*
* 1.d + 2
* >>> 3.d
*
* 1 + 2.d
* >>> 3.d
*
* 0.5 + 1.d
* >>> 1.5.d
*
* Precision and rounding:
*
* - division uses the default decimal context unless overridden
* - use `withDecimalContext(...)` to apply a local precision/rounding policy
*
* Exact decimal literal style:
*
* If you want the source text itself to be the decimal value, use a string:
*
* "2.2".d
*
* That is the precise form. `2.2.d` remains a `Real -> BigDecimal` conversion by design.
*/
extern class BigDecimal() {
/** Add another decimal-compatible value. */
extern fun plus(other: Object): BigDecimal
/** Subtract another decimal-compatible value. */
extern fun minus(other: Object): BigDecimal
/** Multiply by another decimal-compatible value. */
extern fun mul(other: Object): BigDecimal
/**
* Divide by another decimal-compatible value.
*
* Division uses the current decimal context:
* - by default: `34` significant digits, `HalfEven`
* - inside `withDecimalContext(...)`: the context active for the current block
*/
extern fun div(other: Object): BigDecimal
/** Remainder with another decimal-compatible value. */
extern fun mod(other: Object): BigDecimal
/** Compare with another decimal-compatible value. */
extern fun compareTo(other: Object): Int
/** Unary minus. */
extern fun negate(): BigDecimal
/** Convert to `Int` by dropping the fractional part according to backend conversion rules. */
extern fun toInt(): Int
/** Convert to `Real`. */
extern fun toReal(): Real
/**
* Convert to a plain decimal string without scientific notation.
*
* This is the preferred representation for user-facing decimal tests and diagnostics.
*/
extern fun toStringExpanded(): String
/** Create a decimal from an `Int`. */
static extern fun fromInt(value: Int): BigDecimal
/**
* Create a decimal from a `Real`.
*
* This preserves the current IEEE-754 value using a round-trip-safe decimal conversion.
* It does not try to recover the original source text.
*/
static extern fun fromReal(value: Real): BigDecimal
/** Parse exact decimal text. */
static extern fun fromString(value: String): BigDecimal
}
/**
* Run [block] with the provided decimal context.
*
* This is the main way to control decimal division precision and rounding locally without changing global behavior.
*
* Example:
*
* import lyng.decimal
*
* withDecimalContext(10) {
* (1.d / 3.d).toStringExpanded()
* }
* >>> "0.3333333333"
*
* Contexts are dynamic and block-local. After the block finishes, the previous context is restored.
*/
extern fun withDecimalContext<T>(context: DecimalContext, block: ()->T): T
/**
* Convenience overload for changing only precision.
*
* Equivalent to `withDecimalContext(DecimalContext(precision, DecimalRounding.HalfEven), block)`.
*/
extern fun withDecimalContext<T>(precision: Int, block: ()->T): T
/**
* Convenience overload for changing precision and rounding explicitly.
*
* Example:
*
* import lyng.decimal
*
* withDecimalContext(2, DecimalRounding.HalfAwayFromZero) {
* (1.d / 8.d).toStringExpanded()
* }
* >>> "0.13"
*/
extern fun withDecimalContext<T>(precision: Int, rounding: DecimalRounding, block: ()->T): T
""".trimIndent()
@@ -0,0 +1,191 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.stdlib_included
@Suppress("Unused", "MemberVisibilityCanBePrivate")
internal val operatorsLyng = """
package lyng.operators
/**
* Binary operators that can be bridged between two different operand classes.
*
* Registering a pair means:
* - the runtime can evaluate `left op right` when `left` has class `L` and `right` has class `R`
* - both operands are first converted to a shared "common" class `C`
* - the actual operator implementation is then looked up on `C`
*
* This is primarily useful when:
* - you add a new numeric-like type in a library or in pure Lyng code
* - your type already implements operators against itself
* - you also want existing left-hand types such as `Int` or `Real` to work when your type is on the right
*
* Example:
*
* import lyng.operators
*
* class DecimalBox(val value: Int) {
* fun plus(other: DecimalBox) = DecimalBox(value + other.value)
* fun compareTo(other: DecimalBox) = value <=> other.value
* }
*
* OperatorInterop.register(
* Int,
* DecimalBox,
* DecimalBox,
* [BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
* { x: Int -> DecimalBox(x) },
* { x: DecimalBox -> x }
* )
*
* After registration:
* - `1 + DecimalBox(2)` works
* - `1 < DecimalBox(2)` works
* - `2 == DecimalBox(2)` works
*
* But this registration does not replace methods on the original classes. It only teaches
* Lyng how to bridge a mixed pair into a common class for the listed operators.
*/
enum BinaryOperator {
/** `a + b` */
Plus,
/** `a - b` */
Minus,
/** `a * b` */
Mul,
/** `a / b` */
Div,
/** `a % b` */
Mod,
/**
* Ordering comparisons.
*
* Registering `Compare` enables `<`, `<=`, `>`, `>=`, and the shuttle operator `<=>`
* for the mixed operand pair.
*/
Compare,
/**
* Equality comparisons.
*
* Registering `Equals` enables `==` and `!=` for the mixed operand pair.
*/
Equals
}
/**
* Runtime registry for mixed-class binary operators.
*
* `register(L, R, C, ...)` defines how Lyng should evaluate expressions where:
* - the left operand has class `L`
* - the right operand has class `R`
* - the actual operation should be executed as if both were values of class `C`
*
* The registry is symmetric for the converted values, but not for the original syntax.
* Its job is specifically to fill the gap where your custom type appears on the right:
*
* - `myDecimal + 1` usually already works if `BigDecimal.plus(Int)` exists
* - `1 + myDecimal` needs registration because `Int` itself is not rewritten
*
* Typical pattern for a custom type:
*
* import lyng.operators
*
* class Rational(val num: Int, val den: Int) {
* fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
* fun minus(other: Rational) = Rational(num * other.den - other.num * den, den * other.den)
* fun mul(other: Rational) = Rational(num * other.num, den * other.den)
* fun div(other: Rational) = Rational(num * other.den, den * other.num)
* fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
*
* static fun fromInt(value: Int) = Rational(value, 1)
* }
*
* OperatorInterop.register(
* Int,
* Rational,
* Rational,
* [
* BinaryOperator.Plus,
* BinaryOperator.Minus,
* BinaryOperator.Mul,
* BinaryOperator.Div,
* BinaryOperator.Compare,
* BinaryOperator.Equals
* ],
* { x: Int -> Rational.fromInt(x) },
* { x: Rational -> x }
* )
*
* Then:
* - `1 + Rational(1, 2)` works
* - `3 > Rational(5, 2)` works
* - `2 == Rational(2, 1)` works
*
* Decimal uses the same mechanism internally to make `Int + BigDecimal` and `Real + BigDecimal`
* work without changing the built-in `Int` or `Real` classes.
*/
extern object OperatorInterop {
/**
* Register a mixed-operand operator bridge.
*
* @param leftClass class of the original left operand
* @param rightClass class of the original right operand
* @param commonClass class that will actually execute the operator methods
* @param operators operators supported for this mixed pair
* @param leftToCommon conversion from `L` to `C`
* @param rightToCommon conversion from `R` to `C`
*
* Requirements for `commonClass`:
* - if you register `Plus`, `C` should implement `fun plus(other: C): C` or equivalent accepted result type
* - if you register `Minus`, `C` should implement `fun minus(other: C): ...`
* - if you register `Mul`, `C` should implement `fun mul(other: C): ...`
* - if you register `Div`, `C` should implement `fun div(other: C): ...`
* - if you register `Mod`, `C` should implement `fun mod(other: C): ...`
* - if you register `Compare`, `C` should implement `fun compareTo(other: C): Int`
*
* `Equals` reuses comparison/equality semantics of the promoted values.
*
* Registration is usually done once at module initialization time:
*
* package my.rational
* import lyng.operators
*
* class Rational(val num: Int, val den: Int) {
* fun plus(other: Rational) = Rational(num * other.den + other.num * den, den * other.den)
* fun compareTo(other: Rational) = (num * other.den) <=> (other.num * den)
* static fun fromInt(value: Int) = Rational(value, 1)
* }
*
* OperatorInterop.register(
* Int,
* Rational,
* Rational,
* [BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
* { x: Int -> Rational.fromInt(x) },
* { x: Rational -> x }
* )
*/
extern fun register<L, R, C>(
leftClass: Class<L>,
rightClass: Class<R>,
commonClass: Class<C>,
operators: List<BinaryOperator>,
leftToCommon: (L)->C,
rightToCommon: (R)->C
): Void
}
""".trimIndent()
@@ -0,0 +1,88 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.pacman.ImportManager
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class CompilerVmReviewRegressionTest {
@Test
fun missingModuleCaptureFailsFastInsteadOfBecomingUnset() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<missing-module-capture>",
"""
import foo
fun make() = { answer }
make()
""".trimIndent()
),
manager
)
val prepared = manager.newModule()
script.importInto(prepared)
val preparedLambda = script.execute(prepared)
assertEquals(42, prepared.asFacade().call(preparedLambda).toInt())
val rawModule = manager.newModule()
val hostScope = Scope(parent = rawModule, thisObj = ObjString("receiver"))
val lambda = script.execute(hostScope)
val ex = assertFailsWith<ScriptError> {
hostScope.asFacade().call(lambda)
}
assertContains(ex.errorMessage, "module binding 'answer'")
}
@Test
fun subjectlessWhenReportsScriptError() = runTest {
val ex = assertFailsWith<ScriptError> {
Compiler.compile(
Source(
"<when-without-subject>",
"""
when {
true -> 1
}
""".trimIndent()
),
Script.defaultImportManager
)
}
assertContains(ex.errorMessage, "when without subject")
}
}
@@ -0,0 +1,52 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder
import kotlin.test.Test
import kotlin.test.assertEquals
class GlobalPropertyCaptureRegressionTest {
@Test
fun externGlobalVarAssignmentInsideFunctionShouldCallBoundSetter() = runTest {
val scope = Script.newScope()
var x = 1.0
scope.eval(
"""
extern var X: Real
fun main() {
X = X + 1.0
}
""".trimIndent()
)
scope.globalBinder().bindGlobalVar(
name = "X",
get = { x },
set = { x = it }
)
scope.eval("main()")
assertEquals(2.0, x, "bound extern var should stay live inside function bodies")
}
}
@@ -114,7 +114,7 @@ class ObjectExpressionTest {
eval(""" eval("""
val x = object { } val x = object { }
val name = ((x::class as Class).className as String) val name = ((x::class as Class).className as String)
assert(name.startsWith("${'$'}Anon_")) assert(name.startsWith("\${'$'}Anon_"))
""".trimIndent()) """.trimIndent())
} }
} }
@@ -0,0 +1,87 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Script
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.pacman.ImportManager
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull
class ScriptImportPreparationTest {
@Test
fun scriptImportIntoExplicitlyPreparesExistingScope() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<prepare-scope>",
"""
import foo
answer
""".trimIndent()
),
manager
)
val scope = manager.newModule()
assertNull(scope["answer"])
script.importInto(scope)
val record = assertNotNull(scope["answer"])
assertEquals(42, scope.resolve(record, "answer").toInt())
}
@Test
fun scriptInstantiateModuleUsesSeedScopeImportProvider() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<instantiate-module>",
"""
import foo
answer
""".trimIndent()
),
manager
)
val seedScope = manager.newModule()
val module = script.instantiateModule(seedScope)
val record = assertNotNull(module["answer"])
assertEquals(42, module.resolve(record, "answer").toInt())
}
}
+37 -20
View File
@@ -4194,26 +4194,43 @@ class ScriptTest {
// } // }
// @Ignore @Test
// @Test fun interpolationTest() = runTest {
// fun interpolationTest() = runTest { val d = '$'
// eval($$$""" eval(
// """
// val foo = "bar" val foo = "bar"
// val buzz = ["foo", "bar"] val buzz = ["foo", "bar"]
//
// // 1. simple interpolation // 1. simple interpolation
// assertEquals( "bar", "$foo" ) assertEquals("bar", "${d}foo")
// assertEquals( "bar", "${foo}" ) assertEquals("bar", "${d}{foo}")
//
// // 2. escaping the dollar sign // 2. escaping / literal dollar forms
// assertEquals( "$", "\$foo"[0] ) assertEquals("${d}${d}foo", "\${d}foo")
// assertEquals( "foo, "\$foo"[1..] ) assertEquals("${d}${d}foo", "${d}${d}foo")
// assertEquals("\\bar", "\\${d}foo")
// // 3. interpolation with expression
// assertEquals( "foo!. bar?", "${buzz[0]+"!"}. ${buzz[1]+"?"}" ) // 3. interpolation with expression
// """.trimIndent()) assertEquals("foo!. bar?", "${d}{buzz[0] + "!"}. ${d}{buzz[1] + "?"}")
// } """.trimIndent()
)
}
@Test
fun interpolationCanBeDisabledByFeatureComment() = runTest {
val d = '$'
eval(
"""
// feature: interpolation: off
val name = "lyng"
assertEquals("hello, ${d}name!", "hello, ${d}name!")
assertEquals("${d}{name}", "${d}{name}")
assertEquals("${d}${d}name", "${d}${d}name")
assertEquals("\\${d}name", "\\${d}name")
""".trimIndent()
)
}
@Test @Test
fun testInlineArrayLiteral() = runTest { fun testInlineArrayLiteral() = runTest {
@@ -0,0 +1,60 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.bytecode.BytecodeConst
import net.sergeych.lyng.bytecode.CmdFrame
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.bytecode.seedFrameLocalsFromScope
import kotlin.test.Test
import kotlin.test.assertNull
class SeedLocalsRegressionTest {
@Test
fun seedFrameLocalsSkipsSelfReferentialFrameSlotRef() = runTest {
val fn = CmdFunction(
name = "seed-self-ref",
localCount = 1,
addrCount = 0,
returnLabels = emptySet(),
scopeSlotCount = 1,
scopeSlotIndices = intArrayOf(0),
scopeSlotNames = arrayOf(null),
scopeSlotIsModule = booleanArrayOf(false),
localSlotNames = arrayOf("x"),
localSlotMutables = booleanArrayOf(true),
localSlotDelegated = booleanArrayOf(false),
localSlotCaptures = booleanArrayOf(false),
constants = listOf(BytecodeConst.IntVal(0)),
cmds = emptyArray(),
posByIp = emptyArray()
)
val scope = Scope(null, pos = Pos.builtIn)
val record = scope.addConst("x", net.sergeych.lyng.obj.ObjInt.of(1))
val frame = CmdFrame(CmdVm(), fn, scope, emptyList())
record.value = FrameSlotRef(frame.frame, 0)
scope.updateSlotFor("x", record)
seedFrameLocalsFromScope(frame, scope)
assertNull(frame.frame.getRawObj(0))
}
}
@@ -172,4 +172,73 @@ class StdlibTest {
""".trimIndent()) """.trimIndent())
} }
@Test
fun testRandomSeededDeterministic() = runTest {
eval("""
val a = Random.seeded(123456)
val b = Random.seeded(123456)
for( i in 1..20 ) {
assertEquals(a.nextInt(), b.nextInt())
assertEquals(a.nextFloat(), b.nextFloat())
assertEquals(a.next(1..100), b.next(1..100))
}
""".trimIndent())
}
@Test
fun testRandomNextFloatBounds() = runTest {
eval("""
for( i in 1..400 ) {
val x = Random.nextFloat()
assert(x >= 0.0)
assert(x < 1.0)
}
""".trimIndent())
}
@Test
fun testRandomNextRangeVariants() = runTest {
eval("""
val rnd = Random.seeded(77)
for( i in 1..300 ) {
val x = rnd.next(10..<20)
assert(x in 10..<20)
}
val allowed = [0, 3, 6, 9]
for( i in 1..300 ) {
val x = rnd.next(0..9 step 3)
assert(x in allowed)
}
for( i in 1..300 ) {
val ch = rnd.next('a'..<'f')
assert(ch in 'a'..<'f')
}
for( i in 1..300 ) {
val rf = rnd.next(1.5..<4.5)
assert(rf >= 1.5)
assert(rf < 4.5)
}
val qAllowed = [0.0, 0.25, 0.5, 0.75, 1.0]
for( i in 1..300 ) {
val q = rnd.next(0.0..1.0 step 0.25)
assert(q in qAllowed)
}
""".trimIndent())
}
@Test
fun testRandomRejectsOpenRange() = runTest {
eval("""
assertThrows(IllegalArgumentException) { Random.next(1..) }
assertThrows(IllegalArgumentException) { Random.next(..10) }
assertThrows(IllegalArgumentException) { Random.next(..) }
""".trimIndent())
}
} }
+210 -82
View File
@@ -16,9 +16,10 @@
*/ */
import kotlinx.coroutines.test.runTest import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Script import net.sergeych.lyng.*
import net.sergeych.lyng.ScriptError import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.eval import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjNull
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertFailsWith import kotlin.test.assertFailsWith
import kotlin.test.assertTrue import kotlin.test.assertTrue
@@ -27,33 +28,42 @@ class TypesTest {
@Test @Test
fun testTypeCollection1() = runTest { fun testTypeCollection1() = runTest {
eval(""" eval(
"""
class Point(x: Real, y: Real) class Point(x: Real, y: Real)
assert(Point(1,2).x == 1) assert(Point(1,2).x == 1)
assert(Point(1,2).y == 2) assert(Point(1,2).y == 2)
assert(Point(1,2) is Point) assert(Point(1,2) is Point)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testTypeCollection2() = runTest { fun testTypeCollection2() = runTest {
eval(""" eval(
"""
fun fn1(x: Real, y: Real): Real { x + y } fun fn1(x: Real, y: Real): Real { x + y }
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testTypeCollection3() = runTest { fun testTypeCollection3() = runTest {
eval(""" eval(
"""
class Test(a: Int) { class Test(a: Int) {
fun fn1(x: Real, y: Real): Real { x + y } fun fn1(x: Real, y: Real): Real { x + y }
} }
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testExternDeclarations() = runTest { fun testExternDeclarations() = runTest {
eval(""" eval(
"""
extern fun foo1(a: String): Void extern fun foo1(a: String): Void
assertThrows { foo1("1") } assertThrows { foo1("1") }
class Test(a: Int) { class Test(a: Int) {
@@ -69,22 +79,26 @@ class TypesTest {
} }
// println("4") // println("4")
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testUserClassCompareTo() = runTest { fun testUserClassCompareTo() = runTest {
eval(""" eval(
"""
class Point(val a,b) class Point(val a,b)
assertEquals(Point(0,1), Point(0,1) ) assertEquals(Point(0,1), Point(0,1) )
assertNotEquals(Point(0,1), Point(1,1) ) assertNotEquals(Point(0,1), Point(1,1) )
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testUserClassCompareTo2() = runTest { fun testUserClassCompareTo2() = runTest {
eval(""" eval(
"""
class Point(val a,b) { class Point(val a,b) {
var c = 0 var c = 0
} }
@@ -98,12 +112,14 @@ class TypesTest {
assertEquals(p1, p2) assertEquals(p1, p2)
assertNotEquals(Point(0,1), Point(1,1) ) assertNotEquals(Point(0,1), Point(1,1) )
assertNotEquals(Point(0,1), p3) assertNotEquals(Point(0,1), p3)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testNumericInference() = runTest { fun testNumericInference() = runTest {
eval(""" eval(
"""
val x = 1 val x = 1
var y = 2.0 var y = 2.0
assert( x is Int ) assert( x is Int )
@@ -111,11 +127,14 @@ class TypesTest {
assert( x + y is Real ) assert( x + y is Real )
assert( abs(x+y) is Real ) assert( abs(x+y) is Real )
assert( abs(x/y) is Real ) assert( abs(x/y) is Real )
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testNumericInferenceBug1() = runTest { fun testNumericInferenceBug1() = runTest {
eval(""" eval(
"""
fun findSumLimit(f) { fun findSumLimit(f) {
var sum = 0.0 var sum = 0.0
for( n in 1..100 ) { for( n in 1..100 ) {
@@ -142,12 +161,14 @@ class TypesTest {
val limit = findSumLimit { n -> 1.0/n/n } val limit = findSumLimit { n -> 1.0/n/n }
assert( limit != null ) assert( limit != null )
println("Result: "+limit) println("Result: "+limit)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testNullableHints() = runTest { fun testNullableHints() = runTest {
eval(""" eval(
"""
// nullable, without type os Object? // nullable, without type os Object?
class N(x=null) class N(x=null)
assertEquals(null, N().x) assertEquals(null, N().x)
@@ -167,7 +188,8 @@ class TypesTest {
@Test @Test
fun testIsUnionIntersection() = runTest { fun testIsUnionIntersection() = runTest {
eval(""" eval(
"""
class A class A
class B class B
class C: A, B class C: A, B
@@ -179,7 +201,8 @@ class TypesTest {
val v = 1 val v = 1
assert( v is Int | String | Real ) assert( v is Int | String | Real )
assert( !(v is String | Bool) ) assert( !(v is String | Bool) )
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
@@ -221,51 +244,64 @@ class TypesTest {
@Test @Test
fun testListLiteralInferenceForBounds() = runTest { fun testListLiteralInferenceForBounds() = runTest {
eval(""" eval(
"""
fun acceptInts<T: Int>(xs: List<T>) { } fun acceptInts<T: Int>(xs: List<T>) { }
acceptInts([1, 2, 3]) acceptInts([1, 2, 3])
val base = [1, 2] val base = [1, 2]
acceptInts([...base, 3]) acceptInts([...base, 3])
""".trimIndent()) """.trimIndent()
eval(""" )
eval(
"""
fun acceptReals<T: Real>(xs: List<T>) { } fun acceptReals<T: Real>(xs: List<T>) { }
acceptReals([1.0, 2.0, 3.0]) acceptReals([1.0, 2.0, 3.0])
val base = [1.0, 2.0] val base = [1.0, 2.0]
acceptReals([...base, 3.0]) acceptReals([...base, 3.0])
""".trimIndent()) """.trimIndent()
)
assertFailsWith<net.sergeych.lyng.ScriptError> { assertFailsWith<net.sergeych.lyng.ScriptError> {
eval(""" eval(
"""
fun acceptInts<T: Int>(xs: List<T>) { } fun acceptInts<T: Int>(xs: List<T>) { }
acceptInts([1, "a"]) acceptInts([1, "a"])
""".trimIndent()) """.trimIndent()
)
} }
assertFailsWith<net.sergeych.lyng.ScriptError> { assertFailsWith<net.sergeych.lyng.ScriptError> {
eval(""" eval(
"""
fun acceptReals<T: Real>(xs: List<T>) { } fun acceptReals<T: Real>(xs: List<T>) { }
acceptReals([1.0, "a"]) acceptReals([1.0, "a"])
""".trimIndent()) """.trimIndent()
)
} }
} }
@Test @Test
fun testMapLiteralInferenceForBounds() = runTest { fun testMapLiteralInferenceForBounds() = runTest {
eval(""" eval(
"""
fun acceptMap<T: Int>(m: Map<String, T>) { } fun acceptMap<T: Int>(m: Map<String, T>) { }
acceptMap({ "a": 1, "b": 2 }) acceptMap({ "a": 1, "b": 2 })
val base = { "a": 1 } val base = { "a": 1 }
acceptMap({ ...base, "b": 3 }) acceptMap({ ...base, "b": 3 })
""".trimIndent()) """.trimIndent()
)
assertFailsWith<net.sergeych.lyng.ScriptError> { assertFailsWith<net.sergeych.lyng.ScriptError> {
eval(""" eval(
"""
fun acceptMap<T: Int>(m: Map<String, T>) { } fun acceptMap<T: Int>(m: Map<String, T>) { }
acceptMap({ "a": 1, "b": "x" }) acceptMap({ "a": 1, "b": "x" })
""".trimIndent()) """.trimIndent()
)
} }
} }
@Test @Test
fun testUnionTypeLists() = runTest { fun testUnionTypeLists() = runTest {
eval(""" eval(
"""
fun fMixed<T>(list: List<T>) { fun fMixed<T>(list: List<T>) {
println(list) println(list)
@@ -282,12 +318,14 @@ class TypesTest {
} }
fMixed([1, "two", true]) fMixed([1, "two", true])
fInts([1,2,3]) fInts([1,2,3])
""") """
)
} }
@Test @Test
fun testTypeAliases() = runTest { fun testTypeAliases() = runTest {
eval(""" eval(
"""
type Num = Int | Real type Num = Int | Real
type AB = A & B type AB = A & B
class A class A
@@ -308,12 +346,14 @@ class TypesTest {
type IntList<T: Int> = List<T> type IntList<T: Int> = List<T>
fun accept<T: Int>(xs: IntList<T>) { } fun accept<T: Int>(xs: IntList<T>) { }
accept([1,2,3]) accept([1,2,3])
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testMultipleReceivers() = runTest { fun testMultipleReceivers() = runTest {
eval(""" eval(
"""
class R1(shared,r1="r1") class R1(shared,r1="r1")
class R2(shared,r2="r2") class R2(shared,r2="r2")
@@ -340,69 +380,85 @@ class TypesTest {
assertEquals("r1", r1) assertEquals("r1", r1)
} }
} }
""") """
)
} }
@Test @Test
fun testLambdaTypes1() = runTest { fun testLambdaTypes1() = runTest {
val scope = Script.newScope() val scope = Script.newScope()
// declare: ok // declare: ok
scope.eval(""" scope.eval(
"""
var l1: (Int,String)->String var l1: (Int,String)->String
""".trimIndent()) """.trimIndent()
)
// this should be Lyng compile time exception // this should be Lyng compile time exception
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval(""" scope.eval(
"""
fun test() { fun test() {
// compiler should detect that l1 us called with arguments that does not match // compiler should detect that l1 us called with arguments that does not match
// declare type (Int,String)->String: // declare type (Int,String)->String:
l1() l1()
} }
""".trimIndent()) """.trimIndent()
)
} }
} }
@Test @Test
fun testLambdaTypesEllipsis() = runTest { fun testLambdaTypesEllipsis() = runTest {
val scope = Script.newScope() val scope = Script.newScope()
scope.eval(""" scope.eval(
"""
var l2: (Int,Object...,String)->Real var l2: (Int,Object...,String)->Real
var l4: (Int,String...,String)->Real var l4: (Int,String...,String)->Real
var l3: (...)->Int var l3: (...)->Int
""".trimIndent()) """.trimIndent()
)
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval(""" scope.eval(
"""
fun testTooFew() { fun testTooFew() {
l2(1) l2(1)
} }
""".trimIndent()) """.trimIndent()
)
} }
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval(""" scope.eval(
"""
fun testWrongHead() { fun testWrongHead() {
l2("x", "y") l2("x", "y")
} }
""".trimIndent()) """.trimIndent()
)
} }
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval(""" scope.eval(
"""
fun testWrongEllipsis() { fun testWrongEllipsis() {
l4(1, 2, "x") l4(1, 2, "x")
} }
""".trimIndent()) """.trimIndent()
)
} }
scope.eval(""" scope.eval(
"""
fun testOk1() { l2(1, "x") } fun testOk1() { l2(1, "x") }
fun testOk2() { l2(1, 2, 3, "x") } fun testOk2() { l2(1, 2, 3, "x") }
fun testOk3() { l3() } fun testOk3() { l3() }
fun testOk4() { l3(1, true, "x") } fun testOk4() { l3(1, true, "x") }
fun testOk5() { l4(1, "a", "b", "x") } fun testOk5() { l4(1, "a", "b", "x") }
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testSetTyped() = runTest { fun testSetTyped() = runTest {
eval(""" eval(
"""
var s = Set<String>() var s = Set<String>()
val typed: Set<String> = s val typed: Set<String> = s
assertEquals(Set(), typed) assertEquals(Set(), typed)
@@ -413,12 +469,14 @@ class TypesTest {
assertEquals(Set(), s) assertEquals(Set(), s)
s += ["foo", "bar"] s += ["foo", "bar"]
assertEquals(Set("foo", "bar"), s) assertEquals(Set("foo", "bar"), s)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testListTyped() = runTest { fun testListTyped() = runTest {
eval(""" eval(
"""
var l = List<String>() var l = List<String>()
val typed: List<String> = l val typed: List<String> = l
assertEquals(List(), typed) assertEquals(List(), typed)
@@ -430,13 +488,15 @@ class TypesTest {
l += ["foo", "bar"] l += ["foo", "bar"]
assertEquals(List("foo", "bar"), l) assertEquals(List("foo", "bar"), l)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testAliasesInGenerics1() = runTest { fun testAliasesInGenerics1() = runTest {
val scope = Script.newScope() val scope = Script.newScope()
scope.eval(""" scope.eval(
"""
type IntList<T: Int> = List<T> type IntList<T: Int> = List<T>
type IntMap<K,V> = Map<K,V> type IntMap<K,V> = Map<K,V>
type IntSet<T: Int> = Set<T> type IntSet<T: Int> = Set<T>
@@ -459,13 +519,16 @@ class TypesTest {
assertEquals(Set("tag1", "tag2", Buffer("tag3")), x.tags) assertEquals(Set("tag1", "tag2", Buffer("tag3")), x.tags)
x.tags += Buffer("tag4") x.tags += Buffer("tag4")
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4")), x.tags) assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4")), x.tags)
""") """
scope.eval(""" )
scope.eval(
"""
assert(x is X) assert(x is X)
x.tags += "42" x.tags += "42"
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4"), "42"), x.tags) assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4"), "42"), x.tags)
""".trimIndent()) """.trimIndent()
)
// now this must fail becaise element type does not match the declared: // now this must fail becaise element type does not match the declared:
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval( scope.eval(
@@ -479,7 +542,8 @@ class TypesTest {
@Test @Test
fun testAliasesInGenericsList1() = runTest { fun testAliasesInGenericsList1() = runTest {
val scope = Script.newScope() val scope = Script.newScope()
scope.eval(""" scope.eval(
"""
import lyng.buffer import lyng.buffer
type Tag = String | Buffer type Tag = String | Buffer
@@ -495,12 +559,15 @@ class TypesTest {
assertEquals(List("tag1", "tag2", Buffer("tag3")), x.tags) assertEquals(List("tag1", "tag2", Buffer("tag3")), x.tags)
x.tags += ["tag4", Buffer("tag5")] x.tags += ["tag4", Buffer("tag5")]
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5")), x.tags) assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5")), x.tags)
""") """
scope.eval(""" )
scope.eval(
"""
assert(x is X) assert(x is X)
x.tags += "42" x.tags += "42"
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5"), "42"), x.tags) assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5"), "42"), x.tags)
""".trimIndent()) """.trimIndent()
)
assertFailsWith<ScriptError> { assertFailsWith<ScriptError> {
scope.eval( scope.eval(
""" """
@@ -512,18 +579,21 @@ class TypesTest {
@Test @Test
fun testClassName() = runTest { fun testClassName() = runTest {
eval(""" eval(
"""
class X { class X {
var x = 1 var x = 1
} }
assert( X::class is Class) assert( X::class is Class)
assertEquals("Class", X::class.name) assertEquals("Class", X::class.name)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testGenericTypes() = runTest { fun testGenericTypes() = runTest {
eval(""" eval(
"""
fun t<T>(): String = fun t<T>(): String =
when(T) { when(T) {
null -> "%s is Null"(T::class.name) null -> "%s is Null"(T::class.name)
@@ -532,24 +602,28 @@ class TypesTest {
} }
assert( Int is Object) assert( Int is Object)
assertEquals( t<Int>(), "Class is Object") assertEquals( t<Int>(), "Class is Object")
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testGenericNullableTypePredicate() = runTest { fun testGenericNullableTypePredicate() = runTest {
eval(""" eval(
"""
fun isTypeNullable<T>(x: T): Bool = T is nullable fun isTypeNullable<T>(x: T): Bool = T is nullable
type MaybeInt = Int? type MaybeInt = Int?
assert(isTypeNullable<Int?>(null)) assert(isTypeNullable<Int?>(null))
assert(!isTypeNullable<Int>(1)) assert(!isTypeNullable<Int>(1))
assert(MaybeInt is nullable) assert(MaybeInt is nullable)
assert(!(Int is nullable)) assert(!(Int is nullable))
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testWhenNullableTypeCase() = runTest { fun testWhenNullableTypeCase() = runTest {
eval(""" eval(
"""
fun describe<T>(x: T): String = when(T) { fun describe<T>(x: T): String = when(T) {
nullable -> "nullable" nullable -> "nullable"
else -> "non-null" else -> "non-null"
@@ -562,11 +636,14 @@ class TypesTest {
assertEquals("non-null", describe<Int>(1)) assertEquals("non-null", describe<Int>(1))
assertEquals("nullable", describeIs<Int?>(null)) assertEquals("nullable", describeIs<Int?>(null))
assertEquals("non-null", describeIs<Int>(1)) assertEquals("non-null", describeIs<Int>(1))
""".trimIndent()) """.trimIndent()
)
} }
@Test fun testIndexer() = runTest { @Test
eval(""" fun testIndexer() = runTest {
eval(
"""
class Greeter { class Greeter {
override fun getAt(name) = "Hello, %s!"(name) override fun getAt(name) = "Hello, %s!"(name)
} }
@@ -581,11 +658,14 @@ class TypesTest {
assertEquals("How do you do, Bob?",Polite["Bob"]) assertEquals("How do you do, Bob?",Polite["Bob"])
""".trimIndent()) """.trimIndent()
)
} }
@Test fun testIndexer2() = runTest { @Test
eval(""" fun testIndexer2() = runTest {
eval(
"""
class Foo(bar) class Foo(bar)
class Greeter { class Greeter {
@@ -613,17 +693,65 @@ class TypesTest {
assertEquals("How do you do, Bob?",g2v.bar) assertEquals("How do you do, Bob?",g2v.bar)
assertEquals("How do you do, Bob?",Greeter2()["Bob"].bar) assertEquals("How do you do, Bob?",Greeter2()["Bob"].bar)
""".trimIndent()) """.trimIndent()
)
} }
@Test @Test
fun testExternGenerics() = runTest { fun testExternGenerics() = runTest {
eval(""" eval(
"""
extern fun f<T>(x: T): T extern fun f<T>(x: T): T
extern class Cell<T> { extern class Cell<T> {
var value: T var value: T
} }
""") """
)
}
class ObjFoo : Obj() {
override val objClass = klass
var value: Obj = ObjNull
companion object {
val klass = object : ObjClass("ObjFoo") {
override suspend fun callOn(scope: Scope): Obj {
return ObjFoo()
}
}.apply {
addProperty("bar", {
check(thisObj is ObjFoo)
thisAs<ObjFoo>().value
}, {
thisAs<ObjFoo>().value = args.firstAndOnly()
})
}
}
}
@Test
fun testExtensionToExternClasses() = runTest {
val scope = Script.newScope()
scope.addConst("Foo", ObjFoo.klass)
scope.eval(
"""
extern class Foo {
var bar
}
fun Foo.foobar() = "foo" + bar
val f = Foo()
f.bar = 42
assert( f is Foo )
assertEquals(42, f.bar)
assertEquals("foo42", f.foobar())
""".trimIndent()
)
} }
@Test @Test
@@ -0,0 +1,60 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.ObjChar
import net.sergeych.lyng.obj.ObjString
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class UnicodeEscapeTest {
@Test
fun parserDecodesUnicodeEscapeInStringLiteral() {
val token = parseLyng("\"\\u263A\"".toSource()).first()
assertEquals(Token.Type.STRING, token.type)
assertEquals("☺", token.value)
}
@Test
fun parserDecodesUnicodeEscapeInCharLiteral() {
val token = parseLyng("'\\u263A'".toSource()).first()
assertEquals(Token.Type.CHAR, token.type)
assertEquals("☺", token.value)
}
@Test
fun parserRejectsMalformedUnicodeEscapeInStringLiteral() {
assertFailsWith<ScriptError> {
parseLyng("\"\\u12G4\"".toSource())
}
}
@Test
fun parserRejectsShortUnicodeEscapeInCharLiteral() {
assertFailsWith<ScriptError> {
parseLyng("'\\u12'".toSource())
}
}
@Test
fun evalDecodesUnicodeEscapes() = runTest {
assertEquals(ObjString("☺"), eval("\"\\u263A\""))
assertEquals(ObjChar('☺'), eval("'\\u263A'"))
}
}
@@ -0,0 +1,138 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class BigDecimalModuleTest {
@Test
fun testDecimalModuleFactoriesAndConversions() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("12.34", BigDecimal.fromString("12.34").toStringExpanded())
assertEquals("1", BigDecimal.fromInt(1).toStringExpanded())
assertEquals("2.5", "2.5".d.toStringExpanded())
assertEquals("1", 1.d.toStringExpanded())
assertEquals("2.2", 2.2.d.toStringExpanded())
assertEquals("3", (1 + 2).d.toStringExpanded())
assertEquals("1.5", (1 + 0.5).d.toStringExpanded())
assertEquals("3", (1 + 2.d).toStringExpanded())
assertEquals("3", (2.d + 1).toStringExpanded())
assertEquals(2.5, "2.5".d.toReal())
assertEquals(2, "2.5".d.toInt())
assertEquals(2.2, 2.2.d.toReal())
assertEquals("0.30000000000000004", (0.1 + 0.2).d.toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalModuleMixedIntOperators() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals(3.d, 1 + 2.d)
assertEquals(3.d, 2.d + 1)
assertEquals(1.d, 3 - 2.d)
assertEquals(1.d, 3.d - 2)
assertEquals(8.d, 4 * 2.d)
assertEquals(8.d, 4.d * 2)
assertEquals(4.d, 8 / 2.d)
assertEquals(4.d, 8.d / 2)
assertEquals(1.d, 7 % 2.d)
assertEquals(1.d, 7.d % 2)
assert(1 < 2.d)
assert(2 <= 2.d)
assert(3 > 2.d)
assert(3.d > 2)
assert(2 == 2.d)
assert(2.d == 2)
""".trimIndent()
)
}
@Test
fun testDecimalDivisionUsesDefaultContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.125", (1.d / 8.d).toStringExpanded())
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.6666666666666666666666666666666667", ("2".d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testWithDecimalContextOverridesDivisionContext() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
assertEquals("0.3333333333", withDecimalContext(10) { (1.d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(6) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.666667", withDecimalContext(DecimalContext(6)) { ("2".d / 3.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(DecimalContext(2, DecimalRounding.HalfAwayFromZero)) { (1.d / 8.d).toStringExpanded() })
assertEquals("0.3333333333333333333333333333333333", (1.d / 3.d).toStringExpanded())
""".trimIndent()
)
}
@Test
fun testDecimalDivisionRoundingMatrix() = runTest {
val scope = Script.newScope()
scope.eval(
"""
import lyng.decimal
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfEven) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.HalfAwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.Ceiling) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.Ceiling) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.Floor) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.Floor) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.13", withDecimalContext(2, DecimalRounding.AwayFromZero) { (-1.d / 8.d).toStringExpanded() })
assertEquals("0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (1.d / 8.d).toStringExpanded() })
assertEquals("-0.12", withDecimalContext(2, DecimalRounding.TowardsZero) { (-1.d / 8.d).toStringExpanded() })
""".trimIndent()
)
}
}
@@ -212,6 +212,96 @@ class DelegationTest {
assertTrue(badThrown) assertTrue(badThrown)
} }
@Test
fun testPureLyngLazyPreservesReceiverAndClosure() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val GLOBAL_NUMBERS = [1,2,3]
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset
override fun bind(name: String, access, thisRef: ThisRefType): Object = this
override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset)
value = creator(thisRef)
value as T
}
}
fun pureLazy<T,ThisRefType=Object>(creator: ThisRefType.()->T): Delegate<T,ThisRefType> = PureLazy(creator)
class A {
val numbers = [1,2,3]
val fromThis: List by pureLazy { this.numbers }
val fromScope: List by pureLazy { GLOBAL_NUMBERS }
}
class B {
val a: A by pureLazy { A() }
val test: List by pureLazy { (a as A).fromThis + [4] }
}
assertEquals([1,2,3], A().fromThis)
assertEquals([1,2,3], A().fromScope)
assertEquals([1,2,3,4], B().test)
""".trimIndent()
)
}
@Test
fun testImportedPureLyngLazyPreservesReceiverAndClosure() = runTest {
val scope = Script.newScope()
scope.importManager.addTextPackages(
"""
package repro.lazy
import lyng.stdlib
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
if (access != DelegateAccess.Val) throw "lazy delegate can only be used with 'val'"
this
}
override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset)
value = with(thisRef, creator)
value as T
}
}
""".trimIndent()
)
scope.eval(
"""
import repro.lazy
val GLOBAL_NUMBERS = [1,2,3]
class A {
val numbers = [1,2,3]
val fromThis: List by PureLazy { this.numbers }
val fromScope: List by PureLazy { GLOBAL_NUMBERS }
}
class B {
val a: A by PureLazy { A() }
val test: List by PureLazy { (a as A).fromThis + [4] }
}
assertEquals([1,2,3], A().fromThis)
assertEquals([1,2,3], A().fromScope)
assertEquals([1,2,3,4], B().test)
""".trimIndent()
)
}
@Test @Test
fun testLazyIsDelegate() = runTest { fun testLazyIsDelegate() = runTest {
eval(""" eval("""
@@ -0,0 +1,111 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
class OperatorInteropTest {
@Test
fun testPureLyngOperatorInteropRegistration() = runTest {
val im = Script.defaultImportManager.copy()
im.addPackage("test.decimalbox") { scope ->
scope.eval(
"""
package test.decimalbox
import lyng.operators
class DecimalBox(val value: Int) {
fun plus(other: DecimalBox) = DecimalBox(value + other.value)
fun minus(other: DecimalBox) = DecimalBox(value - other.value)
fun mul(other: DecimalBox) = DecimalBox(value * other.value)
fun div(other: DecimalBox) = DecimalBox(value / other.value)
fun mod(other: DecimalBox) = DecimalBox(value % other.value)
fun compareTo(other: DecimalBox) = value <=> other.value
}
OperatorInterop.register(
Int,
DecimalBox,
DecimalBox,
[BinaryOperator.Plus, BinaryOperator.Minus, BinaryOperator.Mul, BinaryOperator.Div, BinaryOperator.Mod, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Int -> DecimalBox(x) },
{ x: DecimalBox -> x }
)
""".trimIndent()
)
}
val scope = im.newStdScope()
scope.eval(
"""
import test.decimalbox
assertEquals(DecimalBox(3), 1 + DecimalBox(2))
assertEquals(DecimalBox(1), 3 - DecimalBox(2))
assertEquals(DecimalBox(8), 4 * DecimalBox(2))
assertEquals(DecimalBox(4), 8 / DecimalBox(2))
assertEquals(DecimalBox(1), 7 % DecimalBox(2))
assert(1 < DecimalBox(2))
assert(2 <= DecimalBox(2))
assert(3 > DecimalBox(2))
assert(2 >= DecimalBox(2))
assert(2 == DecimalBox(2))
assert(2 != DecimalBox(3))
""".trimIndent()
)
}
@Test
fun testRealInteropRegistrationUsesTopLevelModuleCode() = runTest {
val im = Script.defaultImportManager.copy()
im.addPackage("test.realbox") { scope ->
scope.eval(
"""
package test.realbox
import lyng.operators
class RealBox(val value: Real) {
fun plus(other: RealBox) = RealBox(value + other.value)
fun compareTo(other: RealBox) = value <=> other.value
}
OperatorInterop.register(
Real,
RealBox,
RealBox,
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Real -> RealBox(x) },
{ x: RealBox -> x }
)
""".trimIndent()
)
}
val scope = im.newStdScope()
scope.eval(
"""
import test.realbox
assertEquals(RealBox(1.75), 0.5 + RealBox(1.25))
assert(1.5 < RealBox(2.0))
assert(2.0 == RealBox(2.0))
""".trimIndent()
)
}
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on JS
}
@@ -0,0 +1,46 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
import java.io.File
import java.time.Instant
private val vmIterLogFilePath: String =
System.getenv("LYNG_VM_DEBUG_LOG")
?.takeIf { it.isNotBlank() }
?: "/tmp/lyng_vm_iter_debug.log"
private val vmIterLogLock = Any()
internal actual fun vmIterDebug(message: String, error: Throwable?) {
runCatching {
val line = buildString {
append(Instant.now().toString())
append(" [vm-iter] ")
append(message)
append('\n')
if (error != null) {
append(error.stackTraceToString())
append('\n')
}
}
synchronized(vmIterLogLock) {
File(vmIterLogFilePath).appendText(line)
}
}
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on Native
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on wasmJs
}
+42 -29
View File
@@ -8,22 +8,22 @@ extern class IllegalArgumentException
extern class NotImplementedException extern class NotImplementedException
extern class Delegate extern class Delegate
extern class Iterable<T> { extern class Iterable<T> {
extern fun iterator(): Iterator<T> fun iterator(): Iterator<T>
extern fun forEach(action: (T)->void): void fun forEach(action: (T)->void): void
extern fun map<R>(transform: (T)->R): List<R> fun map<R>(transform: (T)->R): List<R>
extern fun toList(): List<T> fun toList(): List<T>
extern fun toImmutableList(): ImmutableList<T> fun toImmutableList(): ImmutableList<T>
extern val toSet: Set<T> val toSet: Set<T>
extern val toImmutableSet: ImmutableSet<T> val toImmutableSet: ImmutableSet<T>
extern val toMap: Map<Object,Object> val toMap: Map<Object,Object>
extern val toImmutableMap: ImmutableMap<Object,Object> val toImmutableMap: ImmutableMap<Object,Object>
} }
extern class Iterator<T> { extern class Iterator<T> {
extern fun hasNext(): Bool fun hasNext(): Bool
extern fun next(): T fun next(): T
extern fun cancelIteration(): void fun cancelIteration(): void
extern fun toList(): List<T> fun toList(): List<T>
} }
// Host-provided iterator wrapper for Kotlin collections. // Host-provided iterator wrapper for Kotlin collections.
@@ -33,47 +33,47 @@ class KotlinIterator<T> : Iterator<T> {
} }
extern class Collection<T> : Iterable<T> { extern class Collection<T> : Iterable<T> {
extern val size: Int val size: Int
} }
extern class Array<T> : Collection<T> { extern class Array<T> : Collection<T> {
} }
extern class ImmutableList<T> : Array<T> { extern class ImmutableList<T> : Array<T> {
extern fun toMutable(): List<T> fun toMutable(): List<T>
} }
extern class List<T> : Array<T> { extern class List<T> : Array<T> {
extern fun add(value: T, more...): void fun add(value: T, more...): void
extern fun toImmutable(): ImmutableList<T> fun toImmutable(): ImmutableList<T>
} }
extern class RingBuffer<T> : Iterable<T> { extern class RingBuffer<T> : Iterable<T> {
extern val size: Int val size: Int
extern fun first(): T fun first(): T
extern fun add(value: T): void fun add(value: T): void
} }
extern class Set<T> : Collection<T> { extern class Set<T> : Collection<T> {
extern fun toImmutable(): ImmutableSet<T> fun toImmutable(): ImmutableSet<T>
} }
extern class ImmutableSet<T> : Collection<T> { extern class ImmutableSet<T> : Collection<T> {
extern fun toMutable(): Set<T> fun toMutable(): Set<T>
} }
extern class Map<K,V> : Collection<MapEntry<K,V>> { extern class Map<K,V> : Collection<MapEntry<K,V>> {
extern fun toImmutable(): ImmutableMap<K,V> fun toImmutable(): ImmutableMap<K,V>
} }
extern class ImmutableMap<K,V> : Collection<MapEntry<K,V>> { extern class ImmutableMap<K,V> : Collection<MapEntry<K,V>> {
extern fun getOrNull(key: K): V? fun getOrNull(key: K): V?
extern fun toMutable(): Map<K,V> fun toMutable(): Map<K,V>
} }
extern class MapEntry<K,V> : Array<Object> { extern class MapEntry<K,V> : Array<Object> {
extern val key: K val key: K
extern val value: V val value: V
} }
// Built-in math helpers (implemented in host runtime). // Built-in math helpers (implemented in host runtime).
@@ -81,6 +81,20 @@ extern fun abs(x: Object): Real
extern fun ln(x: Object): Real extern fun ln(x: Object): Real
extern fun pow(x: Object, y: Object): Real extern fun pow(x: Object, y: Object): Real
extern fun sqrt(x: Object): Real extern fun sqrt(x: Object): Real
extern fun clamp<T>(value: T, range: Range<T>): T
class SeededRandom {
extern fun nextInt(): Int
extern fun nextFloat(): Real
extern fun next<T>(range: Range): T
}
extern object Random {
extern fun nextInt(): Int
extern fun nextFloat(): Real
extern fun next<T>(range: Range): T
extern fun seeded(seed: Int): SeededRandom
}
// Last regex match result, updated by =~ / !~. // Last regex match result, updated by =~ / !~.
var $~: Object? = null var $~: Object? = null
@@ -407,7 +421,6 @@ fun with<T,R>(self: T, block: T.()->R): R {
Can only be used with 'val' properties. Can only be used with 'val' properties.
*/ */
class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> { class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset private var value = Unset
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object { override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
@@ -417,7 +430,7 @@ class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,T
override fun getValue(thisRef: ThisRefType, name: String): T { override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset) if (value == Unset)
value = with(thisRef,creator) value = with(thisRef, creatorParam)
value as T value as T
} }
} }
+3 -2
View File
@@ -12,9 +12,10 @@ Current focus
Key recent changes Key recent changes
- Updated AI helper docs to reflect static typing, type expressions, and compile-time-only name resolution. - Updated AI helper docs to reflect static typing, type expressions, and compile-time-only name resolution.
- Added stdlib random API: `Random` and deterministic `SeededRandom` with `nextInt`, `nextFloat`, and generic `next(range)`.
Known failing tests Known failing tests
- Not checked in this session. - None in :lynglib:jvmTest after Random/SeededRandom integration.
Last test run Last test run
- Not checked in this session. - `./gradlew :lynglib:jvmTest` (PASS).
@@ -0,0 +1,69 @@
# :lynglib Compiler and VM Review (2026-03-26)
## Scope
- Reviewed `:lynglib` compiler and bytecode VM paths, focusing on compile/execution correctness.
- Read core files around `Compiler`, `Script`, `BytecodeCompiler`, `CmdRuntime`, `Scope`, `ModuleScope`, and capture/slot plumbing.
- Ran `./gradlew :lynglib:jvmTest` on 2026-03-26: PASS.
## Findings
### 1. High: local seeding uses the wrong slot index when checking for self-referential `FrameSlotRef`
- Status: fixed in worktree on 2026-03-26; covered by `SeedLocalsRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/SeedLocals.kt:39`
- The self-reference guard compares `FrameSlotRef` against `base + i`, but `FrameSlotRef` stores the underlying `BytecodeFrame` local slot index, not the VM absolute slot id.
- The same slot is then written using `setObjUnchecked(base + i, value)` at `SeedLocals.kt:42`, which means a self-reference is not filtered out before being reinserted.
- Impact: this can seed a local with a reference to itself, creating recursive `FrameSlotRef` chains. Reads then recurse through `BytecodeFrame.getObj()` / `FrameSlotRef.read()` instead of resolving to a value, which is a realistic path to stack overflow or non-terminating execution in bytecode-only helper execution (`executeBytecodeWithSeed`).
- Why this looks real: the equivalent check in `CmdFrame.applyCaptureRecords()` uses the local index directly (`CmdRuntime.kt:3867`), and `Script.seedModuleLocals()` also compares with the local index, not `scopeSlotCount + i` (`Script.kt:109`).
- Suggested fix: compare with `i`, not `base + i`, and add a regression test around `executeBytecodeWithSeed` seeding a scope that already contains a `FrameSlotRef` to the same local.
### 2. Design note: script-specific import/module preparation should stay explicit, not hidden in `execute(scope)`
- Status: resolved by API addition, without changing `Script.execute(scope)` semantics.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt:51-57`
- `shouldSeedModule` is only true when `execScope` is a `ModuleScope` or `thisObj === ObjVoid`.
- If a compiled script is executed against a non-module scope with a real receiver object, `seedModuleSlots()` is skipped entirely, so script imports and explicit module bindings are never installed into `moduleTarget`.
- Original concern: top-level bytecode that expects imported names or module globals can see different behavior depending on whether the host prepared the target scope explicitly.
- Resolution taken: do **not** change `Script.execute(scope)`, because in this codebase it is expected to run on exactly the provided scope and many embedding flows already rely on explicit scope setup via `Script.newScope()`, `Scope.eval(...)`, `addFn(...)`, `addConst(...)`, and direct import-manager configuration.
- New explicit APIs added instead:
- `Script.importInto(scope, seedScope = scope)`
- `Script.instantiateModule(seedScope = null, pos = script.pos)`
- This keeps existing execution behavior stable while giving hosts an opt-in way to apply a script's import/module bindings when they actually want that preparation step.
- Coverage added: `ScriptImportPreparationTest`.
### 3. Medium: missing module captures are silently converted into fresh `Unset` slots
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdRuntime.kt:3950-3970`
- In `CmdFrame.buildCaptureRecords()`, the module-capture path first tries several lookups. If the requested `slotId` is missing but the capture has a `name`, it calls `target.applySlotPlan(mapOf(name to slotId))` and immediately returns `target.getSlotRecord(slotId)`.
- That record is a newly created placeholder from `Scope.applySlotPlan()` (`Scope.kt:460-471`) and defaults to `ObjUnset`.
- Impact: a compiler/runtime disagreement in capture resolution is masked as a normal capture of `Unset`, so the failure moves far away from closure creation and becomes data corruption or an unrelated later exception. This will be difficult to debug when it happens.
- Resolution taken: the VM now refuses to treat synthetic placeholder slots as real module/captured bindings. Reads and capture construction fail with a source-positioned `ScriptError` when the execution scope was not prepared with the script's required module/import bindings.
### 4. Medium: subject-less `when { ... }` still crashes through a raw Kotlin `TODO`
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt:6447-6449`
- The unsupported branch uses `TODO("when without object is not yet implemented")`.
- Current docs explicitly say subject-less `when` is not implemented, so the language limitation itself is documented. The problem is the failure mode: the compiler throws a raw Kotlin `NotImplementedError` instead of a normal `ScriptError` or a feature diagnostic.
- Impact: IDE/embedding callers get an implementation exception rather than a source-positioned language error, which is especially bad across non-JVM targets and for editor tooling.
- Resolution taken: the parser now throws a normal `ScriptError` at the `when` position with an explicit "when without subject is not implemented" message.
## Risks Worth Checking Next
### 5. Medium risk: module frame growth only retargets records stored in `objects`/`localBindings`
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/ModuleScope.kt:39-67`
- When `ensureModuleFrame()` replaces the old `BytecodeFrame` with a larger one, it retargets `FrameSlotRef`s only in `objects` and `localBindings`.
- Existing closures/capture records that already hold `FrameSlotRef(oldFrame, slot)` are not retargeted here.
- Impact: if a module scope survives across recompilation/re-execution with a larger local frame, previously exported closures can keep reading stale values from the old frame instance.
- Confidence is lower because this depends on module reuse across differing compiled shapes, but the reference-retargeting logic is clearly incomplete for that scenario.
- Suggested check: add a regression covering module re-execution with increased local count and an exported closure captured before the resize.
## Test Status
- `./gradlew :lynglib:jvmTest` passed during this review.
- `./gradlew :lynglib:jvmTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after the fixes/API additions.
- `./gradlew :lynglib:jvmTest --tests CompilerVmReviewRegressionTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after fixing findings 3 and 4.
- Finding 1 is covered directly; finding 2 is covered by explicit preparation API tests.
## Suggested Fix Order
1. Fix finding 1 first: it is a concrete slot-index bug with likely recursive failure modes. Done.
2. Keep `Script.execute(scope)` semantics stable and use explicit preparation APIs where script-owned import/module setup is needed. Done.
3. Tighten finding 3 next: fail fast on capture mismatches. Done.
4. Replace the raw `TODO` in finding 4 so unsupported syntax produces normal diagnostics. Done.
5. Decide whether finding 5 matters for current module-reload workflows; add a regression before changing behavior.
+46
View File
@@ -0,0 +1,46 @@
WASM использует стековую модель памяти. Lyng стеки не использует. В чем разница?
Стек это очень древняя структура, была придумана в 1955 (магазинная память Бауэра и Самельсона), и приняла современную форму в 1960, благодаря Барбаре Лисокв, вполседствии лауреата премии Тьюринга, которого, в свою очередь, за выдающийся вклад в развитие IT кастрировали, формально, за гомосексуализм, но в британии, где на трех джентльменов приходилось тогда, и приходится и теперь, четыре гомосексуала, все понимают, что это был просто предлог.
Стек был прекрасен в 60е годы, когда IBM планировала продавать по компьютеру в год в лучшем случае, а за идеи о микропроцессорах или ядрах можно было устроиться только пациентом психушки. Стек это заранее жестко выделенная область памяти, которая обычно вообще не используется, и по ней в одну сторону растет используемая область, которая хранит локальные переменные, адреса возврата и иногда состояние процессора.
Она крайне плохо подходит для многозадачности. Представь себе что у тебя есть wasm процесс, со своим стеком, и ему надо переключиться, остановив текущий поток исполнения (например, он ждет ответа от сети). Тогда тебе придется создать _новый стек_ — пока еще пустой, переключиться на него и исполнять там другую задачу. Сколько потоков - столько и стеков. И все они по большей части не используются — там просто запас памяти "на вырост", если исполнение потребует. А оценить заранее адекватно почти невозможно, дают с запасом.
Далее, васм использует фиксированную память выделенную на процесс. Ее тоже приходится брать "с запасом", так как если по ходу не хватит, процесс вылетит. И она тоже в изрядной части пустая. Ну и назасладочку, васм был задуман однозадачным, и все попытки туда хотя бы треды засунуть, получаются очень кривыми.
Линг использует фреймы и сопрограммы. Линг вообще треды не использует. Основная команда исполнения программы на линге - сопрограмма (coroutine), ей не нужен стейк, она им не пользуется. Вместо этого каждый вызов в линге, грубо говоря, это вызов сопрограммы. Для него формируется фрейм (не на стеке, а в динамической памяти!), которого гарантировано достаточно для исполнения собственно кода. Он заменяет собой "стековый фрейм", но его размер известен заранее, и его можно распределять и освобождать проще, как обычную динамическую память.
Далее, линг использует ту же динамическую память, что и его родительская платформа. Если он работает на Java, то использует память со сборкой мусора JVM, на Javascript - память машины JS, в нативных машинах - специальнй менеджер памяти со сборкой мусора, от Kotlin Native (довольно хороший и очень быстро развивающийся). В результате, запустить одновременно десять, или сто тысяч программ на лигне, которые будут исполняться конкурентно, вполне реально. Просто попытка запустить 10к васм-машин на v8 или другом движке скорее всего убьет систему, да и 10 тысяч тредов редко какой сервер приложению даст. Огромный перерасход ресурсов и тормоза.
Далее. Васм СТЕКОВАЯ машина со стековыми командами, он без стека вообще не может. Посмотрим как он считает примитивное выражение:
```wasm
(module
;; Экспортируем функцию, чтобы её можно было вызвать из JS
(func (export "calc") (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32)
;; --- вычисление (a + b) / c * d ---
local.get $a ;; помещаем a на стек
local.get $b ;; помещаем b на стек
i32.add ;; складываем: стек содержит (a+b)
local.get $c ;; помещаем c
i32.div_s ;; знаковое деление: стек содержит ((a+b) / c)
local.get $d ;; помещаем d
i32.mul ;; умножение: стек содержит (((a+b)/c) * d)
;; результат остаётся на стеке — это возвращаемое значение функции
)
)
```
На ВМ Линга нет стека, он трехадресный универсальный ассемблер, если можно так сказать:
```
add_int s1, s2 -> s5 // a + b -> s5
div_int s5, s3 -> s5 // s5 -> s5 / c
mul_int s5, s4 -> s5 // s5 -> s5 * d
return s5
```
Этот код крайне эффективно реализуется на любом реальном процессоре, и хорошо оптимизируется. Исполняется он без всякого стека.
+21
View File
@@ -0,0 +1,21 @@
Почему не WASM?
- wasm очень громоздкий и неудобный для разработки, он проектировался очень давно и с другими целями, так что сейчас его безуспешно пытаются "перезаточить" в современные области, но он поддается с трудом. Компилировать в wasm была бы задача по сложности превосходящая весь проект, а результат был бы уныл: мы и так имеем все достоинсва wasm, полезные для Lyng, но не имеем многих его недостатков.
Виртуалка lyng легкая, и доступна на всех платформах уже сейчас, а вот прикрутить скажем wasm машину к котлину на сервере, чтобы она работала как сопрограммы первого класса вместе с котлинскими, задача сейчас неразрешимая.
То есть, преимущества wasm что он доступен на многих платформах, для нас неважно - мы и так на тех же платформах имеем полную поддержку.
- Lyng VM изначально заточена на исполнение именно сопрограмм со сборкой мусора. Эти два ключевых механизма линга практически отсутствуют в wasm, их мучительно прикручивают как расширения, и они довольно слабо поддерживаются.
- LyngVM заточен на исполнение программ с гибридной ООП-ФП моделью, она хорошо поддерживает множественное наследование, делегацию, работу со сложными списками аргументов (ФП фичи, подстановки, деструктурирование), на васме это очень непросто написать, будет медленно и громоздко.
- одна из целей Lyng была получить быстрое безопасное и очень мощное скриптовое решение для вклучения в проекты на Java/Kotlin multiplatform. На wasm это в принципе невозможно - его включение это кошмар, он громоздкий. К тому же требует компиляции, а Lyng работает с JIT (исполняет прямо исходник, компилируя его на лету, как JS), и может использоваться как скрипт (wasm не может)
- типы данных которые мы используем в Lyng в WASM отсутстсвтуют, их бы пришлось добавлять
В результате если бы мы компилировали Lyng->WASM мы бы получили огромный и медленный код. Для которого потребовалась бы огромная wasm VM. Практического смысла в этом нет.
Если же ты рассматриваешь идею в единой платформе использовать разные языки, а wasm как промежуточный язых совместимости, то это собственно противоречит идее использовать общую кодовую базу и интерфейсы. Разные языки имеют несовпадающие, несовместимые интерфейсы вызовов, так что приходится писать руками биндинги, которые не добавляют скорости и добавляют ошибки, к тому же, разные языки предоставляют часто вообще несовместимые модели программирования (например прототипы в JS, множественное наследование С++ или Линга и кошмар на улице вязов от руста, в владением ссылками).
Платформ на васме полно, и там и ловить нечего, и неинтересно. Я же предлагаю вылезти в другой класс. Навеяно реальным опоытом переносов контрактов из старого золота в мольтпей, которое получается на удивление хорошо
+91 -77
View File
@@ -27,74 +27,85 @@ import org.jetbrains.compose.web.dom.*
fun HomePage() { fun HomePage() {
val samples = remember { val samples = remember {
listOf( listOf(
"""
// Decimal arithmetic with explicit local precision
import lyng.decimal
val exact = "0.3".d
val fromReal = (0.1 + 0.2).d
println(exact.toStringExpanded())
println(fromReal.toStringExpanded())
println(withDecimalContext(10) { (1.d / 3.d).toStringExpanded() })
""".trimIndent(),
"""
// Mixed operators for your own type
import lyng.operators
class Coins(val amount: Int) {
fun plus(other: Coins) = Coins(amount + other.amount)
fun compareTo(other: Coins) = amount <=> other.amount
}
OperatorInterop.register(
Int,
Coins,
Coins,
[BinaryOperator.Plus, BinaryOperator.Compare, BinaryOperator.Equals],
{ x: Int -> Coins(x) },
{ x: Coins -> x }
)
println(1 + Coins(2))
println(3 > Coins(2))
""".trimIndent(),
"""
// Non-local returns from closures
fun findFirst<T>(list: Iterable<T>, predicate: (T)->Bool): T? {
list.forEach {
if (predicate(it)) return@findFirst it
}
null
}
val found: Int? = findFirst([1, 5, 8, 12]) { it > 10 }
println("Found: " + found)
""".trimIndent(),
"""
// Implicit coroutines: parallelism without ceremony
import lyng.time
val d1 = launch {
delay(100.milliseconds)
"Task A finished"
}
val d2 = launch {
delay(50.milliseconds)
"Task B finished"
}
println(d1.await())
println(d2.await())
""".trimIndent(),
""" """
// Everything is an expression // Everything is an expression
val x: Int = 10 val x: Int = 10
val status: String = if (x > 0) "Positive" else "Zero or Negative" val status: String = if (x > 0) "Positive" else "Zero or Negative"
// Even loops return values!
val result = for (i in 1..5) { val result = for (i in 1..5) {
if (i == 3) break "Found 3!" if (i == 3) break "Found 3!"
} else "Not found" } else "Not found"
println("Result: " + result) println(status)
println(result)
""".trimIndent(), """.trimIndent(),
""" """
// Functional power with generics and collections // Functional collections with strict static types
val squares: List<Int> = (1..10) val squares: List<Int> = (1..10)
.filter { it % 2 == 0 } .filter { it % 2 == 0 }
.map { it * it } .map { it * it }
println("Even squares: " + squares) println("Even squares: " + squares)
// Output: [4, 16, 36, 64, 100]
""".trimIndent(),
"""
// Generics and type aliases
type Num = Int | Real
class Box<out T: Num>(val value: T) {
fun get(): T = value
}
val intBox = Box(42)
val realBox = Box(3.14)
println("Boxes: " + intBox.get() + ", " + realBox.get())
""".trimIndent(),
"""
// Strict compile-time types and symbol resolution
fun greet(name: String, count: Int) {
for (i in 1..count) {
println("Hello, " + name + "!")
}
}
greet("Lyng", 3)
// greet(10, "error") // This would be a compile-time error!
""".trimIndent(),
"""
// Flexible map literals and shorthands
val id = 101
val name = "Lyng"
val base = { id:, name: } // Shorthand for id: id, name: name
val full = { ...base, version: "1.5.0-SNAPSHOT", status: "active" }
println(full)
""".trimIndent(),
"""
// Modern null safety
var config: Map<String, Int>? = null
config ?= { timeout: 30 } // Assign only if null
val timeout = config?["timeout"] ?: 60
println("Timeout is: " + timeout)
""".trimIndent(),
"""
// Destructuring with splat operator
val [first, middle..., last] = [1, 2, 3, 4, 5, 6]
println("First: " + first)
println("Middle: " + middle)
println("Last: " + last)
""".trimIndent(), """.trimIndent(),
""" """
// Diamond-safe Multiple Inheritance (C3 MRO) // Diamond-safe Multiple Inheritance (C3 MRO)
@@ -123,18 +134,6 @@ fun HomePage() {
println([10, 20, 30].second) println([10, 20, 30].second)
""".trimIndent(), """.trimIndent(),
""" """
// Non-local returns from closures
fun findFirst<T>(list: Iterable<T>, predicate: (T)->Bool): T? {
list.forEach {
if (predicate(it)) return@findFirst it
}
null
}
val found: Int? = findFirst([1, 5, 8, 12]) { it > 10 }
println("Found: " + found)
""".trimIndent(),
"""
// Easy operator overloading // Easy operator overloading
class Vector(val x: Real, val y: Real) { class Vector(val x: Real, val y: Real) {
fun plus(other: Vector): Vector = Vector(x + other.x, y + other.y) fun plus(other: Vector): Vector = Vector(x + other.x, y + other.y)
@@ -156,20 +155,13 @@ fun HomePage() {
println("User name: " + u.name) println("User name: " + u.name)
""".trimIndent(), """.trimIndent(),
""" """
// Implicit coroutines: parallelism without ceremony // Flexible map literals and shorthands
import lyng.time val id = 101
val name = "Lyng"
val base = { id:, name: }
val full = { ...base, status: "active", tags: ["typed", "portable"] }
val d1 = launch { println(full)
delay(100.milliseconds)
"Task A finished"
}
val d2 = launch {
delay(50.milliseconds)
"Task B finished"
}
println(d1.await())
println(d2.await())
""".trimIndent() """.trimIndent()
) )
} }
@@ -195,6 +187,8 @@ fun HomePage() {
Div({ classes("d-flex", "justify-content-center", "gap-2", "flex-wrap", "mb-4") }) { Div({ classes("d-flex", "justify-content-center", "gap-2", "flex-wrap", "mb-4") }) {
// Benefits pills // Benefits pills
listOf( listOf(
"Decimal arithmetic",
"Operator interop",
"Strict static typing", "Strict static typing",
"Generics & Type Aliases", "Generics & Type Aliases",
"Implicit coroutines", "Implicit coroutines",
@@ -233,6 +227,26 @@ fun HomePage() {
} }
} }
Div({ classes("row", "g-3", "mb-4") }) {
listOf(
Triple("New: Decimal", "Exact decimal values, local precision control, and mixed operators with Int and Real.", "#/docs/Decimal.md"),
Triple("New: Operator Interop", "Teach Lyng how your custom types interact with built-ins on the left-hand side.", "#/docs/OperatorInterop.md"),
Triple("What Changed", "Recent language, stdlib, and tooling improvements in one place.", "#/docs/whats_new.md")
).forEach { (title, text, href) ->
Div({ classes("col-12", "col-lg-4") }) {
A(attrs = {
classes("text-decoration-none")
attr("href", href)
}) {
Div({ classes("h-100", "p-3", "border", "rounded-3", "bg-body-tertiary") }) {
H3({ classes("h5", "mb-2", "text-body") }) { Text(title) }
P({ classes("mb-0", "text-muted") }) { Text(text) }
}
}
}
}
}
// Code sample slideshow // Code sample slideshow
Div({ Div({
classes("markdown-body", "mt-0", "slide-container", "position-relative") classes("markdown-body", "mt-0", "slide-container", "position-relative")
+1 -1
View File
@@ -339,7 +339,7 @@
<!-- Top-left version ribbon --> <!-- Top-left version ribbon -->
<div class="corner-ribbon bg-danger text-white"> <div class="corner-ribbon bg-danger text-white">
<span style="margin-left: -5em"> <span style="margin-left: -5em">
v1.5.0-SNAPSHOT! v1.5.1
</span> </span>
</div> </div>
<!-- Fixed top navbar for the whole site --> <!-- Fixed top navbar for the whole site -->
Binary file not shown.

After

Width:  |  Height:  |  Size: 124 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 115 KiB

+189
View File
@@ -0,0 +1,189 @@
# Lyng as a Common Platform for Smart Contracts and Distributed Execution
## Executive Summary
This proposal describes Lyng as a shared execution layer for:
- smart contracts across different blockchain networks,
- distributed compute workflows,
- decentralized application logic.
The goal is simple: write business logic once in Lyng, then run it consistently across chains, trusted execution nodes, and off-chain workers.
## Why a Common Lyng Layer
A unified language and runtime reduces fragmentation between contract code, off-chain services, and automation scripts.
Key benefits:
- One language across environments: the same Lyng code can be reused in contracts, validators, and distributed tasks.
- Capability-safe by default: no filesystem, process, or host access unless explicitly exposed by the host platform.
- Async-first execution model: lightweight concurrent tasks are natural, and host runtimes can schedule them efficiently.
- Strong typing with inference: concise source code without sacrificing type safety.
- Deterministic execution options: instruction/gas counting can be enabled for metered environments.
- Broad platform support: JVM, JS/Wasm, and native targets enable consistent tooling and deployment.
## Where It Fits
Lyng is a strong fit for:
- contract logic that must also run in simulation or off-chain verification,
- distributed orchestration and rule-based automations,
- cross-network shared libraries (validation, accounting rules, policy checks),
- deterministic business logic that should be portable between operators.
## Proposed Architecture
1. **Primary runtime**: Lyng VM/JIT for high-throughput trusted execution.
2. **Metered runtime**: Lyng VM mode with instruction counting and gas limits for blockchain execution.
3. **Standard API surface**:
- core Lyng standard library,
- storage contract (`key/value/tags`) shared across network adapters.
4. **Developer sandbox**:
- local deterministic sandbox for test/debug,
- optional feature-rich sandbox profile for integration testing.
## Strong Parts of the Lyng Approach
- **Code portability**: contract logic and off-chain logic remain aligned.
- **Lower maintenance**: fewer language/runtime rewrites across components.
- **Faster onboarding**: modern, readable syntax and concise constructs.
- **Safer host integration**: explicit capability injection limits accidental exposure.
- **Operational flexibility**: same package can run in metered or non-metered mode.
## Example: Deterministic Ledger Transfer
```lyng
class Ledger(storage) {
fun transfer(from: Int, to: Int, amount: Int) {
require(amount > 0)
val fromKey = "bal:$from"
val toKey = "bal:$to"
val fromBal = storage[fromKey] ?: 0
require(fromBal >= amount)
storage[fromKey] = fromBal - amount
storage[toKey] = (storage[toKey] ?: 0) + amount
}
}
```
The same logic can run:
- in a gas-metered contract runtime,
- in off-chain simulation,
- in distributed batch reconciliation.
## Example: Parallel Verification Workflow
```lyng
fun verifyBatch(items, verifier) {
val jobs = []
for (item in items) {
jobs += launch { verifier(item) }
}
val results = []
for (job in jobs) {
results += await(job)
}
results
}
```
This model is useful for distributed validation, scoring, and pre-consensus checks.
## Feature Showcases
### 1. Runtime generics with bounds (non-erased behavior)
```lyng
fun square<T: Int | Real>(x: T) = x * x
fun describeValue<T: Int | Real>(x: T): String = when (T) {
Int -> "Int value=$x"
Real -> "Real value=$x"
else -> "Numeric value=$x"
}
fun sameType<T>(x: T, y: Object): Bool = y is T
```
This enables practical runtime type-aware logic in generic code without JVM-style erasure limitations.
### 2. Multiple inheritance with lifted enums
```lyng
class Payable(val accountId: Int) {
fun channel() = "onchain"
}
class Audited {
fun mark() = "audited"
}
class Payment(accountId: Int) : Payable(accountId), Audited() {
enum Status* { Pending, Settled }
}
val p = Payment(42)
assertEquals("onchain", p.channel())
assertEquals("audited", p.mark())
assertEquals(Payment.Pending, Payment.Status.Pending)
```
This combines reusable behavior composition with concise domain modeling.
### 3. Unified delegation model (`val`, `var`, `fun`)
```lyng
val state = { "owner": "alice", "limit": 10 }
val owner by state
var limit by state
object RpcDelegate {
fun invoke(thisRef, name, args...) = "$name:${args.size}"
}
fun remoteCall by RpcDelegate
limit = 25
assertEquals(25, state["limit"])
assertEquals("remoteCall:2", remoteCall("alice", 10))
```
Delegation helps build compact, extensible models with minimal boilerplate.
## Rollout Strategy
1. Define the minimal portable storage API (`get/put/find by tags`) as a stable contract.
2. Publish a compatibility profile for metered execution (determinism + gas accounting).
3. Provide chain adapters that map Lyng storage/API calls to each target network.
4. Ship a reference sandbox and conformance tests for runtime parity.
5. Build shared Lyng libraries for common contract and compute patterns.
6. Launch a Lyng package manager and registry (NPM/Maven-style) with first-class support for unified scripts:
- package metadata for runtime profile (metered/off-chain), storage API version, and capability requirements,
- deterministic dependency resolution and lockfiles,
- signed package publishing and verification for supply-chain integrity.
## Existing Resources
- Lyng project repository: https://github.com/sergeych/lyng
- Lyng docs home: https://lynglang.com
- Lyng tutorial: https://lynglang.com/#/docs/tutorial.md
- Embedding Lyng: https://lynglang.com/#/docs/embedding.md
## Conclusion
Lyng can serve as a practical common platform for blockchain contracts and distributed execution by combining:
- portable language semantics,
- safe-by-default host interaction,
- metered deterministic execution when required,
- and reusable code across on-chain and off-chain environments.
This reduces duplication, improves consistency, and shortens delivery cycles for decentralized systems.