Compare commits

...
40 Commits
Author SHA1 Message Date
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
sergeych 8e0442670d extern generics classes fix, documentation on extern classes updated 2026-03-15 04:32:06 +03:00
sergeych 74eb8ff082 proposal: extending kotlin bridging ABI for generic externs 2026-03-15 04:22:36 +03:00
sergeych 2b13fe8053 Improve extern member diagnostics and cover extern generic class test 2026-03-15 04:09:24 +03:00
sergeych 979e6ea9b7 Require explicit extern members in extern class/object and update docs 2026-03-15 03:27:50 +03:00
sergeych e447c778ed fixed few bugs in compiler and plugin 2026-03-15 02:53:33 +03:00
sergeych 37d093817e added T is nullable support 2026-03-14 20:57:15 +03:00
sergeych c54d947f1c indexer fix 2026-03-14 20:04:44 +03:00
sergeych 8a32ffe655 bridge: add ScopeFacade receiver overloads for binder callbacks 2026-03-14 19:53:46 +03:00
sergeych 65edf9fe67 Fix generic type checks and explicit type arg runtime binding 2026-03-14 19:18:09 +03:00
sergeych 18394ce286 build/deploy optimizations 2026-03-13 00:03:50 +03:00
sergeych 298c2a09fe Add lyng.observable ObservableList hooks, flow events, and docs 2026-03-12 22:07:33 +03:00
sergeych a9da21e7a4 deploy improved/2 2026-03-12 21:21:10 +03:00
sergeych 4581998ba3 deploy improved 2026-03-12 21:14:20 +03:00
sergeych 62dc501657 fixed version 2026-03-12 21:10:24 +03:00
sergeych 8b5e6ee993 Add immutable collections hierarchy with runtime/compiler/docs/tests 2026-03-12 21:07:56 +03:00
sergeych 9417f8f0cc Type-aware += checks for declared collection members; preserve field type metadata 2026-03-12 19:41:42 +03:00
sergeych c9021eb9cf Make List/Set += and -= element-type aware 2026-03-12 19:13:17 +03:00
sergeych 3bfb80a7c1 Improve Set handling with type-aware operations and enhance generic function parsing logic 2026-03-12 19:08:29 +03:00
sergeych 32a7adf56e more types tests and fixes 2026-03-09 12:32:37 +03:00
sergeych 90e586b5d2 Enable smart-cast handling for expressions and add relevant tests. 2026-03-09 10:29:04 +03:00
sergeych f03006ce37 added tests of println override 2026-03-09 11:54:30 +03:00
sergeych 1502a365bf Add API for binding global functions and variables; implement tests and update embedding documentation. 2026-03-07 19:03:52 +03:00
sergeych d6a535590e improved docs on embedding 2026-03-07 18:04:03 +03:00
sergeych c351e6ff1e Add support for dynamic theme switching in highlight.js styles within Kotlin fenced code blocks 2026-03-07 17:08:20 +03:00
124 changed files with 9697 additions and 583 deletions

No files matched your search

+18
View File
@@ -1,5 +1,19 @@
# 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
- 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).
@@ -21,3 +35,7 @@
- Create closure references only when a capture is detected; use a direct frame+slot reference (foreign slot ref) instead of scope slots.
- Keep Scope as a lazy reflection facade: resolve name -> slot only on demand for Kotlin interop (no eager name mapping on every call).
- Avoid PUSH_SCOPE/POP_SCOPE in bytecode for loops/functions unless dynamic name access or Kotlin reflection is requested.
## ABI proposal notes
- Runtime generic metadata for generic extern classes is tracked in `proposals/extern_generic_runtime_abi.md`.
- Keep this design `Obj`-centric: do not assume extern-class values are `ObjInstance`; collection must be enabled on `ObjClass`.
+73 -141
View File
@@ -1,156 +1,88 @@
## 1.5.0-SNAPSHOT
# Changelog
### Language Features
- 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.
This file tracks user-visible Lyng language/runtime/tooling changes.
### Standard Library
- Added `with(self, block)` for scoped execution.
- Added `clamp()` function and extension.
- Improved `Exception` and `StackTraceEntry` reporting.
History note:
- The project had periods where changelog maintenance lagged behind commits.
- Entries below are synchronized and curated for `1.5.x`.
- Earlier history may be incomplete and should be cross-checked with git tags/commits when needed.
### Tooling and IDE
- **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.
## 1.5.1 (2026-03-25)
### 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
- 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).
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass.
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic.
### Docs and AI references
- Updated compiler-accurate AI language docs:
- interpolation syntax and escaping
- 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
- `return [expression]` exits the innermost enclosing callable (function or lambda).
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`).
- 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`.
### Compatibility notes
- Interpolation is enabled by default for normal string literals.
- Existing code that intentionally used `$name` as literal text should use `\$name`, `$$name`, or the file directive `// feature: interpolation: off`.
- Language: stdlib improvements
- 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.
## 1.5.0 (2026-03-22)
- Language: Class properties with accessors
- Support for `val` (read-only) and `var` (read-write) properties in classes.
- Syntax: `val name [ : Type ] get() { body }` or `var name [ : Type ] get() { body } set(value) { body }`.
- Laconic Expression Shorthand: `val prop get() = expression` and `var prop get() = read set(v) = write`.
- 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`.
### Major runtime/compiler direction
- Completed migration to bytecode-first/bytecode-only execution paths.
- Removed interpreter fallback behavior in core execution hot paths.
- Continued frame-slot-first local/capture model improvements and related diagnostics.
- Language: Restricted Setter Visibility
- Support for `private set` and `protected set` modifiers on `var` fields and properties.
- Allows members to be publicly readable but only writable from within the declaring class or its subclasses.
- Enforcement at runtime: throws `AccessException` on unauthorized writes.
- Supported only for declarations in class bodies (fields and properties).
- Documentation: New "Restricted Setter Visibility" section in `docs/OOP.md`.
### Language features and semantics
- Added/finished `return` semantics including labeled non-local forms (`return@label`).
- Added abstract classes/members and `interface` support (as abstract-class-style construct).
- Completed and enabled multiple inheritance with C3 MRO by default.
- Added class properties with accessors (`get`/`set`) and restricted setter visibility (`private set`, `protected set`).
- 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
- Support for declaring `val` without an immediate initializer in class bodies.
- Compulsory initialization: every late-init `val` must be assigned at least once within the class body or an `init` block.
- Write-once enforcement: assigning to a `val` is allowed only if its current value is `Unset`.
- 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`.
### Type system and collections
- Added immutable collections hierarchy (`ImmutableList`, `ImmutableSet`, `ImmutableMap`).
- Improved generic runtime binding/checking for explicit type arguments and bounds.
- Added smarter type-aware collection ops (`+=`, `-=`) and stronger declared-member type checks.
- Docs: OOP improvements
- 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`).
- 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`).
- Tutorial: added quick link to Scopes and Closures.
### Extern/Kotlin bridge
- Tightened extern declaration rules:
- explicit extern members are required for extern class/object declarations.
- 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)
- Global completion: local declarations, in‑scope parameters, imported modules, and stdlib symbols.
- 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.
- Inheritance-aware: direct class members first, then inherited (e.g., `List` includes `Collection`/`Iterable` methods).
- Heuristics: handles literals (`"…"` → `String`, numbers → `Int/Real`, `[...]` → `List`, `{...}` → `Dict`) and static `Namespace.` members.
- 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.
### Standard library and modules
- Added `lyng.observable` improvements (`ObservableList` hooks/events).
- Added `Random` stdlib API used by updated samples.
- Added/extended `lyngio.console` support and CLI integration for console interaction.
- Migrated time APIs to `kotlin.time` (`Instant` migration and related docs/tests).
- Language: Named arguments and named splats
- New call-site syntax for named arguments using colon: `name: value`.
- Positional arguments must come before named; positionals after a named argument inside parentheses are rejected.
- Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal.
- Named splats: `...` can now expand a Map into named arguments.
- Only string keys are allowed; non-string keys raise a clear error.
- Duplicate assignment across named args and named splats is an error.
- Ellipsis (variadic) parameters remain positional-only and cannot be named.
- 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?`.
- Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases.
- Tests added covering success cases and errors for named args/splats and trailing-lambda interactions.
### CLI, IDE, and docs/tooling
- CLI:
- added first-class `fmt` command
- preserved direct script fast-path invocation
- improved command help/dispatch behavior
- IntelliJ plugin:
- improved lightweight completion and documentation/inspection behavior
- continued highlighter and Grazie/spellchecking integration work
- Docs:
- substantial updates across tutorial/OOP/type/runtime references
- expanded bytecode and advanced topics coverage
- Tooling: Highlighters and TextMate bundle updated for named args
- 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.
## Migration checklist for 1.5.x
- Multiple Inheritance (MI) completed and enabled by default:
- Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds.
- Qualified dispatch:
- `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor.
- Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`).
- Field inheritance (`val`/`var`) under MI:
- 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.
- If you rely on literal `$...` strings:
- replace with `\$...` or `$$...`, or
- add `// feature: interpolation: off` at file top.
- Review any code relying on interpreter-era fallback behavior; 1.5.x assumes bytecode-first execution.
- For extern declarations, ensure members are explicitly declared where required.
- For named arguments/splats, verify call sites follow stricter ordering/duplication rules.
+5 -6
View File
@@ -20,13 +20,12 @@
set -e
echo "publishing all artifacts"
echo
./gradlew publishToMavenLocal
./gradlew publish
./gradlew publishToMavenLocal site:jsBrowserDistribution publish buildInstallablePlugin :lyng:linkReleaseExecutableLinuxX64 :lyng:installJvmDist --parallel
echo
echo "Creating plugin"
echo
./gradlew buildInstallablePlugin
#echo
#echo "Creating plugin"
#echo
#./gradlew buildInstallablePlugin
echo
echo "building CLI tools"
+3 -2
View File
@@ -1,8 +1,8 @@
# Array
It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
[List].
Array therefore implements [Iterable] too. Well known implementations of `Array` are
[List] and [ImmutableList].
Array adds the following methods:
@@ -35,3 +35,4 @@ To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families,
[Collection]: Collection.md
[Iterable]: Iterable.md
[List]: List.md
[ImmutableList]: ImmutableList.md
+13 -1
View File
@@ -6,6 +6,13 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
val size
}
`Collection` is a read/traversal contract shared by mutable and immutable collections.
Concrete collection classes:
- Mutable: [List], [Set], [Map]
- Immutable: [ImmutableList], [ImmutableSet], [ImmutableMap]
- Observable mutable lists (opt-in module): [ObservableList]
| name | description |
|------------------------|------------------------------------------------------|
@@ -16,4 +23,9 @@ See [List], [Set], [Iterable] and [Efficient Iterables in Kotlin Interop](Effici
[Iterable]: Iterable.md
[List]: List.md
[Set]: Set.md
[Set]: Set.md
[Map]: Map.md
[ImmutableList]: ImmutableList.md
[ImmutableSet]: ImmutableSet.md
[ImmutableMap]: ImmutableMap.md
[ObservableList]: ObservableList.md
+37
View File
@@ -0,0 +1,37 @@
# ImmutableList built-in class
`ImmutableList` is an immutable, indexable list value.
It implements [Array], therefore [Collection] and [Iterable].
Use it when API contracts require a list that cannot be mutated through aliases.
## Creating
val a = ImmutableList(1,2,3)
val b = [1,2,3].toImmutable()
val c = (1..3).toImmutableList()
>>> void
## Converting
val i = ImmutableList(1,2,3)
val m = i.toMutable()
m += 4
assertEquals( ImmutableList(1,2,3), i )
assertEquals( [1,2,3,4], m )
>>> void
## Members
| name | meaning |
|---------------|-----------------------------------------|
| `size` | number of elements |
| `[index]` | element access by index |
| `[Range]` | immutable slice |
| `+` | append element(s), returns new immutable list |
| `-` | remove element(s), returns new immutable list |
| `toMutable()` | create mutable copy |
[Array]: Array.md
[Collection]: Collection.md
[Iterable]: Iterable.md
+36
View File
@@ -0,0 +1,36 @@
# ImmutableMap built-in class
`ImmutableMap` is an immutable map of key-value pairs.
It implements [Collection] and [Iterable] of [MapEntry].
## Creating
val a = ImmutableMap("a" => 1, "b" => 2)
val b = Map("a" => 1, "b" => 2).toImmutable()
val c = ["a" => 1, "b" => 2].toImmutableMap
>>> void
## Converting
val i = ImmutableMap("a" => 1)
val m = i.toMutable()
m["a"] = 2
assertEquals( 1, i["a"] )
assertEquals( 2, m["a"] )
>>> void
## Members
| name | meaning |
|-----------------|------------------------------------------|
| `size` | number of entries |
| `[key]` | get value by key, or `null` if absent |
| `getOrNull(key)`| same as `[key]` |
| `keys` | list of keys |
| `values` | list of values |
| `+` | merge (rightmost wins), returns new immutable map |
| `toMutable()` | create mutable copy |
[Collection]: Collection.md
[Iterable]: Iterable.md
[MapEntry]: Map.md
+34
View File
@@ -0,0 +1,34 @@
# ImmutableSet built-in class
`ImmutableSet` is an immutable set of unique elements.
It implements [Collection] and [Iterable].
## Creating
val a = ImmutableSet(1,2,3)
val b = Set(1,2,3).toImmutable()
val c = [1,2,3].toImmutableSet
>>> void
## Converting
val i = ImmutableSet(1,2,3)
val m = i.toMutable()
m += 4
assertEquals( ImmutableSet(1,2,3), i )
assertEquals( Set(1,2,3,4), m )
>>> void
## Members
| name | meaning |
|---------------|-----------------------------------------------------|
| `size` | number of elements |
| `contains(x)` | membership test |
| `+`, `union` | union, returns new immutable set |
| `-`, `subtract` | subtraction, returns new immutable set |
| `*`, `intersect` | intersection, returns new immutable set |
| `toMutable()` | create mutable copy |
[Collection]: Collection.md
[Iterable]: Iterable.md
+8 -1
View File
@@ -147,12 +147,15 @@ Search for the first element that satisfies the given predicate:
| fun/method | description |
|------------------------|---------------------------------------------------------------------------------|
| toList() | create a list from iterable |
| toImmutableList() | create an immutable list from iterable |
| toSet() | create a set from iterable |
| toImmutableSet | create an immutable set from iterable |
| contains(i) | check that iterable contains `i` |
| `i in iterable` | same as `contains(i)` |
| isEmpty() | check iterable is empty |
| forEach(f) | call f for each element |
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
| toImmutableMap | create an immutable map from list of key-value pairs |
| any(p) | true if any element matches predicate `p` |
| all(p) | true if all elements match predicate `p` |
| map(f) | create a list of values returned by `f` called for each element of the iterable |
@@ -206,16 +209,20 @@ For high-performance Kotlin-side interop and custom iterable implementation deta
## Implemented in classes:
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
- [List], [ImmutableList], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [ImmutableSet], [Map], [ImmutableMap], [RingBuffer]
[Collection]: Collection.md
[List]: List.md
[ImmutableList]: ImmutableList.md
[Flow]: parallelism.md#flow
[Range]: Range.md
[Set]: Set.md
[ImmutableSet]: ImmutableSet.md
[Map]: Map.md
[ImmutableMap]: ImmutableMap.md
[RingBuffer]: RingBuffer.md
+49 -1
View File
@@ -1,6 +1,8 @@
# List built-in class
Mutable list of any objects.
For immutable list values, see [ImmutableList].
For observable mutable lists and change hooks, see [ObservableList].
It's class in Lyng is `List`:
@@ -179,6 +181,50 @@ for `sort()` will be `sort { a, b -> a <=> b }
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
## Observable list hooks
Observable hooks are provided by module `lyng.observable` and are opt-in:
import lyng.observable
val src = [1,2,3]
val xs = src.observable()
assert(xs is ObservableList<Int>)
var before = 0
var after = 0
xs.beforeChange { before++ }
xs.onChange { after++ }
xs += 4
xs[0] = 100
assertEquals([100,2,3,4], xs)
assertEquals(2, before)
assertEquals(2, after)
>>> void
`beforeChange` runs before mutation commit and may reject it by throwing exception (typically `ChangeRejectionException` from the same module):
import lyng.observable
val xs = [1,2].observable()
xs.beforeChange { throw ChangeRejectionException("read only") }
assertThrows(ChangeRejectionException) { xs += 3 }
assertEquals([1,2], xs)
>>> void
`changes()` returns `Flow<ListChange<T>>` of committed events:
import lyng.observable
val xs = [10,20].observable()
val it = xs.changes().iterator()
xs += 30
assert(it.hasNext())
val e = it.next()
assert(e is ListInsert<Int>)
assertEquals([30], (e as ListInsert<Int>).values)
it.cancelIteration()
>>> void
## Member inherited from Array
| name | meaning | type |
@@ -196,4 +242,6 @@ It inherits from [Iterable] too and thus all iterable methods are applicable to
[Range]: Range.md
[Iterable]: Iterable.md
[Iterable]: Iterable.md
[ImmutableList]: ImmutableList.md
[ObservableList]: ObservableList.md
+2
View File
@@ -3,6 +3,7 @@
Map is a mutable collection of key-value pairs, where keys are unique. You can create maps in two ways:
- with the constructor `Map(...)` or `.toMap()` helpers; and
- with map literals using braces: `{ "key": value, id: expr, id: }`.
For immutable map values, see [ImmutableMap].
When constructing from a list, each list item must be a [Collection] with exactly 2 elements, for example, a [List].
@@ -177,3 +178,4 @@ Notes:
- When you need computed or non-string keys, use the constructor form `Map(...)`, map literals with computed keys (if supported), or build entries with `=>` and then merge.
[Collection](Collection.md)
[ImmutableMap]: ImmutableMap.md
+70
View File
@@ -0,0 +1,70 @@
# ObservableList module
`ObservableList` lives in explicit module `lyng.observable`.
Import it first:
import lyng.observable
>>> void
Create from a regular mutable list:
import lyng.observable
val xs = [1,2,3].observable()
assert(xs is ObservableList<Int>)
assertEquals([1,2,3], xs)
>>> void
## Hook flow
Event order is:
1. `beforeChange(change)` listeners
2. mutation commit
3. `onChange(change)` listeners
4. `changes()` flow emission
Rejection is done by throwing in `beforeChange`.
import lyng.observable
val xs = [1,2].observable()
xs.beforeChange {
throw ChangeRejectionException("no mutation")
}
assertThrows(ChangeRejectionException) { xs += 3 }
assertEquals([1,2], xs)
>>> void
## Subscriptions
`beforeChange` and `onChange` return `Subscription`.
Call `cancel()` to unsubscribe.
import lyng.observable
val xs = [1].observable()
var hits = 0
val sub = xs.onChange { hits++ }
xs += 2
sub.cancel()
xs += 3
assertEquals(1, hits)
>>> void
## Change events
`changes()` returns `Flow<ListChange<T>>` with concrete event classes:
- `ListInsert`
- `ListSet`
- `ListRemove`
- `ListClear`
- `ListReorder`
import lyng.observable
val xs = [10,20].observable()
val it = xs.changes().iterator()
xs[1] = 200
val ev = it.next()
assert(ev is ListSet<Int>)
assertEquals(20, (ev as ListSet<Int>).oldValue)
assertEquals(200, ev.newValue)
it.cancelIteration()
>>> void
+3 -1
View File
@@ -1,7 +1,8 @@
# List built-in class
# Set built-in class
Mutable set of any objects: a group of different objects, no repetitions.
Sets are not ordered, order of appearance does not matter.
For immutable set values, see [ImmutableSet].
val set = Set(1,2,3, "foo")
assert( 1 in set )
@@ -92,3 +93,4 @@ Also, it inherits methods from [Iterable].
[Range]: Range.md
[ImmutableSet]: ImmutableSet.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`).
+135 -38
View File
@@ -4,7 +4,7 @@ Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows,
- add Lyng to your build
- create a runtime and execute scripts
- define functions and variables from Kotlin
- declare extern globals in Lyng and bind them from Kotlin
- read variable values back in Kotlin
- call Lyng functions from Kotlin
- create your own packages and import them in Lyng
@@ -65,30 +65,74 @@ val run2 = script.execute(scope)
`Scope.eval("...")` is a shortcut that compiles and executes on the given scope.
### 3) Define variables from Kotlin
### 3) Preferred: bind extern globals from Kotlin
To expose data to Lyng, add constants (read‑only) or mutable variables to the scope. All values in Lyng are `Obj` instances; the core types live in `net.sergeych.lyng.obj`.
For module-level APIs, the default workflow is:
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
```kotlin
// Read‑only constant
scope.addConst("pi", ObjReal(3.14159))
import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjString
// Mutable variable: create or update
scope.addOrUpdateItem("counter", ObjInt(0))
val im = Script.defaultImportManager.copy()
im.addPackage("my.api") { module ->
module.eval("""
extern fun globalFun(v: Int): Int
extern var globalProp: String
extern val globalVersion: String
""".trimIndent())
// Use it from Lyng
scope.eval("counter = counter + 1")
val binder = module.globalBinder()
binder.bindGlobalFun1<Int>("globalFun") { v ->
ObjInt.of((v + 1).toLong())
}
var prop = "initial"
binder.bindGlobalVar(
name = "globalProp",
get = { prop },
set = { prop = it }
)
binder.bindGlobalVar(
name = "globalVersion",
get = { "1.0.0" } // readonly: setter omitted
)
}
```
Tip: Lyng values can be converted back to Kotlin with `toKotlin(scope)`:
Usage from Lyng:
```lyng
import my.api
assertEquals(42, globalFun(41))
assertEquals("initial", globalProp)
globalProp = "changed"
assertEquals("changed", globalProp)
assertEquals("1.0.0", globalVersion)
```
For custom argument handling and full runtime access:
```kotlin
val current = (scope.eval("counter")).toKotlin(scope) // Any? (e.g., Int/Double/String/List)
binder.bindGlobalFun("sum3") {
requireExactCount(3)
ObjInt.of((int(0) + int(1) + int(2)).toLong())
}
binder.bindGlobalFunRaw("echoRaw") { _, args ->
args.firstAndOnly()
}
```
### 4) Add Kotlin‑backed functions
### 4) Low-level: direct functions/variables from Kotlin
Use `Scope.addFn`/`addVoidFn` to register functions implemented in Kotlin. Inside the lambda, use `this.args` to access arguments and return an `Obj`.
Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3.
```kotlin
// A function returning value
@@ -199,6 +243,12 @@ For extensions and libraries, the **preferred** workflow is Lyng‑first: declar
This keeps Lyng semantics (visibility, overrides, type checks) in Lyng, while Kotlin supplies the behavior.
Pure extern declarations use the simplified rule set:
- `extern class` / `extern object` are declaration-only ABI surfaces.
- Every member in their body is implicitly extern (you may still write `extern`, but it is redundant).
- Plain Lyng member implementations inside `extern class` / `extern object` are not allowed.
- Put Lyng behavior into regular classes or extension methods.
```lyng
// Lyng side (in a module)
class Counter {
@@ -207,7 +257,22 @@ class Counter {
}
```
Note: members must be marked `extern` so the compiler emits the ABI slots that Kotlin bindings attach to. This applies to functions and properties bound via `addFun` / `addVal` / `addVar`.
Note: members of `extern class` / `extern object` are treated as extern by default, so the compiler emits ABI slots that Kotlin bindings attach to. This applies to functions and properties bound via `addFun` / `addVal` / `addVar`.
Example of pure extern class declaration:
```lyng
extern class HostCounter {
var value: Int
fun inc(by: Int): Int
}
```
If you need Lyng-side convenience behavior, add it as an extension:
```lyng
fun HostCounter.bump() = inc(1)
```
```kotlin
// Kotlin side (binding)
@@ -217,14 +282,14 @@ moduleScope.eval("class Counter { extern var value: Int; extern fun inc(by: Int)
moduleScope.bind("Counter") {
addVar(
name = "value",
get = { _, self -> self.readField(this, "value").value },
set = { _, self, v -> self.writeField(this, "value", v) }
get = { thisObj.readField(this, "value").value },
set = { v -> thisObj.writeField(this, "value", v) }
)
addFun("inc") { _, self, args ->
addFun("inc") {
val by = args.requiredArg<ObjInt>(0).value
val current = self.readField(this, "value").value as ObjInt
val current = thisObj.readField(this, "value").value as ObjInt
val next = ObjInt(current.value + by)
self.writeField(this, "value", next)
thisObj.writeField(this, "value", next)
next
}
}
@@ -240,41 +305,62 @@ Notes:
For `extern object` declarations, bind implementations to the singleton instance using `ModuleScope.bindObject`.
This mirrors class binding but targets an already created object instance.
```lyng
// Lyng side (in a module)
extern object HostObject {
extern fun add(a: Int, b: Int): Int
extern val status: String
extern var count: Int
}
```
As with class binding, you must first add/evaluate the Lyng declaration into that module scope, then bind Kotlin handlers.
```kotlin
// Kotlin side (binding)
val moduleScope = importManager.createModuleScope(Pos.builtIn, "bridge.obj")
// 1) Seed the module with the Lyng declaration first
moduleScope.eval("""
extern object HostObject {
extern fun add(a: Int, b: Int): Int
extern val status: String
extern var count: Int
}
""".trimIndent())
// 2) Then bind Kotlin implementations to that declared object
moduleScope.bindObject("HostObject") {
classData = "OK"
init { _ -> data = 0L }
addFun("add") { _, _, args ->
addFun("add") {
val a = args.requiredArg<ObjInt>(0).value
val b = args.requiredArg<ObjInt>(1).value
ObjInt.of(a + b)
}
addVal("status") { _, _ -> ObjString(classData as String) }
addVal("status") { ObjString(classData as String) }
addVar(
"count",
get = { _, inst -> ObjInt.of((inst as ObjInstance).data as Long) },
set = { _, inst, value -> (inst as ObjInstance).data = (value as ObjInt).value }
get = { ObjInt.of((thisObj as ObjInstance).data as Long) },
set = { value -> (thisObj as ObjInstance).data = (value as ObjInt).value }
)
}
```
Notes:
- Members must be marked `extern` so the compiler emits ABI slots for Kotlin bindings.
- Required order: declare/eval Lyng object in the module first, then call `bindObject(...)`.
This is the pattern covered by `BridgeBindingTest.testExternObjectBinding`.
- Members must be extern (explicitly, or implicitly via `extern object`) so the compiler emits ABI slots for Kotlin bindings.
- You can also bind by name/module via `LyngObjectBridge.bind(...)`.
Minimal `extern fun` example:
```kotlin
val moduleScope = importManager.createModuleScope(Pos.builtIn, "bridge.ping")
moduleScope.eval("""
extern object HostObject {
extern fun ping(): Int
}
""".trimIndent())
moduleScope.bindObject("HostObject") {
addFun("ping") { ObjInt.of(7) }
}
```
### 6.6) Preferred: Kotlin reflection bridge for call‑by‑name
For Kotlin code that needs dynamic access to Lyng variables, functions, or members, use the bridge resolver.
@@ -363,6 +449,9 @@ Key concepts:
Register a Kotlin‑built package:
```kotlin
import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt
val scope = Script.newScope()
// Access the import manager behind this scope
@@ -370,11 +459,19 @@ val im: ImportManager = scope.importManager
// Register a package "my.tools"
im.addPackage("my.tools") { module: ModuleScope ->
// Expose symbols inside the module scope
module.addConst("version", ObjString("1.0"))
module.addFn<ObjInt>("triple") {
val x = args.firstAndOnly() as ObjInt
ObjInt(x.value * 3)
module.eval(
"""
extern val version: String
extern fun triple(x: Int): Int
""".trimIndent()
)
val binder = module.globalBinder()
binder.bindGlobalVar(
name = "version",
get = { "1.0" }
)
binder.bindGlobalFun1<Int>("triple") { x ->
ObjInt.of((x * 3).toLong())
}
}
+18
View File
@@ -109,6 +109,24 @@ Examples (T = A | B):
B in T // true
T is A | B // true
# Nullability checks for types
Use `is nullable` to check whether a type expression accepts `null`:
T is nullable
T !is nullable
This works with concrete and generic types:
fun describe<T>(x: T): String = when (T) {
nullable -> "nullable"
else -> "non-null"
}
Equivalent legacy form:
null is T
# Practical examples
fun acceptInts<T: Int>(xs: List<T>) { }
+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.
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
- **[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.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.io.fs.createFs
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.process.security.PermitAllProcessAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun runMyScript() {
val scope = Script.newScope()
@@ -48,14 +51,17 @@ suspend fun runMyScript() {
// Install modules with policies
createFs(PermitAllAccessPolicy, scope)
createProcessModule(PermitAllProcessAccessPolicy, scope)
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
// Now scripts can import them
scope.eval("""
import lyng.io.fs
import lyng.io.process
import lyng.io.console
println("Working dir: " + Path(".").readUtf8())
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).
- **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:
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
- [Process Security Details](lyng.io.process.md#security-policy)
- [Console Module Details](lyng.io.console.md)
---
#### Platform Support Overview
| Platform | lyng.io.fs | lyng.io.process |
| :--- | :---: | :---: |
| **JVM** | ✅ | ✅ |
| **Native (Linux/macOS)** | ✅ | ✅ |
| **Native (Windows)** | ✅ | 🚧 (Planned) |
| **Android** | ✅ | ❌ |
| **NodeJS** | ✅ | ❌ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ |
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console |
| :--- | :---: | :---: | :---: |
| **JVM** | ✅ | ✅ | ✅ (baseline) |
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
| **Android** | ✅ | ❌ | ❌ |
| **NodeJS** | ✅ | ❌ | ❌ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
+23
View File
@@ -110,6 +110,29 @@ For example:
assert( 5.clamp(0..10) == 5 )
>>> 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
| name | meaning |
+10
View File
@@ -0,0 +1,10 @@
fun describe<T>(x: T): String = when (T) {
nullable -> "nullable"
else -> "non-null"
}
type MaybeInt = Int?
assert(MaybeInt is nullable)
assert(!(Int is nullable))
assertEquals("nullable", describe<Int?>(null))
assertEquals("non-null", describe<Int>(1))
+73 -3
View File
@@ -14,7 +14,7 @@ __Other documents to read__ maybe after this one:
- [time](time.md) and [parallelism](parallelism.md)
- [parallelism] - multithreaded code, coroutines, etc.
- Some class
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
references: [List], [ImmutableList], [Set], [ImmutableSet], [Map], [ImmutableMap], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
@@ -502,6 +502,18 @@ Aliases expand to their underlying type expressions. See `docs/generics.md` for
`Null` is the class of `null`. It is a singleton type and mostly useful for type inference results.
For type expressions, you can check nullability directly:
T is nullable
T !is nullable
This is especially useful in generic code and in `when` over a type parameter:
fun describe<T>(x: T): String = when (T) {
nullable -> "nullable"
else -> "non-null"
}
## Type inference
The compiler infers types from:
@@ -785,6 +797,7 @@ Lyng has built-in mutable array class `List` with simple literals:
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
many collection based methods are implemented there.
For immutable list values, use `list.toImmutable()` and [ImmutableList].
Lists can contain any type of objects, lists too:
@@ -967,6 +980,7 @@ Set are unordered collection of unique elements, see [Set]. Sets are [Iterable]
>>> void
Please see [Set] for detailed description.
For immutable set values, use `set.toImmutable()` and [ImmutableSet].
# Maps
@@ -1027,6 +1041,7 @@ Notes:
- When you need computed (expression) keys or non-string keys, use `Map(...)` constructor with entries, e.g. `Map( ("a" + "b") => 1 )`, then merge with a literal if needed: `{ base: } + (computedKey => 42)`.
Please see the [Map] reference for a deeper guide.
For immutable map values, use `map.toImmutable()` and [ImmutableMap].
# Flow control operators
@@ -1540,21 +1555,70 @@ The type for the character objects is `Char`.
| \t | 0x07, tabulation |
| \\ | \ slash character |
| \" | " 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.:
val s = "\a"
assert(s[0] == '\')
assert(s[0] == '\\')
assert(s[1] == 'a')
>>> void
same as:
val s = "\\a"
assert(s[0] == '\')
assert(s[0] == '\\')
assert(s[1] == 'a')
>>> 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
Are the same as in string literals with little difference:
@@ -1566,6 +1630,9 @@ Are the same as in string literals with little difference:
| \t | 0x07, tabulation |
| \\ | \ slash character |
| \' | ' apostrophe |
| \uXXXX | unicode code point |
For char literals, use `'\\'` to represent a single backslash character; `'\'` is invalid.
### Char instance members
@@ -1750,6 +1817,7 @@ Lambda avoid unnecessary execution if assertion is not failed. for example:
| π | See [math](math.md) |
[List]: List.md
[ImmutableList]: ImmutableList.md
[Testing]: Testing.md
@@ -1766,8 +1834,10 @@ Lambda avoid unnecessary execution if assertion is not failed. for example:
[string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
[Set]: Set.md
[ImmutableSet]: ImmutableSet.md
[Map]: Map.md
[ImmutableMap]: ImmutableMap.md
[Buffer]: Buffer.md
+2 -1
View File
@@ -248,6 +248,7 @@ The `Obj.getLyngExceptionMessageWithStackTrace()` extension method has been adde
Lyng now provides a public Kotlin reflection bridge and a Lyng‑first class binding workflow. This is the **preferred** way to write Kotlin extensions and library integrations:
- **Bridge resolver**: explicit handles for values, vars, and callables with predictable lookup rules.
- **Class bridge binding**: declare classes/members in Lyng (marked `extern`) and bind the implementations in Kotlin before the first instance is created.
- **Class bridge binding**: declare extern surfaces in Lyng (`extern` members, or members inside `extern class/object`) and bind the implementations in Kotlin before the first instance is created.
- **Extern declaration rule**: `extern class` / `extern object` are declaration-only; all members in their bodies are implicitly extern.
See **Embedding Lyng** for full samples and usage details.
+5
View File
@@ -18,6 +18,11 @@ In particular, it means no slow and flaky runtime lookups. Once compiled, code g
The API is fixed and will be kept with further Lyng core changes. It is now the recommended way to write Lyng extensions in Kotlin. It is much simpler and more elegant than the internal one. See [Kotlin Bridge Binding](../notes/kotlin_bridge_binding.md).
Extern declaration clarification:
- `extern class` / `extern object` are pure extern surfaces.
- Members inside them are implicitly extern (`extern` on a member is optional/redundant).
- Lyng method/property bodies for these declarations should be implemented as extensions instead.
### Smart types system
- **Deep inference**: The compiler analyzes types of symbols along the execution path and in many cases eliminates unnecessary casts or type specifications.
+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))
}
}
+3 -1
View File
@@ -37,4 +37,6 @@ kotlin.native.cacheKind.linuxX64=none
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
android.experimental.lint.migrateToK2=false
android.lint.useK2Uast=false
kotlin.mpp.applyDefaultHierarchyTemplate=true
kotlin.mpp.applyDefaultHierarchyTemplate=true
org.gradle.parallel=true
+4 -1
View File
@@ -1,6 +1,7 @@
[versions]
agp = "8.5.2"
clikt = "5.0.3"
mordant = "3.0.2"
kotlin = "2.3.0"
android-minSdk = "24"
android-compileSdk = "34"
@@ -14,6 +15,8 @@ compiler = "3.2.0-alpha11"
[libraries]
clikt = { module = "com.github.ajalt.clikt:clikt", 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" }
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" }
@@ -28,4 +31,4 @@ compiler = { group = "androidx.databinding", name = "compiler", version.ref = "c
[plugins]
androidLibrary = { id = "com.android.library", version.ref = "agp" }
kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.29.0" }
vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.29.0" }
@@ -88,9 +88,11 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
// Imports: each segment as namespace/path
mini?.imports?.forEach { imp ->
imp.segments.forEach { seg ->
val start = analysis.source.offsetOf(seg.range.start)
val end = analysis.source.offsetOf(seg.range.end)
putRange(start, end, LyngHighlighterColors.NAMESPACE)
if (seg.range.start.source === analysis.source && seg.range.end.source === analysis.source) {
val start = analysis.source.offsetOf(seg.range.start)
val end = analysis.source.offsetOf(seg.range.end)
putRange(start, end, LyngHighlighterColors.NAMESPACE)
}
}
}
@@ -35,7 +35,7 @@ class LyngLexer : LexerBase() {
"fun", "val", "var", "class", "interface", "type", "import", "as",
"abstract", "closed", "override", "static", "extern", "open", "private", "protected",
"if", "else", "for", "while", "return", "true", "false", "null",
"when", "in", "is", "break", "continue", "try", "catch", "finally",
"when", "in", "is", "break", "continue", "try", "catch", "finally", "void",
"get", "set", "object", "enum", "init", "by", "step", "property", "constructor"
)
@@ -26,23 +26,17 @@ import com.intellij.psi.search.FilenameIndex
import com.intellij.psi.search.GlobalSearchScope
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.binding.BindingSnapshot
import net.sergeych.lyng.miniast.BuiltinDocRegistry
import net.sergeych.lyng.miniast.DocLookupUtils
import net.sergeych.lyng.miniast.MiniEnumDecl
import net.sergeych.lyng.miniast.MiniRange
import net.sergeych.lyng.miniast.MiniScript
import net.sergeych.lyng.tools.IdeLenientImportProvider
import net.sergeych.lyng.tools.LyngAnalysisRequest
import net.sergeych.lyng.tools.LyngAnalysisResult
import net.sergeych.lyng.tools.LyngDiagnostic
import net.sergeych.lyng.tools.LyngLanguageTools
import net.sergeych.lyng.idea.LyngFileType
import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.tools.*
object LyngAstManager {
private val MINI_KEY = Key.create<MiniScript>("lyng.mini.cache")
private val BINDING_KEY = Key.create<BindingSnapshot>("lyng.binding.cache")
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
private val implicitBuiltinNames = setOf("void")
private val includeSymbolsDirective = Regex("""(?im)^\s*//\s*include\s+symbols\s*:\s*(.+?)\s*$""")
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
getAnalysis(file)?.mini
@@ -51,8 +45,8 @@ object LyngAstManager {
fun getCombinedStamp(file: PsiFile): Long = runReadAction {
var combinedStamp = file.viewProvider.modificationStamp
if (!file.name.endsWith(".lyng.d")) {
collectDeclarationFiles(file).forEach { df ->
combinedStamp += df.viewProvider.modificationStamp
collectDeclarationFiles(file).forEach { symbolsFile ->
combinedStamp += symbolsFile.viewProvider.modificationStamp
}
}
combinedStamp
@@ -73,6 +67,22 @@ object LyngAstManager {
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
// Fallback for virtual/light files without a stable parent chain (e.g., tests)
@@ -217,7 +227,7 @@ object LyngAstManager {
val msg = diag.message
if (msg.startsWith("unresolved name: ")) {
val name = msg.removePrefix("unresolved name: ").trim()
name in declaredTopLevel || name in builtinTopLevel
name in declaredTopLevel || name in builtinTopLevel || name in implicitBuiltinNames
} else if (msg.startsWith("unresolved member: ")) {
val name = msg.removePrefix("unresolved member: ").trim()
val range = diag.range
@@ -50,6 +50,18 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
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() {
addDefinitionsFile()
enableCompletion()
@@ -124,4 +136,47 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
assertTrue("Should not report unresolved name for Declared", messages.none { it.contains("unresolved name: Declared") })
assertTrue("Should not report unresolved member for greet", messages.none { it.contains("unresolved member: greet") })
}
fun test_DiagnosticsDoNotReportVoidAsUnresolvedName() {
val code = """
fun f(): void {
return void
}
""".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 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");
* 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.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.obj.*
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.mp_tools.globalDefer
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.
// Scripts still need to `import lyng.io.fs` to use Path API.
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(libs.okio)
api(libs.kotlinx.coroutines.core)
api(libs.mordant.core)
}
}
val commonTest by getting {
@@ -94,6 +95,13 @@ kotlin {
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
// val wasmJsMain by getting {
// 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 {
namespace = "net.sergeych.lyngio"
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
}
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
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
@@ -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
}
@@ -220,6 +220,7 @@ data class ParsedArgument(
val list: List<Obj>,
val tailBlockMode: Boolean = false,
val named: Map<String, Obj> = emptyMap(),
val explicitTypeArgs: List<TypeDecl> = emptyList(),
) : List<Obj> by list {
constructor(vararg values: Obj) : this(values.toList())
@@ -33,6 +33,7 @@ class ClassInstanceFieldDeclStatement(
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val typeDecl: TypeDecl?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
@@ -169,12 +169,15 @@ class Compiler(
)
private val typeAliases: MutableMap<String, TypeAliasDecl> = mutableMapOf()
private val methodReturnTypeDeclByRef: MutableMap<ObjRef, TypeDecl> = mutableMapOf()
private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
mutableMapOf()
private val classFieldTypesByName: MutableMap<String, MutableMap<String, ObjClass>> = mutableMapOf()
private val classMethodReturnTypeByName: MutableMap<String, MutableMap<String, ObjClass>> = mutableMapOf()
private val classMethodReturnTypeDeclByName: MutableMap<String, MutableMap<String, TypeDecl>> = mutableMapOf()
private val classScopeMembersByClassName: MutableMap<String, MutableSet<String>> = mutableMapOf()
private val classScopeCallableMembersByClassName: MutableMap<String, MutableSet<String>> = mutableMapOf()
private val encodedPayloadTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
@@ -211,6 +214,9 @@ class Compiler(
scopeSeedNames.add(name)
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
if (nameObjClass[name] == null) {
resolveTypeDeclObjClass(record.typeDecl)?.let { nameObjClass[name] = it }
}
}
val instance = record.value as? ObjInstance
if (instance != null && nameObjClass[name] == null) {
@@ -290,6 +296,9 @@ class Compiler(
scopeSeedNames.add(name)
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
if (nameObjClass[name] == null) {
resolveTypeDeclObjClass(record.typeDecl)?.let { nameObjClass[name] = it }
}
}
if (record.typeDecl != null) {
slotTypeDeclByScopeId.getOrPut(plan.id) { mutableMapOf() }[slotIndex] = record.typeDecl
@@ -1111,7 +1120,16 @@ class Compiler(
if (implicitType != null) {
resolutionSink?.referenceMember(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)) {
resolutionSink?.referenceMember(name, pos, classCtx.name)
@@ -1207,6 +1225,11 @@ class Compiler(
for ((name, record) in current.objects) {
if (!record.visibility.isPublic) continue
if (nameObjClass.containsKey(name)) continue
val declaredClass = record.typeDecl?.let { resolveTypeDeclObjClass(it) }
if (declaredClass != null) {
nameObjClass[name] = declaredClass
continue
}
val resolved = when (val raw = record.value) {
is FrameSlotRef -> raw.peekValue() ?: raw.read()
is RecordSlotRef -> raw.peekValue() ?: raw.read()
@@ -2235,6 +2258,7 @@ class Compiler(
is WhenEqualsCondition -> containsDelegatedRefs(cond.expr)
is WhenInCondition -> containsDelegatedRefs(cond.expr)
is WhenIsCondition -> false
is WhenNullableCondition -> false
}
} || containsDelegatedRefs(case.block)
} ||
@@ -2403,13 +2427,13 @@ class Compiler(
parseKeywordStatement(t)?.let { wrapBytecode(it) }
?: run {
cc.previous()
parseExpression()?.let { wrapBytecode(it) }
parseExpressionWithContracts()
}
}
Token.Type.PLUS2, Token.Type.MINUS2 -> {
cc.previous()
parseExpression()?.let { wrapBytecode(it) }
parseExpressionWithContracts()
}
Token.Type.ATLABEL -> {
@@ -2441,7 +2465,7 @@ class Compiler(
Token.Type.LBRACE -> {
cc.previous()
if (braceMeansLambda)
parseExpression()?.let { wrapBytecode(it) }
parseExpressionWithContracts()
else
wrapBytecode(parseBlock())
}
@@ -2456,12 +2480,18 @@ class Compiler(
else -> {
// could be expression
cc.previous()
parseExpression()?.let { wrapBytecode(it) }
parseExpressionWithContracts()
}
}
}
}
private suspend fun parseExpressionWithContracts(): Statement? {
val expression = parseExpression() ?: return null
applyAssertSmartCasts(expression)
return wrapBytecode(expression)
}
private suspend fun parseExpression(): Statement? {
val pos = cc.currentPos()
return parseExpressionLevel()?.let { ref ->
@@ -2502,16 +2532,29 @@ class Compiler(
CastRef(lvalue!!, typeRef, true, opToken.pos)
}
} else if (opToken.type == Token.Type.IS || opToken.type == Token.Type.NOTIS) {
val (typeDecl, _) = parseTypeExpressionWithMini()
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, opToken.pos)
if (opToken.type == Token.Type.IS) {
BinaryOpRef(BinOp.IS, lvalue!!, typeRef)
val nullablePredicate = tryConsumeNullablePredicate()
if (nullablePredicate) {
val nullRef = ConstRef(ObjNull.asReadonly)
if (opToken.type == Token.Type.IS) {
BinaryOpRef(BinOp.IS, nullRef, lvalue!!)
} else {
BinaryOpRef(BinOp.NOTIS, nullRef, lvalue!!)
}
} else {
BinaryOpRef(BinOp.NOTIS, lvalue!!, typeRef)
val (typeDecl, _) = parseTypeExpressionWithMini()
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, opToken.pos)
if (opToken.type == Token.Type.IS) {
BinaryOpRef(BinOp.IS, lvalue!!, typeRef)
} else {
BinaryOpRef(BinOp.NOTIS, lvalue!!, typeRef)
}
}
} else {
val rvalue = parseExpressionLevel(level + 1)
?: throw ScriptError(opToken.pos, "Expecting expression")
if (opToken.type == Token.Type.PLUSASSIGN) {
checkCollectionPlusAssignTypes(lvalue!!, rvalue, opToken.pos)
}
op.generate(opToken.pos, lvalue!!, rvalue)
}
if (opToken.type == Token.Type.ASSIGN) {
@@ -2536,8 +2579,20 @@ class Compiler(
return lvalue
}
private fun tryConsumeNullablePredicate(): Boolean {
val save = cc.savePos()
val t = cc.nextNonWhitespace()
return if (t.type == Token.Type.ID && t.value == "nullable") {
true
} else {
cc.restorePos(save)
false
}
}
private suspend fun parseTerm(): ObjRef? {
var operand: ObjRef? = null
var pendingCallTypeArgs: List<TypeDecl>? = null
// newlines _before_
cc.skipWsTokens()
@@ -2570,7 +2625,34 @@ class Compiler(
}
Token.Type.NOT -> {
if (operand != null) throw ScriptError(t.pos, "unexpected operator not '!' ")
if (operand != null) {
val save = cc.savePos()
val next = cc.next()
if (next.type == Token.Type.NOT) {
val operandRef = operand
val receiverClass = resolveReceiverClassForMember(operandRef)
val inferredType = resolveReceiverTypeDecl(operandRef)
?: receiverClass?.let { TypeDecl.Simple(it.className, false) }
if (inferredType == null) {
operand = operandRef
continue
}
if (inferredType == TypeDecl.TypeAny || inferredType == TypeDecl.TypeNullableAny) {
operand = operandRef
continue
}
val nonNullType = makeTypeDeclNonNullable(inferredType)
operand = CastRef(
operandRef,
TypeDeclRef(nonNullType, t.pos),
isNullable = false,
atPos = t.pos
)
continue
}
cc.restorePos(save)
throw ScriptError(t.pos, "unexpected operator not '!' ")
}
val op = parseTerm() ?: throw ScriptError(t.pos, "Expecting expression")
operand = UnaryOpRef(UnaryOp.NOT, op)
}
@@ -2785,20 +2867,35 @@ class Compiler(
operand = parseScopeOperator(operand)
}
Token.Type.LT -> {
val parsedTypeArgs = operand
?.takeIf { isGenericCallCalleeCandidate(it) }
?.let { tryParseCallTypeArgsAfterLt() }
if (parsedTypeArgs != null) {
pendingCallTypeArgs = parsedTypeArgs
continue
}
cc.previous()
return operand
}
Token.Type.LPAREN, Token.Type.NULL_COALESCE_INVOKE -> {
operand?.let { left ->
// this is function call from <left>
operand = parseFunctionCall(
left,
false,
t.type == Token.Type.NULL_COALESCE_INVOKE
t.type == Token.Type.NULL_COALESCE_INVOKE,
pendingCallTypeArgs
)
pendingCallTypeArgs = null
} ?: run {
// Expression in parentheses
val statement = parseStatement() ?: throw ScriptError(t.pos, "Expecting expression")
operand = StatementRef(statement)
cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
cc.skipTokenOfType(Token.Type.RPAREN, "missing ')'")
pendingCallTypeArgs = null
}
}
@@ -2978,7 +3075,8 @@ class Compiler(
parseFunctionCall(
left,
blockArgument = true,
isOptional = t.type == Token.Type.NULL_COALESCE_BLOCKINVOKE
isOptional = t.type == Token.Type.NULL_COALESCE_BLOCKINVOKE,
explicitTypeArgs = pendingCallTypeArgs
)
} ?: run {
// Disambiguate between lambda and map literal.
@@ -3005,6 +3103,54 @@ class Compiler(
}
}
private suspend fun tryParseCallTypeArgsAfterLt(): List<TypeDecl>? {
val savedAfterLt = cc.savePos()
return try {
val args = mutableListOf<TypeDecl>()
do {
val (argSem, _) = parseTypeExpressionWithMini()
args += argSem
val sep = cc.next()
when (sep.type) {
Token.Type.COMMA -> continue
Token.Type.GT -> break
Token.Type.SHR -> {
cc.pushPendingGT()
break
}
else -> {
cc.restorePos(savedAfterLt)
return null
}
}
} while (true)
val nextType = cc.peekNextNonWhitespace().type
if (nextType != Token.Type.LPAREN && nextType != Token.Type.NULL_COALESCE_INVOKE) {
cc.restorePos(savedAfterLt)
return null
}
args
} catch (_: ScriptError) {
cc.restorePos(savedAfterLt)
null
}
}
private fun isGenericCallCalleeCandidate(ref: ObjRef): Boolean {
val name = when (ref) {
is LocalVarRef -> ref.name
is FastLocalVarRef -> ref.name
is LocalSlotRef -> ref.name
else -> null
}
if (name != null) {
if (lookupGenericFunctionDecl(name) != null) return true
if (name.firstOrNull()?.isUpperCase() == true) return true
return false
}
return ref is ConstRef && ref.constValue is ObjClass
}
/**
* Parse lambda expression, leading '{' is already consumed
*/
@@ -3713,6 +3859,21 @@ class Compiler(
}
}
private fun makeTypeDeclNonNullable(type: TypeDecl): TypeDecl {
if (!type.isNullable) return type
return when (type) {
TypeDecl.TypeAny -> type
TypeDecl.TypeNullableAny -> TypeDecl.TypeAny
is TypeDecl.Function -> type.copy(nullable = false)
is TypeDecl.Ellipsis -> type.copy(nullable = false)
is TypeDecl.TypeVar -> type.copy(nullable = false)
is TypeDecl.Union -> type.copy(nullable = false)
is TypeDecl.Intersection -> type.copy(nullable = false)
is TypeDecl.Simple -> TypeDecl.Simple(type.name, false)
is TypeDecl.Generic -> TypeDecl.Generic(type.name, type.args, false)
}
}
private fun makeMiniTypeNullable(type: MiniTypeRef): MiniTypeRef {
return when (type) {
is MiniTypeName -> type.copy(nullable = true)
@@ -4125,6 +4286,22 @@ class Compiler(
is ListLiteralRef -> inferListLiteralTypeDecl(ref)
is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
is ConstRef -> inferTypeDeclFromConst(ref.constValue)
is CallRef -> {
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) }
?: run {
val targetName = when (val target = ref.target) {
is LocalVarRef -> target.name
is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name
else -> null
}
if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
TypeDecl.Simple(targetName, false)
} else {
null
}
}
}
else -> null
}
}
@@ -4237,7 +4414,7 @@ class Compiler(
val mapType = inferTypeDeclFromRef(entry.ref) ?: return TypeDecl.TypeAny to TypeDecl.TypeAny
if (mapType is TypeDecl.Generic) {
val base = mapType.name.substringAfterLast('.')
if (base == "Map") {
if (base == "Map" || base == "ImmutableMap") {
val k = mapType.args.getOrNull(0) ?: TypeDecl.TypeAny
val v = mapType.args.getOrNull(1) ?: TypeDecl.TypeAny
addKey(k)
@@ -4272,13 +4449,73 @@ class Compiler(
if (listType == TypeDecl.TypeAny || listType == TypeDecl.TypeNullableAny) return listType
if (listType is TypeDecl.Generic) {
val base = listType.name.substringAfterLast('.')
if (base == "List" || base == "Array" || base == "Iterable") {
if (base == "List" || base == "ImmutableList" || base == "Array" || base == "Iterable") {
return listType.args.firstOrNull() ?: TypeDecl.TypeAny
}
}
return TypeDecl.TypeAny
}
private fun inferCollectionElementType(typeDecl: TypeDecl): TypeDecl? {
val generic = typeDecl as? TypeDecl.Generic ?: return null
val base = generic.name.substringAfterLast('.')
return when (base) {
"Set", "ImmutableSet", "List", "ImmutableList", "Iterable", "Collection", "Array" -> generic.args.firstOrNull()
else -> null
}
}
private fun typeDeclSubtypeOf(arg: TypeDecl, param: TypeDecl): Boolean {
if (param == TypeDecl.TypeAny || param == TypeDecl.TypeNullableAny) return true
val (argBase, argNullable) = stripNullable(arg)
val (paramBase, paramNullable) = stripNullable(param)
if (argNullable && !paramNullable) return false
if (paramBase == TypeDecl.TypeAny) return true
if (paramBase is TypeDecl.TypeVar) return true
if (argBase is TypeDecl.TypeVar) return true
if (paramBase is TypeDecl.Simple && (paramBase.name == "Object" || paramBase.name == "Obj")) return true
if (argBase is TypeDecl.Ellipsis) return typeDeclSubtypeOf(argBase.elementType, paramBase)
if (paramBase is TypeDecl.Ellipsis) return typeDeclSubtypeOf(argBase, paramBase.elementType)
return when (argBase) {
is TypeDecl.Union -> argBase.options.all { typeDeclSubtypeOf(it, paramBase) }
is TypeDecl.Intersection -> argBase.options.any { typeDeclSubtypeOf(it, paramBase) }
else -> when (paramBase) {
is TypeDecl.Union -> paramBase.options.any { typeDeclSubtypeOf(argBase, it) }
is TypeDecl.Intersection -> paramBase.options.all { typeDeclSubtypeOf(argBase, it) }
else -> {
val argClass = resolveTypeDeclObjClass(argBase) ?: return false
val paramClass = resolveTypeDeclObjClass(paramBase) ?: return false
argClass == paramClass || argClass.allParentsSet.contains(paramClass)
}
}
}
}
private fun checkCollectionPlusAssignTypes(targetRef: ObjRef, valueRef: ObjRef, pos: Pos) {
// Enforce strict compile-time element checks for declared members.
// Local vars can be inferred from literals and are allowed to widen dynamically.
if (targetRef !is FieldRef) return
val targetDeclRaw = resolveReceiverTypeDecl(targetRef) ?: return
val targetDecl = expandTypeAliases(targetDeclRaw, pos)
val targetGeneric = targetDecl as? TypeDecl.Generic ?: return
val targetBase = targetGeneric.name.substringAfterLast('.')
if (targetBase != "Set" && targetBase != "List") return
val elementRaw = targetGeneric.args.firstOrNull() ?: return
val elementDecl = expandTypeAliases(elementRaw, pos)
val valueDeclRaw = inferTypeDeclFromRef(valueRef) ?: return
val valueDecl = expandTypeAliases(valueDeclRaw, pos)
if (typeDeclSubtypeOf(valueDecl, elementDecl)) return
val sourceElementDecl = inferCollectionElementType(valueDecl)?.let { expandTypeAliases(it, pos) }
if (sourceElementDecl != null && typeDeclSubtypeOf(sourceElementDecl, elementDecl)) return
throw ScriptError(
pos,
"argument type ${typeDeclName(valueDecl)} does not match ${typeDeclName(elementDecl)} for '+='"
)
}
private fun stripNullable(type: TypeDecl): Pair<TypeDecl, Boolean> {
if (type is TypeDecl.TypeNullableAny) return TypeDecl.TypeAny to true
val nullable = type.isNullable
@@ -4307,6 +4544,48 @@ class Compiler(
is TypeDecl.Intersection -> "I:${type.options.joinToString("&") { typeDeclKey(it) }}"
}
private fun classMethodReturnTypeDecl(targetClass: ObjClass?, name: String): TypeDecl? {
if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return TypeDecl.TypeAny
val member = targetClass.getInstanceMemberOrNull(name, includeAbstract = true)
val declaringName = member?.declaringClass?.className
if (declaringName != null) {
classMethodReturnTypeDeclByName[declaringName]?.get(name)?.let { return it }
classMethodReturnTypeByName[declaringName]?.get(name)?.let {
return TypeDecl.Simple(it.className, false)
}
}
classMethodReturnTypeDeclByName[targetClass.className]?.get(name)?.let { return it }
classMethodReturnTypeByName[targetClass.className]?.get(name)?.let {
return TypeDecl.Simple(it.className, false)
}
member?.typeDecl?.let { declaredType ->
if (declaredType is TypeDecl.Function) return declaredType.returnType
return declaredType
}
return null
}
private fun classMethodReturnClass(targetClass: ObjClass?, name: String): ObjClass? {
if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return ObjDynamic.type
classMethodReturnTypeDecl(targetClass, name)?.let { declared ->
resolveTypeDeclObjClass(declared)?.let { return it }
if (declared is TypeDecl.TypeVar) return Obj.rootObjectType
}
val member = targetClass.getInstanceMemberOrNull(name, includeAbstract = true)
val declaringName = member?.declaringClass?.className
if (declaringName != null) {
classMethodReturnTypeByName[declaringName]?.get(name)?.let { return it }
}
classMethodReturnTypeByName[targetClass.className]?.get(name)?.let { return it }
val declaredType = member?.typeDecl
if (declaredType is TypeDecl.Function) {
resolveTypeDeclObjClass(declaredType.returnType)?.let { return it }
}
return null
}
private fun inferObjClassFromRef(ref: ObjRef): ObjClass? = when (ref) {
is ConstRef -> ref.constValue as? ObjClass ?: ref.constValue.objClass
is LocalVarRef -> nameObjClass[ref.name] ?: resolveClassByName(ref.name)
@@ -4325,20 +4604,57 @@ class Compiler(
is ListLiteralRef -> ObjList.type
is MapLiteralRef -> ObjMap.type
is RangeRef -> ObjRange.type
is ClassOperatorRef -> ObjClassType
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
is IndexRef -> {
val targetClass = resolveReceiverClassForMember(ref.targetRef)
classMethodReturnClass(targetClass, "getAt")
?: inferFieldReturnClass(targetClass, "getAt")
}
else -> null
}
private fun seedTypeDeclByName(name: String): TypeDecl? {
seedScope?.getLocalRecordDirect(name)?.typeDecl?.let { return it }
seedScope?.get(name)?.typeDecl?.let { return it }
importManager.rootScope.getLocalRecordDirect(name)?.typeDecl?.let { return it }
importManager.rootScope.get(name)?.typeDecl?.let { return it }
for (module in importedModules.asReversed()) {
module.scope.get(name)?.typeDecl?.let { return it }
}
return null
}
private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? {
return when (ref) {
is LocalSlotRef -> {
val ownerScopeId = ref.captureOwnerScopeId ?: ref.scopeId
val ownerSlot = ref.captureOwnerSlot ?: ref.slot
slotTypeDeclByScopeId[ownerScopeId]?.get(ownerSlot)
?: nameTypeDecl[ref.name]
?: seedTypeDeclByName(ref.name)
}
is LocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name)
is FastLocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name)
is FieldRef -> {
val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null
val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target)
targetClass?.getInstanceMemberOrNull(ref.name, includeAbstract = true)?.typeDecl?.let { return it }
classFieldTypesByName[targetClass?.className]?.get(ref.name)
?.let { return TypeDecl.Simple(it.className, false) }
when (targetDecl) {
TypeDecl.TypeAny, TypeDecl.TypeNullableAny -> null
else -> TypeDecl.TypeVar("${typeDeclName(targetDecl)}.${ref.name}", false)
}
}
is IndexRef -> {
val targetDecl = resolveReceiverTypeDecl(ref.targetRef)
inferMethodCallReturnTypeDecl("getAt", targetDecl)?.let { return it }
val targetClass = resolveReceiverClassForMember(ref.targetRef)
classMethodReturnTypeDecl(targetClass, "getAt")
}
is LocalVarRef -> nameTypeDecl[ref.name]
is FastLocalVarRef -> nameTypeDecl[ref.name]
is MethodCallRef -> methodReturnTypeDeclByRef[ref]
is CallRef -> callReturnTypeDeclByRef[ref]
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
else -> null
}
@@ -4355,6 +4671,8 @@ class Compiler(
} else {
slotTypeByScopeId[ownerScopeId]?.get(ownerSlot)
?: slotTypeDeclByScopeId[ownerScopeId]?.get(ownerSlot)?.let { resolveTypeDeclObjClass(it) }
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: seedTypeDeclByName(ref.name)?.let { resolveTypeDeclObjClass(it) }
?: knownClass
}
?: resolveClassByName(ref.name)
@@ -4391,6 +4709,7 @@ class Compiler(
is ListLiteralRef -> ObjList.type
is MapLiteralRef -> ObjMap.type
is RangeRef -> ObjRange.type
is ClassOperatorRef -> ObjClassType
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
is QualifiedThisRef -> resolveClassByName(ref.typeName)
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverClassForMember(it.ref) }
@@ -4403,6 +4722,12 @@ class Compiler(
val targetClass = resolveReceiverClassForMember(ref.target)
inferFieldReturnClass(targetClass, ref.name)
}
is IndexRef -> {
val targetClass = resolveReceiverClassForMember(ref.targetRef)
classMethodReturnClass(targetClass, "getAt")
?: inferFieldReturnClass(targetClass, "getAt")
?: inferMethodCallReturnClass("getAt")
}
else -> null
}
}
@@ -4463,6 +4788,11 @@ class Compiler(
if (payload != null) return payload
}
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)
}
@@ -4480,6 +4810,74 @@ class Compiler(
name == "next" && receiver is TypeDecl.Generic && base == "Iterator" -> {
receiver.args.firstOrNull()
}
name == "toImmutableList" && receiver is TypeDecl.Generic && (base == "Iterable" || base == "Collection" || base == "Array" || base == "List" || base == "ImmutableList") -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("ImmutableList", listOf(arg), false)
}
name == "toList" && receiver is TypeDecl.Generic && (base == "ImmutableList" || base == "List") -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("List", listOf(arg), false)
}
name == "toMutable" && receiver is TypeDecl.Generic && base == "ImmutableList" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("List", listOf(arg), false)
}
name == "toImmutable" && receiver is TypeDecl.Generic && base == "List" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("ImmutableList", listOf(arg), false)
}
name == "toImmutableSet" && receiver is TypeDecl.Generic && (base == "Iterable" || base == "Collection" || base == "Set" || base == "ImmutableSet") -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("ImmutableSet", listOf(arg), false)
}
name == "toSet" && receiver is TypeDecl.Generic && (base == "Iterable" || base == "Collection" || base == "Set" || base == "ImmutableSet") -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("Set", listOf(arg), false)
}
name == "toMutable" && receiver is TypeDecl.Generic && base == "ImmutableSet" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("Set", listOf(arg), false)
}
name == "toImmutable" && receiver is TypeDecl.Generic && base == "Set" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("ImmutableSet", listOf(arg), false)
}
name == "toImmutableMap" && receiver is TypeDecl.Generic && base == "Iterable" -> {
TypeDecl.Generic("ImmutableMap", listOf(TypeDecl.TypeAny, TypeDecl.TypeAny), false)
}
name == "observable" && receiver is TypeDecl.Generic && (base == "List" || base == "ObservableList") -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("ObservableList", listOf(arg), false)
}
name == "changes" && receiver is TypeDecl.Generic && base == "ObservableList" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("Flow", listOf(TypeDecl.Generic("ListChange", listOf(arg), false)), false)
}
name == "changes" && receiver is TypeDecl.Generic && base == "Observable" -> {
val arg = receiver.args.firstOrNull() ?: TypeDecl.TypeAny
TypeDecl.Generic("Flow", listOf(arg), false)
}
(name == "beforeChange" || name == "onChange") && receiver is TypeDecl.Generic &&
(base == "Observable" || base == "ObservableList") -> {
TypeDecl.Simple("Subscription", false)
}
name == "toMap" && receiver is TypeDecl.Generic && base == "Iterable" -> {
TypeDecl.Generic("Map", listOf(TypeDecl.TypeAny, TypeDecl.TypeAny), false)
}
name == "toMutable" && receiver is TypeDecl.Generic && base == "ImmutableMap" -> {
val args = receiver.args.ifEmpty { listOf(TypeDecl.TypeAny, TypeDecl.TypeAny) }
TypeDecl.Generic("Map", args, false)
}
name == "toImmutable" && receiver is TypeDecl.Generic && base == "Map" -> {
val args = receiver.args.ifEmpty { listOf(TypeDecl.TypeAny, TypeDecl.TypeAny) }
TypeDecl.Generic("ImmutableMap", args, false)
}
name == "toImmutable" && base == "List" -> TypeDecl.Simple("ImmutableList", false)
name == "toMutable" && base == "ImmutableList" -> TypeDecl.Simple("List", false)
name == "toImmutable" && base == "Set" -> TypeDecl.Simple("ImmutableSet", false)
name == "toMutable" && base == "ImmutableSet" -> TypeDecl.Simple("Set", false)
name == "toImmutable" && base == "Map" -> TypeDecl.Simple("ImmutableMap", false)
name == "toMutable" && base == "ImmutableMap" -> TypeDecl.Simple("Map", false)
else -> null
}
}
@@ -4550,6 +4948,13 @@ class Compiler(
"matches" -> ObjBool.type
"toInt",
"toEpochSeconds" -> ObjInt.type
"toImmutableList" -> ObjImmutableList.type
"toImmutableSet" -> ObjImmutableSet.type
"toImmutableMap" -> ObjImmutableMap.type
"observable" -> ObjObservableList.type
"beforeChange", "onChange" -> ObjSubscription.type
"changes" -> ObjFlow.type
"toImmutable" -> Obj.rootObjectType
"toMutable" -> ObjMutableBuffer.type
"seq" -> ObjFlow.type
"encode" -> ObjBitBuffer.type
@@ -4561,6 +4966,18 @@ class Compiler(
if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return ObjDynamic.type
classFieldTypesByName[targetClass.className]?.get(name)?.let { return it }
var hasUntypedMember = false
targetClass.getInstanceMemberOrNull(name, includeAbstract = true)?.let { member ->
member.typeDecl?.let { declaredType ->
when (declaredType) {
TypeDecl.TypeAny, TypeDecl.TypeNullableAny -> return Obj.rootObjectType
else -> {
resolveTypeDeclObjClass(declaredType)?.let { return it }
}
}
}
hasUntypedMember = true
}
enumEntriesByName[targetClass.className]?.let { entries ->
return when {
name == "entries" -> ObjList.type
@@ -4647,6 +5064,9 @@ class Compiler(
if (targetClass == ObjRegex.type && name == "pattern") {
return ObjString.type
}
if (hasUntypedMember) {
return ObjDynamic.type
}
return null
}
@@ -4660,6 +5080,10 @@ class Compiler(
if (left is LocalSlotRef && left.name == "scope") return
val receiverClass = resolveReceiverClassForMember(left)
if (receiverClass == null) {
val receiverDecl = resolveReceiverTypeDecl(left)
if (receiverDecl != null && receiverDecl != TypeDecl.TypeAny && receiverDecl != TypeDecl.TypeNullableAny) {
return
}
if (isAllowedObjectMember(memberName)) return
throw ScriptError(pos, "member access requires compile-time receiver type: $memberName")
}
@@ -4795,6 +5219,7 @@ class Compiler(
}
private fun resolveTypeRefClass(ref: ObjRef): ObjClass? = when (ref) {
is TypeDeclRef -> resolveTypeDeclObjClass(ref.decl())
is ConstRef -> ref.constValue as? ObjClass
is LocalSlotRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
is LocalVarRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
@@ -5063,6 +5488,10 @@ class Compiler(
typeParams: List<TypeDecl.TypeParam>
): Map<String, Obj> {
if (typeParams.isEmpty()) return emptyMap()
val explicitTypeArgs = context.args.explicitTypeArgs
if (explicitTypeArgs.size > typeParams.size) {
context.raiseError("too many type arguments: expected ${typeParams.size}, got ${explicitTypeArgs.size}")
}
val inferred = mutableMapOf<String, TypeDecl>()
val argValues = context.args.list
for ((index, param) in argsDeclaration.params.withIndex()) {
@@ -5075,8 +5504,11 @@ class Compiler(
collectRuntimeTypeVarBindings(param.type, value, inferred)
}
val boundValues = LinkedHashMap<String, Obj>(typeParams.size)
for (tp in typeParams) {
val inferredType = inferred[tp.name] ?: tp.defaultType ?: TypeDecl.TypeAny
for ((index, tp) in typeParams.withIndex()) {
val inferredType = explicitTypeArgs.getOrNull(index)
?: inferred[tp.name]
?: tp.defaultType
?: TypeDecl.TypeAny
val normalized = normalizeRuntimeTypeDecl(inferredType)
val cls = resolveTypeDeclObjClass(normalized)
val boundValue = if (cls != null &&
@@ -5356,7 +5788,8 @@ class Compiler(
private suspend fun parseFunctionCall(
left: ObjRef,
blockArgument: Boolean,
isOptional: Boolean
isOptional: Boolean,
explicitTypeArgs: List<TypeDecl>? = null
): ObjRef {
var detectedBlockArgument = blockArgument
val expectedReceiver = tailBlockReceiverType(left)
@@ -5397,7 +5830,9 @@ class Compiler(
val result = when (left) {
is ImplicitThisMemberRef ->
if (left.methodId == null && left.fieldId != null) {
CallRef(left, args, detectedBlockArgument, isOptional)
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
}
} else {
ImplicitThisMethodCallRef(
left.name,
@@ -5430,7 +5865,9 @@ class Compiler(
checkFunctionTypeCallArity(left, args, left.pos())
checkFunctionTypeCallTypes(left, args, left.pos())
checkGenericBoundsAtCall(left.name, args, left.pos())
CallRef(left, args, detectedBlockArgument, isOptional)
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
}
}
}
is LocalSlotRef -> {
@@ -5454,14 +5891,30 @@ class Compiler(
checkFunctionTypeCallArity(left, args, left.pos())
checkFunctionTypeCallTypes(left, args, left.pos())
checkGenericBoundsAtCall(left.name, args, left.pos())
CallRef(left, args, detectedBlockArgument, isOptional)
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
}
}
}
else -> CallRef(left, args, detectedBlockArgument, isOptional)
else -> CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
}
}
return result
}
private fun applyExplicitCallTypeArgs(callRef: CallRef, explicitTypeArgs: List<TypeDecl>?) {
if (explicitTypeArgs.isNullOrEmpty()) return
val baseName = when (val target = callRef.target) {
is LocalVarRef -> target.name
is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name
is ConstRef -> (target.constValue as? ObjClass)?.className
else -> null
} ?: return
callReturnTypeDeclByRef[callRef] = TypeDecl.Generic(baseName, explicitTypeArgs, isNullable = false)
}
private fun inferReceiverTypeFromArgs(args: List<ParsedArgument>): String? {
val stmt = args.firstOrNull()?.value as? ExpressionStatement ?: return null
val ref = stmt.ref
@@ -5939,10 +6392,14 @@ class Compiler(
Token.Type.IS,
Token.Type.NOTIS -> {
val negated = t.type == Token.Type.NOTIS
val (typeDecl, _) = parseTypeExpressionWithMini()
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, t.pos)
val caseType = ExpressionStatement(typeRef, t.pos)
currentConditions += WhenIsCondition(caseType, negated, t.pos)
if (tryConsumeNullablePredicate()) {
currentConditions += WhenNullableCondition(negated, t.pos)
} else {
val (typeDecl, _) = parseTypeExpressionWithMini()
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, t.pos)
val caseType = ExpressionStatement(typeRef, t.pos)
currentConditions += WhenIsCondition(caseType, negated, t.pos)
}
}
Token.Type.COMMA ->
@@ -5955,7 +6412,9 @@ class Compiler(
break@outer
else -> {
if (t.value == "else") {
if (t.type == Token.Type.ID && t.value == "nullable") {
currentConditions += WhenNullableCondition(negated = false, t.pos)
} else if (t.value == "else") {
cc.skipTokens(Token.Type.ARROW)
if (elseCase != null) throw ScriptError(
cc.currentPos(),
@@ -7205,6 +7664,27 @@ class Compiler(
}
}
private fun applyAssertSmartCasts(statement: Statement) {
val ref = unwrapDirectRef(statement) as? CallRef ?: return
val targetName = when (val target = ref.target) {
is LocalVarRef -> target.name
is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name
else -> null
} ?: return
if (targetName != "assert") return
val conditionArg = ref.args.firstOrNull { !it.isSplat && it.name == null }
?: ref.args.firstOrNull { !it.isSplat && it.name == "condition" }
?: return
val conditionStatement = when (val argValue = conditionArg.value) {
is Statement -> argValue
is ObjRef -> ExpressionStatement(argValue, conditionArg.pos)
else -> return
}
val (trueCasts, _) = extractSmartCasts(conditionStatement)
applySmartCasts(trueCasts)
}
private suspend fun parseIfStatement(): Statement {
val start = ensureLparen()
@@ -7523,6 +8003,23 @@ class Compiler(
val rawFnStatements = parsedFnStatements?.let { unwrapBytecodeDeep(it) }
val inferredReturnClass = returnTypeDecl?.let { resolveTypeDeclObjClass(it) }
?: inferReturnClassFromStatement(rawFnStatements)
if (declKind == SymbolKind.MEMBER && extTypeName == null) {
val ownerClassName = (parentContext as? CodeContext.ClassBody)?.name
if (ownerClassName != null) {
val returnDecl = returnTypeDecl
?: inferredReturnClass?.let { TypeDecl.Simple(it.className, false) }
if (returnDecl != null) {
classMethodReturnTypeDeclByName
.getOrPut(ownerClassName) { mutableMapOf() }[name] = returnDecl
resolveTypeDeclObjClass(returnDecl)?.let { returnClass ->
classMethodReturnTypeByName
.getOrPut(ownerClassName) { mutableMapOf() }[name] = returnClass
classFieldTypesByName
.getOrPut(ownerClassName) { mutableMapOf() }[name] = returnClass
}
}
}
}
if (declKind != SymbolKind.MEMBER && inferredReturnClass != null) {
callableReturnTypeByName[name] = inferredReturnClass
val slotLoc = lookupSlotLocation(name, includeModule = true)
@@ -7998,8 +8495,11 @@ class Compiler(
"Bool" -> ObjBool.type
"Char" -> ObjChar.type
"List" -> ObjList.type
"ImmutableList" -> ObjImmutableList.type
"Map" -> ObjMap.type
"ImmutableMap" -> ObjImmutableMap.type
"Set" -> ObjSet.type
"ImmutableSet" -> ObjImmutableSet.type
"Range", "IntRange" -> ObjRange.type
"Iterator" -> ObjIterator
"Iterable" -> ObjIterable
@@ -8013,6 +8513,16 @@ class Compiler(
"Regex" -> ObjRegex.type
"RegexMatch" -> ObjRegexMatch.type
"MapEntry" -> ObjMapEntry.type
"Observable" -> ObjObservable
"Subscription" -> ObjSubscription.type
"ListChange" -> ObjListChange.type
"ListSet" -> ObjListSetChange.type
"ListInsert" -> ObjListInsertChange.type
"ListRemove" -> ObjListRemoveChange.type
"ListClear" -> ObjListClearChange.type
"ListReorder" -> ObjListReorderChange.type
"ObservableList" -> ObjObservableList.type
"ChangeRejectionException" -> ObjChangeRejectionExceptionClass
"Exception" -> ObjException.Root
"Instant" -> ObjInstant.type
"DateTime" -> ObjDateTime.type
@@ -8286,7 +8796,6 @@ class Compiler(
name = nameToken.value
nameStartPos = nameToken.pos
}
val receiverNormalization = normalizeReceiverTypeDecl(receiverTypeDecl, emptySet())
val implicitTypeParams = receiverNormalization.second
if (implicitTypeParams.isNotEmpty()) pendingTypeParamStack.add(implicitTypeParams)
@@ -8879,6 +9388,7 @@ class Compiler(
isMutable = isMutable,
visibility = visibility,
writeVisibility = setterVisibility,
typeDecl = if (varTypeDecl == TypeDecl.TypeAny || varTypeDecl == TypeDecl.TypeNullableAny) null else varTypeDecl,
isAbstract = isAbstract,
isClosed = isClosed,
isOverride = isOverride,
@@ -26,7 +26,10 @@ val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
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>()
do {
val t = p.nextToken()
@@ -35,9 +38,70 @@ fun parseLyng(source: Source): List<Token> {
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 bufferedTokens = ArrayDeque<Token>()
/**
* Immutable copy of current position
@@ -47,6 +111,7 @@ private class Parser(fromPos: Pos) {
private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg)
fun nextToken(): Token {
if (bufferedTokens.isNotEmpty()) return bufferedTokens.removeFirst()
skipws()
if (pos.end) return Token("", currentPos, Token.Type.EOF)
val from = currentPos
@@ -296,7 +361,7 @@ private class Parser(fromPos: Pos) {
Token(":", from, Token.Type.COLON)
}
'"' -> loadStringToken()
'"' -> loadStringTokens(from)
in digitsSet -> {
pos.back()
@@ -306,17 +371,41 @@ private class Parser(fromPos: Pos) {
'\'' -> {
val start = pos.toPos()
var value = currentChar
pos.advance()
if (currentChar == '\\') {
value = currentChar
pos.advance()
value = when (value) {
'n' -> '\n'
'r' -> '\r'
't' -> '\t'
'\'', '\\' -> value
else -> throw ScriptError(currentPos, "unsupported escape character: $value")
if (pos.end) throw ScriptError(start, "unterminated character literal")
value = when (currentChar) {
'n' -> {
pos.advance()
'\n'
}
'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: '")
pos.advance()
@@ -461,11 +550,6 @@ private class Parser(fromPos: Pos) {
private fun loadStringToken(): Token {
val start = currentPos
// if (currentChar == '"') pos.advance()
// else start = start.back()
// start = start.back()
val sb = StringBuilder()
var newlineDetected = false
while (currentChar != '"') {
@@ -494,6 +578,10 @@ private class Parser(fromPos: Pos) {
sb.append('\\'); pos.advance()
}
'u' -> {
sb.append(loadUnicodeEscape(start))
}
else -> {
sb.append('\\').append(currentChar)
pos.advance()
@@ -520,6 +608,279 @@ private class Parser(fromPos: Pos) {
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.
* stop at EOF on character filtered by [isValidChar].
@@ -471,6 +471,62 @@ open class Scope(
}
}
private fun resolvedRecordValueOrNull(record: ObjRecord): Obj? {
return when (val raw = record.value) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
else -> raw
}
}
private fun declaredTypeForValueInThisScope(value: Obj): TypeDecl? {
// Prefer direct bindings first.
for (record in objects.values) {
val decl = record.typeDecl ?: continue
if (resolvedRecordValueOrNull(record) === value) return decl
}
for ((_, record) in localBindings) {
val decl = record.typeDecl ?: continue
if (resolvedRecordValueOrNull(record) === value) return decl
}
// Then slots (for frame-first locals).
var i = 0
while (i < slots.size) {
val record = slots[i]
val decl = record.typeDecl
if (decl != null && resolvedRecordValueOrNull(record) === value) return decl
i++
}
return null
}
private fun declaredCollectionElementTypeForValue(value: Obj, rawName: String): TypeDecl? {
var s: Scope? = this
var hops = 0
while (s != null && hops++ < 1024) {
val decl = s.declaredTypeForValueInThisScope(value)
if (decl is TypeDecl.Generic && decl.name.substringAfterLast('.') == rawName) {
return decl.args.firstOrNull()
}
s = s.parent
}
return null
}
/**
* Best-effort lookup of the declared Set element type for a runtime set instance.
* Returns null when type info is unavailable.
*/
fun declaredSetElementTypeForValue(value: Obj): TypeDecl? =
declaredCollectionElementTypeForValue(value, "Set")
/**
* Best-effort lookup of the declared List element type for a runtime list instance.
* Returns null when type info is unavailable.
*/
fun declaredListElementTypeForValue(value: Obj): TypeDecl? =
declaredCollectionElementTypeForValue(value, "List")
internal fun applySlotPlanReset(plan: Map<String, Int>, records: Map<String, ObjRecord>) {
if (plan.isEmpty()) return
slots.clear()
@@ -20,15 +20,19 @@ package net.sergeych.lyng
import kotlinx.coroutines.delay
import kotlinx.coroutines.yield
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.CmdVm
import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer
import kotlin.math.*
import kotlin.random.Random as KRandom
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
class Script(
@@ -522,9 +526,12 @@ class Script(
addConst("Bool", ObjBool.type)
addConst("Char", ObjChar.type)
addConst("List", ObjList.type)
addConst("ImmutableList", ObjImmutableList.type)
addConst("Set", ObjSet.type)
addConst("ImmutableSet", ObjImmutableSet.type)
addConst("Range", ObjRange.type)
addConst("Map", ObjMap.type)
addConst("ImmutableMap", ObjImmutableMap.type)
addConst("MapEntry", ObjMapEntry.type)
@Suppress("RemoveRedundantQualifierName")
addConst("Callable", Statement.type)
@@ -584,11 +591,110 @@ 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 {
ImportManager(rootScope, SecurityManager.allowAll).apply {
addPackage("lyng.stdlib") { module ->
module.eval(Source("lyng.stdlib", rootLyng))
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 ->
module.addConst("Observable", ObjObservable)
module.addConst("Subscription", ObjSubscription.type)
module.addConst("ListChange", ObjListChange.type)
module.addConst("ListSet", ObjListSetChange.type)
module.addConst("ListInsert", ObjListInsertChange.type)
module.addConst("ListRemove", ObjListRemoveChange.type)
module.addConst("ListClear", ObjListClearChange.type)
module.addConst("ListReorder", ObjListReorderChange.type)
module.addConst("ObservableList", ObjObservableList.type)
module.addConst("ChangeRejectionException", ObjChangeRejectionExceptionClass)
module.eval(Source("lyng.observable", observableLyng))
}
addPackage("lyng.buffer") {
it.addConstDoc(
@@ -1,5 +1,5 @@
/*
* Copyright 2026 Sergey S. Chernov
* 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.
@@ -12,6 +12,7 @@
* 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
@@ -55,6 +56,15 @@ class WhenIsCondition(
}
}
class WhenNullableCondition(
val negated: Boolean,
override val pos: Pos,
) : WhenCondition(ExpressionStatement(net.sergeych.lyng.obj.ConstRef(net.sergeych.lyng.obj.ObjVoid.asReadonly), pos), pos) {
override suspend fun matches(scope: Scope, value: Obj): Boolean {
return bytecodeOnly(scope)
}
}
data class WhenCase(val conditions: List<WhenCondition>, val block: Statement)
class WhenStatement(
@@ -51,8 +51,9 @@ interface BridgeInstanceContext {
* Use [LyngClassBridge.bind] to obtain a binder and register implementations.
* Bindings must happen before the first instance of the class is created.
*
* Important: members you bind here must be declared as `extern` in Lyng so the
* compiler emits the ABI slots that Kotlin bindings attach to.
* Important: members you bind here must be extern in Lyng (explicitly, or
* implicitly by being inside `extern class` / `extern object`) so the compiler
* emits the ABI slots that Kotlin bindings attach to.
*/
interface ClassBridgeBinder {
/** Arbitrary Kotlin-side data attached to the class. */
@@ -60,12 +61,54 @@ interface ClassBridgeBinder {
/** Register an initialization hook that runs for each instance. */
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
/** Register an initialization hook with direct access to the instance. */
fun initWithInstance(block: suspend ScopeFacade.() -> Unit)
/**
* Legacy initWithInstance form.
* Prefer [initWithInstance] with [ScopeFacade] receiver and use [ScopeFacade.thisObj].
*/
@Deprecated(
message = "Use initWithInstance { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("initWithInstance { block(this, thisObj) }")
)
fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit)
/** Bind a Lyng function/member to a Kotlin implementation (requires `extern` in Lyng). */
/** Bind a Lyng function/member to a Kotlin implementation (requires extern member in Lyng). */
fun addFun(name: String, impl: suspend ScopeFacade.() -> Obj)
/**
* Legacy addFun form.
* Prefer [addFun] with [ScopeFacade] receiver and use [ScopeFacade.thisObj]/[ScopeFacade.args].
*/
@Deprecated(
message = "Use addFun(name) { ... } with ScopeFacade receiver; use thisObj/args from scope",
replaceWith = ReplaceWith("addFun(name) { impl(this, thisObj, args) }")
)
fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj)
/** Bind a read-only member (val/property getter) declared as `extern`. */
/** Bind a read-only member (val/property getter) declared extern in Lyng. */
fun addVal(name: String, impl: suspend ScopeFacade.() -> Obj)
/**
* Legacy addVal form.
* Prefer [addVal] with [ScopeFacade] receiver and use [ScopeFacade.thisObj].
*/
@Deprecated(
message = "Use addVal(name) { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("addVal(name) { impl(this, thisObj) }")
)
fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj)
/** Bind a mutable member (var/property getter/setter) declared as `extern`. */
/** Bind a mutable member (var/property getter/setter) declared extern in Lyng. */
fun addVar(
name: String,
get: suspend ScopeFacade.() -> Obj,
set: suspend ScopeFacade.(Obj) -> Unit
)
/**
* Legacy addVar form.
* Prefer [addVar] with [ScopeFacade] receiver and use [ScopeFacade.thisObj].
*/
@Deprecated(
message = "Use addVar(name, get, set) with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith(
"addVar(name, get = { get(this, thisObj) }, set = { value -> set(this, thisObj, value) })"
)
)
fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
@@ -77,8 +120,9 @@ interface ClassBridgeBinder {
* Entry point for Kotlin bindings to declared Lyng classes.
*
* The workflow is Lyng-first: declare the class and its members in Lyng,
* then bind the implementations from Kotlin. Bound members must be marked
* `extern` so the compiler emits the ABI slots for Kotlin to attach to.
* then bind the implementations from Kotlin. Bound members must be extern
* (explicitly or by enclosing `extern class` / `extern object`) so the compiler
* emits the ABI slots for Kotlin to attach to.
*/
object LyngClassBridge {
/**
@@ -170,7 +214,7 @@ object LyngObjectBridge {
/**
* Sugar for [LyngClassBridge.bind] on a module scope.
*
* Bound members must be declared as `extern` in Lyng.
* Bound members must be extern in Lyng (explicitly or via enclosing extern class/object).
*/
suspend fun ModuleScope.bind(
className: String,
@@ -180,7 +224,7 @@ suspend fun ModuleScope.bind(
/**
* Sugar for [LyngObjectBridge.bind] on a module scope.
*
* Bound members must be declared as `extern` in Lyng.
* Bound members must be extern in Lyng (explicitly or via enclosing extern class/object).
*/
suspend fun ModuleScope.bindObject(
objectName: String,
@@ -234,17 +278,27 @@ private class ClassBridgeBinderImpl(
}
}
override fun initWithInstance(block: suspend ScopeFacade.() -> Unit) {
initHooks.add { scope, _ ->
scope.block()
}
}
@Deprecated(
message = "Use initWithInstance { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("initWithInstance { block(this, thisObj) }")
)
override fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit) {
initHooks.add { scope, inst ->
block(scope, inst)
}
}
override fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj) {
override fun addFun(name: String, impl: suspend ScopeFacade.() -> Obj) {
ensureTemplateNotBuilt()
val target = findMember(name)
val callable = ObjExternCallable.fromBridge {
impl(this, thisObj, args)
impl()
}
val methodId = cls.ensureMethodIdForBridge(name, target.record)
val newRecord = target.record.copy(
@@ -255,14 +309,24 @@ private class ClassBridgeBinderImpl(
replaceMember(target, newRecord)
}
override fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj) {
@Deprecated(
message = "Use addFun(name) { ... } with ScopeFacade receiver; use thisObj/args from scope",
replaceWith = ReplaceWith("addFun(name) { impl(this, thisObj, args) }")
)
override fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj) {
addFun(name) {
impl(this, thisObj, args)
}
}
override fun addVal(name: String, impl: suspend ScopeFacade.() -> Obj) {
ensureTemplateNotBuilt()
val target = findMember(name)
if (target.record.isMutable) {
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
impl(this, thisObj)
impl()
}
val prop = ObjProperty(name, getter, null)
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
@@ -287,10 +351,20 @@ private class ClassBridgeBinderImpl(
replaceMember(target, newRecord)
}
@Deprecated(
message = "Use addVal(name) { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("addVal(name) { impl(this, thisObj) }")
)
override fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj) {
addVal(name) {
impl(this, thisObj)
}
}
override fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
get: suspend ScopeFacade.() -> Obj,
set: suspend ScopeFacade.(Obj) -> Unit
) {
ensureTemplateNotBuilt()
val target = findMember(name)
@@ -298,11 +372,11 @@ private class ClassBridgeBinderImpl(
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
get(this, thisObj)
get()
}
val setter = ObjExternCallable.fromBridge {
val value = requiredArg<Obj>(0)
set(this, thisObj, value)
set(value)
ObjVoid
}
val prop = ObjProperty(name, getter, setter)
@@ -328,6 +402,24 @@ private class ClassBridgeBinderImpl(
replaceMember(target, newRecord)
}
@Deprecated(
message = "Use addVar(name, get, set) with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith(
"addVar(name, get = { get(this, thisObj) }, set = { value -> set(this, thisObj, value) })"
)
)
override fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
) {
addVar(
name,
get = { get(this, thisObj) },
set = { value -> set(this, thisObj, value) }
)
}
fun commit() {
if (initHooks.isNotEmpty()) {
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
@@ -399,16 +491,26 @@ private class ObjectBridgeBinderImpl(
}
}
override fun initWithInstance(block: suspend ScopeFacade.() -> Unit) {
initHooks.add { scope, _ ->
scope.block()
}
}
@Deprecated(
message = "Use initWithInstance { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("initWithInstance { block(this, thisObj) }")
)
override fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit) {
initHooks.add { scope, inst ->
block(scope, inst)
}
}
override fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj) {
override fun addFun(name: String, impl: suspend ScopeFacade.() -> Obj) {
val target = findMember(name)
val callable = ObjExternCallable.fromBridge {
impl(this, thisObj, args)
impl()
}
val methodId = cls.ensureMethodIdForBridge(name, target.record)
val newRecord = target.record.copy(
@@ -420,13 +522,23 @@ private class ObjectBridgeBinderImpl(
updateInstanceMember(target, newRecord)
}
override fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj) {
@Deprecated(
message = "Use addFun(name) { ... } with ScopeFacade receiver; use thisObj/args from scope",
replaceWith = ReplaceWith("addFun(name) { impl(this, thisObj, args) }")
)
override fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj) {
addFun(name) {
impl(this, thisObj, args)
}
}
override fun addVal(name: String, impl: suspend ScopeFacade.() -> Obj) {
val target = findMember(name)
if (target.record.isMutable) {
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
impl(this, thisObj)
impl()
}
val prop = ObjProperty(name, getter, null)
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
@@ -452,21 +564,31 @@ private class ObjectBridgeBinderImpl(
updateInstanceMember(target, newRecord)
}
@Deprecated(
message = "Use addVal(name) { ... } with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith("addVal(name) { impl(this, thisObj) }")
)
override fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj) {
addVal(name) {
impl(this, thisObj)
}
}
override fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
get: suspend ScopeFacade.() -> Obj,
set: suspend ScopeFacade.(Obj) -> Unit
) {
val target = findMember(name)
if (!target.record.isMutable) {
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
get(this, thisObj)
get()
}
val setter = ObjExternCallable.fromBridge {
val value = requiredArg<Obj>(0)
set(this, thisObj, value)
set(value)
ObjVoid
}
val prop = ObjProperty(name, getter, setter)
@@ -493,6 +615,24 @@ private class ObjectBridgeBinderImpl(
updateInstanceMember(target, newRecord)
}
@Deprecated(
message = "Use addVar(name, get, set) with ScopeFacade receiver; use thisObj from scope",
replaceWith = ReplaceWith(
"addVar(name, get = { get(this, thisObj) }, set = { value -> set(this, thisObj, value) })"
)
)
override fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
) {
addVar(
name,
get = { get(this, thisObj) },
set = { value -> set(this, thisObj, value) }
)
}
suspend fun commit() {
if (initHooks.isNotEmpty()) {
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
@@ -0,0 +1,264 @@
/*
* 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.bridge
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjExternCallable
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjProperty
import net.sergeych.lyng.obj.ObjReal
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.toBool
import net.sergeych.lyng.obj.toDouble
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.obj.toLong
import net.sergeych.lyng.obj.toObj
import net.sergeych.lyng.requiredArg
/**
* Global/module-level binding API for Lyng-first extern declarations.
*
* Typical flow:
* 1) declare `extern fun` / `extern val` / `extern var` in Lyng module;
* 2) bind Kotlin implementation using this API.
*/
interface LyngGlobalBinder {
fun bindGlobalFunRaw(
name: String,
fn: suspend (scope: ScopeFacade, args: Arguments) -> Obj
)
fun bindGlobalFun(
name: String,
fn: suspend GlobalArgReader.() -> Obj
)
fun bindGlobalVarRaw(
name: String,
get: suspend (scope: ScopeFacade) -> Obj,
set: (suspend (scope: ScopeFacade, value: Obj) -> Unit)? = null
)
}
/**
* Reader helper for Kotlin-typed argument access.
*/
interface GlobalArgReader {
val scope: ScopeFacade
val args: Arguments
val size: Int
fun requireExactCount(count: Int)
fun obj(index: Int): Obj
fun objOrNull(index: Int): Obj?
fun int(index: Int): Int
fun long(index: Int): Long
fun double(index: Int): Double
fun bool(index: Int): Boolean
fun string(index: Int): String
}
private class ModuleGlobalBinder(
private val module: ModuleScope
) : LyngGlobalBinder {
override fun bindGlobalFunRaw(
name: String,
fn: suspend (scope: ScopeFacade, args: Arguments) -> Obj
) {
val existing = module[name]
val callable = ObjExternCallable.fromBridge {
fn(this, args)
}
module.addItem(
name = name,
isMutable = false,
value = callable,
visibility = existing?.visibility ?: Visibility.Public,
writeVisibility = existing?.writeVisibility,
recordType = ObjRecord.Type.Fun,
callSignature = existing?.callSignature,
typeDecl = existing?.typeDecl
)
}
override fun bindGlobalFun(
name: String,
fn: suspend GlobalArgReader.() -> Obj
) {
bindGlobalFunRaw(name) { scope, args ->
val reader = GlobalArgReaderImpl(scope, args)
fn(reader)
}
}
override fun bindGlobalVarRaw(
name: String,
get: suspend (scope: ScopeFacade) -> Obj,
set: (suspend (scope: ScopeFacade, value: Obj) -> Unit)?
) {
val existing = module[name]
if (existing != null) {
if (existing.isMutable && set == null) {
throw net.sergeych.lyng.ScriptError(Pos.builtIn, "extern var $name requires a setter")
}
if (!existing.isMutable && set != null) {
throw net.sergeych.lyng.ScriptError(Pos.builtIn, "extern val $name does not allow a setter")
}
}
val mutable = existing?.isMutable ?: (set != null)
val getter = ObjExternCallable.fromBridge {
get(this)
}
val setter = set?.let { setterImpl ->
ObjExternCallable.fromBridge {
setterImpl(this, requiredArg(0))
ObjVoid
}
}
module.addItem(
name = name,
isMutable = mutable,
value = ObjProperty(name, getter, setter),
visibility = existing?.visibility ?: Visibility.Public,
writeVisibility = existing?.writeVisibility,
recordType = ObjRecord.Type.Property,
callSignature = existing?.callSignature,
typeDecl = existing?.typeDecl
)
}
}
private class GlobalArgReaderImpl(
override val scope: ScopeFacade,
override val args: Arguments
) : GlobalArgReader {
override val size: Int
get() = args.list.size
override fun requireExactCount(count: Int) {
if (size != count) scope.raiseIllegalArgument("Expected exactly $count arguments, got $size")
}
override fun obj(index: Int): Obj =
objOrNull(index) ?: scope.raiseIllegalArgument("Missing required argument at index $index")
override fun objOrNull(index: Int): Obj? =
args.list.getOrNull(index)
override fun int(index: Int): Int = long(index).toInt()
override fun long(index: Int): Long = obj(index).toLong()
override fun double(index: Int): Double = obj(index).toDouble()
override fun bool(index: Int): Boolean = obj(index).toBool()
override fun string(index: Int): String {
val value = obj(index)
return (value as? ObjString)?.value
?: scope.raiseClassCastError("Expected String at index $index, got ${value.objClass.className}")
}
}
fun ModuleScope.globalBinder(): LyngGlobalBinder = ModuleGlobalBinder(this)
inline fun <reified T> GlobalArgReader.required(index: Int): T =
coerceArg(scope, obj(index), index)
inline fun <reified T> GlobalArgReader.optional(index: Int, default: T): T {
val value = objOrNull(index) ?: return default
return coerceArg(scope, value, index)
}
inline fun <reified A1> LyngGlobalBinder.bindGlobalFun1(
name: String,
noinline fn: suspend (A1) -> Obj
) {
bindGlobalFun(name) {
requireExactCount(1)
fn(required(0))
}
}
inline fun <reified A1, reified A2> LyngGlobalBinder.bindGlobalFun2(
name: String,
noinline fn: suspend (A1, A2) -> Obj
) {
bindGlobalFun(name) {
requireExactCount(2)
fn(required(0), required(1))
}
}
inline fun <reified A1, reified A2, reified A3> LyngGlobalBinder.bindGlobalFun3(
name: String,
noinline fn: suspend (A1, A2, A3) -> Obj
) {
bindGlobalFun(name) {
requireExactCount(3)
fn(required(0), required(1), required(2))
}
}
inline fun <reified T> LyngGlobalBinder.bindGlobalVar(
name: String,
noinline get: suspend () -> T,
noinline set: (suspend (T) -> Unit)? = null
) {
bindGlobalVarRaw(
name = name,
get = { get().toObj() },
set = set?.let { setter ->
{ scope, value ->
setter(coerceArg<T>(scope = scope, value = value, index = 0))
}
}
)
}
@PublishedApi
internal inline fun <reified T> coerceArg(scope: ScopeFacade, value: Obj, index: Int): T {
if (value === ObjNull && null is T) return null as T
(value as? T)?.let { return it }
@Suppress("UNCHECKED_CAST")
return when (T::class) {
Int::class -> value.toInt() as T
Long::class -> value.toLong() as T
Double::class -> value.toDouble() as T
Float::class -> value.toDouble().toFloat() as T
Boolean::class -> value.toBool() as T
String::class -> (value as? ObjString)?.value as? T
?: scope.raiseClassCastError("Expected String at index $index, got ${value.objClass.className}")
Obj::class -> value as T
ObjInt::class -> (value as? ObjInt) as? T
?: scope.raiseClassCastError("Expected ObjInt at index $index, got ${value.objClass.className}")
ObjString::class -> (value as? ObjString) as? T
?: scope.raiseClassCastError("Expected ObjString at index $index, got ${value.objClass.className}")
ObjReal::class -> (value as? ObjReal) as? T
?: scope.raiseClassCastError("Expected ObjReal at index $index, got ${value.objClass.className}")
ObjBool::class -> (value as? ObjBool) as? T
?: scope.raiseClassCastError("Expected ObjBool at index $index, got ${value.objClass.className}")
else -> scope.raiseClassCastError("Unsupported typed argument binding for ${T::class.simpleName}")
}
}
@@ -1067,18 +1067,9 @@ class BytecodeCompiler(
updateSlotType(dst, SlotType.OBJ)
return CompiledValue(dst, SlotType.OBJ)
}
if (receiverClass == null && memberName == "negate") {
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
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)) {
if (memberName == "negate" &&
(receiverClass == null || isDelegateClass(receiverClass) || receiverClass in setOf(ObjInt.type, ObjReal.type))
) {
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
val zeroSlot = allocSlot()
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
@@ -1095,6 +1086,11 @@ class BytecodeCompiler(
)
}
private fun isDelegateClass(receiverClass: ObjClass): Boolean =
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
private fun operatorMemberName(op: BinOp): String? = when (op) {
BinOp.PLUS -> "plus"
BinOp.MINUS -> "minus"
@@ -1142,11 +1138,7 @@ class BytecodeCompiler(
): CompiledValue? {
val memberName = operatorMemberName(op) ?: return null
val receiverClass = resolveReceiverClass(leftRef)
if (receiverClass == null ||
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
) {
if (receiverClass == null || isDelegateClass(receiverClass)) {
val objOpcode = when (op) {
BinOp.PLUS -> Opcode.ADD_OBJ
BinOp.MINUS -> Opcode.SUB_OBJ
@@ -4345,6 +4337,22 @@ class BytecodeCompiler(
CompiledValue(neg, SlotType.BOOL)
}
}
is WhenNullableCondition -> {
val nullSlot = allocSlot()
builder.emit(Opcode.CONST_NULL, nullSlot)
updateSlotType(nullSlot, SlotType.OBJ)
val baseDst = allocSlot()
builder.emit(Opcode.CHECK_IS, nullSlot, subject.slot, baseDst)
updateSlotType(baseDst, SlotType.BOOL)
if (!cond.negated) {
CompiledValue(baseDst, SlotType.BOOL)
} else {
val neg = allocSlot()
builder.emit(Opcode.NOT_BOOL, baseDst, neg)
updateSlotType(neg, SlotType.BOOL)
CompiledValue(neg, SlotType.BOOL)
}
}
}
}
@@ -4395,7 +4403,7 @@ class BytecodeCompiler(
val dst = allocSlot()
val encodedMethodId = encodeMemberId(receiverClass, methodId) ?: methodId
if (!ref.isOptionalInvoke) {
val args = compileCallArgs(ref.args, ref.tailBlock) ?: return null
val args = compileCallArgs(ref.args, ref.tailBlock, ref.explicitTypeArgs) ?: return null
val encodedCount = encodeCallArgCount(args) ?: return null
setPos(callPos)
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
@@ -4410,7 +4418,7 @@ class BytecodeCompiler(
Opcode.JMP_IF_TRUE,
listOf(CmdBuilder.Operand.IntVal(cmpSlot), CmdBuilder.Operand.LabelRef(nullLabel))
)
val args = compileCallArgs(ref.args, ref.tailBlock) ?: return null
val args = compileCallArgs(ref.args, ref.tailBlock, ref.explicitTypeArgs) ?: return null
val encodedCount = encodeCallArgCount(args) ?: return null
setPos(callPos)
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
@@ -4439,13 +4447,18 @@ class BytecodeCompiler(
}
val initClass = when (localTarget?.name) {
"List" -> ObjList.type
"ImmutableList" -> ObjImmutableList.type
"ObservableList" -> ObjObservableList.type
"Map" -> ObjMap.type
"ImmutableMap" -> ObjImmutableMap.type
"Set" -> ObjSet.type
"ImmutableSet" -> ObjImmutableSet.type
else -> null
}
val callee = compileRefWithFallback(ref.target, null, refPosOrCurrent(ref.target)) ?: return null
val dst = allocSlot()
if (!ref.isOptionalInvoke) {
val args = compileCallArgs(ref.args, ref.tailBlock) ?: return null
val args = compileCallArgs(ref.args, ref.tailBlock, ref.explicitTypeArgs) ?: return null
val encodedCount = encodeCallArgCount(args) ?: return null
setPos(callPos)
builder.emit(
@@ -4470,7 +4483,7 @@ class BytecodeCompiler(
Opcode.JMP_IF_TRUE,
listOf(CmdBuilder.Operand.IntVal(cmpSlot), CmdBuilder.Operand.LabelRef(nullLabel))
)
val args = compileCallArgs(ref.args, ref.tailBlock) ?: return null
val args = compileCallArgs(ref.args, ref.tailBlock, ref.explicitTypeArgs) ?: return null
val encodedCount = encodeCallArgCount(args) ?: return null
setPos(callPos)
builder.emit(
@@ -4800,9 +4813,26 @@ class BytecodeCompiler(
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) {
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 &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
@@ -4814,32 +4844,39 @@ class BytecodeCompiler(
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? {
for (cls in receiverClass.mro) {
val candidate = extensionPropertyGetterName(cls.className, memberName)
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertyGetterName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_get__")
}
private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
for (cls in receiverClass.mro) {
val candidate = extensionPropertySetterName(cls.className, memberName)
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertySetterName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_set__")
}
private fun compileCallArgsWithReceiver(
@@ -4871,10 +4908,14 @@ class BytecodeCompiler(
return CallArgs(base = argSlots[0], count = argSlots.size, planId = planId)
}
private fun compileCallArgs(args: List<ParsedArgument>, tailBlock: Boolean): CallArgs? {
if (args.isEmpty()) return CallArgs(base = 0, count = 0, planId = null)
private fun compileCallArgs(
args: List<ParsedArgument>,
tailBlock: Boolean,
explicitTypeArgs: List<TypeDecl>? = null
): CallArgs? {
if (args.isEmpty() && explicitTypeArgs.isNullOrEmpty()) return CallArgs(base = 0, count = 0, planId = null)
val argSlots = IntArray(args.size) { allocSlot() }
val needPlan = tailBlock || args.any { it.isSplat || it.name != null }
val needPlan = tailBlock || args.any { it.isSplat || it.name != null } || !explicitTypeArgs.isNullOrEmpty()
val specs = if (needPlan) ArrayList<BytecodeConst.CallArgSpec>(args.size) else null
for ((index, arg) in args.withIndex()) {
val compiled = compileArgValue(arg.value) ?: return null
@@ -4886,11 +4927,17 @@ class BytecodeCompiler(
specs?.add(BytecodeConst.CallArgSpec(arg.name, arg.isSplat))
}
val planId = if (needPlan) {
builder.addConst(BytecodeConst.CallArgsPlan(tailBlock, specs ?: emptyList()))
builder.addConst(
BytecodeConst.CallArgsPlan(
tailBlock = tailBlock,
specs = specs ?: emptyList(),
explicitTypeArgs = explicitTypeArgs ?: emptyList()
)
)
} else {
null
}
return CallArgs(base = argSlots[0], count = argSlots.size, planId = planId)
return CallArgs(base = if (argSlots.isEmpty()) 0 else argSlots[0], count = argSlots.size, planId = planId)
}
private fun compileArgValue(value: Obj): CompiledValue? {
@@ -5174,6 +5221,7 @@ class BytecodeCompiler(
isMutable = stmt.isMutable,
visibility = stmt.visibility,
writeVisibility = stmt.writeVisibility,
typeDecl = stmt.typeDecl,
isTransient = stmt.isTransient,
isAbstract = stmt.isAbstract,
isClosed = stmt.isClosed,
@@ -6998,7 +7046,9 @@ class BytecodeCompiler(
val slot = resolveSlot(ref)
val fromSlot = slot?.let { slotObjClass[it] }
fromSlot
?: slot?.let { typeDeclForSlot(it) }?.let { resolveClassFromTypeDecl(it) }
?: slotTypeByScopeId[ownerScopeId]?.get(ownerSlot)
?: slotTypeDeclByScopeId[ownerScopeId]?.get(ownerSlot)?.let { resolveClassFromTypeDecl(it) }
?: nameObjClass[ref.name]
?: resolveTypeNameClass(ref.name)
?: slotInitClassByKey[ScopeSlotKey(ownerScopeId, ownerSlot)]
@@ -7016,9 +7066,14 @@ class BytecodeCompiler(
}
val fromSlot = resolveDirectNameSlot(ref.name)?.let { slotObjClass[it.slot] }
if (fromSlot != null) return fromSlot
val fromDirectTypeDecl = resolveDirectNameSlot(ref.name)
?.let { typeDeclForSlot(it.slot) }
?.let { resolveClassFromTypeDecl(it) }
if (fromDirectTypeDecl != null) return fromDirectTypeDecl
val key = localSlotInfoMap.entries.firstOrNull { it.value.name == ref.name }?.key
key?.let {
slotTypeByScopeId[it.scopeId]?.get(it.slot)
?: slotTypeDeclByScopeId[it.scopeId]?.get(it.slot)?.let { decl -> resolveClassFromTypeDecl(decl) }
?: slotInitClassByKey[it]
} ?: nameObjClass[ref.name]
?: resolveTypeNameClass(ref.name)
@@ -7029,9 +7084,14 @@ class BytecodeCompiler(
}
val fromSlot = resolveDirectNameSlot(ref.name)?.let { slotObjClass[it.slot] }
if (fromSlot != null) return fromSlot
val fromDirectTypeDecl = resolveDirectNameSlot(ref.name)
?.let { typeDeclForSlot(it.slot) }
?.let { resolveClassFromTypeDecl(it) }
if (fromDirectTypeDecl != null) return fromDirectTypeDecl
val key = localSlotInfoMap.entries.firstOrNull { it.value.name == ref.name }?.key
key?.let {
slotTypeByScopeId[it.scopeId]?.get(it.slot)
?: slotTypeDeclByScopeId[it.scopeId]?.get(it.slot)?.let { decl -> resolveClassFromTypeDecl(decl) }
?: slotInitClassByKey[it]
} ?: nameObjClass[ref.name]
?: resolveTypeNameClass(ref.name)
@@ -7073,6 +7133,23 @@ class BytecodeCompiler(
}
}
private fun resolveClassFromTypeDecl(typeDecl: TypeDecl): ObjClass? {
return when (typeDecl) {
is TypeDecl.Simple -> {
resolveTypeNameClass(typeDecl.name) ?: nameObjClass[typeDecl.name]?.let { cls ->
if (cls == ObjClassType) ObjDynamic.type else cls
}
}
is TypeDecl.Generic -> {
resolveTypeNameClass(typeDecl.name) ?: nameObjClass[typeDecl.name]?.let { cls ->
if (cls == ObjClassType) ObjDynamic.type else cls
}
}
is TypeDecl.Ellipsis -> resolveClassFromTypeDecl(typeDecl.elementType)
else -> null
}
}
private fun isKnownClassReceiver(ref: ObjRef): Boolean {
return when (ref) {
is LocalVarRef -> {
@@ -7274,8 +7351,11 @@ class BytecodeCompiler(
"Bool" -> ObjBool.type
"Char" -> ObjChar.type
"List" -> ObjList.type
"ImmutableList" -> ObjImmutableList.type
"Map" -> ObjMap.type
"ImmutableMap" -> ObjImmutableMap.type
"Set" -> ObjSet.type
"ImmutableSet" -> ObjImmutableSet.type
"Range", "IntRange" -> ObjRange.type
"Iterator" -> ObjIterator
"Iterable" -> ObjIterable
@@ -7289,6 +7369,16 @@ class BytecodeCompiler(
"Regex" -> ObjRegex.type
"RegexMatch" -> ObjRegexMatch.type
"MapEntry" -> ObjMapEntry.type
"Observable" -> ObjObservable
"Subscription" -> ObjSubscription.type
"ListChange" -> ObjListChange.type
"ListSet" -> ObjListSetChange.type
"ListInsert" -> ObjListInsertChange.type
"ListRemove" -> ObjListRemoveChange.type
"ListClear" -> ObjListClearChange.type
"ListReorder" -> ObjListReorderChange.type
"ObservableList" -> ObjObservableList.type
"ChangeRejectionException" -> ObjChangeRejectionExceptionClass
"Instant" -> ObjInstant.type
"DateTime" -> ObjDateTime.type
"Duration" -> ObjDuration.type
@@ -7349,7 +7439,12 @@ class BytecodeCompiler(
"iterator" -> ObjIterator
"count" -> ObjInt.type
"toSet" -> ObjSet.type
"toImmutableSet" -> ObjImmutableSet.type
"toMap" -> ObjMap.type
"toImmutableMap" -> ObjImmutableMap.type
"observable" -> ObjObservableList.type
"beforeChange", "onChange" -> ObjSubscription.type
"changes" -> ObjFlow.type
"joinToString" -> ObjString.type
"now",
"truncateToSecond",
@@ -7376,6 +7471,8 @@ class BytecodeCompiler(
"matches" -> ObjBool.type
"toInt",
"toEpochSeconds" -> ObjInt.type
"toImmutableList" -> ObjImmutableList.type
"toImmutable" -> Obj.rootObjectType
"toMutable" -> ObjMutableBuffer.type
"seq" -> ObjFlow.type
"encode" -> ObjBitBuffer.type
@@ -7387,7 +7484,7 @@ class BytecodeCompiler(
if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return ObjDynamic.type
classFieldTypesByName[targetClass.className]?.get(name)?.let { cls ->
if (cls.className == "Delegate" || cls.className == "LazyDelegate" || cls.implementingNames.contains("Delegate")) {
if (isDelegateClass(cls)) {
return null
}
return cls
@@ -7474,8 +7571,8 @@ class BytecodeCompiler(
private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) {
val name = extensionCallableName(cls.className, memberName)
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val name = extensionCallableName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(name)) {
pendingScopeNameRefs.add(name)
}
@@ -7484,12 +7581,12 @@ class BytecodeCompiler(
private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) {
val getter = extensionPropertyGetterName(cls.className, memberName)
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val getter = extensionPropertyGetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(getter)) {
pendingScopeNameRefs.add(getter)
}
val setter = extensionPropertySetterName(cls.className, memberName)
val setter = extensionPropertySetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(setter)) {
pendingScopeNameRefs.add(setter)
}
@@ -8409,6 +8506,9 @@ class BytecodeCompiler(
collectScopeSlotsRef(ref.targetRef)
collectScopeSlotsRef(ref.indexRef)
}
is ClassOperatorRef -> {
collectScopeSlotsRef(ref.target)
}
is ListLiteralRef -> {
for (entry in ref.entries()) {
when (entry) {
@@ -100,6 +100,7 @@ sealed class BytecodeConst {
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val typeDecl: TypeDecl?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
@@ -179,6 +180,10 @@ sealed class BytecodeConst {
val pattern: ListLiteralRef,
val pos: Pos,
) : BytecodeConst()
data class CallArgsPlan(val tailBlock: Boolean, val specs: List<CallArgSpec>) : BytecodeConst()
data class CallArgsPlan(
val tailBlock: Boolean,
val specs: List<CallArgSpec>,
val explicitTypeArgs: List<TypeDecl> = emptyList()
) : BytecodeConst()
data class CallArgSpec(val name: String?, val isSplat: Boolean)
}
@@ -348,6 +348,7 @@ class BytecodeStatement private constructor(
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.typeDecl,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
@@ -442,6 +443,7 @@ class BytecodeStatement private constructor(
is WhenEqualsCondition -> WhenEqualsCondition(unwrapDeep(cond.expr), cond.pos)
is WhenInCondition -> WhenInCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
is WhenIsCondition -> WhenIsCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
is WhenNullableCondition -> WhenNullableCondition(cond.negated, cond.pos)
}
}
}
@@ -2750,6 +2750,7 @@ class CmdDeclClassInstanceField(internal val constId: Int, internal val slot: In
isClosed = decl.isClosed,
isOverride = decl.isOverride,
isTransient = decl.isTransient,
typeDecl = decl.typeDecl,
type = ObjRecord.Type.Field,
fieldId = decl.fieldId
)
@@ -3783,6 +3784,7 @@ class CmdFrame(
val exceptionSlot: Int,
val catchIp: Int,
val finallyIp: Int,
val iterDepthAtPush: Int,
var inCatch: Boolean = false
)
internal val tryStack = ArrayDeque<TryHandler>()
@@ -4068,11 +4070,15 @@ class CmdFrame(
return scope
}
fun handleException(t: Throwable): Boolean {
suspend fun handleException(t: Throwable): Boolean {
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
if (t is ReturnException || t is LoopBreakContinueException) {
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:returnOrLoop->finally")
pendingThrowable = t
ip = finallyIp
return true
@@ -4081,6 +4087,7 @@ class CmdFrame(
}
if (handler.inCatch) {
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:inCatch->finally")
pendingThrowable = t
ip = finallyIp
return true
@@ -4090,6 +4097,7 @@ class CmdFrame(
handler.inCatch = true
pendingThrowable = t
if (handler.catchIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toCatch")
val caughtObj = when (t) {
is ExecutionError -> t.errorObject
else -> ObjUnknownException(ensureScope(), t.message ?: t.toString())
@@ -4099,6 +4107,7 @@ class CmdFrame(
return true
}
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toFinallyNoCatch")
ip = finallyIp
return true
}
@@ -4106,7 +4115,7 @@ class CmdFrame(
}
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() {
@@ -4163,24 +4172,47 @@ class CmdFrame(
fun pushIterator(iter: Obj) {
iterStack.addLast(iter)
if (iter.objClass.className == "FlowIterator") {
vmIterDebug("pushIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
}
}
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()
}
suspend fun cancelTopIterator() {
val iter = iterStack.removeLastOrNull() ?: return
vmIterDebug("cancelTopIterator fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
}
suspend fun cancelIterators() {
while (iterStack.isNotEmpty()) {
val iter = iterStack.removeLast()
vmIterDebug("cancelIterators fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
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>) {
if (scope.hasSlotPlanConflict(plan)) {
scopeStack.addLast(scope)
@@ -4698,7 +4730,12 @@ class CmdFrame(
positional.add(value)
}
}
return Arguments(positional, plan.tailBlock, named ?: emptyMap())
return Arguments(
list = positional,
tailBlockMode = plan.tailBlock,
named = named ?: emptyMap(),
explicitTypeArgs = plan.explicitTypeArgs
)
}
private fun resolveLocalScope(localIndex: Int): Scope? {
@@ -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)
@@ -46,7 +46,7 @@ private val fallbackKeywordIds = setOf(
"private", "protected", "static", "open", "extern", "init", "get", "set", "by", "step",
// control flow and misc
"if", "else", "when", "while", "do", "for", "try", "catch", "finally",
"throw", "return", "break", "continue", "this", "null", "true", "false", "unset"
"throw", "return", "break", "continue", "this", "null", "true", "false", "unset", "void"
)
/** Maps lexer token type (and sometimes value) to a [HighlightKind]. */
@@ -37,8 +37,20 @@ object StdlibDocsBootstrap {
@Suppress("UNUSED_VARIABLE")
val _list = net.sergeych.lyng.obj.ObjList.type
@Suppress("UNUSED_VARIABLE")
val _immutableList = net.sergeych.lyng.obj.ObjImmutableList.type
@Suppress("UNUSED_VARIABLE")
val _map = net.sergeych.lyng.obj.ObjMap.type
@Suppress("UNUSED_VARIABLE")
val _immutableMap = net.sergeych.lyng.obj.ObjImmutableMap.type
@Suppress("UNUSED_VARIABLE")
val _set = net.sergeych.lyng.obj.ObjSet.type
@Suppress("UNUSED_VARIABLE")
val _immutableSet = net.sergeych.lyng.obj.ObjImmutableSet.type
@Suppress("UNUSED_VARIABLE")
val _observableList = net.sergeych.lyng.obj.ObjObservableList.type
@Suppress("UNUSED_VARIABLE")
val _subscription = net.sergeych.lyng.obj.ObjSubscription.type
@Suppress("UNUSED_VARIABLE")
val _int = net.sergeych.lyng.obj.ObjInt.type
@Suppress("UNUSED_VARIABLE")
val _real = net.sergeych.lyng.obj.ObjReal.type
@@ -646,6 +646,9 @@ open class Obj {
}
open suspend fun getAt(scope: Scope, index: Obj): Obj {
if (hasNonRootIndexerMember("getAt")) {
return invokeInstanceMethod(scope, "getAt", Arguments(index))
}
if (index is ObjString) {
return readField(scope, index.value).value
}
@@ -655,6 +658,16 @@ open class Obj {
suspend fun getAt(scope: Scope, index: Int): Obj = getAt(scope, ObjInt(index.toLong()))
open suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
when {
hasNonRootIndexerMember("putAt") -> {
invokeInstanceMethod(scope, "putAt", Arguments(index, newValue))
return
}
hasNonRootIndexerMember("setAt") -> {
invokeInstanceMethod(scope, "setAt", Arguments(index, newValue))
return
}
}
if (index is ObjString) {
writeField(scope, index.value, newValue)
return
@@ -662,6 +675,17 @@ open class Obj {
scope.raiseNotImplemented("indexing")
}
private fun hasNonRootIndexerMember(name: String): Boolean {
for (cls in objClass.mro) {
if (cls.className == "Obj") break
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
if (rec != null && !rec.isAbstract && rec.type != ObjRecord.Type.Delegated) {
return true
}
}
return false
}
open suspend fun callOn(scope: Scope): Obj {
scope.raiseNotImplemented()
}
@@ -826,6 +826,7 @@ open class ObjClass(
type: ObjRecord.Type = ObjRecord.Type.Field,
fieldId: Int? = null,
methodId: Int? = null,
typeDecl: net.sergeych.lyng.TypeDecl? = null,
): ObjRecord {
// Validation of override rules: only for non-system declarations
var existing: ObjRecord? = null
@@ -921,6 +922,7 @@ open class ObjClass(
isOverride = isOverride,
isTransient = isTransient,
type = type,
typeDecl = typeDecl,
memberName = name,
fieldId = effectiveFieldId,
methodId = effectiveMethodId
@@ -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");
* 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.sync.Mutex
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.TypeGenericDoc
import net.sergeych.lyng.miniast.addFnDoc
@@ -55,7 +56,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
else
// Flow consumer is no longer collecting; signal producer to stop
throw ScriptFlowIsNoMoreCollected()
} catch (x: Exception) {
} catch (x: Throwable) {
// Any failure to send (including closed channel) should gracefully stop the producer.
if (x is CancellationException) {
// Cancellation is a normal control-flow event
@@ -80,7 +81,7 @@ private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj
producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK
} catch (x: Exception) {
} catch (x: Throwable) {
channel.close(x)
return@globalLaunch
}
@@ -0,0 +1,197 @@
/*
* 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.Scope
import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
class ObjImmutableList(items: List<Obj> = emptyList()) : Obj() {
private val data: List<Obj> = items.toList()
override val objClass: ObjClass
get() = type
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
return when (other) {
is ObjImmutableList -> data.size == other.data.size && data.indices.all { i -> data[i].equals(scope, other.data[i]) }
else -> {
if (other.isInstanceOf(ObjIterable)) compareTo(scope, other) == 0 else false
}
}
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjImmutableList) {
val mySize = data.size
val otherSize = other.data.size
val commonSize = minOf(mySize, otherSize)
for (i in 0..<commonSize) {
val d = data[i].compareTo(scope, other.data[i])
if (d != 0) return d
}
return mySize.compareTo(otherSize)
}
if (other.isInstanceOf(ObjIterable)) {
val it1 = data.iterator()
val it2 = other.invokeInstanceMethod(scope, "iterator")
val hasNext2 = it2.getInstanceMethod(scope, "hasNext")
val next2 = it2.getInstanceMethod(scope, "next")
while (it1.hasNext()) {
if (!hasNext2.invoke(scope, it2).toBool()) return 1
val d = it1.next().compareTo(scope, next2.invoke(scope, it2))
if (d != 0) return d
}
return if (hasNext2.invoke(scope, it2).toBool()) -1 else 0
}
return -2
}
override suspend fun getAt(scope: Scope, index: Obj): Obj {
return when (index) {
is ObjInt -> data[index.toInt()]
is ObjRange -> {
when {
index.start is ObjInt && index.end is ObjInt -> {
if (index.isEndInclusive)
ObjImmutableList(data.subList(index.start.toInt(), index.end.toInt() + 1))
else
ObjImmutableList(data.subList(index.start.toInt(), index.end.toInt()))
}
index.isOpenStart && !index.isOpenEnd -> {
if (index.isEndInclusive)
ObjImmutableList(data.subList(0, index.end!!.toInt() + 1))
else
ObjImmutableList(data.subList(0, index.end!!.toInt()))
}
index.isOpenEnd && !index.isOpenStart -> ObjImmutableList(data.subList(index.start!!.toInt(), data.size))
index.isOpenStart && index.isOpenEnd -> ObjImmutableList(data)
else -> throw RuntimeException("Can't apply range for index: $index")
}
}
else -> scope.raiseIllegalArgument("Illegal index object for immutable list: ${index.inspect(scope)}")
}
}
override suspend fun contains(scope: Scope, other: Obj): Boolean {
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS && other is ObjInt) {
var i = 0
val sz = data.size
while (i < sz) {
val v = data[i]
if (v is ObjInt && v.value == other.value) return true
i++
}
return false
}
return data.contains(other)
}
override suspend fun enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
for (item in data) {
if (!callback(item)) break
}
}
override suspend fun plus(scope: Scope, other: Obj): Obj {
return when {
other is ObjImmutableList -> ObjImmutableList(data + other.data)
other is ObjList -> ObjImmutableList(data + other.list)
other.isInstanceOf(ObjIterable) && other !is ObjString && other !is ObjBuffer -> {
val l = other.callMethod<ObjList>(scope, "toList")
ObjImmutableList(data + l.list)
}
else -> ObjImmutableList(data + other)
}
}
override suspend fun minus(scope: Scope, other: Obj): Obj {
if (other !is ObjString && other !is ObjBuffer && other.isInstanceOf(ObjIterable)) {
val toRemove = mutableSetOf<Obj>()
other.enumerate(scope) {
toRemove += it
true
}
return ObjImmutableList(data.filterNot { toRemove.contains(it) })
}
val out = data.toMutableList()
out.remove(other)
return ObjImmutableList(out)
}
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
encoder.encodeAnyList(scope, data)
}
override suspend fun lynonType(): LynonType = LynonType.List
override suspend fun defaultToString(scope: Scope): ObjString {
return ObjString(buildString {
append("ImmutableList(")
var first = true
for (v in data) {
if (first) first = false else append(",")
append(v.toString(scope).value)
}
append(")")
})
}
fun toMutableList(): MutableList<Obj> = data.toMutableList()
companion object {
val type = object : ObjClass("ImmutableList", ObjArray) {
override suspend fun callOn(scope: Scope): Obj {
return ObjImmutableList(scope.args.list)
}
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
return ObjImmutableList(decoder.decodeAnyList(scope))
}
}.apply {
addPropertyDoc(
name = "size",
doc = "Number of elements in this immutable list.",
type = type("lyng.Int"),
moduleName = "lyng.stdlib",
getter = { (this.thisObj as ObjImmutableList).data.size.toObj() }
)
addFnDoc(
name = "toMutable",
doc = "Create a mutable copy of this immutable list.",
returns = type("lyng.List"),
moduleName = "lyng.stdlib"
) {
ObjList(thisAs<ObjImmutableList>().toMutableList())
}
addFnDoc(
name = "toImmutable",
doc = "Return this immutable list.",
returns = type("lyng.ImmutableList"),
moduleName = "lyng.stdlib"
) {
thisObj
}
}
}
}
@@ -0,0 +1,196 @@
/*
* 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 kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.TypeGenericDoc
import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
class ObjImmutableMap(entries: Map<Obj, Obj> = emptyMap()) : Obj() {
val map: Map<Obj, Obj> = LinkedHashMap(entries)
override val objClass get() = type
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
val otherMap = when (other) {
is ObjImmutableMap -> other.map
is ObjMap -> other.map
else -> return false
}
if (map.size != otherMap.size) return false
for ((k, v) in map) {
val ov = other.getAt(scope, k)
if (ov === ObjNull && !other.contains(scope, k)) return false
if (!v.equals(scope, ov)) return false
}
return true
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
val otherMap = when (other) {
is ObjImmutableMap -> other.map
is ObjMap -> other.map
else -> return -1
}
if (map == otherMap) return 0
if (map.size != otherMap.size) return map.size.compareTo(otherMap.size)
return map.toString().compareTo(otherMap.toString())
}
override suspend fun getAt(scope: Scope, index: Obj): Obj = map[index] ?: ObjNull
override suspend fun contains(scope: Scope, other: Obj): Boolean = other in map
override suspend fun defaultToString(scope: Scope): ObjString {
val rendered = buildString {
append("ImmutableMap(")
var first = true
for ((k, v) in map) {
if (!first) append(",")
append(k.inspect(scope))
append(" => ")
append(v.toString(scope).value)
first = false
}
append(")")
}
return ObjString(rendered)
}
override suspend fun lynonType(): LynonType = LynonType.Map
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
val keys = map.keys.map { it.toObj() }
val values = map.values.map { it.toObj() }
encoder.encodeAnyList(scope, keys)
encoder.encodeAnyList(scope, values, fixedSize = true)
}
override suspend fun toJson(scope: Scope): JsonElement {
return JsonObject(map.map { it.key.toString(scope).value to it.value.toJson(scope) }.toMap())
}
override suspend fun plus(scope: Scope, other: Obj): Obj {
val out = LinkedHashMap(map)
mergeIn(scope, out, other)
return ObjImmutableMap(out)
}
private suspend fun mergeIn(scope: Scope, out: MutableMap<Obj, Obj>, other: Obj) {
when (other) {
is ObjImmutableMap -> out.putAll(other.map)
is ObjMap -> out.putAll(other.map)
is ObjMapEntry -> out[other.key] = other.value
is ObjList -> {
for (e in other.list) {
when (e) {
is ObjMapEntry -> out[e.key] = e.value
else -> {
if (e.isInstanceOf(ObjArray)) {
if (e.invokeInstanceMethod(scope, "size").toInt() != 2)
scope.raiseIllegalArgument("Array element to merge into map must have 2 elements, got $e")
out[e.getAt(scope, 0)] = e.getAt(scope, 1)
} else {
scope.raiseIllegalArgument("map can only be merged with MapEntry elements; got $e")
}
}
}
}
}
else -> scope.raiseIllegalArgument("map can only be merged with Map, ImmutableMap, MapEntry, or List<MapEntry>")
}
}
fun toMutableMapCopy(): MutableMap<Obj, Obj> = LinkedHashMap(map)
companion object {
val type = object : ObjClass("ImmutableMap", ObjCollection) {
override suspend fun callOn(scope: Scope): Obj {
return ObjImmutableMap(ObjMap.listToMap(scope, scope.args.list))
}
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
val keys = decoder.decodeAnyList(scope)
val values = decoder.decodeAnyList(scope, fixedSize = keys.size)
if (keys.size != values.size) scope.raiseIllegalArgument("map keys and values should be same size")
return ObjImmutableMap(keys.zip(values).toMap())
}
}.apply {
addFnDoc(
name = "getOrNull",
doc = "Get value by key or return null if the key is absent.",
params = listOf(ParamDoc("key")),
returns = type("lyng.Any", nullable = true),
moduleName = "lyng.stdlib"
) {
thisAs<ObjImmutableMap>().map[args.firstAndOnly(pos)] ?: ObjNull
}
addPropertyDoc(
name = "size",
doc = "Number of entries in the immutable map.",
type = type("lyng.Int"),
moduleName = "lyng.stdlib",
getter = { thisAs<ObjImmutableMap>().map.size.toObj() }
)
addPropertyDoc(
name = "keys",
doc = "List of keys in this immutable map.",
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
moduleName = "lyng.stdlib",
getter = { thisAs<ObjImmutableMap>().map.keys.toObj() }
)
addPropertyDoc(
name = "values",
doc = "List of values in this immutable map.",
type = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
moduleName = "lyng.stdlib",
getter = { ObjList(thisAs<ObjImmutableMap>().map.values.toMutableList()) }
)
addFnDoc(
name = "iterator",
doc = "Iterator over map entries as MapEntry objects.",
moduleName = "lyng.stdlib"
) {
ObjKotlinIterator(thisAs<ObjImmutableMap>().map.entries.iterator())
}
addFnDoc(
name = "toMutable",
doc = "Create a mutable copy of this immutable map.",
returns = type("lyng.Map"),
moduleName = "lyng.stdlib"
) {
ObjMap(thisAs<ObjImmutableMap>().toMutableMapCopy())
}
addFnDoc(
name = "toImmutable",
doc = "Return this immutable map.",
returns = type("lyng.ImmutableMap"),
moduleName = "lyng.stdlib"
) { thisObj }
}
}
}
@@ -0,0 +1,172 @@
/*
* 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.Scope
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
class ObjImmutableSet(items: Collection<Obj> = emptyList()) : Obj() {
private val data: Set<Obj> = LinkedHashSet(items)
override val objClass get() = type
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
val otherSet = when (other) {
is ObjImmutableSet -> other.data
is ObjSet -> other.set
else -> return false
}
if (data.size != otherSet.size) return false
for (e in data) {
if (!other.contains(scope, e)) return false
}
return true
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
val otherSet = when (other) {
is ObjImmutableSet -> other.data
is ObjSet -> other.set
else -> return -2
}
if (data == otherSet) return 0
if (data.size != otherSet.size) return data.size.compareTo(otherSet.size)
return data.toString().compareTo(otherSet.toString())
}
override suspend fun contains(scope: Scope, other: Obj): Boolean = data.contains(other)
override suspend fun enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
for (item in data) {
if (!callback(item)) break
}
}
override suspend fun plus(scope: Scope, other: Obj): Obj {
val merged = LinkedHashSet(data)
when {
other is ObjImmutableSet -> merged.addAll(other.data)
other is ObjSet -> merged.addAll(other.set)
other is ObjString || other is ObjBuffer || !other.isInstanceOf(ObjIterable) -> merged.add(other)
else -> other.enumerate(scope) { merged += it; true }
}
return ObjImmutableSet(merged)
}
override suspend fun minus(scope: Scope, other: Obj): Obj {
val out = LinkedHashSet(data)
when {
other is ObjImmutableSet -> out.removeAll(other.data)
other is ObjSet -> out.removeAll(other.set)
other is ObjString || other is ObjBuffer || !other.isInstanceOf(ObjIterable) -> out.remove(other)
else -> other.enumerate(scope) { out.remove(it); true }
}
return ObjImmutableSet(out)
}
override suspend fun mul(scope: Scope, other: Obj): Obj {
val right = when (other) {
is ObjImmutableSet -> other.data
is ObjSet -> other.set
else -> scope.raiseIllegalArgument("set operator * requires another set")
}
return ObjImmutableSet(data.intersect(right))
}
override suspend fun lynonType(): LynonType = LynonType.Set
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
encoder.encodeAnyList(scope, data.toList())
}
fun toMutableSet(): MutableSet<Obj> = LinkedHashSet(data)
companion object {
val type: ObjClass = object : ObjClass("ImmutableSet", ObjCollection) {
override suspend fun callOn(scope: Scope): Obj {
return ObjImmutableSet(scope.args.list)
}
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
ObjImmutableSet(decoder.decodeAnyList(scope))
}.apply {
addFnDoc(
name = "size",
doc = "Number of elements in this immutable set.",
returns = type("lyng.Int"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjImmutableSet>().data.size.toObj()
}
addFnDoc(
name = "intersect",
doc = "Intersection with another set. Returns a new immutable set.",
params = listOf(ParamDoc("other")),
returns = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjImmutableSet>().mul(requireScope(), args.firstAndOnly())
}
addFnDoc(
name = "iterator",
doc = "Iterator over elements of this immutable set.",
moduleName = "lyng.stdlib"
) {
ObjKotlinObjIterator(thisAs<ObjImmutableSet>().data.iterator())
}
addFnDoc(
name = "union",
doc = "Union with another set or iterable. Returns a new immutable set.",
params = listOf(ParamDoc("other")),
returns = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjImmutableSet>().plus(requireScope(), args.firstAndOnly())
}
addFnDoc(
name = "subtract",
doc = "Subtract another set or iterable from this set. Returns a new immutable set.",
params = listOf(ParamDoc("other")),
returns = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib"
) {
thisAs<ObjImmutableSet>().minus(requireScope(), args.firstAndOnly())
}
addFnDoc(
name = "toMutable",
doc = "Create a mutable copy of this immutable set.",
returns = type("lyng.Set"),
moduleName = "lyng.stdlib"
) {
ObjSet(thisAs<ObjImmutableSet>().toMutableSet())
}
addFnDoc(
name = "toImmutable",
doc = "Return this immutable set.",
returns = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib"
) { thisObj }
}
}
}
@@ -50,6 +50,21 @@ val ObjIterable by lazy {
ObjList(result)
}
addFnDoc(
name = "toImmutableList",
doc = "Collect elements of this iterable into a new immutable list.",
returns = type("lyng.ImmutableList"),
moduleName = "lyng.stdlib"
) {
val scope = requireScope()
val result = mutableListOf<Obj>()
val it = thisObj.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
result.add(it.invokeInstanceMethod(scope, "next"))
}
ObjImmutableList(result)
}
// it is not effective, but it is open:
addFnDoc(
name = "contains",
@@ -109,6 +124,28 @@ val ObjIterable by lazy {
}
)
addPropertyDoc(
name = "toImmutableSet",
doc = "Collect elements of this iterable into a new immutable set.",
type = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib",
getter = {
when (val self = this.thisObj) {
is ObjImmutableSet -> self
is ObjSet -> ObjImmutableSet(self.set)
else -> {
val result = mutableSetOf<Obj>()
val scope = requireScope()
val it = self.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
result.add(it.invokeInstanceMethod(scope, "next"))
}
ObjImmutableSet(result)
}
}
}
)
addPropertyDoc(
name = "toMap",
doc = "Collect pairs into a map using [0] as key and [1] as value for each element.",
@@ -128,6 +165,25 @@ val ObjIterable by lazy {
}
)
addPropertyDoc(
name = "toImmutableMap",
doc = "Collect pairs into an immutable map using [0] as key and [1] as value for each element.",
type = type("lyng.ImmutableMap"),
moduleName = "lyng.stdlib",
getter = {
val result = linkedMapOf<Obj, Obj>()
val scope = requireScope()
this.thisObj.enumerate(scope) { pair ->
when (pair) {
is ObjMapEntry -> result[pair.key] = pair.value
else -> result[pair.getAt(scope, 0)] = pair.getAt(scope, 1)
}
true
}
ObjImmutableMap(result)
}
)
addFnDoc(
name = "associateBy",
doc = "Build a map from elements using the lambda result as key.",
@@ -45,18 +45,18 @@ class ObjKotlinIterator(val iterator: Iterator<Any?>) : Obj() {
}
boundType = cls
LyngClassBridge.bind(cls) {
addFun("next") { scope, self, _ ->
when (self) {
addFun("next") {
when (val self = thisObj) {
is ObjKotlinIterator -> self.iterator.next().toObj()
is ObjKotlinObjIterator -> self.iterator.next()
else -> scope.raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
else -> raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
}
}
addFun("hasNext") { scope, self, _ ->
when (self) {
addFun("hasNext") {
when (val self = thisObj) {
is ObjKotlinIterator -> self.iterator.hasNext().toObj()
is ObjKotlinObjIterator -> self.iterator.hasNext().toObj()
else -> scope.raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
else -> raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
}
}
}
@@ -29,7 +29,16 @@ import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
open class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
protected open fun shouldTreatAsSingleElement(scope: Scope, other: Obj): Boolean {
if (!other.isInstanceOf(ObjIterable)) return true
val declaredElementType = scope.declaredListElementTypeForValue(this)
if (declaredElementType != null && matchesTypeDecl(scope, other, declaredElementType)) {
return true
}
if (other is ObjString || other is ObjBuffer) return true
return false
}
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
@@ -86,7 +95,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
}
}
override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
open override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
list[index.toInt()] = newValue
}
@@ -127,7 +136,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
other is ObjList ->
ObjList((list + other.list).toMutableList())
other.isInstanceOf(ObjIterable) && other !is ObjString && other !is ObjBuffer -> {
!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable) -> {
val l = other.callMethod<ObjList>(scope, "toList")
ObjList((list + l.list).toMutableList())
}
@@ -140,10 +149,10 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
}
override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
open override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
if (other is ObjList) {
list.addAll(other.list)
} else if (other.isInstanceOf(ObjIterable) && other !is ObjString && other !is ObjBuffer) {
} else if (!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable)) {
val otherList = (other.invokeInstanceMethod(scope, "toList") as ObjList).list
list.addAll(otherList)
} else {
@@ -152,6 +161,43 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
return this
}
override suspend fun minus(scope: Scope, other: Obj): Obj {
val out = list.toMutableList()
if (shouldTreatAsSingleElement(scope, other)) {
out.remove(other)
return ObjList(out)
}
if (other.isInstanceOf(ObjIterable)) {
val toRemove = mutableSetOf<Obj>()
other.enumerate(scope) {
toRemove += it
true
}
out.removeAll { toRemove.contains(it) }
return ObjList(out)
}
out.remove(other)
return ObjList(out)
}
open override suspend fun minusAssign(scope: Scope, other: Obj): Obj {
if (shouldTreatAsSingleElement(scope, other)) {
list.remove(other)
return this
}
if (other.isInstanceOf(ObjIterable)) {
val toRemove = mutableSetOf<Obj>()
other.enumerate(scope) {
toRemove += it
true
}
list.removeAll { toRemove.contains(it) }
return this
}
list.remove(other)
return this
}
override suspend fun contains(scope: Scope, other: Obj): Boolean {
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
// Fast path: int membership in a list of ints (common case in benches)
@@ -175,7 +221,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
}
}
override val objClass: ObjClass
open override val objClass: ObjClass
get() = type
override suspend fun toKotlin(scope: Scope): Any {
@@ -516,6 +562,14 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
}
ObjInt((-1).toLong())
}
addFnDoc(
name = "toImmutable",
doc = "Create an immutable snapshot of this list.",
returns = type("lyng.ImmutableList"),
moduleName = "lyng.stdlib"
) {
ObjImmutableList(thisAs<ObjList>().list)
}
}
}
}
@@ -107,8 +107,12 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
if (other !is ObjMap) return false
if (map.size != other.map.size) return false
val otherSize = when (other) {
is ObjMap -> other.map.size
is ObjImmutableMap -> other.map.size
else -> return false
}
if (map.size != otherSize) return false
for ((k, v) in map) {
val otherV = other.getAt(scope, k)
if (otherV === ObjNull && !other.contains(scope, k)) return false
@@ -131,14 +135,16 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjMap) {
if (map == other.map) return 0
if (map.size != other.map.size) return map.size.compareTo(other.map.size)
// for same size, if they are not equal, we don't have a stable order
// but let's try to be consistent
return map.toString().compareTo(other.map.toString())
val otherMap = when (other) {
is ObjMap -> other.map
is ObjImmutableMap -> other.map
else -> return -1
}
return -1
if (map == otherMap) return 0
if (map.size != otherMap.size) return map.size.compareTo(otherMap.size)
// for same size, if they are not equal, we don't have a stable order
// but let's try to be consistent
return map.toString().compareTo(otherMap.toString())
}
override suspend fun defaultToString(scope: Scope): ObjString {
@@ -311,6 +317,14 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
) {
ObjKotlinIterator(thisAs<ObjMap>().map.entries.iterator())
}
addFnDoc(
name = "toImmutable",
doc = "Create an immutable snapshot of this map.",
returns = type("lyng.ImmutableMap"),
moduleName = "lyng.stdlib"
) {
ObjImmutableMap(thisAs<ObjMap>().map)
}
}
}
@@ -334,6 +348,11 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
map[k] = v
}
}
is ObjImmutableMap -> {
for ((k, v) in other.map) {
map[k] = v
}
}
is ObjMapEntry -> {
map[other.key] = other.value
}
@@ -0,0 +1,589 @@
/*
* 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 kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Scope
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.TypeGenericDoc
import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
val ObjObservable = ObjClass("Observable").apply {
addFn("beforeChange") { raiseNotImplemented("Observable.beforeChange") }
addFn("onChange") { raiseNotImplemented("Observable.onChange") }
addFn("changes") { raiseNotImplemented("Observable.changes") }
}
val ObjChangeRejectionExceptionClass = ObjException.Companion.ExceptionClass("ChangeRejectionException", ObjException.Root)
open class ObjListChange : Obj() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListChange")
}
}
class ObjListSetChange(val index: Int, val oldValue: Obj, val newValue: Obj) : ObjListChange() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListSet", ObjListChange.type).apply {
addPropertyDoc("index", "Changed index.", type("lyng.Int"), moduleName = "lyng.observable", getter = { thisAs<ObjListSetChange>().index.toObj() })
addPropertyDoc("oldValue", "Value before assignment.", type("lyng.Any"), moduleName = "lyng.observable", getter = { thisAs<ObjListSetChange>().oldValue })
addPropertyDoc("newValue", "Assigned value.", type("lyng.Any"), moduleName = "lyng.observable", getter = { thisAs<ObjListSetChange>().newValue })
}
}
}
class ObjListInsertChange(val index: Int, val values: ObjList) : ObjListChange() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListInsert", ObjListChange.type).apply {
addPropertyDoc("index", "Insertion index.", type("lyng.Int"), moduleName = "lyng.observable", getter = { thisAs<ObjListInsertChange>().index.toObj() })
addPropertyDoc(
"values",
"Inserted values.",
TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
moduleName = "lyng.observable",
getter = { thisAs<ObjListInsertChange>().values }
)
}
}
}
class ObjListRemoveChange(val index: Int, val oldValue: Obj) : ObjListChange() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListRemove", ObjListChange.type).apply {
addPropertyDoc("index", "Removed index.", type("lyng.Int"), moduleName = "lyng.observable", getter = { thisAs<ObjListRemoveChange>().index.toObj() })
addPropertyDoc("oldValue", "Removed value.", type("lyng.Any"), moduleName = "lyng.observable", getter = { thisAs<ObjListRemoveChange>().oldValue })
}
}
}
class ObjListClearChange(val oldValues: ObjList) : ObjListChange() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListClear", ObjListChange.type).apply {
addPropertyDoc(
"oldValues",
"All list values before clear.",
TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
moduleName = "lyng.observable",
getter = { thisAs<ObjListClearChange>().oldValues }
)
}
}
}
class ObjListReorderChange(val oldValues: ObjList, val newValues: Obj) : ObjListChange() {
override val objClass: ObjClass get() = type
companion object {
val type = ObjClass("ListReorder", ObjListChange.type).apply {
addPropertyDoc(
"oldValues",
"Values before reorder.",
TypeGenericDoc(type("lyng.List"), listOf(type("lyng.Any"))),
moduleName = "lyng.observable",
getter = { thisAs<ObjListReorderChange>().oldValues }
)
addPropertyDoc(
"newValues",
"Values after reorder (or Unset in beforeChange when unknown before commit).",
type("lyng.Any"),
moduleName = "lyng.observable",
getter = { thisAs<ObjListReorderChange>().newValues }
)
}
}
}
class ObjSubscription(private val onCancel: suspend () -> Unit) : Obj() {
private val access = Mutex()
private var cancelled = false
override val objClass: ObjClass get() = type
suspend fun cancel() {
var action: (suspend () -> Unit)? = null
access.withLock {
if (!cancelled) {
cancelled = true
action = onCancel
}
}
action?.invoke()
}
companion object {
val type = object : ObjClass("Subscription") {
override suspend fun callOn(scope: Scope): Obj = scope.raiseIllegalArgument("Subscription constructor is not available")
}.apply {
addFnDoc(
"cancel",
"Unsubscribe listener. Safe to call multiple times.",
returns = type("lyng.Void"),
moduleName = "lyng.observable"
) {
thisAs<ObjSubscription>().cancel()
ObjVoid
}
}
}
}
private class ObjObservableListFlowProducer(
private val owner: ObjObservableList,
private val subscriptionId: Long,
private val channel: ReceiveChannel<Obj>
) : Obj() {
override val objClass: ObjClass get() = Obj.rootObjectType
override suspend fun callOn(scope: Scope): Obj {
val builder = scope.thisObj as? ObjFlowBuilder
?: scope.raiseIllegalState("flow builder is not available")
try {
for (change in channel) {
builder.invokeInstanceMethod(scope, "emit", change)
}
} finally {
owner.unsubscribeChangeChannel(subscriptionId)
}
return ObjVoid
}
}
class ObjObservableList(list: MutableList<Obj> = mutableListOf()) : ObjList(list) {
private val access = Mutex()
private var nextSubscriptionId: Long = 1L
private val beforeListeners = linkedMapOf<Long, Obj>()
private val afterListeners = linkedMapOf<Long, Obj>()
private val changeChannels = linkedMapOf<Long, Channel<Obj>>()
override val objClass: ObjClass get() = type
private fun nextId(): Long = nextSubscriptionId++
private suspend fun addBeforeListener(listener: Obj): ObjSubscription {
val id = access.withLock {
val id = nextId()
beforeListeners[id] = listener
id
}
return ObjSubscription {
access.withLock { beforeListeners.remove(id) }
}
}
private suspend fun addAfterListener(listener: Obj): ObjSubscription {
val id = access.withLock {
val id = nextId()
afterListeners[id] = listener
id
}
return ObjSubscription {
access.withLock { afterListeners.remove(id) }
}
}
private suspend fun notifyListeners(scope: Scope, listeners: Collection<Obj>, change: Obj) {
val facade = scope.asFacade()
for (listener in listeners) {
facade.call(listener, Arguments(change))
}
}
private suspend fun snapshotBeforeListeners(): List<Obj> = access.withLock { beforeListeners.values.toList() }
private suspend fun snapshotAfterListeners(): List<Obj> = access.withLock { afterListeners.values.toList() }
private suspend fun notifyBefore(scope: Scope, change: Obj) {
notifyListeners(scope, snapshotBeforeListeners(), change)
}
private suspend fun notifyAfter(scope: Scope, change: Obj) {
notifyListeners(scope, snapshotAfterListeners(), change)
}
private suspend fun emitCommittedChange(change: Obj) {
val channels = access.withLock { changeChannels.toMap() }
val dead = mutableListOf<Long>()
for ((id, channel) in channels) {
if (channel.trySend(change).isFailure) {
dead += id
}
}
if (dead.isNotEmpty()) {
access.withLock {
for (id in dead) {
changeChannels.remove(id)?.close()
}
}
}
}
private suspend fun mutate(scope: Scope, beforeChange: Obj, mutation: suspend () -> Obj?): Obj? {
notifyBefore(scope, beforeChange)
val committed = mutation()
if (committed != null) {
notifyAfter(scope, committed)
emitCommittedChange(committed)
}
return committed
}
private fun snapshotList(): ObjList = ObjList(list.toMutableList())
private suspend fun createChangesFlow(scope: Scope): ObjFlow {
val channel = Channel<Obj>(Channel.UNLIMITED)
val id = access.withLock {
val id = nextId()
changeChannels[id] = channel
id
}
val producer = ObjObservableListFlowProducer(this, id, channel)
return ObjFlow(producer, scope)
}
internal suspend fun unsubscribeChangeChannel(id: Long) {
access.withLock {
changeChannels.remove(id)?.close()
}
}
override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
val idx = index.toInt()
val old = list[idx]
val change = ObjListSetChange(idx, old, newValue)
mutate(scope, change) {
list[idx] = newValue
change
}
}
override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
when {
other is ObjList -> {
if (other.list.isEmpty()) return this
val insert = ObjListInsertChange(list.size, ObjList(other.list.toMutableList()))
mutate(scope, insert) {
list.addAll(other.list)
insert
}
}
!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable) -> {
val otherList = (other.invokeInstanceMethod(scope, "toList") as ObjList).list
if (otherList.isEmpty()) return this
val insert = ObjListInsertChange(list.size, ObjList(otherList.toMutableList()))
mutate(scope, insert) {
list.addAll(otherList)
insert
}
}
else -> {
val insert = ObjListInsertChange(list.size, ObjList(mutableListOf(other)))
mutate(scope, insert) {
list.add(other)
insert
}
}
}
return this
}
override suspend fun minusAssign(scope: Scope, other: Obj): Obj {
if (shouldTreatAsSingleElement(scope, other)) {
val index = list.indexOf(other)
if (index < 0) return this
val old = list[index]
val remove = ObjListRemoveChange(index, old)
mutate(scope, remove) {
list.removeAt(index)
remove
}
return this
}
if (other.isInstanceOf(ObjIterable)) {
val toRemove = mutableSetOf<Obj>()
other.enumerate(scope) {
toRemove += it
true
}
val oldValues = snapshotList()
val filtered = list.filterNot { toRemove.contains(it) }
if (filtered.size == list.size) return this
val committed = if (filtered.isEmpty()) {
ObjListClearChange(oldValues)
} else {
ObjListReorderChange(oldValues, ObjList(filtered.toMutableList()))
}
mutate(scope, committed) {
list.clear()
list.addAll(filtered)
committed
}
return this
}
val index = list.indexOf(other)
if (index < 0) return this
val old = list[index]
val remove = ObjListRemoveChange(index, old)
mutate(scope, remove) {
list.removeAt(index)
remove
}
return this
}
companion object {
val type = object : ObjClass("ObservableList", ObjList.type) {
override suspend fun callOn(scope: Scope): Obj {
return ObjObservableList(scope.args.list.toMutableList())
}
}.apply {
addFnDoc(
"beforeChange",
"Subscribe to pre-commit list changes. Throw to reject mutation.",
params = listOf(ParamDoc("listener", type("lyng.Any"))),
returns = type("lyng.observable.Subscription"),
moduleName = "lyng.observable"
) {
thisAs<ObjObservableList>().addBeforeListener(requireOnlyArg())
}
addFnDoc(
"onChange",
"Subscribe to post-commit list changes.",
params = listOf(ParamDoc("listener", type("lyng.Any"))),
returns = type("lyng.observable.Subscription"),
moduleName = "lyng.observable"
) {
thisAs<ObjObservableList>().addAfterListener(requireOnlyArg())
}
addFnDoc(
"changes",
"Get a flow of committed list changes.",
returns = TypeGenericDoc(type("lyng.Flow"), listOf(type("lyng.observable.ListChange"))),
moduleName = "lyng.observable"
) {
thisAs<ObjObservableList>().createChangesFlow(requireScope())
}
addFnDoc(
"observable",
"Observable list is already observable; returns this.",
returns = type("lyng.observable.ObservableList"),
moduleName = "lyng.observable"
) { thisObj }
addFnDoc(
"add",
"Append one or more elements and emit ListInsert.",
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
if (args.isEmpty()) return@addFnDoc ObjVoid
val inserted = ObjList(args.list.toMutableList())
val change = ObjListInsertChange(self.list.size, inserted)
self.mutate(requireScope(), change) {
self.list.addAll(args.list)
change
}
ObjVoid
}
addFnDoc(
"insertAt",
"Insert one or more values at index and emit ListInsert.",
params = listOf(ParamDoc("index", type("lyng.Int"))),
moduleName = "lyng.observable"
) {
if (args.size < 2) raiseError("insertAt takes 2+ arguments")
val self = thisAs<ObjObservableList>()
val index = requiredArg<ObjInt>(0).value.toInt()
val values = args.list.drop(1)
val change = ObjListInsertChange(index, ObjList(values.toMutableList()))
self.mutate(requireScope(), change) {
var i = index
for (v in values) self.list.add(i++, v)
change
}
ObjVoid
}
addFnDoc(
"removeAt",
"Remove element at index or range and emit remove/reorder/clear changes.",
params = listOf(ParamDoc("start", type("lyng.Int")), ParamDoc("end", type("lyng.Int"))),
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
val start = requiredArg<ObjInt>(0).value.toInt()
if (args.size == 2) {
val end = requireOnlyArg<ObjInt>().value.toInt()
val oldValues = self.snapshotList()
val newValues = self.list.toMutableList().apply { subList(start, end).clear() }
if (newValues == self.list) return@addFnDoc self
val change = if (newValues.isEmpty()) ObjListClearChange(oldValues)
else ObjListReorderChange(oldValues, ObjList(newValues.toMutableList()))
self.mutate(requireScope(), change) {
self.list.subList(start, end).clear()
change
}
} else {
val old = self.list[start]
val change = ObjListRemoveChange(start, old)
self.mutate(requireScope(), change) {
self.list.removeAt(start)
change
}
}
self
}
addFnDoc(
"removeLast",
"Remove last element(s) and emit remove/reorder/clear changes.",
params = listOf(ParamDoc("count", type("lyng.Int"))),
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
if (self.list.isEmpty()) return@addFnDoc self
if (args.isNotEmpty()) {
val count = requireOnlyArg<ObjInt>().value.toInt()
if (count <= 0) return@addFnDoc self
val oldValues = self.snapshotList()
val newValues = if (count >= self.list.size) emptyList() else self.list.subList(0, self.list.size - count).toList()
val change = if (newValues.isEmpty()) ObjListClearChange(oldValues)
else ObjListReorderChange(oldValues, ObjList(newValues.toMutableList()))
self.mutate(requireScope(), change) {
if (count >= self.list.size) self.list.clear()
else self.list.subList(self.list.size - count, self.list.size).clear()
change
}
} else {
val index = self.list.lastIndex
val old = self.list[index]
val change = ObjListRemoveChange(index, old)
self.mutate(requireScope(), change) {
self.list.removeAt(index)
change
}
}
self
}
addFnDoc(
"removeRange",
"Remove a range and emit reorder/clear changes.",
params = listOf(ParamDoc("range")),
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
val before = self.snapshotList()
val copy = self.list.toMutableList()
val range = requiredArg<Obj>(0)
if (range is ObjRange) {
val index = range
when {
index.start is ObjInt && index.end is ObjInt -> {
if (index.isEndInclusive) copy.subList(index.start.toInt(), index.end.toInt() + 1)
else copy.subList(index.start.toInt(), index.end.toInt())
}
index.isOpenStart && !index.isOpenEnd -> {
if (index.isEndInclusive) copy.subList(0, index.end!!.toInt() + 1)
else copy.subList(0, index.end!!.toInt())
}
index.isOpenEnd && !index.isOpenStart -> {
copy.subList(index.start!!.toInt(), copy.size)
}
index.isOpenStart && index.isOpenEnd -> {
copy
}
else -> {
throw RuntimeException("Can't apply range for index: $index")
}
}.clear()
} else {
val start = range.toInt()
val end = requiredArg<ObjInt>(1).value.toInt() + 1
copy.subList(start, end).clear()
}
if (copy == self.list) return@addFnDoc self
val change = if (copy.isEmpty()) ObjListClearChange(before)
else ObjListReorderChange(before, ObjList(copy.toMutableList()))
self.mutate(requireScope(), change) {
self.list.clear()
self.list.addAll(copy)
change
}
self
}
addFnDoc(
"sortWith",
"Sort list in place and emit ListReorder.",
params = listOf(ParamDoc("comparator")),
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
if (self.list.size < 2) return@addFnDoc ObjVoid
val comparator = requireOnlyArg<Obj>()
val oldValues = self.snapshotList()
val beforeChange = ObjListReorderChange(oldValues, ObjUnset)
self.notifyBefore(requireScope(), beforeChange)
self.quicksort { a, b -> call(comparator, Arguments(a, b)).toInt() }
val newValues = self.snapshotList()
if (oldValues.list != newValues.list) {
val committed = ObjListReorderChange(oldValues, newValues)
self.notifyAfter(requireScope(), committed)
self.emitCommittedChange(committed)
}
ObjVoid
}
addFnDoc(
"shuffle",
"Shuffle list in place and emit ListReorder.",
moduleName = "lyng.observable"
) {
val self = thisAs<ObjObservableList>()
if (self.list.size < 2) return@addFnDoc ObjVoid
val oldValues = self.snapshotList()
val beforeChange = ObjListReorderChange(oldValues, ObjUnset)
self.notifyBefore(requireScope(), beforeChange)
self.list.shuffle()
val newValues = self.snapshotList()
if (oldValues.list != newValues.list) {
val committed = ObjListReorderChange(oldValues, newValues)
self.notifyAfter(requireScope(), committed)
self.emitCommittedChange(committed)
}
ObjVoid
}
}
}
}
@@ -469,6 +469,7 @@ class CallRef(
internal val args: List<ParsedArgument>,
internal val tailBlock: Boolean,
internal val isOptionalInvoke: Boolean,
internal val explicitTypeArgs: List<TypeDecl>? = null,
) : ObjRef {
override suspend fun get(scope: Scope): ObjRecord = scope.raiseObjRefEvalDisabled()
}
@@ -27,11 +27,25 @@ import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
private fun shouldTreatAsSingleElement(scope: Scope, other: Obj): Boolean {
if (!other.isInstanceOf(ObjIterable)) return true
val declaredElementType = scope.declaredSetElementTypeForValue(this)
if (declaredElementType != null && matchesTypeDecl(scope, other, declaredElementType)) {
return true
}
// Strings and buffers are iterable but usually expected to be atomic values for set +/- operators.
if (other is ObjString || other is ObjBuffer) return true
return false
}
override suspend fun equals(scope: Scope, other: Obj): Boolean {
if (this === other) return true
if (other !is ObjSet) return false
if (set.size != other.set.size) return false
val otherSet = when (other) {
is ObjSet -> other.set
is ObjImmutableSet -> other.toMutableSet()
else -> return false
}
if (set.size != otherSet.size) return false
// Sets are equal if all my elements are in other and vice versa
// contains() in ObjSet uses equals(scope, ...), so we need to be careful
for (e in set) {
@@ -53,6 +67,9 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
}
override suspend fun plus(scope: Scope, other: Obj): Obj {
if (shouldTreatAsSingleElement(scope, other)) {
return ObjSet((set + other).toMutableSet())
}
return ObjSet(
if (other is ObjSet)
(set + other.set).toMutableSet()
@@ -73,6 +90,10 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
}
override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
if (shouldTreatAsSingleElement(scope, other)) {
set += other
return this
}
when (other) {
is ObjSet -> {
set += other.set
@@ -98,13 +119,17 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
}
override suspend fun mul(scope: Scope, other: Obj): Obj {
return if (other is ObjSet) {
ObjSet(set.intersect(other.set).toMutableSet())
} else
scope.raiseIllegalArgument("set operator * requires another set")
return when (other) {
is ObjSet -> ObjSet(set.intersect(other.set).toMutableSet())
is ObjImmutableSet -> ObjSet(set.intersect(other.toMutableSet()).toMutableSet())
else -> scope.raiseIllegalArgument("set operator * requires another set")
}
}
override suspend fun minus(scope: Scope, other: Obj): Obj {
if (shouldTreatAsSingleElement(scope, other)) {
return ObjSet((set - other).toMutableSet())
}
return when {
other is ObjSet -> ObjSet(set.minus(other.set).toMutableSet())
other.isInstanceOf(ObjIterable) -> {
@@ -115,8 +140,7 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
}
ObjSet((set - otherSet).toMutableSet())
}
else ->
scope.raiseIllegalArgument("set operator - requires another set or Iterable")
else -> ObjSet((set - other).toMutableSet())
}
}
@@ -125,12 +149,14 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
}
override suspend fun compareTo(scope: Scope, other: Obj): Int {
if (other is ObjSet) {
if (set == other.set) return 0
if (set.size != other.set.size) return set.size.compareTo(other.set.size)
return set.toString().compareTo(other.set.toString())
val otherSet = when (other) {
is ObjSet -> other.set
is ObjImmutableSet -> other.toMutableSet()
else -> return -2
}
return -2
if (set == otherSet) return 0
if (set.size != otherSet.size) return set.size.compareTo(otherSet.size)
return set.toString().compareTo(otherSet.toString())
}
override fun hashCode(): Int {
@@ -214,6 +240,14 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
for( x in args.list ) set -= x
if( n == set.size ) ObjFalse else ObjTrue
}
addFnDoc(
name = "toImmutable",
doc = "Create an immutable snapshot of this set.",
returns = type("lyng.ImmutableSet"),
moduleName = "lyng.stdlib"
) {
ObjImmutableSet(thisAs<ObjSet>().set)
}
}
}
}
@@ -99,7 +99,9 @@ internal fun typeDeclIsSubtype(scope: Scope, left: TypeDecl, right: TypeDecl): B
is TypeDecl.Simple, is TypeDecl.Generic, is TypeDecl.Function, is TypeDecl.Ellipsis -> {
val leftClass = resolveTypeDeclClass(scope, l) ?: return false
val rightClass = resolveTypeDeclClass(scope, r) ?: return false
leftClass == rightClass || leftClass.allParentsSet.contains(rightClass)
leftClass == rightClass ||
rightClass == Obj.rootObjectType ||
leftClass.allParentsSet.contains(rightClass)
}
else -> false
}
@@ -0,0 +1,73 @@
/*
* 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 observableLyng = """
package lyng.observable
extern class ChangeRejectionException : Exception
extern class Subscription {
extern fun cancel(): Void
}
extern class Observable<Change> {
extern fun beforeChange(listener: (Change)->Void): Subscription
extern fun onChange(listener: (Change)->Void): Subscription
extern fun changes(): Flow<Change>
}
extern class ListChange<T>
extern class ListSet<T> : ListChange<T> {
extern val index: Int
extern val oldValue: Object
extern val newValue: Object
}
extern class ListInsert<T> : ListChange<T> {
extern val index: Int
extern val values: List<T>
}
extern class ListRemove<T> : ListChange<T> {
extern val index: Int
extern val oldValue: Object
}
extern class ListClear<T> : ListChange<T> {
extern val oldValues: List<T>
}
extern class ListReorder<T> : ListChange<T> {
extern val oldValues: List<T>
extern val newValues: Object
}
extern class ObservableList<T> : List<T> {
extern fun beforeChange(listener: (ListChange<T>)->Void): Subscription
extern fun onChange(listener: (ListChange<T>)->Void): Subscription
extern fun changes(): Flow<ListChange<T>>
}
fun List<T>.observable(): ObservableList<T> {
if( this is ObservableList<T> ) this
else ObservableList(...this)
}
""".trimIndent()
@@ -179,6 +179,7 @@ object LyngLanguageTools {
val source = analysis.source
val out = ArrayList<LyngSemanticSpan>(128)
val covered = HashSet<Pair<Int, Int>>()
fun isCurrentSource(pos: Pos): Boolean = pos.source === source
fun addRange(start: Int, end: Int, kind: LyngSemanticKind) {
if (start < 0 || end <= start || end > analysis.text.length) return
@@ -187,6 +188,7 @@ object LyngLanguageTools {
}
fun addName(pos: Pos, name: String, kind: LyngSemanticKind) {
if (!isCurrentSource(pos)) return
val s = source.offsetOf(pos)
addRange(s, s + name.length, kind)
}
@@ -206,7 +208,9 @@ object LyngLanguageTools {
addTypeSegments(t.returnType)
}
is MiniTypeVar -> {
addRange(source.offsetOf(t.range.start), source.offsetOf(t.range.end), LyngSemanticKind.TypeRef)
if (isCurrentSource(t.range.start) && isCurrentSource(t.range.end)) {
addRange(source.offsetOf(t.range.start), source.offsetOf(t.range.end), LyngSemanticKind.TypeRef)
}
}
is MiniTypeUnion -> {
t.options.forEach { addTypeSegments(it) }
@@ -262,7 +266,9 @@ object LyngLanguageTools {
mini.imports.forEach { imp ->
imp.segments.forEach { seg ->
addRange(source.offsetOf(seg.range.start), source.offsetOf(seg.range.end), LyngSemanticKind.TypeRef)
if (isCurrentSource(seg.range.start) && isCurrentSource(seg.range.end)) {
addRange(source.offsetOf(seg.range.start), source.offsetOf(seg.range.end), LyngSemanticKind.TypeRef)
}
}
}
+1 -2
View File
@@ -164,7 +164,7 @@ class BindingTest {
val ms = Script.newScope()
ms.eval("""
extern class A {
fun get1(): String
extern fun get1(): String
}
extern fun getA(): A
@@ -184,4 +184,3 @@ class BindingTest {
}
}
@@ -61,39 +61,39 @@ class BridgeBindingTest {
init { _ ->
data = CounterState(0)
}
addFun("add") { _, _, args ->
addFun("add") {
val a = (args.list[0] as ObjInt).value
val b = (args.list[1] as ObjInt).value
ObjInt.of(a + b)
}
addVal("status") { _, _ -> ObjString(classData as String) }
addVal("status") { ObjString(classData as String) }
addVar(
"count",
get = { _, instance ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
get = {
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
ObjInt.of(st.count)
},
set = { _, instance, value ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
set = { value ->
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
st.count = (value as ObjInt).value
}
)
addFun("secret") { _, _, _ -> ObjInt.of(42) }
addFun("ping") { _, _, _ -> ObjInt.of(7) }
addFun("secret") { ObjInt.of(42) }
addFun("ping") { ObjInt.of(7) }
}
LyngClassBridge.bind(className = "Bar", module = "bridge.mod", importManager = im) {
initWithInstance { _, instance ->
(instance as net.sergeych.lyng.obj.ObjInstance).data = CounterState(10)
initWithInstance {
(thisObj as net.sergeych.lyng.obj.ObjInstance).data = CounterState(10)
}
addVar(
"count",
get = { _, instance ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
get = {
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
ObjInt.of(st.count)
},
set = { _, instance, value ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
set = { value ->
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
st.count = (value as ObjInt).value
}
)
@@ -156,7 +156,7 @@ class BridgeBindingTest {
val bindFailed = try {
LyngClassBridge.bind(className = "Late", module = "bridge.late", importManager = im) {
addVal("status") { _, _ -> ObjString("late") }
addVal("status") { ObjString("late") }
}
false
} catch (_: ScriptError) {
@@ -183,20 +183,20 @@ class BridgeBindingTest {
init { _ ->
data = CounterState(5)
}
addFun("add") { _, _, args ->
addFun("add") {
val a = (args.list[0] as ObjInt).value
val b = (args.list[1] as ObjInt).value
ObjInt.of(a + b)
}
addVal("status") { _, _ -> ObjString(classData as String) }
addVal("status") { ObjString(classData as String) }
addVar(
"count",
get = { _, instance ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
get = {
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
ObjInt.of(st.count)
},
set = { _, instance, value ->
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
set = { value ->
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
st.count = (value as ObjInt).value
}
)
@@ -231,7 +231,7 @@ class BridgeBindingTest {
val ms = Script.newScope()
ms.eval("""
extern class A {
val field: Int
extern val field: Int
}
fun test(a: A) = a.field
@@ -0,0 +1,139 @@
/*
* 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.bindGlobalFun1
import net.sergeych.lyng.bridge.bindGlobalFun3
import net.sergeych.lyng.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjString
import kotlin.test.Test
import kotlin.test.assertTrue
class GlobalBindingTest {
@Test
fun testPackageGlobalFunAndVarBinding() = runTest {
val im = Script.defaultImportManager.copy()
var prop = "initial"
im.addPackage("bridge.globals") { module ->
module.eval(
"""
extern fun globalFun(v: Int): Int
extern fun join3(a: String, b: String, c: String): String
extern var globalProp: String
extern val answer: Int
""".trimIndent()
)
val binder = module.globalBinder()
binder.bindGlobalFun1<Int>("globalFun") { v ->
ObjInt.of((v + 10).toLong())
}
binder.bindGlobalFun3<String, String, String>("join3") { a, b, c ->
ObjString(a + b + c)
}
binder.bindGlobalVar(
name = "globalProp",
get = { prop },
set = { prop = it }
)
binder.bindGlobalVar(
name = "answer",
get = { 42 }
)
}
val scope = im.newStdScope()
scope.eval(
"""
import bridge.globals
assertEquals(15, globalFun(5))
assertEquals("abc", join3("a", "b", "c"))
assertEquals("initial", globalProp)
globalProp = "changed"
assertEquals("changed", globalProp)
assertEquals(42, answer)
""".trimIndent()
)
}
@Test
fun testPackageGlobalRawAndArgReaderBinding() = runTest {
val im = Script.defaultImportManager.copy()
im.addPackage("bridge.raw") { module ->
module.eval(
"""
extern fun sum3(a: Int, b: Int, c: Int): Int
extern fun echoRaw(x: Int): Int
""".trimIndent()
)
val binder = module.globalBinder()
binder.bindGlobalFun("sum3") {
requireExactCount(3)
ObjInt.of((int(0) + int(1) + int(2)).toLong())
}
binder.bindGlobalFunRaw("echoRaw") { _, args ->
args.firstAndOnly()
}
}
val scope = im.newStdScope()
scope.eval(
"""
import bridge.raw
assertEquals(6, sum3(1, 2, 3))
assertEquals(77, echoRaw(77))
""".trimIndent()
)
}
@Test
fun testGlobalVarExternCompatibilityChecks() = runTest {
val im = Script.defaultImportManager.copy()
im.addPackage("bridge.compat") { module ->
module.eval(
"""
extern var needsSetter: String
extern val noSetterAllowed: String
""".trimIndent()
)
val binder = module.globalBinder()
val missingSetter = try {
binder.bindGlobalVar(
name = "needsSetter",
get = { "x" }
)
false
} catch (_: ScriptError) {
true
}
val readonlySetter = try {
binder.bindGlobalVar(
name = "noSetterAllowed",
get = { "x" },
set = { _ -> }
)
false
} catch (_: ScriptError) {
true
}
assertTrue(missingSetter)
assertTrue(readonlySetter)
}
}
}
@@ -0,0 +1,107 @@
/*
* 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.eval
import kotlin.test.Test
import kotlin.test.assertFails
class ImmutableCollectionsTest {
@Test
fun immutableListSnapshotAndConversion() = runTest {
eval(
"""
val src = [1,2,3]
val imm = src.toImmutable()
assert(imm is ImmutableList<Int>)
assert(imm is Array<Int>)
assert(imm is Collection<Int>)
assert(imm is Iterable<Int>)
src += 4
assertEquals(3, imm.size)
assertEquals([1,2,3], imm.toMutable())
assertEquals([1,2,3], (1..3).toImmutableList().toMutable())
"""
)
}
@Test
fun immutableSetSnapshotAndConversion() = runTest {
eval(
"""
val src = Set(1,2,3)
val imm = src.toImmutable()
assert(imm is ImmutableSet<Int>)
assert(imm is Collection<Int>)
assert(imm is Iterable<Int>)
src += 4
assertEquals(3, imm.size)
assertEquals(Set(1,2,3), imm.toMutable())
assertEquals(Set(1,2,3), [1,2,3].toImmutableSet.toMutable())
"""
)
}
@Test
fun immutableMapSnapshotAndConversion() = runTest {
eval(
"""
val src = Map("a" => 1, "b" => 2)
val imm = src.toImmutable()
assert(imm is ImmutableMap<String,Int>)
assert(imm is Collection<MapEntry<String,Int>>)
assert(imm is Iterable<MapEntry<String,Int>>)
src["a"] = 100
assertEquals(1, imm["a"])
assertEquals(Map("a" => 1, "b" => 2), imm.toMutable())
val imm2 = ["x" => 10, "y" => 20].toImmutableMap
assertEquals(10, imm2["x"])
assertEquals(Map("x" => 10, "y" => 20), imm2.toMutable())
"""
)
}
@Test
fun immutableCollectionsRejectMutationOps() = runTest {
assertFails {
eval(
"""
val xs = ImmutableList(1,2,3)
xs += 4
"""
)
}
assertFails {
eval(
"""
val s = ImmutableSet(1,2,3)
s += 4
"""
)
}
assertFails {
eval(
"""
val m = ImmutableMap("a" => 1)
m["a"] = 10
"""
)
}
}
}
+2 -2
View File
@@ -249,13 +249,13 @@ class MiniAstTest {
// Doc2
extern class C1 {
// Doc3
fun m1()
extern fun m1()
}
// Doc4
extern object O1 {
// Doc5
val v1: String
extern val v1: String
}
// Doc6
@@ -114,7 +114,7 @@ class ObjectExpressionTest {
eval("""
val x = object { }
val name = ((x::class as Class).className as String)
assert(name.startsWith("${'$'}Anon_"))
assert(name.startsWith("\${'$'}Anon_"))
""".trimIndent())
}
}
@@ -0,0 +1,117 @@
/*
* 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.eval
import kotlin.test.Test
class ObservableListTest {
@Test
fun observableHooksAndSubscriptionCancel() = runTest {
eval(
"""
import lyng.observable
val src = [1,2]
val xs = src.observable()
assert(xs is ObservableList<Int>)
assert(src == [1,2])
assert(xs == [1,2])
var before = 0
var after = 0
val beforeSub = xs.beforeChange { before++ }
val afterSub = xs.onChange { after++ }
xs += 3
assertEquals([1,2,3], xs)
assertEquals(1, before)
assertEquals(1, after)
afterSub.cancel()
xs[0] = 100
assertEquals([100,2,3], xs)
assertEquals(2, before)
assertEquals(1, after)
beforeSub.cancel()
xs.removeAt(0)
assertEquals([2,3], xs)
assertEquals(2, before)
assertEquals(1, after)
"""
)
}
@Test
fun observableBeforeChangeRejectsMutation() = runTest {
eval(
"""
import lyng.observable
val xs = [1,2].observable()
var after = 0
xs.beforeChange {
throw ChangeRejectionException("no changes accepted")
}
xs.onChange { after++ }
assertThrows(ChangeRejectionException) {
xs += 3
}
assertEquals([1,2], xs)
assertEquals(0, after)
"""
)
}
@Test
fun observableChangesFlowEmitsCommittedEvents() = runTest {
eval(
"""
import lyng.observable
val xs = [10,20].observable()
val it = xs.changes().iterator()
xs += 30
assert(it.hasNext())
val e1 = it.next()
assert(e1 is ListInsert<Int>)
assertEquals(2, (e1 as ListInsert<Int>).index)
assertEquals([30], e1.values)
xs[1] = 200
assert(it.hasNext())
val e2 = it.next()
assert(e2 is ListSet<Int>)
assertEquals(1, (e2 as ListSet<Int>).index)
assertEquals(20, e2.oldValue)
assertEquals(200, e2.newValue)
xs.removeAt(0)
assert(it.hasNext())
val e3 = it.next()
assert(e3 is ListRemove<Int>)
assertEquals(0, (e3 as ListRemove<Int>).index)
assertEquals(10, e3.oldValue)
it.cancelIteration()
"""
)
}
}
Loaded 100 of 124 files, more files were not shown because too many files have changed in this diff. Show more