Compare commits
29
Commits
62dc501657
...
1.5.1
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
3d8bfe8863 | ||
|
|
3b83439788 | ||
|
|
0af0f31e48 | ||
|
|
d17ad9ef0d | ||
|
|
222a653040 | ||
|
|
f24c7d2715 | ||
|
|
2546a5327f | ||
|
|
4df6612eca | ||
|
|
2a79c718ba | ||
|
|
d92309d76c | ||
|
|
767e995a96 | ||
|
|
794553d81d | ||
|
|
d9d7cafec8 | ||
|
|
1a080bc53e | ||
|
|
a6492bb750 | ||
|
|
d2a47d34a3 | ||
|
|
8e0442670d | ||
|
|
74eb8ff082 | ||
|
|
2b13fe8053 | ||
|
|
979e6ea9b7 | ||
|
|
e447c778ed | ||
|
|
37d093817e | ||
|
|
c54d947f1c | ||
|
|
8a32ffe655 | ||
|
|
65edf9fe67 | ||
|
|
18394ce286 | ||
|
|
298c2a09fe | ||
|
|
a9da21e7a4 | ||
|
|
4581998ba3 |
No files matched your search
@@ -1,5 +1,19 @@
|
|||||||
# AI Agent Notes
|
# AI Agent Notes
|
||||||
|
|
||||||
|
## Canonical AI References
|
||||||
|
- Use `docs/ai_language_reference.md` as the primary, compiler-verified Lyng language reference for code generation.
|
||||||
|
- For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`.
|
||||||
|
- Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface.
|
||||||
|
- Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above.
|
||||||
|
- Prefer the shortest clear loop: use `for` for straightforward iteration/ranges; use `while` only when loop state/condition is irregular or changes in ways `for` cannot express cleanly.
|
||||||
|
- In Lyng code, slice strings with range indexing (`text[a..<b]`, `text[..<n]`, `text[n..]`) and avoid Java/Kotlin-style `substring(...)`.
|
||||||
|
|
||||||
|
## Lyng-First API Declarations
|
||||||
|
- Use `.lyng` declarations as the single source of truth for Lyng-facing API docs and types (especially module extern declarations).
|
||||||
|
- Prefer defining Lyng entities (enums/classes/type shapes) in `.lyng` files; only define them in Kotlin when there is Kotlin/platform-specific implementation detail that cannot be expressed in Lyng.
|
||||||
|
- Avoid hardcoding Lyng API documentation in Kotlin registrars when it can be declared in `.lyng`; Kotlin-side docs should be fallback/bridge only.
|
||||||
|
- For mixed pluggable modules (Lyng + Kotlin), embed module `.lyng` sources as generated Kotlin string literals, evaluate them into module scope during registration, then attach Kotlin implementations/bindings.
|
||||||
|
|
||||||
## Kotlin/Wasm generation guardrails
|
## Kotlin/Wasm generation guardrails
|
||||||
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
|
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
|
||||||
- Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks).
|
- Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks).
|
||||||
@@ -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.
|
- 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).
|
- 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.
|
- 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
@@ -1,156 +1,88 @@
|
|||||||
## 1.5.0-SNAPSHOT
|
# Changelog
|
||||||
|
|
||||||
### Language Features
|
This file tracks user-visible Lyng language/runtime/tooling changes.
|
||||||
- Added `return` statement with local and non-local exit support (`return@label`).
|
|
||||||
- Support for `abstract` classes, methods, and variables.
|
|
||||||
- Introduced `interface` as a synonym for `abstract class`.
|
|
||||||
- Multiple Inheritance (MI) completed and enabled by default (C3 MRO).
|
|
||||||
- Class properties with custom accessors (`get`, `set`).
|
|
||||||
- Restricted setter visibility (`private set`, `protected set`).
|
|
||||||
- Late-initialized `val` fields in classes with `Unset` protection.
|
|
||||||
- Named arguments (`name: value`) and named splats (`...Map`).
|
|
||||||
- Assign-if-null operator `?=`.
|
|
||||||
- Refined `protected` visibility rules and `closed` modifier.
|
|
||||||
- Transient attribute `@Transient` for serialization and equality.
|
|
||||||
- Unified Delegation model for `val`, `var`, and `fun`.
|
|
||||||
- Singleton objects (`object`) and object expressions.
|
|
||||||
|
|
||||||
### Standard Library
|
History note:
|
||||||
- Added `with(self, block)` for scoped execution.
|
- The project had periods where changelog maintenance lagged behind commits.
|
||||||
- Added `clamp()` function and extension.
|
- Entries below are synchronized and curated for `1.5.x`.
|
||||||
- Improved `Exception` and `StackTraceEntry` reporting.
|
- Earlier history may be incomplete and should be cross-checked with git tags/commits when needed.
|
||||||
|
|
||||||
### Tooling and IDE
|
## 1.5.1 (2026-03-25)
|
||||||
- **CLI**: Added `fmt` as a first-class subcommand for code formatting.
|
|
||||||
- **IDEA Plugin**: Lightweight autocompletion (experimental), improved docs, and Grazie integration.
|
|
||||||
- **Highlighters**: Updated TextMate bundle and website highlighters for new syntax.
|
|
||||||
|
|
||||||
### Detailed Changes:
|
### Language
|
||||||
|
- Added string interpolation:
|
||||||
|
- `"$name"` identifier interpolation.
|
||||||
|
- `"${expr}"` expression interpolation.
|
||||||
|
- Added literal-dollar forms in strings:
|
||||||
|
- `"\$"` -> `$`
|
||||||
|
- `"$$"` -> `$`
|
||||||
|
- `\\$x` is parsed as backslash + interpolation of `x`.
|
||||||
|
- Added per-file interpolation opt-out via leading directive comment:
|
||||||
|
- `// feature: interpolation: off`
|
||||||
|
|
||||||
- Language: Refined `protected` visibility rules
|
### Docs and AI references
|
||||||
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor).
|
- Updated compiler-accurate AI language docs:
|
||||||
- This allows patterns where a base class calls a `protected` method that is implemented in a subclass.
|
- interpolation syntax and escaping
|
||||||
- Fixed a regression where self-calls to unmangled members sometimes bypassed visibility checks incorrectly; these are now handled by the refined logic.
|
- per-file feature switch behavior
|
||||||
|
- Refreshed tutorial examples and doctests to reflect new interpolation semantics.
|
||||||
|
- Added/reworked current proposal/reference materials for Lyng common-platform guidance.
|
||||||
|
|
||||||
- Language: Added `return` statement
|
### Compatibility notes
|
||||||
- `return [expression]` exits the innermost enclosing callable (function or lambda).
|
- Interpolation is enabled by default for normal string literals.
|
||||||
- Supports non-local returns using `@label` syntax (e.g., `return@outer 42`).
|
- Existing code that intentionally used `$name` as literal text should use `\$name`, `$$name`, or the file directive `// feature: interpolation: off`.
|
||||||
- Named functions automatically provide their name as a label for non-local returns.
|
|
||||||
- Labeled lambdas: lambdas can be explicitly labeled using `@label { ... }`.
|
|
||||||
- Restriction: `return` is forbidden in shorthand function definitions (e.g., `fun f(x) = return x` is a syntax error).
|
|
||||||
- Control Flow: `return` and `break` are now protected from being caught by user-defined `try-catch` blocks in Lyng.
|
|
||||||
- Documentation: New `docs/return_statement.md` and updated `tutorial.md`.
|
|
||||||
|
|
||||||
- Language: stdlib improvements
|
## 1.5.0 (2026-03-22)
|
||||||
- Added `with(self, block)` function to `root.lyng` which executes a block with `this` set to the provided object.
|
|
||||||
- Language: Abstract Classes and Interfaces
|
|
||||||
- Support for `abstract` modifier on classes, methods, and variables.
|
|
||||||
- Introduced `interface` as a synonym for `abstract class`, supporting full state (constructors, fields, `init` blocks) and implementation by parts via MI.
|
|
||||||
- New `closed` modifier (antonym to `open`) to prevent overriding class members.
|
|
||||||
- Refined `override` logic: mandatory keyword when re-declaring members that exist in the ancestor chain (MRO).
|
|
||||||
- MI Satisfaction: Abstract requirements are automatically satisfied by matching concrete members found later in the C3 MRO chain without requiring explicit proxy methods.
|
|
||||||
- Integration: Updated highlighters (lynglib, lyngweb, IDEA plugin), IDEA completion, and Grazie grammar checking.
|
|
||||||
- Documentation: Updated `docs/OOP.md` with sections on "Abstract Classes and Members", "Interfaces", and "Overriding and Virtual Dispatch".
|
|
||||||
- IDEA plugin: Improved natural language support and spellchecking
|
|
||||||
- Disabled the limited built-in English and Technical dictionaries.
|
|
||||||
- Enforced usage of the platform's standard Natural Languages (Grazie) and Spellchecker components.
|
|
||||||
- Integrated `SpellCheckerManager` for word suggestions and validation, respecting users' personal and project dictionaries.
|
|
||||||
- Added project-specific "learned words" support via `Lyng Formatter` settings and quick-fixes.
|
|
||||||
- Enhanced fallback spellchecker for technical terms and Lyng-specific vocabulary.
|
|
||||||
|
|
||||||
- Language: Class properties with accessors
|
### Major runtime/compiler direction
|
||||||
- Support for `val` (read-only) and `var` (read-write) properties in classes.
|
- Completed migration to bytecode-first/bytecode-only execution paths.
|
||||||
- Syntax: `val name [ : Type ] get() { body }` or `var name [ : Type ] get() { body } set(value) { body }`.
|
- Removed interpreter fallback behavior in core execution hot paths.
|
||||||
- Laconic Expression Shorthand: `val prop get() = expression` and `var prop get() = read set(v) = write`.
|
- Continued frame-slot-first local/capture model improvements and related diagnostics.
|
||||||
- Properties are pure accessors and do **not** have automatic backing fields.
|
|
||||||
- Validation: `var` properties must have both accessors; `val` must have only a getter.
|
|
||||||
- Integration: Updated TextMate grammar and IntelliJ plugin (highlighting + keywords).
|
|
||||||
- Documentation: New "Properties" section in `docs/OOP.md`.
|
|
||||||
|
|
||||||
- Language: Restricted Setter Visibility
|
### Language features and semantics
|
||||||
- Support for `private set` and `protected set` modifiers on `var` fields and properties.
|
- Added/finished `return` semantics including labeled non-local forms (`return@label`).
|
||||||
- Allows members to be publicly readable but only writable from within the declaring class or its subclasses.
|
- Added abstract classes/members and `interface` support (as abstract-class-style construct).
|
||||||
- Enforcement at runtime: throws `AccessException` on unauthorized writes.
|
- Completed and enabled multiple inheritance with C3 MRO by default.
|
||||||
- Supported only for declarations in class bodies (fields and properties).
|
- Added class properties with accessors (`get`/`set`) and restricted setter visibility (`private set`, `protected set`).
|
||||||
- Documentation: New "Restricted Setter Visibility" section in `docs/OOP.md`.
|
- Added late-initialized class `val` support with `Unset` protection rules.
|
||||||
|
- Added named arguments (`name: value`) and named splats (`...map`) with stricter validation.
|
||||||
|
- Added assign-if-null operator `?=`.
|
||||||
|
- Improved nullable/type-checking behavior (including `T is nullable` and related type checks).
|
||||||
|
- Added variadic function types (`...` in function type declarations) and tighter lambda type checks.
|
||||||
|
|
||||||
- Language: Late-initialized `val` fields in classes
|
### Type system and collections
|
||||||
- Support for declaring `val` without an immediate initializer in class bodies.
|
- Added immutable collections hierarchy (`ImmutableList`, `ImmutableSet`, `ImmutableMap`).
|
||||||
- Compulsory initialization: every late-init `val` must be assigned at least once within the class body or an `init` block.
|
- Improved generic runtime binding/checking for explicit type arguments and bounds.
|
||||||
- Write-once enforcement: assigning to a `val` is allowed only if its current value is `Unset`.
|
- Added smarter type-aware collection ops (`+=`, `-=`) and stronger declared-member type checks.
|
||||||
- Access protection: reading a late-init `val` before it is assigned returns the `Unset` singleton; using `Unset` for most operations throws an `UnsetException`.
|
|
||||||
- Extension properties do not support late-init.
|
|
||||||
- Documentation: New "Late-initialized `val` fields" and "The `Unset` singleton" sections in `docs/OOP.md`.
|
|
||||||
|
|
||||||
- Docs: OOP improvements
|
### Extern/Kotlin bridge
|
||||||
- New page: `docs/scopes_and_closures.md` detailing `ClosureScope` resolution order, recursion‑safe helpers (`chainLookupIgnoreClosure`, `chainLookupWithMembers`, `baseGetIgnoreClosure`), cycle prevention, and capturing lexical environments for callbacks (`snapshotForClosure`).
|
- Tightened extern declaration rules:
|
||||||
- Updated: `docs/advanced_topics.md` (link to the new page), `docs/parallelism.md` (closures in `launch`/`flow`), `docs/OOP.md` (visibility from closures with preserved `currentClassCtx`), `docs/exceptions_handling.md` (compatibility alias `SymbolNotFound`).
|
- explicit extern members are required for extern class/object declarations.
|
||||||
- Tutorial: added quick link to Scopes and Closures.
|
- Improved extern generic class behavior and diagnostics.
|
||||||
|
- Extended bridge APIs for binding global functions/variables and object/member interop scenarios.
|
||||||
|
|
||||||
- IDEA plugin: Lightweight autocompletion (experimental)
|
### Standard library and modules
|
||||||
- Global completion: local declarations, in‑scope parameters, imported modules, and stdlib symbols.
|
- Added `lyng.observable` improvements (`ObservableList` hooks/events).
|
||||||
- Member completion: after a dot, suggests only members of the inferred receiver type (incl. chained calls like `Path(".." ).lines().` → `Iterator` methods). No global identifiers appear after a dot.
|
- Added `Random` stdlib API used by updated samples.
|
||||||
- Inheritance-aware: direct class members first, then inherited (e.g., `List` includes `Collection`/`Iterable` methods).
|
- Added/extended `lyngio.console` support and CLI integration for console interaction.
|
||||||
- Heuristics: handles literals (`"…"` → `String`, numbers → `Int/Real`, `[...]` → `List`, `{...}` → `Dict`) and static `Namespace.` members.
|
- Migrated time APIs to `kotlin.time` (`Instant` migration and related docs/tests).
|
||||||
- Performance: capped results, early prefix filtering, per‑document MiniAst cache, cancellation checks.
|
|
||||||
- Toggle: Settings | Lyng Formatter → "Enable Lyng autocompletion (experimental)" (default ON).
|
|
||||||
- Stabilization: DEBUG completion/Quick Doc logs are OFF by default; behavior aligned between IDE and isolated engine tests.
|
|
||||||
|
|
||||||
- Language: Named arguments and named splats
|
### CLI, IDE, and docs/tooling
|
||||||
- New call-site syntax for named arguments using colon: `name: value`.
|
- CLI:
|
||||||
- Positional arguments must come before named; positionals after a named argument inside parentheses are rejected.
|
- added first-class `fmt` command
|
||||||
- Trailing-lambda interaction: if the last parameter is already assigned by name (or via a named splat), a trailing `{ ... }` block is illegal.
|
- preserved direct script fast-path invocation
|
||||||
- Named splats: `...` can now expand a Map into named arguments.
|
- improved command help/dispatch behavior
|
||||||
- Only string keys are allowed; non-string keys raise a clear error.
|
- IntelliJ plugin:
|
||||||
- Duplicate assignment across named args and named splats is an error.
|
- improved lightweight completion and documentation/inspection behavior
|
||||||
- Ellipsis (variadic) parameters remain positional-only and cannot be named.
|
- continued highlighter and Grazie/spellchecking integration work
|
||||||
- Rationale: `=` is assignment and an expression in Lyng; `:` at call sites avoids ambiguity. Declarations keep `name: Type`; call-site casts continue to use `as` / `as?`.
|
- Docs:
|
||||||
- Documentation updated: proposals and declaring-arguments sections now cover named args/splats and error cases.
|
- substantial updates across tutorial/OOP/type/runtime references
|
||||||
- Tests added covering success cases and errors for named args/splats and trailing-lambda interactions.
|
- expanded bytecode and advanced topics coverage
|
||||||
|
|
||||||
- Tooling: Highlighters and TextMate bundle updated for named args
|
## Migration checklist for 1.5.x
|
||||||
- Website/editor highlighter (lyngweb + site) works with `name: value` and `...Map("k" => v)`; added JS tests covering punctuation/operator spans for `:` and `...`.
|
|
||||||
- TextMate grammar updated to recognize named call arguments: `name: value` after `(` or `,` with `name` highlighted as `variable.parameter.named.lyng` and `:` as punctuation; excludes `::`.
|
|
||||||
- TextMate bundle version bumped to 0.0.3; README updated with details and guidance.
|
|
||||||
|
|
||||||
- Multiple Inheritance (MI) completed and enabled by default:
|
- If you rely on literal `$...` strings:
|
||||||
- Active C3 Method Resolution Order (MRO) for deterministic, monotonic lookup across complex hierarchies and diamonds.
|
- replace with `\$...` or `$$...`, or
|
||||||
- Qualified dispatch:
|
- add `// feature: interpolation: off` at file top.
|
||||||
- `this@Type.member(...)` inside class bodies starts lookup at the specified ancestor.
|
- Review any code relying on interpreter-era fallback behavior; 1.5.x assumes bytecode-first execution.
|
||||||
- Cast-based disambiguation: `(expr as Type).member(...)`, `(expr as? Type)?.member(...)` (works with existing safe-call `?.`).
|
- For extern declarations, ensure members are explicitly declared where required.
|
||||||
- Field inheritance (`val`/`var`) under MI:
|
- For named arguments/splats, verify call sites follow stricter ordering/duplication rules.
|
||||||
- Instance storage is disambiguated per declaring class; unqualified read/write resolves to the first match in MRO.
|
|
||||||
- Qualified read/write targets the chosen ancestor’s storage.
|
|
||||||
- Constructors and initialization:
|
|
||||||
- Direct bases are initialized left-to-right; each ancestor is initialized at most once (diamond-safe de-duplication).
|
|
||||||
- Header-specified constructor arguments are passed to direct bases.
|
|
||||||
- Visibility enforcement under MI:
|
|
||||||
- `private` visible only inside the declaring class body.
|
|
||||||
- `protected` visible inside the declaring class and its transitive subclasses. Additionally, ancestor classes can access protected members of their descendants if it's an override of a member known to the ancestor. Unrelated contexts cannot access it (qualification/casts do not bypass).
|
|
||||||
- Diagnostics improvements:
|
|
||||||
- Missing member/field messages include receiver class and linearization order; hints for `this@Type` or casts when helpful.
|
|
||||||
- Invalid `this@Type` reports that the qualifier is not an ancestor and shows the receiver lineage.
|
|
||||||
- `as`/`as?` cast errors include actual and target type names.
|
|
||||||
|
|
||||||
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
|
|
||||||
|
|
||||||
- CLI: Added `fmt` as a first-class Clikt subcommand.
|
|
||||||
- Default behavior: formats files to stdout (no in-place edits by default).
|
|
||||||
- Options:
|
|
||||||
- `--check`: check only; print files that would change; exit with code 2 if any changes are needed.
|
|
||||||
- `-i, --in-place`: write formatted result back to files.
|
|
||||||
- `--spacing`: apply spacing normalization.
|
|
||||||
- `--wrap`, `--wrapping`: enable line wrapping.
|
|
||||||
- Mutually exclusive: `--check` and `--in-place` together now produce an error and exit with code 1.
|
|
||||||
- Multi-file stdout prints headers `--- <path> ---` per file.
|
|
||||||
- `lyng --help` shows `fmt`; `lyng fmt --help` displays dedicated help.
|
|
||||||
- Fix: Property accessors (`get`, `set`, `private set`, `protected set`) are now correctly indented relative to the property declaration.
|
|
||||||
- Fix: Indentation now correctly carries over into blocks that start on extra‑indented lines (e.g., nested `if` statements or property accessor bodies).
|
|
||||||
- Fix: Formatting Markdown files no longer deletes content in `.lyng` code fences and works correctly with injected files (resolves clobbering, `StringIndexOutOfBoundsException`, and `nonempty text is not covered by block` errors).
|
|
||||||
|
|
||||||
- CLI: Preserved legacy script invocation fast-paths:
|
|
||||||
- `lyng script.lyng [args...]` executes the script directly.
|
|
||||||
- `lyng -- -file.lyng [args...]` executes a script whose name begins with `-`.
|
|
||||||
|
|
||||||
- CLI: Fixed a regression where the root help banner could print before subcommands.
|
|
||||||
- Root command no longer prints help when a subcommand (e.g., `fmt`) is invoked.
|
|
||||||
+1
-1
@@ -20,7 +20,7 @@
|
|||||||
set -e
|
set -e
|
||||||
echo "publishing all artifacts"
|
echo "publishing all artifacts"
|
||||||
echo
|
echo
|
||||||
./gradlew publishToMavenLocal publish buildInstallablePlugin
|
./gradlew publishToMavenLocal site:jsBrowserDistribution publish buildInstallablePlugin :lyng:linkReleaseExecutableLinuxX64 :lyng:installJvmDist --parallel
|
||||||
|
|
||||||
#echo
|
#echo
|
||||||
#echo "Creating plugin"
|
#echo "Creating plugin"
|
||||||
|
|||||||
@@ -11,6 +11,7 @@ Concrete collection classes:
|
|||||||
|
|
||||||
- Mutable: [List], [Set], [Map]
|
- Mutable: [List], [Set], [Map]
|
||||||
- Immutable: [ImmutableList], [ImmutableSet], [ImmutableMap]
|
- Immutable: [ImmutableList], [ImmutableSet], [ImmutableMap]
|
||||||
|
- Observable mutable lists (opt-in module): [ObservableList]
|
||||||
|
|
||||||
| name | description |
|
| name | description |
|
||||||
|------------------------|------------------------------------------------------|
|
|------------------------|------------------------------------------------------|
|
||||||
@@ -27,3 +28,4 @@ See [List], [Set], [Iterable] and [Efficient Iterables in Kotlin Interop](Effici
|
|||||||
[ImmutableList]: ImmutableList.md
|
[ImmutableList]: ImmutableList.md
|
||||||
[ImmutableSet]: ImmutableSet.md
|
[ImmutableSet]: ImmutableSet.md
|
||||||
[ImmutableMap]: ImmutableMap.md
|
[ImmutableMap]: ImmutableMap.md
|
||||||
|
[ObservableList]: ObservableList.md
|
||||||
@@ -2,6 +2,7 @@
|
|||||||
|
|
||||||
Mutable list of any objects.
|
Mutable list of any objects.
|
||||||
For immutable list values, see [ImmutableList].
|
For immutable list values, see [ImmutableList].
|
||||||
|
For observable mutable lists and change hooks, see [ObservableList].
|
||||||
|
|
||||||
It's class in Lyng is `List`:
|
It's class in Lyng is `List`:
|
||||||
|
|
||||||
@@ -180,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.
|
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
|
## Member inherited from Array
|
||||||
|
|
||||||
| name | meaning | type |
|
| name | meaning | type |
|
||||||
@@ -199,3 +244,4 @@ It inherits from [Iterable] too and thus all iterable methods are applicable to
|
|||||||
|
|
||||||
[Iterable]: Iterable.md
|
[Iterable]: Iterable.md
|
||||||
[ImmutableList]: ImmutableList.md
|
[ImmutableList]: ImmutableList.md
|
||||||
|
[ObservableList]: ObservableList.md
|
||||||
@@ -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
|
||||||
@@ -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.
|
||||||
@@ -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`).
|
||||||
+33
-12
@@ -243,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.
|
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
|
||||||
// Lyng side (in a module)
|
// Lyng side (in a module)
|
||||||
class Counter {
|
class Counter {
|
||||||
@@ -251,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
|
||||||
// Kotlin side (binding)
|
// Kotlin side (binding)
|
||||||
@@ -261,14 +282,14 @@ moduleScope.eval("class Counter { extern var value: Int; extern fun inc(by: Int)
|
|||||||
moduleScope.bind("Counter") {
|
moduleScope.bind("Counter") {
|
||||||
addVar(
|
addVar(
|
||||||
name = "value",
|
name = "value",
|
||||||
get = { _, self -> self.readField(this, "value").value },
|
get = { thisObj.readField(this, "value").value },
|
||||||
set = { _, self, v -> self.writeField(this, "value", v) }
|
set = { v -> thisObj.writeField(this, "value", v) }
|
||||||
)
|
)
|
||||||
addFun("inc") { _, self, args ->
|
addFun("inc") {
|
||||||
val by = args.requiredArg<ObjInt>(0).value
|
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)
|
val next = ObjInt(current.value + by)
|
||||||
self.writeField(this, "value", next)
|
thisObj.writeField(this, "value", next)
|
||||||
next
|
next
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -303,16 +324,16 @@ moduleScope.eval("""
|
|||||||
moduleScope.bindObject("HostObject") {
|
moduleScope.bindObject("HostObject") {
|
||||||
classData = "OK"
|
classData = "OK"
|
||||||
init { _ -> data = 0L }
|
init { _ -> data = 0L }
|
||||||
addFun("add") { _, _, args ->
|
addFun("add") {
|
||||||
val a = args.requiredArg<ObjInt>(0).value
|
val a = args.requiredArg<ObjInt>(0).value
|
||||||
val b = args.requiredArg<ObjInt>(1).value
|
val b = args.requiredArg<ObjInt>(1).value
|
||||||
ObjInt.of(a + b)
|
ObjInt.of(a + b)
|
||||||
}
|
}
|
||||||
addVal("status") { _, _ -> ObjString(classData as String) }
|
addVal("status") { ObjString(classData as String) }
|
||||||
addVar(
|
addVar(
|
||||||
"count",
|
"count",
|
||||||
get = { _, inst -> ObjInt.of((inst as ObjInstance).data as Long) },
|
get = { ObjInt.of((thisObj as ObjInstance).data as Long) },
|
||||||
set = { _, inst, value -> (inst as ObjInstance).data = (value as ObjInt).value }
|
set = { value -> (thisObj as ObjInstance).data = (value as ObjInt).value }
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
@@ -321,7 +342,7 @@ Notes:
|
|||||||
|
|
||||||
- Required order: declare/eval Lyng object in the module first, then call `bindObject(...)`.
|
- Required order: declare/eval Lyng object in the module first, then call `bindObject(...)`.
|
||||||
This is the pattern covered by `BridgeBindingTest.testExternObjectBinding`.
|
This is the pattern covered by `BridgeBindingTest.testExternObjectBinding`.
|
||||||
- Members must be marked `extern` so the compiler emits ABI slots for Kotlin bindings.
|
- 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(...)`.
|
- You can also bind by name/module via `LyngObjectBridge.bind(...)`.
|
||||||
|
|
||||||
Minimal `extern fun` example:
|
Minimal `extern fun` example:
|
||||||
@@ -336,7 +357,7 @@ moduleScope.eval("""
|
|||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
|
|
||||||
moduleScope.bindObject("HostObject") {
|
moduleScope.bindObject("HostObject") {
|
||||||
addFun("ping") { _, _, _ -> ObjInt.of(7) }
|
addFun("ping") { ObjInt.of(7) }
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
|
|||||||
@@ -109,6 +109,24 @@ Examples (T = A | B):
|
|||||||
B in T // true
|
B in T // true
|
||||||
T is A | B // 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
|
# Practical examples
|
||||||
|
|
||||||
fun acceptInts<T: Int>(xs: List<T>) { }
|
fun acceptInts<T: Int>(xs: List<T>) { }
|
||||||
|
|||||||
@@ -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
|
||||||
|
|
||||||
|

|
||||||
|
|
||||||
|
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
@@ -6,12 +6,13 @@
|
|||||||
|
|
||||||
1. **Security:** I/O and process execution are sensitive operations. By keeping them in a separate module, we ensure that the Lyng core remains 100% safe by default. You only enable what you explicitly need.
|
1. **Security:** I/O and process execution are sensitive operations. By keeping them in a separate module, we ensure that the Lyng core remains 100% safe by default. You only enable what you explicitly need.
|
||||||
2. **Footprint:** Not every script needs filesystem or process access. Keeping these as a separate module helps minimize the dependency footprint for small embedded projects.
|
2. **Footprint:** Not every script needs filesystem or process access. Keeping these as a separate module helps minimize the dependency footprint for small embedded projects.
|
||||||
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`) that allow you to control exactly what a script can do.
|
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`, `ConsoleAccessPolicy`) that allow you to control exactly what a script can do.
|
||||||
|
|
||||||
#### Included Modules
|
#### Included Modules
|
||||||
|
|
||||||
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
|
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
|
||||||
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
|
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
|
||||||
|
- **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
@@ -39,8 +40,10 @@ To use `lyngio` modules in your scripts, you must install them into your Lyng sc
|
|||||||
import net.sergeych.lyng.Script
|
import net.sergeych.lyng.Script
|
||||||
import net.sergeych.lyng.io.fs.createFs
|
import net.sergeych.lyng.io.fs.createFs
|
||||||
import net.sergeych.lyng.io.process.createProcessModule
|
import net.sergeych.lyng.io.process.createProcessModule
|
||||||
|
import net.sergeych.lyng.io.console.createConsoleModule
|
||||||
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
||||||
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
|
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
|
||||||
|
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||||
|
|
||||||
suspend fun runMyScript() {
|
suspend fun runMyScript() {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
@@ -48,14 +51,17 @@ suspend fun runMyScript() {
|
|||||||
// Install modules with policies
|
// Install modules with policies
|
||||||
createFs(PermitAllAccessPolicy, scope)
|
createFs(PermitAllAccessPolicy, scope)
|
||||||
createProcessModule(PermitAllProcessAccessPolicy, scope)
|
createProcessModule(PermitAllProcessAccessPolicy, scope)
|
||||||
|
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
|
||||||
|
|
||||||
// Now scripts can import them
|
// Now scripts can import them
|
||||||
scope.eval("""
|
scope.eval("""
|
||||||
import lyng.io.fs
|
import lyng.io.fs
|
||||||
import lyng.io.process
|
import lyng.io.process
|
||||||
|
import lyng.io.console
|
||||||
|
|
||||||
println("Working dir: " + Path(".").readUtf8())
|
println("Working dir: " + Path(".").readUtf8())
|
||||||
println("OS: " + Platform.details().name)
|
println("OS: " + Platform.details().name)
|
||||||
|
println("TTY: " + Console.isTty())
|
||||||
""")
|
""")
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
@@ -68,20 +74,22 @@ suspend fun runMyScript() {
|
|||||||
|
|
||||||
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
|
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
|
||||||
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
|
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
|
||||||
|
- **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching.
|
||||||
|
|
||||||
For more details, see the specific module documentation:
|
For more details, see the specific module documentation:
|
||||||
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
|
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
|
||||||
- [Process Security Details](lyng.io.process.md#security-policy)
|
- [Process Security Details](lyng.io.process.md#security-policy)
|
||||||
|
- [Console Module Details](lyng.io.console.md)
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
#### Platform Support Overview
|
#### Platform Support Overview
|
||||||
|
|
||||||
| Platform | lyng.io.fs | lyng.io.process |
|
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console |
|
||||||
| :--- | :---: | :---: |
|
| :--- | :---: | :---: | :---: |
|
||||||
| **JVM** | ✅ | ✅ |
|
| **JVM** | ✅ | ✅ | ✅ (baseline) |
|
||||||
| **Native (Linux/macOS)** | ✅ | ✅ |
|
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
|
||||||
| **Native (Windows)** | ✅ | 🚧 (Planned) |
|
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
|
||||||
| **Android** | ✅ | ❌ |
|
| **Android** | ✅ | ❌ | ❌ |
|
||||||
| **NodeJS** | ✅ | ❌ |
|
| **NodeJS** | ✅ | ❌ | ❌ |
|
||||||
| **Browser / Wasm** | ✅ (In-memory) | ❌ |
|
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
|
||||||
@@ -110,6 +110,29 @@ For example:
|
|||||||
assert( 5.clamp(0..10) == 5 )
|
assert( 5.clamp(0..10) == 5 )
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## Random values
|
||||||
|
|
||||||
|
Lyng stdlib provides a global random singleton and deterministic seeded generators:
|
||||||
|
|
||||||
|
| name | meaning |
|
||||||
|
|--------------------------|---------|
|
||||||
|
| Random.nextInt() | random `Int` from full platform range |
|
||||||
|
| Random.nextFloat() | random `Real` in `[0,1)` |
|
||||||
|
| Random.next(range) | random value from the given finite range |
|
||||||
|
| Random.seeded(seed) | creates deterministic generator |
|
||||||
|
| SeededRandom.nextInt() | deterministic random `Int` |
|
||||||
|
| SeededRandom.nextFloat() | deterministic random `Real` in `[0,1)` |
|
||||||
|
| SeededRandom.next(range) | deterministic random value from range |
|
||||||
|
|
||||||
|
Examples:
|
||||||
|
|
||||||
|
val rng = Random.seeded(1234)
|
||||||
|
assert( rng.next(1..10) in 1..10 )
|
||||||
|
assert( rng.next('a'..<'f') in 'a'..<'f' )
|
||||||
|
assert( rng.next(0.0..<1.0) >= 0.0 )
|
||||||
|
assert( rng.next(0.0..<1.0) < 1.0 )
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Scientific constant
|
## Scientific constant
|
||||||
|
|
||||||
| name | meaning |
|
| name | meaning |
|
||||||
|
|||||||
@@ -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))
|
||||||
+66
-2
@@ -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.
|
`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
|
## Type inference
|
||||||
|
|
||||||
The compiler infers types from:
|
The compiler infers types from:
|
||||||
@@ -1543,21 +1555,70 @@ The type for the character objects is `Char`.
|
|||||||
| \t | 0x07, tabulation |
|
| \t | 0x07, tabulation |
|
||||||
| \\ | \ slash character |
|
| \\ | \ slash character |
|
||||||
| \" | " double quote |
|
| \" | " double quote |
|
||||||
|
| \uXXXX | unicode code point |
|
||||||
|
|
||||||
|
Unicode escape form is exactly 4 hex digits, e.g. `"\u263A"` -> `☺`.
|
||||||
|
|
||||||
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
|
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
|
||||||
|
|
||||||
val s = "\a"
|
val s = "\a"
|
||||||
assert(s[0] == '\')
|
assert(s[0] == '\\')
|
||||||
assert(s[1] == 'a')
|
assert(s[1] == 'a')
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
same as:
|
same as:
|
||||||
|
|
||||||
val s = "\\a"
|
val s = "\\a"
|
||||||
assert(s[0] == '\')
|
assert(s[0] == '\\')
|
||||||
assert(s[1] == 'a')
|
assert(s[1] == 'a')
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
### String interpolation
|
||||||
|
|
||||||
|
Supported forms:
|
||||||
|
|
||||||
|
- `$name`
|
||||||
|
- `${expr}`
|
||||||
|
|
||||||
|
Literal dollar forms:
|
||||||
|
|
||||||
|
- `\$` -> `$`
|
||||||
|
- `$$` -> `$`
|
||||||
|
|
||||||
|
Example:
|
||||||
|
|
||||||
|
val name = "Lyng"
|
||||||
|
assertEquals("hello, Lyng!", "hello, $name!")
|
||||||
|
assertEquals("sum=3", "sum=${1+2}")
|
||||||
|
assertEquals("\$name", "\$name")
|
||||||
|
assertEquals("\$name", "$$name")
|
||||||
|
assertEquals("\\Lyng", "\\$name")
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Interpolation and `printf`-style formatting can be combined when needed:
|
||||||
|
|
||||||
|
val method = "transfer"
|
||||||
|
val argc = 2
|
||||||
|
val compact = "%s:%d"(method, argc)
|
||||||
|
assertEquals("call=transfer:2", "call=$compact")
|
||||||
|
assertEquals("[transfer:2] ok", "[${"%s:%d"(method, argc)}] ok")
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Interpolation also works well with regex patterns. To keep a literal `$` in the
|
||||||
|
regex, escape it in the resulting pattern:
|
||||||
|
|
||||||
|
val currency = "USD"
|
||||||
|
val amount = 15
|
||||||
|
val escapedDollar = "\\$"
|
||||||
|
val re = Regex("^${currency}${escapedDollar}${amount}$")
|
||||||
|
assert("USD$15" =~ re)
|
||||||
|
assert("USD15" !~ re)
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
If you need old literal behavior in a file, add a leading directive comment:
|
||||||
|
|
||||||
|
// feature: interpolation: off
|
||||||
|
|
||||||
### Char literal escapes
|
### Char literal escapes
|
||||||
|
|
||||||
Are the same as in string literals with little difference:
|
Are the same as in string literals with little difference:
|
||||||
@@ -1569,6 +1630,9 @@ Are the same as in string literals with little difference:
|
|||||||
| \t | 0x07, tabulation |
|
| \t | 0x07, tabulation |
|
||||||
| \\ | \ slash character |
|
| \\ | \ slash character |
|
||||||
| \' | ' apostrophe |
|
| \' | ' apostrophe |
|
||||||
|
| \uXXXX | unicode code point |
|
||||||
|
|
||||||
|
For char literals, use `'\\'` to represent a single backslash character; `'\'` is invalid.
|
||||||
|
|
||||||
### Char instance members
|
### Char instance members
|
||||||
|
|
||||||
|
|||||||
+2
-1
@@ -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:
|
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.
|
- **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.
|
See **Embedding Lyng** for full samples and usage details.
|
||||||
@@ -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).
|
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
|
### 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.
|
- **Deep inference**: The compiler analyzes types of symbols along the execution path and in many cases eliminates unnecessary casts or type specifications.
|
||||||
|
|||||||
Executable
+814
@@ -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))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -38,3 +38,5 @@ kotlin.native.cacheKind.linuxX64=none
|
|||||||
android.experimental.lint.migrateToK2=false
|
android.experimental.lint.migrateToK2=false
|
||||||
android.lint.useK2Uast=false
|
android.lint.useK2Uast=false
|
||||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||||
|
|
||||||
|
org.gradle.parallel=true
|
||||||
@@ -1,6 +1,7 @@
|
|||||||
[versions]
|
[versions]
|
||||||
agp = "8.5.2"
|
agp = "8.5.2"
|
||||||
clikt = "5.0.3"
|
clikt = "5.0.3"
|
||||||
|
mordant = "3.0.2"
|
||||||
kotlin = "2.3.0"
|
kotlin = "2.3.0"
|
||||||
android-minSdk = "24"
|
android-minSdk = "24"
|
||||||
android-compileSdk = "34"
|
android-compileSdk = "34"
|
||||||
@@ -14,6 +15,8 @@ compiler = "3.2.0-alpha11"
|
|||||||
[libraries]
|
[libraries]
|
||||||
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
|
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
|
||||||
clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref = "clikt" }
|
clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref = "clikt" }
|
||||||
|
mordant-core = { module = "com.github.ajalt.mordant:mordant-core", version.ref = "mordant" }
|
||||||
|
mordant-jvm-jna = { module = "com.github.ajalt.mordant:mordant-jvm-jna", version.ref = "mordant" }
|
||||||
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
|
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
|
||||||
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
|
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
|
||||||
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
|
||||||
|
|||||||
+5
-3
@@ -88,9 +88,11 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
|||||||
// Imports: each segment as namespace/path
|
// Imports: each segment as namespace/path
|
||||||
mini?.imports?.forEach { imp ->
|
mini?.imports?.forEach { imp ->
|
||||||
imp.segments.forEach { seg ->
|
imp.segments.forEach { seg ->
|
||||||
val start = analysis.source.offsetOf(seg.range.start)
|
if (seg.range.start.source === analysis.source && seg.range.end.source === analysis.source) {
|
||||||
val end = analysis.source.offsetOf(seg.range.end)
|
val start = analysis.source.offsetOf(seg.range.start)
|
||||||
putRange(start, end, LyngHighlighterColors.NAMESPACE)
|
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",
|
"fun", "val", "var", "class", "interface", "type", "import", "as",
|
||||||
"abstract", "closed", "override", "static", "extern", "open", "private", "protected",
|
"abstract", "closed", "override", "static", "extern", "open", "private", "protected",
|
||||||
"if", "else", "for", "while", "return", "true", "false", "null",
|
"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"
|
"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 com.intellij.psi.search.GlobalSearchScope
|
||||||
import kotlinx.coroutines.runBlocking
|
import kotlinx.coroutines.runBlocking
|
||||||
import net.sergeych.lyng.binding.BindingSnapshot
|
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.idea.LyngFileType
|
||||||
|
import net.sergeych.lyng.miniast.*
|
||||||
|
import net.sergeych.lyng.tools.*
|
||||||
|
|
||||||
object LyngAstManager {
|
object LyngAstManager {
|
||||||
private val MINI_KEY = Key.create<MiniScript>("lyng.mini.cache")
|
private val MINI_KEY = Key.create<MiniScript>("lyng.mini.cache")
|
||||||
private val BINDING_KEY = Key.create<BindingSnapshot>("lyng.binding.cache")
|
private val BINDING_KEY = Key.create<BindingSnapshot>("lyng.binding.cache")
|
||||||
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
|
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
|
||||||
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
|
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
|
||||||
|
private val implicitBuiltinNames = setOf("void")
|
||||||
|
private val includeSymbolsDirective = Regex("""(?im)^\s*//\s*include\s+symbols\s*:\s*(.+?)\s*$""")
|
||||||
|
|
||||||
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
|
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
|
||||||
getAnalysis(file)?.mini
|
getAnalysis(file)?.mini
|
||||||
@@ -51,8 +45,8 @@ object LyngAstManager {
|
|||||||
fun getCombinedStamp(file: PsiFile): Long = runReadAction {
|
fun getCombinedStamp(file: PsiFile): Long = runReadAction {
|
||||||
var combinedStamp = file.viewProvider.modificationStamp
|
var combinedStamp = file.viewProvider.modificationStamp
|
||||||
if (!file.name.endsWith(".lyng.d")) {
|
if (!file.name.endsWith(".lyng.d")) {
|
||||||
collectDeclarationFiles(file).forEach { df ->
|
collectDeclarationFiles(file).forEach { symbolsFile ->
|
||||||
combinedStamp += df.viewProvider.modificationStamp
|
combinedStamp += symbolsFile.viewProvider.modificationStamp
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
combinedStamp
|
combinedStamp
|
||||||
@@ -73,6 +67,22 @@ object LyngAstManager {
|
|||||||
currentDir = currentDir.parentDirectory
|
currentDir = currentDir.parentDirectory
|
||||||
}
|
}
|
||||||
|
|
||||||
|
val includeSpecs = includeSymbolsDirective.findAll(file.viewProvider.contents)
|
||||||
|
.flatMap { it.groupValues[1].split(',').asSequence() }
|
||||||
|
.map { it.trim() }
|
||||||
|
.filter { it.isNotEmpty() }
|
||||||
|
.toList()
|
||||||
|
val baseDir = file.virtualFile?.parent
|
||||||
|
if (baseDir != null) {
|
||||||
|
for (spec in includeSpecs) {
|
||||||
|
val included = baseDir.findFileByRelativePath(spec) ?: continue
|
||||||
|
if (included.path == file.virtualFile?.path) continue
|
||||||
|
if (seen.add(included.path)) {
|
||||||
|
psiManager.findFile(included)?.let { result.add(it) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
if (result.isNotEmpty()) return@runReadAction result
|
if (result.isNotEmpty()) return@runReadAction result
|
||||||
|
|
||||||
// Fallback for virtual/light files without a stable parent chain (e.g., tests)
|
// Fallback for virtual/light files without a stable parent chain (e.g., tests)
|
||||||
@@ -217,7 +227,7 @@ object LyngAstManager {
|
|||||||
val msg = diag.message
|
val msg = diag.message
|
||||||
if (msg.startsWith("unresolved name: ")) {
|
if (msg.startsWith("unresolved name: ")) {
|
||||||
val name = msg.removePrefix("unresolved name: ").trim()
|
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: ")) {
|
} else if (msg.startsWith("unresolved member: ")) {
|
||||||
val name = msg.removePrefix("unresolved member: ").trim()
|
val name = msg.removePrefix("unresolved member: ").trim()
|
||||||
val range = diag.range
|
val range = diag.range
|
||||||
|
|||||||
+55
@@ -50,6 +50,18 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
|
|||||||
myFixture.addFileToProject("api.lyng.d", defs)
|
myFixture.addFileToProject("api.lyng.d", defs)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private fun addPlainSymbolsFile() {
|
||||||
|
val defs = """
|
||||||
|
/** Symbols exposed via include directive */
|
||||||
|
class PlainDeclared(val name: String) {
|
||||||
|
fun hello(): String = "ok"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun plainTopFun(x: Int): Int = x + 2
|
||||||
|
""".trimIndent()
|
||||||
|
myFixture.addFileToProject("plain_symbols.lyng", defs)
|
||||||
|
}
|
||||||
|
|
||||||
fun test_CompletionsIncludeDefinitions() {
|
fun test_CompletionsIncludeDefinitions() {
|
||||||
addDefinitionsFile()
|
addDefinitionsFile()
|
||||||
enableCompletion()
|
enableCompletion()
|
||||||
@@ -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 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") })
|
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") })
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -1,5 +1,5 @@
|
|||||||
/*
|
/*
|
||||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
*
|
*
|
||||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
* you may not use this file except in compliance with the License.
|
* you may not use this file except in compliance with the License.
|
||||||
@@ -32,8 +32,10 @@ import net.sergeych.lyng.LyngVersion
|
|||||||
import net.sergeych.lyng.Script
|
import net.sergeych.lyng.Script
|
||||||
import net.sergeych.lyng.ScriptError
|
import net.sergeych.lyng.ScriptError
|
||||||
import net.sergeych.lyng.Source
|
import net.sergeych.lyng.Source
|
||||||
|
import net.sergeych.lyng.io.console.createConsoleModule
|
||||||
import net.sergeych.lyng.io.fs.createFs
|
import net.sergeych.lyng.io.fs.createFs
|
||||||
import net.sergeych.lyng.obj.*
|
import net.sergeych.lyng.obj.*
|
||||||
|
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||||
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
|
||||||
import net.sergeych.mp_tools.globalDefer
|
import net.sergeych.mp_tools.globalDefer
|
||||||
import okio.FileSystem
|
import okio.FileSystem
|
||||||
@@ -69,6 +71,9 @@ val baseScopeDefer = globalDefer {
|
|||||||
// Install lyng.io.fs module with full access by default for the CLI tool's Scope.
|
// Install lyng.io.fs module with full access by default for the CLI tool's Scope.
|
||||||
// Scripts still need to `import lyng.io.fs` to use Path API.
|
// Scripts still need to `import lyng.io.fs` to use Path API.
|
||||||
createFs(PermitAllAccessPolicy, this)
|
createFs(PermitAllAccessPolicy, this)
|
||||||
|
// Install console access by default for interactive CLI scripts.
|
||||||
|
// Scripts still need to `import lyng.io.console` to use it.
|
||||||
|
createConsoleModule(PermitAllConsoleAccessPolicy, this)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -78,6 +78,7 @@ kotlin {
|
|||||||
api(project(":lynglib"))
|
api(project(":lynglib"))
|
||||||
api(libs.okio)
|
api(libs.okio)
|
||||||
api(libs.kotlinx.coroutines.core)
|
api(libs.kotlinx.coroutines.core)
|
||||||
|
api(libs.mordant.core)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
val commonTest by getting {
|
val commonTest by getting {
|
||||||
@@ -94,6 +95,13 @@ kotlin {
|
|||||||
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
|
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
val jvmMain by getting {
|
||||||
|
dependencies {
|
||||||
|
implementation(libs.mordant.jvm.jna)
|
||||||
|
implementation("org.jline:jline-reader:3.29.0")
|
||||||
|
implementation("org.jline:jline-terminal:3.29.0")
|
||||||
|
}
|
||||||
|
}
|
||||||
// // For Wasm we use in-memory VFS for now
|
// // For Wasm we use in-memory VFS for now
|
||||||
// val wasmJsMain by getting {
|
// val wasmJsMain by getting {
|
||||||
// dependencies {
|
// dependencies {
|
||||||
@@ -104,6 +112,64 @@ kotlin {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
abstract class GenerateLyngioConsoleDecls : DefaultTask() {
|
||||||
|
@get:InputFile
|
||||||
|
@get:PathSensitive(PathSensitivity.RELATIVE)
|
||||||
|
abstract val sourceFile: RegularFileProperty
|
||||||
|
|
||||||
|
@get:OutputDirectory
|
||||||
|
abstract val outputDir: DirectoryProperty
|
||||||
|
|
||||||
|
@TaskAction
|
||||||
|
fun generate() {
|
||||||
|
val targetPkg = "net.sergeych.lyngio.stdlib_included"
|
||||||
|
val pkgPath = targetPkg.replace('.', '/')
|
||||||
|
val targetDir = outputDir.get().asFile.resolve(pkgPath)
|
||||||
|
targetDir.mkdirs()
|
||||||
|
|
||||||
|
val text = sourceFile.get().asFile.readText()
|
||||||
|
fun escapeForQuoted(s: String): String = buildString {
|
||||||
|
for (ch in s) when (ch) {
|
||||||
|
'\\' -> append("\\\\")
|
||||||
|
'"' -> append("\\\"")
|
||||||
|
'\n' -> append("\\n")
|
||||||
|
'\r' -> {}
|
||||||
|
'\t' -> append("\\t")
|
||||||
|
else -> append(ch)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val out = buildString {
|
||||||
|
append("package ").append(targetPkg).append("\n\n")
|
||||||
|
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||||
|
append("internal val consoleLyng = \"")
|
||||||
|
append(escapeForQuoted(text))
|
||||||
|
append("\"\n")
|
||||||
|
}
|
||||||
|
targetDir.resolve("console_types_lyng.generated.kt").writeText(out)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val lyngioConsoleDeclsFile = layout.projectDirectory.file("stdlib/lyng/io/console.lyng")
|
||||||
|
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
|
||||||
|
|
||||||
|
val generateLyngioConsoleDecls by tasks.registering(GenerateLyngioConsoleDecls::class) {
|
||||||
|
sourceFile.set(lyngioConsoleDeclsFile)
|
||||||
|
outputDir.set(generatedLyngioDeclsDir)
|
||||||
|
}
|
||||||
|
|
||||||
|
kotlin.sourceSets.named("commonMain") {
|
||||||
|
kotlin.srcDir(generateLyngioConsoleDecls)
|
||||||
|
}
|
||||||
|
|
||||||
|
kotlin.targets.configureEach {
|
||||||
|
compilations.configureEach {
|
||||||
|
compileTaskProvider.configure {
|
||||||
|
dependsOn(generateLyngioConsoleDecls)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
android {
|
android {
|
||||||
namespace = "net.sergeych.lyngio"
|
namespace = "net.sergeych.lyngio"
|
||||||
compileSdk = libs.versions.android.compileSdk.get().toInt()
|
compileSdk = libs.versions.android.compileSdk.get().toInt()
|
||||||
|
|||||||
@@ -0,0 +1,22 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||||
|
// no-op on Android
|
||||||
|
}
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
actual fun getSystemConsole(): LyngConsole = MordantLyngConsole
|
||||||
@@ -0,0 +1,494 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.io.console
|
||||||
|
|
||||||
|
import net.sergeych.lyng.ModuleScope
|
||||||
|
import net.sergeych.lyng.Scope
|
||||||
|
import net.sergeych.lyng.ScopeFacade
|
||||||
|
import net.sergeych.lyng.Source
|
||||||
|
import net.sergeych.lyng.obj.Obj
|
||||||
|
import net.sergeych.lyng.obj.ObjBool
|
||||||
|
import net.sergeych.lyng.obj.ObjEnumClass
|
||||||
|
import net.sergeych.lyng.obj.ObjEnumEntry
|
||||||
|
import net.sergeych.lyng.obj.ObjIterable
|
||||||
|
import net.sergeych.lyng.obj.ObjIterationFinishedException
|
||||||
|
import net.sergeych.lyng.obj.ObjIterator
|
||||||
|
import net.sergeych.lyng.obj.ObjNull
|
||||||
|
import net.sergeych.lyng.obj.ObjString
|
||||||
|
import net.sergeych.lyng.obj.ObjVoid
|
||||||
|
import net.sergeych.lyng.obj.requiredArg
|
||||||
|
import net.sergeych.lyng.obj.thisAs
|
||||||
|
import net.sergeych.lyng.obj.toObj
|
||||||
|
import net.sergeych.lyng.pacman.ImportManager
|
||||||
|
import net.sergeych.lyng.raiseIllegalOperation
|
||||||
|
import net.sergeych.lyng.requireScope
|
||||||
|
import net.sergeych.lyngio.console.*
|
||||||
|
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
|
||||||
|
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
|
||||||
|
import net.sergeych.lyngio.console.security.LyngConsoleSecured
|
||||||
|
import net.sergeych.lyngio.stdlib_included.consoleLyng
|
||||||
|
|
||||||
|
private const val CONSOLE_MODULE_NAME = "lyng.io.console"
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Install Lyng module `lyng.io.console` into the given scope's ImportManager.
|
||||||
|
*/
|
||||||
|
fun createConsoleModule(policy: ConsoleAccessPolicy, scope: Scope): Boolean =
|
||||||
|
createConsoleModule(policy, scope.importManager)
|
||||||
|
|
||||||
|
fun createConsole(policy: ConsoleAccessPolicy, scope: Scope): Boolean = createConsoleModule(policy, scope)
|
||||||
|
|
||||||
|
/** Same as [createConsoleModule] but with explicit [ImportManager]. */
|
||||||
|
fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean {
|
||||||
|
if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
|
||||||
|
|
||||||
|
manager.addPackage(CONSOLE_MODULE_NAME) { module ->
|
||||||
|
buildConsoleModule(module, policy)
|
||||||
|
}
|
||||||
|
return true
|
||||||
|
}
|
||||||
|
|
||||||
|
fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager)
|
||||||
|
|
||||||
|
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) {
|
||||||
|
// Load Lyng declarations for console enums/types first (module-local source of truth).
|
||||||
|
module.eval(Source(CONSOLE_MODULE_NAME, consoleLyng))
|
||||||
|
ConsoleEnums.initialize(module)
|
||||||
|
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
|
||||||
|
|
||||||
|
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
|
||||||
|
|
||||||
|
consoleType.apply {
|
||||||
|
addClassFn("isSupported") {
|
||||||
|
ObjBool(console.isSupported)
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("isTty") {
|
||||||
|
consoleGuard {
|
||||||
|
ObjBool(console.isTty())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("ansiLevel") {
|
||||||
|
consoleGuard {
|
||||||
|
ConsoleEnums.ansiLevel(console.ansiLevel().name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("geometry") {
|
||||||
|
consoleGuard {
|
||||||
|
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("details") {
|
||||||
|
consoleGuard {
|
||||||
|
val tty = console.isTty()
|
||||||
|
val ansi = console.ansiLevel()
|
||||||
|
val geometry = console.geometry()
|
||||||
|
ObjConsoleDetails(
|
||||||
|
supported = console.isSupported,
|
||||||
|
isTty = tty,
|
||||||
|
ansiLevel = ConsoleEnums.ansiLevel(ansi.name),
|
||||||
|
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("write") {
|
||||||
|
consoleGuard {
|
||||||
|
val text = requiredArg<ObjString>(0).value
|
||||||
|
console.write(text)
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("flush") {
|
||||||
|
consoleGuard {
|
||||||
|
console.flush()
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("home") {
|
||||||
|
consoleGuard {
|
||||||
|
console.write("\u001B[H")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("clear") {
|
||||||
|
consoleGuard {
|
||||||
|
console.write("\u001B[2J")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("moveTo") {
|
||||||
|
consoleGuard {
|
||||||
|
val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value
|
||||||
|
val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value
|
||||||
|
console.write("\u001B[${row};${col}H")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("clearLine") {
|
||||||
|
consoleGuard {
|
||||||
|
console.write("\u001B[2K")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("enterAltScreen") {
|
||||||
|
consoleGuard {
|
||||||
|
console.write("\u001B[?1049h")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("leaveAltScreen") {
|
||||||
|
consoleGuard {
|
||||||
|
console.write("\u001B[?1049l")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("setCursorVisible") {
|
||||||
|
consoleGuard {
|
||||||
|
val visible = requiredArg<ObjBool>(0).value
|
||||||
|
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("events") {
|
||||||
|
consoleGuard {
|
||||||
|
console.events().toConsoleEventStream()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
addClassFn("setRawMode") {
|
||||||
|
consoleGuard {
|
||||||
|
val enabled = requiredArg<ObjBool>(0).value
|
||||||
|
ObjBool(console.setRawMode(enabled))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
module.addConst("Console", consoleType)
|
||||||
|
module.addConst("ConsoleGeometry", ObjConsoleGeometry.type)
|
||||||
|
module.addConst("ConsoleDetails", ObjConsoleDetails.type)
|
||||||
|
module.addConst("ConsoleEvent", ObjConsoleEvent.type)
|
||||||
|
module.addConst("ConsoleResizeEvent", ObjConsoleResizeEvent.type)
|
||||||
|
module.addConst("ConsoleKeyEvent", ObjConsoleKeyEvent.typeObj)
|
||||||
|
module.addConst("ConsoleEventStream", ObjConsoleEventStream.type)
|
||||||
|
}
|
||||||
|
|
||||||
|
private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj {
|
||||||
|
return try {
|
||||||
|
block()
|
||||||
|
} catch (e: ConsoleAccessDeniedException) {
|
||||||
|
raiseIllegalOperation(e.reasonDetail ?: "console access denied")
|
||||||
|
} catch (e: Exception) {
|
||||||
|
raiseIllegalOperation(e.message ?: "console error")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun ConsoleEventSource.toConsoleEventStream(): ObjConsoleEventStream {
|
||||||
|
return ObjConsoleEventStream(this)
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleEventStream(
|
||||||
|
private val source: ConsoleEventSource,
|
||||||
|
) : Obj() {
|
||||||
|
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||||
|
get() = type
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply {
|
||||||
|
addFn("iterator") {
|
||||||
|
val stream = thisAs<ObjConsoleEventStream>()
|
||||||
|
ObjConsoleEventIterator(stream.source)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleEventIterator(
|
||||||
|
private val source: ConsoleEventSource,
|
||||||
|
) : Obj() {
|
||||||
|
private var cached: Obj? = null
|
||||||
|
private var closed = false
|
||||||
|
|
||||||
|
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||||
|
get() = type
|
||||||
|
|
||||||
|
private suspend fun ensureCached(): Boolean {
|
||||||
|
if (closed) return false
|
||||||
|
if (cached != null) return true
|
||||||
|
while (!closed && cached == null) {
|
||||||
|
val event = try {
|
||||||
|
source.nextEvent()
|
||||||
|
} catch (e: Throwable) {
|
||||||
|
// Consumer loops must survive source/read failures: report and keep polling.
|
||||||
|
consoleFlowDebug("console-bridge: nextEvent failed; dropping failure and continuing", e)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (event == null) {
|
||||||
|
closeSource()
|
||||||
|
return false
|
||||||
|
}
|
||||||
|
cached = try {
|
||||||
|
event.toObjEvent()
|
||||||
|
} catch (e: Throwable) {
|
||||||
|
// Malformed/native event payload must not terminate consumer iteration.
|
||||||
|
consoleFlowDebug("console-bridge: malformed event dropped: $event", e)
|
||||||
|
null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return cached != null
|
||||||
|
}
|
||||||
|
|
||||||
|
private suspend fun closeSource() {
|
||||||
|
if (closed) return
|
||||||
|
closed = true
|
||||||
|
// Do not close the underlying console source from VM iterator cancellation.
|
||||||
|
// CmdFrame.cancelIterators() may call cancelIteration() while user code is still
|
||||||
|
// expected to keep processing input (e.g. recover from app-level exceptions).
|
||||||
|
// The source lifecycle is managed by the console runtime.
|
||||||
|
}
|
||||||
|
|
||||||
|
suspend fun hasNext(): Boolean = ensureCached()
|
||||||
|
|
||||||
|
suspend fun next(scope: Scope): Obj {
|
||||||
|
if (!ensureCached()) {
|
||||||
|
scope.raiseError(ObjIterationFinishedException(scope))
|
||||||
|
}
|
||||||
|
val out = cached ?: scope.raiseError("console iterator internal error: missing cached event")
|
||||||
|
cached = null
|
||||||
|
return out
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply {
|
||||||
|
addFn("hasNext") {
|
||||||
|
thisAs<ObjConsoleEventIterator>().hasNext().toObj()
|
||||||
|
}
|
||||||
|
addFn("next") {
|
||||||
|
thisAs<ObjConsoleEventIterator>().next(requireScope())
|
||||||
|
}
|
||||||
|
addFn("cancelIteration") {
|
||||||
|
thisAs<ObjConsoleEventIterator>().closeSource()
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
|
||||||
|
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
|
||||||
|
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_DOWN, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||||
|
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_UP, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun sanitizedKeyOrFallback(key: String): String {
|
||||||
|
if (key.isNotEmpty()) return key
|
||||||
|
consoleFlowDebug("console-bridge: empty key value received; using fallback key name")
|
||||||
|
return "Unknown"
|
||||||
|
}
|
||||||
|
|
||||||
|
private object ConsoleEnums {
|
||||||
|
lateinit var eventTypeClass: ObjEnumClass
|
||||||
|
private set
|
||||||
|
lateinit var keyCodeClass: ObjEnumClass
|
||||||
|
private set
|
||||||
|
lateinit var ansiLevelClass: ObjEnumClass
|
||||||
|
private set
|
||||||
|
|
||||||
|
private lateinit var eventEntries: Map<String, ObjEnumEntry>
|
||||||
|
private lateinit var keyCodeEntries: Map<String, ObjEnumEntry>
|
||||||
|
private lateinit var ansiLevelEntries: Map<String, ObjEnumEntry>
|
||||||
|
|
||||||
|
val UNKNOWN: ObjEnumEntry get() = event("UNKNOWN")
|
||||||
|
val RESIZE: ObjEnumEntry get() = event("RESIZE")
|
||||||
|
val KEY_DOWN: ObjEnumEntry get() = event("KEY_DOWN")
|
||||||
|
val KEY_UP: ObjEnumEntry get() = event("KEY_UP")
|
||||||
|
val CODE_UNKNOWN: ObjEnumEntry get() = code("UNKNOWN")
|
||||||
|
val CHARACTER: ObjEnumEntry get() = code("CHARACTER")
|
||||||
|
|
||||||
|
fun initialize(module: ModuleScope) {
|
||||||
|
eventTypeClass = resolveEnum(module, "ConsoleEventType")
|
||||||
|
keyCodeClass = resolveEnum(module, "ConsoleKeyCode")
|
||||||
|
ansiLevelClass = resolveEnum(module, "ConsoleAnsiLevel")
|
||||||
|
eventEntries = resolveEntries(
|
||||||
|
eventTypeClass,
|
||||||
|
listOf("UNKNOWN", "RESIZE", "KEY_DOWN", "KEY_UP")
|
||||||
|
)
|
||||||
|
keyCodeEntries = resolveEntries(
|
||||||
|
keyCodeClass,
|
||||||
|
listOf(
|
||||||
|
"UNKNOWN", "CHARACTER", "ARROW_UP", "ARROW_DOWN", "ARROW_LEFT", "ARROW_RIGHT",
|
||||||
|
"HOME", "END", "INSERT", "DELETE", "PAGE_UP", "PAGE_DOWN",
|
||||||
|
"ESCAPE", "ENTER", "TAB", "BACKSPACE", "SPACE"
|
||||||
|
)
|
||||||
|
)
|
||||||
|
ansiLevelEntries = resolveEntries(
|
||||||
|
ansiLevelClass,
|
||||||
|
listOf("NONE", "BASIC16", "ANSI256", "TRUECOLOR")
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun resolveEnum(module: ModuleScope, enumName: String): ObjEnumClass {
|
||||||
|
val local = module.get(enumName)?.value as? ObjEnumClass
|
||||||
|
if (local != null) return local
|
||||||
|
val root = module.importProvider.rootScope.get(enumName)?.value as? ObjEnumClass
|
||||||
|
return root ?: error("lyng.io.console declaration enum is missing: $enumName")
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun resolveEntries(enumClass: ObjEnumClass, names: List<String>): Map<String, ObjEnumEntry> {
|
||||||
|
return names.associateWith { name ->
|
||||||
|
(enumClass.byName[ObjString(name)] as? ObjEnumEntry)
|
||||||
|
?: error("lyng.io.console enum entry is missing: ${enumClass.className}.$name")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun event(name: String): ObjEnumEntry = eventEntries[name]
|
||||||
|
?: error("lyng.io.console enum entry is missing: ${eventTypeClass.className}.$name")
|
||||||
|
|
||||||
|
fun code(name: String): ObjEnumEntry = keyCodeEntries[name]
|
||||||
|
?: error("lyng.io.console enum entry is missing: ${keyCodeClass.className}.$name")
|
||||||
|
|
||||||
|
fun ansiLevel(name: String): ObjEnumEntry = ansiLevelEntries[name]
|
||||||
|
?: error("lyng.io.console enum entry is missing: ${ansiLevelClass.className}.$name")
|
||||||
|
}
|
||||||
|
|
||||||
|
private val KEY_CODE_BY_KEY_NAME = mapOf(
|
||||||
|
"ArrowUp" to "ARROW_UP",
|
||||||
|
"ArrowDown" to "ARROW_DOWN",
|
||||||
|
"ArrowLeft" to "ARROW_LEFT",
|
||||||
|
"ArrowRight" to "ARROW_RIGHT",
|
||||||
|
"Home" to "HOME",
|
||||||
|
"End" to "END",
|
||||||
|
"Insert" to "INSERT",
|
||||||
|
"Delete" to "DELETE",
|
||||||
|
"PageUp" to "PAGE_UP",
|
||||||
|
"PageDown" to "PAGE_DOWN",
|
||||||
|
"Escape" to "ESCAPE",
|
||||||
|
"Enter" to "ENTER",
|
||||||
|
"Tab" to "TAB",
|
||||||
|
"Backspace" to "BACKSPACE",
|
||||||
|
" " to "SPACE",
|
||||||
|
)
|
||||||
|
|
||||||
|
private fun codeFrom(key: String, codeName: String?): ObjEnumEntry {
|
||||||
|
val resolved = KEY_CODE_BY_KEY_NAME[codeName ?: key]
|
||||||
|
return when {
|
||||||
|
resolved != null -> ConsoleEnums.code(resolved)
|
||||||
|
key.length == 1 -> ConsoleEnums.CHARACTER
|
||||||
|
else -> ConsoleEnums.CODE_UNKNOWN
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private abstract class ObjConsoleEventBase(
|
||||||
|
private val type: ObjEnumEntry,
|
||||||
|
final override val objClass: net.sergeych.lyng.obj.ObjClass,
|
||||||
|
) : Obj() {
|
||||||
|
fun type(): ObjEnumEntry = type
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleEvent : ObjConsoleEventBase(ConsoleEnums.UNKNOWN, type) {
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
|
||||||
|
addProperty(name = "type", getter = { (this.thisObj as ObjConsoleEventBase).type() })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleResizeEvent(
|
||||||
|
val columns: Int,
|
||||||
|
val rows: Int,
|
||||||
|
) : ObjConsoleEventBase(ConsoleEnums.RESIZE, type) {
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
|
||||||
|
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() })
|
||||||
|
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleKeyEvent(
|
||||||
|
type: ObjEnumEntry,
|
||||||
|
val key: String,
|
||||||
|
val codeName: String?,
|
||||||
|
val ctrl: Boolean,
|
||||||
|
val alt: Boolean,
|
||||||
|
val shift: Boolean,
|
||||||
|
val meta: Boolean,
|
||||||
|
) : ObjConsoleEventBase(type, typeObj) {
|
||||||
|
init {
|
||||||
|
require(key.isNotEmpty()) { "ConsoleKeyEvent.key must never be empty" }
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
|
||||||
|
addProperty(name = "key", getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) })
|
||||||
|
addProperty(name = "code", getter = { codeFrom((this.thisObj as ObjConsoleKeyEvent).key, (this.thisObj as ObjConsoleKeyEvent).codeName) })
|
||||||
|
addProperty(name = "codeName", getter = {
|
||||||
|
val code = (this.thisObj as ObjConsoleKeyEvent).codeName
|
||||||
|
code?.let(::ObjString) ?: ObjNull
|
||||||
|
})
|
||||||
|
addProperty(name = "ctrl", getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() })
|
||||||
|
addProperty(name = "alt", getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() })
|
||||||
|
addProperty(name = "shift", getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() })
|
||||||
|
addProperty(name = "meta", getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleGeometry(
|
||||||
|
val columns: Int,
|
||||||
|
val rows: Int,
|
||||||
|
) : Obj() {
|
||||||
|
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply {
|
||||||
|
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() })
|
||||||
|
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private class ObjConsoleDetails(
|
||||||
|
val supported: Boolean,
|
||||||
|
val isTty: Boolean,
|
||||||
|
val ansiLevel: ObjEnumEntry,
|
||||||
|
val geometry: ObjConsoleGeometry?,
|
||||||
|
) : Obj() {
|
||||||
|
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply {
|
||||||
|
addProperty(name = "supported", getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() })
|
||||||
|
addProperty(name = "isTty", getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() })
|
||||||
|
addProperty(name = "ansiLevel", getter = { (this.thisObj as ObjConsoleDetails).ansiLevel })
|
||||||
|
addProperty(name = "geometry", getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull })
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,20 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
internal expect fun consoleFlowDebug(message: String, error: Throwable? = null)
|
||||||
@@ -0,0 +1,132 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
/**
|
||||||
|
* ANSI color support level detected for the active console.
|
||||||
|
*/
|
||||||
|
enum class ConsoleAnsiLevel {
|
||||||
|
NONE,
|
||||||
|
BASIC16,
|
||||||
|
ANSI256,
|
||||||
|
TRUECOLOR,
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Console geometry in character cells.
|
||||||
|
*/
|
||||||
|
data class ConsoleGeometry(
|
||||||
|
val columns: Int,
|
||||||
|
val rows: Int,
|
||||||
|
)
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Input/terminal events emitted by the console runtime.
|
||||||
|
*/
|
||||||
|
sealed interface ConsoleEvent {
|
||||||
|
data class Resize(
|
||||||
|
val columns: Int,
|
||||||
|
val rows: Int,
|
||||||
|
) : ConsoleEvent
|
||||||
|
|
||||||
|
data class KeyDown(
|
||||||
|
val key: String,
|
||||||
|
val code: String? = null,
|
||||||
|
val ctrl: Boolean = false,
|
||||||
|
val alt: Boolean = false,
|
||||||
|
val shift: Boolean = false,
|
||||||
|
val meta: Boolean = false,
|
||||||
|
) : ConsoleEvent
|
||||||
|
|
||||||
|
data class KeyUp(
|
||||||
|
val key: String,
|
||||||
|
val code: String? = null,
|
||||||
|
val ctrl: Boolean = false,
|
||||||
|
val alt: Boolean = false,
|
||||||
|
val shift: Boolean = false,
|
||||||
|
val meta: Boolean = false,
|
||||||
|
) : ConsoleEvent
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Pull-based console event source.
|
||||||
|
*
|
||||||
|
* `nextEvent(timeoutMs)` returns:
|
||||||
|
* - next event when available,
|
||||||
|
* - `null` on timeout,
|
||||||
|
* - `null` after close.
|
||||||
|
*/
|
||||||
|
interface ConsoleEventSource {
|
||||||
|
suspend fun nextEvent(timeoutMs: Long = 0L): ConsoleEvent?
|
||||||
|
|
||||||
|
suspend fun close()
|
||||||
|
}
|
||||||
|
|
||||||
|
private object EmptyConsoleEventSource : ConsoleEventSource {
|
||||||
|
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
|
||||||
|
|
||||||
|
override suspend fun close() {
|
||||||
|
// no-op
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Platform-independent console runtime surface.
|
||||||
|
*/
|
||||||
|
interface LyngConsole {
|
||||||
|
val isSupported: Boolean
|
||||||
|
|
||||||
|
suspend fun isTty(): Boolean
|
||||||
|
|
||||||
|
suspend fun geometry(): ConsoleGeometry?
|
||||||
|
|
||||||
|
suspend fun ansiLevel(): ConsoleAnsiLevel
|
||||||
|
|
||||||
|
suspend fun write(text: String)
|
||||||
|
|
||||||
|
suspend fun flush()
|
||||||
|
|
||||||
|
fun events(): ConsoleEventSource
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Set terminal raw input mode. Returns true when mode was changed.
|
||||||
|
*/
|
||||||
|
suspend fun setRawMode(enabled: Boolean): Boolean
|
||||||
|
}
|
||||||
|
|
||||||
|
object UnsupportedLyngConsole : LyngConsole {
|
||||||
|
override val isSupported: Boolean = false
|
||||||
|
|
||||||
|
override suspend fun isTty(): Boolean = false
|
||||||
|
|
||||||
|
override suspend fun geometry(): ConsoleGeometry? = null
|
||||||
|
|
||||||
|
override suspend fun ansiLevel(): ConsoleAnsiLevel = ConsoleAnsiLevel.NONE
|
||||||
|
|
||||||
|
override suspend fun write(text: String) {
|
||||||
|
// no-op
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun flush() {
|
||||||
|
// no-op
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun events(): ConsoleEventSource = EmptyConsoleEventSource
|
||||||
|
|
||||||
|
override suspend fun setRawMode(enabled: Boolean): Boolean = false
|
||||||
|
}
|
||||||
@@ -0,0 +1,292 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
import com.github.ajalt.mordant.input.KeyboardEvent
|
||||||
|
import com.github.ajalt.mordant.input.RawModeScope
|
||||||
|
import com.github.ajalt.mordant.input.enterRawModeOrNull
|
||||||
|
import com.github.ajalt.mordant.rendering.AnsiLevel
|
||||||
|
import com.github.ajalt.mordant.terminal.Terminal
|
||||||
|
import kotlinx.coroutines.*
|
||||||
|
import kotlinx.coroutines.channels.Channel
|
||||||
|
import kotlinx.coroutines.sync.Mutex
|
||||||
|
import kotlinx.coroutines.sync.withLock
|
||||||
|
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
|
||||||
|
import net.sergeych.mp_tools.globalLaunch
|
||||||
|
import kotlin.time.Duration.Companion.milliseconds
|
||||||
|
import kotlin.time.Duration.Companion.seconds
|
||||||
|
import kotlin.time.TimeSource
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Mordant-backed console runtime implementation.
|
||||||
|
*/
|
||||||
|
object MordantLyngConsole : LyngConsole {
|
||||||
|
private val terminal: Terminal? by lazy {
|
||||||
|
runCatching { Terminal() }.getOrNull()
|
||||||
|
}
|
||||||
|
|
||||||
|
private val stateMutex = Mutex()
|
||||||
|
private var rawModeRequested: Boolean = false
|
||||||
|
private var rawModeScope: RawModeScope? = null
|
||||||
|
|
||||||
|
private suspend fun forceRawModeReset(t: Terminal): Boolean = stateMutex.withLock {
|
||||||
|
if (!rawModeRequested) return@withLock false
|
||||||
|
runCatching { rawModeScope?.close() }
|
||||||
|
.onFailure { consoleFlowDebug("forceRawModeReset: close failed", it) }
|
||||||
|
rawModeScope = null
|
||||||
|
rawModeRequested = false
|
||||||
|
if (!t.terminalInfo.inputInteractive) return@withLock false
|
||||||
|
val reopened = t.enterRawModeOrNull()
|
||||||
|
rawModeScope = reopened
|
||||||
|
rawModeRequested = reopened != null
|
||||||
|
reopened != null
|
||||||
|
}
|
||||||
|
|
||||||
|
override val isSupported: Boolean
|
||||||
|
get() = terminal != null
|
||||||
|
|
||||||
|
override suspend fun isTty(): Boolean {
|
||||||
|
val t = terminal ?: return false
|
||||||
|
return t.terminalInfo.outputInteractive
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun geometry(): ConsoleGeometry? {
|
||||||
|
val t = terminal ?: return null
|
||||||
|
val size = t.updateSize()
|
||||||
|
return ConsoleGeometry(size.width, size.height)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun ansiLevel(): ConsoleAnsiLevel {
|
||||||
|
val t = terminal ?: return ConsoleAnsiLevel.NONE
|
||||||
|
return when (t.terminalInfo.ansiLevel) {
|
||||||
|
AnsiLevel.NONE -> ConsoleAnsiLevel.NONE
|
||||||
|
AnsiLevel.ANSI16 -> ConsoleAnsiLevel.BASIC16
|
||||||
|
AnsiLevel.ANSI256 -> ConsoleAnsiLevel.ANSI256
|
||||||
|
AnsiLevel.TRUECOLOR -> ConsoleAnsiLevel.TRUECOLOR
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun write(text: String) {
|
||||||
|
terminal?.rawPrint(text)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun flush() {
|
||||||
|
// Mordant prints via platform streams immediately.
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun events(): ConsoleEventSource {
|
||||||
|
val t = terminal ?: return object : ConsoleEventSource {
|
||||||
|
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
|
||||||
|
|
||||||
|
override suspend fun close() {}
|
||||||
|
}
|
||||||
|
val out = Channel<ConsoleEvent>(Channel.UNLIMITED)
|
||||||
|
val sourceState = Mutex()
|
||||||
|
var running = true
|
||||||
|
|
||||||
|
globalLaunch {
|
||||||
|
val initialSize = runCatching { t.updateSize() }.getOrNull()
|
||||||
|
var lastWidth = initialSize?.width ?: 0
|
||||||
|
var lastHeight = initialSize?.height ?: 0
|
||||||
|
val startMark = TimeSource.Monotonic.markNow()
|
||||||
|
var lastHeartbeatMark = startMark
|
||||||
|
var loops = 0L
|
||||||
|
var readAttempts = 0L
|
||||||
|
var readFailures = 0L
|
||||||
|
var keyEvents = 0L
|
||||||
|
var resizeEvents = 0L
|
||||||
|
var rawNullLoops = 0L
|
||||||
|
var lastKeyMark = startMark
|
||||||
|
var lastRawRecoveryMark = startMark
|
||||||
|
|
||||||
|
fun tryEmitResize(width: Int, height: Int) {
|
||||||
|
if (width < 1 || height < 1) {
|
||||||
|
consoleFlowDebug("events: ignored invalid resize width=$width height=$height")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if (width == lastWidth && height == lastHeight) return
|
||||||
|
out.trySend(ConsoleEvent.Resize(width, height))
|
||||||
|
lastWidth = width
|
||||||
|
lastHeight = height
|
||||||
|
resizeEvents += 1
|
||||||
|
}
|
||||||
|
|
||||||
|
consoleFlowDebug("events: collector started")
|
||||||
|
try {
|
||||||
|
while (currentCoroutineContext().isActive && sourceState.withLock { running }) {
|
||||||
|
loops += 1
|
||||||
|
val currentSize = runCatching { t.updateSize() }.getOrNull()
|
||||||
|
if (currentSize == null) {
|
||||||
|
delay(150)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
tryEmitResize(currentSize.width, currentSize.height)
|
||||||
|
|
||||||
|
val raw = stateMutex.withLock {
|
||||||
|
if (!rawModeRequested) {
|
||||||
|
null
|
||||||
|
} else {
|
||||||
|
// Recover raw scope lazily if it was dropped due to an earlier read failure.
|
||||||
|
if (rawModeScope == null) {
|
||||||
|
rawModeScope = t.enterRawModeOrNull()
|
||||||
|
if (rawModeScope == null) {
|
||||||
|
consoleFlowDebug("events: failed to reopen raw mode scope")
|
||||||
|
} else {
|
||||||
|
consoleFlowDebug("events: raw mode scope reopened")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
rawModeScope
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (raw == null || !t.terminalInfo.inputInteractive) {
|
||||||
|
rawNullLoops += 1
|
||||||
|
delay(150)
|
||||||
|
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
|
||||||
|
consoleFlowDebug(
|
||||||
|
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
|
||||||
|
)
|
||||||
|
lastHeartbeatMark = TimeSource.Monotonic.markNow()
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
readAttempts += 1
|
||||||
|
val readResult = runCatching { raw.readEventOrNull(150.milliseconds) }
|
||||||
|
if (readResult.isFailure) {
|
||||||
|
readFailures += 1
|
||||||
|
consoleFlowDebug("events: readEventOrNull failed; resetting raw scope", readResult.exceptionOrNull())
|
||||||
|
// Raw scope became invalid; close and force reopen on next iteration.
|
||||||
|
stateMutex.withLock {
|
||||||
|
runCatching { rawModeScope?.close() }
|
||||||
|
rawModeScope = null
|
||||||
|
}
|
||||||
|
delay(50)
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
val ev = readResult.getOrNull()
|
||||||
|
|
||||||
|
val resized = runCatching { t.updateSize() }.getOrNull()
|
||||||
|
if (resized != null) {
|
||||||
|
tryEmitResize(resized.width, resized.height)
|
||||||
|
}
|
||||||
|
|
||||||
|
when (ev) {
|
||||||
|
is KeyboardEvent -> {
|
||||||
|
keyEvents += 1
|
||||||
|
lastKeyMark = TimeSource.Monotonic.markNow()
|
||||||
|
out.trySend(
|
||||||
|
ConsoleEvent.KeyDown(
|
||||||
|
key = ev.key,
|
||||||
|
code = null,
|
||||||
|
ctrl = ev.ctrl,
|
||||||
|
alt = ev.alt,
|
||||||
|
shift = ev.shift,
|
||||||
|
meta = false,
|
||||||
|
)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
// Mouse/other events are ignored in Lyng console v1.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Some terminals silently stop delivering keyboard events while raw reads keep succeeding.
|
||||||
|
// If we had keys before and then prolonged key inactivity, proactively recycle raw scope.
|
||||||
|
if (keyEvents > 0L &&
|
||||||
|
lastKeyMark.elapsedNow() >= 4.seconds &&
|
||||||
|
lastRawRecoveryMark.elapsedNow() >= 4.seconds
|
||||||
|
) {
|
||||||
|
if (rawModeRequested) {
|
||||||
|
consoleFlowDebug("events: key inactivity detected; forcing raw reset")
|
||||||
|
val resetOk = forceRawModeReset(t)
|
||||||
|
if (resetOk) {
|
||||||
|
consoleFlowDebug("events: raw reset succeeded during inactivity recovery")
|
||||||
|
lastKeyMark = TimeSource.Monotonic.markNow()
|
||||||
|
} else {
|
||||||
|
consoleFlowDebug("events: raw reset failed during inactivity recovery")
|
||||||
|
}
|
||||||
|
lastRawRecoveryMark = TimeSource.Monotonic.markNow()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
|
||||||
|
consoleFlowDebug(
|
||||||
|
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
|
||||||
|
)
|
||||||
|
lastHeartbeatMark = TimeSource.Monotonic.markNow()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} catch (e: CancellationException) {
|
||||||
|
consoleFlowDebug("events: collector cancelled (normal)")
|
||||||
|
// normal
|
||||||
|
} catch (e: ScriptFlowIsNoMoreCollected) {
|
||||||
|
consoleFlowDebug("events: collector stopped by flow consumer (normal)")
|
||||||
|
// normal
|
||||||
|
} catch (e: Exception) {
|
||||||
|
consoleFlowDebug("events: collector loop failed", e)
|
||||||
|
// terminate event source loop
|
||||||
|
} finally {
|
||||||
|
consoleFlowDebug(
|
||||||
|
"events: collector ended uptime=${startMark.elapsedNow().inWholeMilliseconds}ms loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested"
|
||||||
|
)
|
||||||
|
out.close()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return object : ConsoleEventSource {
|
||||||
|
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
|
||||||
|
if (timeoutMs <= 0L) {
|
||||||
|
return out.receiveCatching().getOrNull()
|
||||||
|
}
|
||||||
|
return withTimeoutOrNull(timeoutMs.milliseconds) {
|
||||||
|
out.receiveCatching().getOrNull()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun close() {
|
||||||
|
sourceState.withLock { running = false }
|
||||||
|
out.close()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun setRawMode(enabled: Boolean): Boolean {
|
||||||
|
val t = terminal ?: return false
|
||||||
|
return stateMutex.withLock {
|
||||||
|
if (enabled) {
|
||||||
|
if (!t.terminalInfo.inputInteractive) return@withLock false
|
||||||
|
if (rawModeRequested) return@withLock false
|
||||||
|
val scope = t.enterRawModeOrNull() ?: return@withLock false
|
||||||
|
rawModeScope = scope
|
||||||
|
rawModeRequested = true
|
||||||
|
consoleFlowDebug("setRawMode(true): enabled")
|
||||||
|
true
|
||||||
|
} else {
|
||||||
|
val hadRaw = rawModeRequested || rawModeScope != null
|
||||||
|
rawModeRequested = false
|
||||||
|
val scope = rawModeScope
|
||||||
|
rawModeScope = null
|
||||||
|
runCatching { scope?.close() }
|
||||||
|
.onFailure { consoleFlowDebug("setRawMode(false): close failed", it) }
|
||||||
|
consoleFlowDebug("setRawMode(false): disabled hadRaw=$hadRaw")
|
||||||
|
hadRaw
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -0,0 +1,23 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyngio.console
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get the system default console implementation.
|
||||||
|
*/
|
||||||
|
expect fun getSystemConsole(): LyngConsole
|
||||||
+55
@@ -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)
|
||||||
|
}
|
||||||
+68
@@ -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
|
||||||
|
}
|
||||||
@@ -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
|
||||||
|
}
|
||||||
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
|||||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||||
|
|
||||||
group = "net.sergeych"
|
group = "net.sergeych"
|
||||||
version = "1.5.0-SNAPSHOT"
|
version = "1.5.1"
|
||||||
|
|
||||||
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
|
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
|
||||||
|
|
||||||
|
|||||||
@@ -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 list: List<Obj>,
|
||||||
val tailBlockMode: Boolean = false,
|
val tailBlockMode: Boolean = false,
|
||||||
val named: Map<String, Obj> = emptyMap(),
|
val named: Map<String, Obj> = emptyMap(),
|
||||||
|
val explicitTypeArgs: List<TypeDecl> = emptyList(),
|
||||||
) : List<Obj> by list {
|
) : List<Obj> by list {
|
||||||
|
|
||||||
constructor(vararg values: Obj) : this(values.toList())
|
constructor(vararg values: Obj) : this(values.toList())
|
||||||
|
|||||||
@@ -176,6 +176,8 @@ class Compiler(
|
|||||||
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
|
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
|
||||||
mutableMapOf()
|
mutableMapOf()
|
||||||
private val classFieldTypesByName: MutableMap<String, MutableMap<String, ObjClass>> = 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 classScopeMembersByClassName: MutableMap<String, MutableSet<String>> = mutableMapOf()
|
||||||
private val classScopeCallableMembersByClassName: MutableMap<String, MutableSet<String>> = mutableMapOf()
|
private val classScopeCallableMembersByClassName: MutableMap<String, MutableSet<String>> = mutableMapOf()
|
||||||
private val encodedPayloadTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
|
private val encodedPayloadTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
|
||||||
@@ -1118,7 +1120,16 @@ class Compiler(
|
|||||||
if (implicitType != null) {
|
if (implicitType != null) {
|
||||||
resolutionSink?.referenceMember(name, pos, implicitType)
|
resolutionSink?.referenceMember(name, pos, implicitType)
|
||||||
val ids = resolveImplicitThisMemberIds(name, pos, implicitType)
|
val ids = resolveImplicitThisMemberIds(name, pos, implicitType)
|
||||||
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, implicitType)
|
val inClassContext = codeContexts.any { ctx -> ctx is CodeContext.ClassBody }
|
||||||
|
val currentImplicitType = currentImplicitThisTypeName()
|
||||||
|
val preferredType = when {
|
||||||
|
inClassContext -> implicitType
|
||||||
|
// Extension receiver aliases (extern class name -> host runtime class) can fail strict
|
||||||
|
// variant casts; keep current receiver untyped but preserve non-current receivers.
|
||||||
|
implicitType == currentImplicitType -> null
|
||||||
|
else -> implicitType
|
||||||
|
}
|
||||||
|
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, preferredType)
|
||||||
}
|
}
|
||||||
if (classCtx != null && classCtx.classScopeMembers.contains(name)) {
|
if (classCtx != null && classCtx.classScopeMembers.contains(name)) {
|
||||||
resolutionSink?.referenceMember(name, pos, classCtx.name)
|
resolutionSink?.referenceMember(name, pos, classCtx.name)
|
||||||
@@ -2247,6 +2258,7 @@ class Compiler(
|
|||||||
is WhenEqualsCondition -> containsDelegatedRefs(cond.expr)
|
is WhenEqualsCondition -> containsDelegatedRefs(cond.expr)
|
||||||
is WhenInCondition -> containsDelegatedRefs(cond.expr)
|
is WhenInCondition -> containsDelegatedRefs(cond.expr)
|
||||||
is WhenIsCondition -> false
|
is WhenIsCondition -> false
|
||||||
|
is WhenNullableCondition -> false
|
||||||
}
|
}
|
||||||
} || containsDelegatedRefs(case.block)
|
} || containsDelegatedRefs(case.block)
|
||||||
} ||
|
} ||
|
||||||
@@ -2520,12 +2532,22 @@ class Compiler(
|
|||||||
CastRef(lvalue!!, typeRef, true, opToken.pos)
|
CastRef(lvalue!!, typeRef, true, opToken.pos)
|
||||||
}
|
}
|
||||||
} else if (opToken.type == Token.Type.IS || opToken.type == Token.Type.NOTIS) {
|
} else if (opToken.type == Token.Type.IS || opToken.type == Token.Type.NOTIS) {
|
||||||
val (typeDecl, _) = parseTypeExpressionWithMini()
|
val nullablePredicate = tryConsumeNullablePredicate()
|
||||||
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, opToken.pos)
|
if (nullablePredicate) {
|
||||||
if (opToken.type == Token.Type.IS) {
|
val nullRef = ConstRef(ObjNull.asReadonly)
|
||||||
BinaryOpRef(BinOp.IS, lvalue!!, typeRef)
|
if (opToken.type == Token.Type.IS) {
|
||||||
|
BinaryOpRef(BinOp.IS, nullRef, lvalue!!)
|
||||||
|
} else {
|
||||||
|
BinaryOpRef(BinOp.NOTIS, nullRef, lvalue!!)
|
||||||
|
}
|
||||||
} else {
|
} 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 {
|
} else {
|
||||||
val rvalue = parseExpressionLevel(level + 1)
|
val rvalue = parseExpressionLevel(level + 1)
|
||||||
@@ -2557,6 +2579,17 @@ class Compiler(
|
|||||||
return lvalue
|
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? {
|
private suspend fun parseTerm(): ObjRef? {
|
||||||
var operand: ObjRef? = null
|
var operand: ObjRef? = null
|
||||||
var pendingCallTypeArgs: List<TypeDecl>? = null
|
var pendingCallTypeArgs: List<TypeDecl>? = null
|
||||||
@@ -2592,7 +2625,34 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
Token.Type.NOT -> {
|
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")
|
val op = parseTerm() ?: throw ScriptError(t.pos, "Expecting expression")
|
||||||
operand = UnaryOpRef(UnaryOp.NOT, op)
|
operand = UnaryOpRef(UnaryOp.NOT, op)
|
||||||
}
|
}
|
||||||
@@ -3799,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 {
|
private fun makeMiniTypeNullable(type: MiniTypeRef): MiniTypeRef {
|
||||||
return when (type) {
|
return when (type) {
|
||||||
is MiniTypeName -> type.copy(nullable = true)
|
is MiniTypeName -> type.copy(nullable = true)
|
||||||
@@ -4469,6 +4544,48 @@ class Compiler(
|
|||||||
is TypeDecl.Intersection -> "I:${type.options.joinToString("&") { typeDeclKey(it) }}"
|
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) {
|
private fun inferObjClassFromRef(ref: ObjRef): ObjClass? = when (ref) {
|
||||||
is ConstRef -> ref.constValue as? ObjClass ?: ref.constValue.objClass
|
is ConstRef -> ref.constValue as? ObjClass ?: ref.constValue.objClass
|
||||||
is LocalVarRef -> nameObjClass[ref.name] ?: resolveClassByName(ref.name)
|
is LocalVarRef -> nameObjClass[ref.name] ?: resolveClassByName(ref.name)
|
||||||
@@ -4487,7 +4604,13 @@ class Compiler(
|
|||||||
is ListLiteralRef -> ObjList.type
|
is ListLiteralRef -> ObjList.type
|
||||||
is MapLiteralRef -> ObjMap.type
|
is MapLiteralRef -> ObjMap.type
|
||||||
is RangeRef -> ObjRange.type
|
is RangeRef -> ObjRange.type
|
||||||
|
is ClassOperatorRef -> ObjClassType
|
||||||
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
|
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
|
||||||
|
is IndexRef -> {
|
||||||
|
val targetClass = resolveReceiverClassForMember(ref.targetRef)
|
||||||
|
classMethodReturnClass(targetClass, "getAt")
|
||||||
|
?: inferFieldReturnClass(targetClass, "getAt")
|
||||||
|
}
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -4524,6 +4647,12 @@ class Compiler(
|
|||||||
else -> TypeDecl.TypeVar("${typeDeclName(targetDecl)}.${ref.name}", false)
|
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 MethodCallRef -> methodReturnTypeDeclByRef[ref]
|
is MethodCallRef -> methodReturnTypeDeclByRef[ref]
|
||||||
is CallRef -> callReturnTypeDeclByRef[ref]
|
is CallRef -> callReturnTypeDeclByRef[ref]
|
||||||
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
|
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
|
||||||
@@ -4580,6 +4709,7 @@ class Compiler(
|
|||||||
is ListLiteralRef -> ObjList.type
|
is ListLiteralRef -> ObjList.type
|
||||||
is MapLiteralRef -> ObjMap.type
|
is MapLiteralRef -> ObjMap.type
|
||||||
is RangeRef -> ObjRange.type
|
is RangeRef -> ObjRange.type
|
||||||
|
is ClassOperatorRef -> ObjClassType
|
||||||
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
|
is CastRef -> resolveTypeRefClass(ref.castTypeRef())
|
||||||
is QualifiedThisRef -> resolveClassByName(ref.typeName)
|
is QualifiedThisRef -> resolveClassByName(ref.typeName)
|
||||||
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverClassForMember(it.ref) }
|
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverClassForMember(it.ref) }
|
||||||
@@ -4592,6 +4722,12 @@ class Compiler(
|
|||||||
val targetClass = resolveReceiverClassForMember(ref.target)
|
val targetClass = resolveReceiverClassForMember(ref.target)
|
||||||
inferFieldReturnClass(targetClass, ref.name)
|
inferFieldReturnClass(targetClass, ref.name)
|
||||||
}
|
}
|
||||||
|
is IndexRef -> {
|
||||||
|
val targetClass = resolveReceiverClassForMember(ref.targetRef)
|
||||||
|
classMethodReturnClass(targetClass, "getAt")
|
||||||
|
?: inferFieldReturnClass(targetClass, "getAt")
|
||||||
|
?: inferMethodCallReturnClass("getAt")
|
||||||
|
}
|
||||||
else -> null
|
else -> null
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -4652,6 +4788,11 @@ class Compiler(
|
|||||||
if (payload != null) return payload
|
if (payload != null) return payload
|
||||||
}
|
}
|
||||||
val receiverClass = resolveReceiverClassForMember(ref.receiver)
|
val receiverClass = resolveReceiverClassForMember(ref.receiver)
|
||||||
|
classMethodReturnClass(receiverClass, ref.name)?.let { return it }
|
||||||
|
inferFieldReturnClass(receiverClass, ref.name)?.let { return it }
|
||||||
|
if (receiverClass != null && isClassScopeCallableMember(receiverClass.className, ref.name)) {
|
||||||
|
resolveClassByName("${receiverClass.className}.${ref.name}")?.let { return it }
|
||||||
|
}
|
||||||
return inferMethodCallReturnClass(ref.name)
|
return inferMethodCallReturnClass(ref.name)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -4704,6 +4845,22 @@ class Compiler(
|
|||||||
name == "toImmutableMap" && receiver is TypeDecl.Generic && base == "Iterable" -> {
|
name == "toImmutableMap" && receiver is TypeDecl.Generic && base == "Iterable" -> {
|
||||||
TypeDecl.Generic("ImmutableMap", listOf(TypeDecl.TypeAny, TypeDecl.TypeAny), false)
|
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" -> {
|
name == "toMap" && receiver is TypeDecl.Generic && base == "Iterable" -> {
|
||||||
TypeDecl.Generic("Map", listOf(TypeDecl.TypeAny, TypeDecl.TypeAny), false)
|
TypeDecl.Generic("Map", listOf(TypeDecl.TypeAny, TypeDecl.TypeAny), false)
|
||||||
}
|
}
|
||||||
@@ -4794,6 +4951,9 @@ class Compiler(
|
|||||||
"toImmutableList" -> ObjImmutableList.type
|
"toImmutableList" -> ObjImmutableList.type
|
||||||
"toImmutableSet" -> ObjImmutableSet.type
|
"toImmutableSet" -> ObjImmutableSet.type
|
||||||
"toImmutableMap" -> ObjImmutableMap.type
|
"toImmutableMap" -> ObjImmutableMap.type
|
||||||
|
"observable" -> ObjObservableList.type
|
||||||
|
"beforeChange", "onChange" -> ObjSubscription.type
|
||||||
|
"changes" -> ObjFlow.type
|
||||||
"toImmutable" -> Obj.rootObjectType
|
"toImmutable" -> Obj.rootObjectType
|
||||||
"toMutable" -> ObjMutableBuffer.type
|
"toMutable" -> ObjMutableBuffer.type
|
||||||
"seq" -> ObjFlow.type
|
"seq" -> ObjFlow.type
|
||||||
@@ -5059,6 +5219,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
private fun resolveTypeRefClass(ref: ObjRef): ObjClass? = when (ref) {
|
private fun resolveTypeRefClass(ref: ObjRef): ObjClass? = when (ref) {
|
||||||
|
is TypeDeclRef -> resolveTypeDeclObjClass(ref.decl())
|
||||||
is ConstRef -> ref.constValue as? ObjClass
|
is ConstRef -> ref.constValue as? ObjClass
|
||||||
is LocalSlotRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
|
is LocalSlotRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
|
||||||
is LocalVarRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
|
is LocalVarRef -> resolveTypeDeclObjClass(TypeDecl.Simple(ref.name, false)) ?: nameObjClass[ref.name]
|
||||||
@@ -5327,6 +5488,10 @@ class Compiler(
|
|||||||
typeParams: List<TypeDecl.TypeParam>
|
typeParams: List<TypeDecl.TypeParam>
|
||||||
): Map<String, Obj> {
|
): Map<String, Obj> {
|
||||||
if (typeParams.isEmpty()) return emptyMap()
|
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 inferred = mutableMapOf<String, TypeDecl>()
|
||||||
val argValues = context.args.list
|
val argValues = context.args.list
|
||||||
for ((index, param) in argsDeclaration.params.withIndex()) {
|
for ((index, param) in argsDeclaration.params.withIndex()) {
|
||||||
@@ -5339,8 +5504,11 @@ class Compiler(
|
|||||||
collectRuntimeTypeVarBindings(param.type, value, inferred)
|
collectRuntimeTypeVarBindings(param.type, value, inferred)
|
||||||
}
|
}
|
||||||
val boundValues = LinkedHashMap<String, Obj>(typeParams.size)
|
val boundValues = LinkedHashMap<String, Obj>(typeParams.size)
|
||||||
for (tp in typeParams) {
|
for ((index, tp) in typeParams.withIndex()) {
|
||||||
val inferredType = inferred[tp.name] ?: tp.defaultType ?: TypeDecl.TypeAny
|
val inferredType = explicitTypeArgs.getOrNull(index)
|
||||||
|
?: inferred[tp.name]
|
||||||
|
?: tp.defaultType
|
||||||
|
?: TypeDecl.TypeAny
|
||||||
val normalized = normalizeRuntimeTypeDecl(inferredType)
|
val normalized = normalizeRuntimeTypeDecl(inferredType)
|
||||||
val cls = resolveTypeDeclObjClass(normalized)
|
val cls = resolveTypeDeclObjClass(normalized)
|
||||||
val boundValue = if (cls != null &&
|
val boundValue = if (cls != null &&
|
||||||
@@ -5662,7 +5830,7 @@ class Compiler(
|
|||||||
val result = when (left) {
|
val result = when (left) {
|
||||||
is ImplicitThisMemberRef ->
|
is ImplicitThisMemberRef ->
|
||||||
if (left.methodId == null && left.fieldId != null) {
|
if (left.methodId == null && left.fieldId != null) {
|
||||||
CallRef(left, args, detectedBlockArgument, isOptional).also { callRef ->
|
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
|
||||||
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
@@ -5697,7 +5865,7 @@ class Compiler(
|
|||||||
checkFunctionTypeCallArity(left, args, left.pos())
|
checkFunctionTypeCallArity(left, args, left.pos())
|
||||||
checkFunctionTypeCallTypes(left, args, left.pos())
|
checkFunctionTypeCallTypes(left, args, left.pos())
|
||||||
checkGenericBoundsAtCall(left.name, args, left.pos())
|
checkGenericBoundsAtCall(left.name, args, left.pos())
|
||||||
CallRef(left, args, detectedBlockArgument, isOptional).also { callRef ->
|
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
|
||||||
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -5723,12 +5891,12 @@ class Compiler(
|
|||||||
checkFunctionTypeCallArity(left, args, left.pos())
|
checkFunctionTypeCallArity(left, args, left.pos())
|
||||||
checkFunctionTypeCallTypes(left, args, left.pos())
|
checkFunctionTypeCallTypes(left, args, left.pos())
|
||||||
checkGenericBoundsAtCall(left.name, args, left.pos())
|
checkGenericBoundsAtCall(left.name, args, left.pos())
|
||||||
CallRef(left, args, detectedBlockArgument, isOptional).also { callRef ->
|
CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
|
||||||
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
else -> CallRef(left, args, detectedBlockArgument, isOptional).also { callRef ->
|
else -> CallRef(left, args, detectedBlockArgument, isOptional, explicitTypeArgs).also { callRef ->
|
||||||
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
applyExplicitCallTypeArgs(callRef, explicitTypeArgs)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -6224,10 +6392,14 @@ class Compiler(
|
|||||||
Token.Type.IS,
|
Token.Type.IS,
|
||||||
Token.Type.NOTIS -> {
|
Token.Type.NOTIS -> {
|
||||||
val negated = t.type == Token.Type.NOTIS
|
val negated = t.type == Token.Type.NOTIS
|
||||||
val (typeDecl, _) = parseTypeExpressionWithMini()
|
if (tryConsumeNullablePredicate()) {
|
||||||
val typeRef = net.sergeych.lyng.obj.TypeDeclRef(typeDecl, t.pos)
|
currentConditions += WhenNullableCondition(negated, t.pos)
|
||||||
val caseType = ExpressionStatement(typeRef, t.pos)
|
} else {
|
||||||
currentConditions += WhenIsCondition(caseType, negated, t.pos)
|
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 ->
|
Token.Type.COMMA ->
|
||||||
@@ -6240,7 +6412,9 @@ class Compiler(
|
|||||||
break@outer
|
break@outer
|
||||||
|
|
||||||
else -> {
|
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)
|
cc.skipTokens(Token.Type.ARROW)
|
||||||
if (elseCase != null) throw ScriptError(
|
if (elseCase != null) throw ScriptError(
|
||||||
cc.currentPos(),
|
cc.currentPos(),
|
||||||
@@ -7829,6 +8003,23 @@ class Compiler(
|
|||||||
val rawFnStatements = parsedFnStatements?.let { unwrapBytecodeDeep(it) }
|
val rawFnStatements = parsedFnStatements?.let { unwrapBytecodeDeep(it) }
|
||||||
val inferredReturnClass = returnTypeDecl?.let { resolveTypeDeclObjClass(it) }
|
val inferredReturnClass = returnTypeDecl?.let { resolveTypeDeclObjClass(it) }
|
||||||
?: inferReturnClassFromStatement(rawFnStatements)
|
?: 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) {
|
if (declKind != SymbolKind.MEMBER && inferredReturnClass != null) {
|
||||||
callableReturnTypeByName[name] = inferredReturnClass
|
callableReturnTypeByName[name] = inferredReturnClass
|
||||||
val slotLoc = lookupSlotLocation(name, includeModule = true)
|
val slotLoc = lookupSlotLocation(name, includeModule = true)
|
||||||
@@ -8322,6 +8513,16 @@ class Compiler(
|
|||||||
"Regex" -> ObjRegex.type
|
"Regex" -> ObjRegex.type
|
||||||
"RegexMatch" -> ObjRegexMatch.type
|
"RegexMatch" -> ObjRegexMatch.type
|
||||||
"MapEntry" -> ObjMapEntry.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
|
"Exception" -> ObjException.Root
|
||||||
"Instant" -> ObjInstant.type
|
"Instant" -> ObjInstant.type
|
||||||
"DateTime" -> ObjDateTime.type
|
"DateTime" -> ObjDateTime.type
|
||||||
@@ -8595,7 +8796,6 @@ class Compiler(
|
|||||||
name = nameToken.value
|
name = nameToken.value
|
||||||
nameStartPos = nameToken.pos
|
nameStartPos = nameToken.pos
|
||||||
}
|
}
|
||||||
|
|
||||||
val receiverNormalization = normalizeReceiverTypeDecl(receiverTypeDecl, emptySet())
|
val receiverNormalization = normalizeReceiverTypeDecl(receiverTypeDecl, emptySet())
|
||||||
val implicitTypeParams = receiverNormalization.second
|
val implicitTypeParams = receiverNormalization.second
|
||||||
if (implicitTypeParams.isNotEmpty()) pendingTypeParamStack.add(implicitTypeParams)
|
if (implicitTypeParams.isNotEmpty()) pendingTypeParamStack.add(implicitTypeParams)
|
||||||
|
|||||||
@@ -26,7 +26,10 @@ val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '
|
|||||||
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
|
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
|
||||||
|
|
||||||
fun parseLyng(source: Source): List<Token> {
|
fun parseLyng(source: Source): List<Token> {
|
||||||
val p = Parser(fromPos = source.startPos)
|
val p = Parser(
|
||||||
|
fromPos = source.startPos,
|
||||||
|
interpolationEnabled = detectInterpolationEnabled(source.text)
|
||||||
|
)
|
||||||
val tokens = mutableListOf<Token>()
|
val tokens = mutableListOf<Token>()
|
||||||
do {
|
do {
|
||||||
val t = p.nextToken()
|
val t = p.nextToken()
|
||||||
@@ -35,9 +38,70 @@ fun parseLyng(source: Source): List<Token> {
|
|||||||
return tokens
|
return tokens
|
||||||
}
|
}
|
||||||
|
|
||||||
private class Parser(fromPos: Pos) {
|
private fun parseLyng(source: Source, interpolationEnabled: Boolean): List<Token> {
|
||||||
|
val p = Parser(
|
||||||
|
fromPos = source.startPos,
|
||||||
|
interpolationEnabled = interpolationEnabled
|
||||||
|
)
|
||||||
|
val tokens = mutableListOf<Token>()
|
||||||
|
do {
|
||||||
|
val t = p.nextToken()
|
||||||
|
tokens += t
|
||||||
|
} while (t.type != Token.Type.EOF)
|
||||||
|
return tokens
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun detectInterpolationEnabled(text: String): Boolean {
|
||||||
|
// Per-file feature switch in leading comments:
|
||||||
|
// // feature: interpolation: off
|
||||||
|
// // feature: interpolation: on
|
||||||
|
var enabled = true
|
||||||
|
val lines = text.split('\n')
|
||||||
|
var i = 0
|
||||||
|
while (i < lines.size) {
|
||||||
|
val line = lines[i]
|
||||||
|
val trimmed = line.trim()
|
||||||
|
if (trimmed.isBlank()) {
|
||||||
|
i++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (i == 0 && trimmed.startsWith("#!")) {
|
||||||
|
i++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (trimmed.startsWith("//")) {
|
||||||
|
val m = Regex("^//\\s*feature\\s*:\\s*interpolation\\s*:\\s*(on|off)\\s*$", RegexOption.IGNORE_CASE)
|
||||||
|
.matchEntire(trimmed)
|
||||||
|
if (m != null) {
|
||||||
|
enabled = m.groupValues[1].equals("on", ignoreCase = true)
|
||||||
|
}
|
||||||
|
i++
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (trimmed.startsWith("/*")) {
|
||||||
|
// Skip leading block comment(s); directives are intentionally line-comment based.
|
||||||
|
var j = i
|
||||||
|
var closed = false
|
||||||
|
while (j < lines.size) {
|
||||||
|
if (lines[j].contains("*/")) {
|
||||||
|
closed = true
|
||||||
|
break
|
||||||
|
}
|
||||||
|
j++
|
||||||
|
}
|
||||||
|
if (!closed) break
|
||||||
|
i = j + 1
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
break
|
||||||
|
}
|
||||||
|
return enabled
|
||||||
|
}
|
||||||
|
|
||||||
|
private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = true) {
|
||||||
|
|
||||||
private val pos = MutablePos(fromPos)
|
private val pos = MutablePos(fromPos)
|
||||||
|
private val bufferedTokens = ArrayDeque<Token>()
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Immutable copy of current position
|
* Immutable copy of current position
|
||||||
@@ -47,6 +111,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg)
|
private fun raise(msg: String): Nothing = throw ScriptError(currentPos, msg)
|
||||||
|
|
||||||
fun nextToken(): Token {
|
fun nextToken(): Token {
|
||||||
|
if (bufferedTokens.isNotEmpty()) return bufferedTokens.removeFirst()
|
||||||
skipws()
|
skipws()
|
||||||
if (pos.end) return Token("", currentPos, Token.Type.EOF)
|
if (pos.end) return Token("", currentPos, Token.Type.EOF)
|
||||||
val from = currentPos
|
val from = currentPos
|
||||||
@@ -296,7 +361,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
Token(":", from, Token.Type.COLON)
|
Token(":", from, Token.Type.COLON)
|
||||||
}
|
}
|
||||||
|
|
||||||
'"' -> loadStringToken()
|
'"' -> loadStringTokens(from)
|
||||||
|
|
||||||
in digitsSet -> {
|
in digitsSet -> {
|
||||||
pos.back()
|
pos.back()
|
||||||
@@ -306,17 +371,41 @@ private class Parser(fromPos: Pos) {
|
|||||||
'\'' -> {
|
'\'' -> {
|
||||||
val start = pos.toPos()
|
val start = pos.toPos()
|
||||||
var value = currentChar
|
var value = currentChar
|
||||||
pos.advance()
|
|
||||||
if (currentChar == '\\') {
|
if (currentChar == '\\') {
|
||||||
value = currentChar
|
|
||||||
pos.advance()
|
pos.advance()
|
||||||
value = when (value) {
|
if (pos.end) throw ScriptError(start, "unterminated character literal")
|
||||||
'n' -> '\n'
|
value = when (currentChar) {
|
||||||
'r' -> '\r'
|
'n' -> {
|
||||||
't' -> '\t'
|
pos.advance()
|
||||||
'\'', '\\' -> value
|
'\n'
|
||||||
else -> throw ScriptError(currentPos, "unsupported escape character: $value")
|
}
|
||||||
|
|
||||||
|
'r' -> {
|
||||||
|
pos.advance()
|
||||||
|
'\r'
|
||||||
|
}
|
||||||
|
|
||||||
|
't' -> {
|
||||||
|
pos.advance()
|
||||||
|
'\t'
|
||||||
|
}
|
||||||
|
|
||||||
|
'\'' -> {
|
||||||
|
pos.advance()
|
||||||
|
'\''
|
||||||
|
}
|
||||||
|
|
||||||
|
'\\' -> {
|
||||||
|
pos.advance()
|
||||||
|
'\\'
|
||||||
|
}
|
||||||
|
|
||||||
|
'u' -> loadUnicodeEscape(start)
|
||||||
|
|
||||||
|
else -> throw ScriptError(currentPos, "unsupported escape character: $currentChar")
|
||||||
}
|
}
|
||||||
|
} else {
|
||||||
|
pos.advance()
|
||||||
}
|
}
|
||||||
if (currentChar != '\'') throw ScriptError(currentPos, "expected end of character literal: '")
|
if (currentChar != '\'') throw ScriptError(currentPos, "expected end of character literal: '")
|
||||||
pos.advance()
|
pos.advance()
|
||||||
@@ -461,11 +550,6 @@ private class Parser(fromPos: Pos) {
|
|||||||
|
|
||||||
private fun loadStringToken(): Token {
|
private fun loadStringToken(): Token {
|
||||||
val start = currentPos
|
val start = currentPos
|
||||||
|
|
||||||
// if (currentChar == '"') pos.advance()
|
|
||||||
// else start = start.back()
|
|
||||||
// start = start.back()
|
|
||||||
|
|
||||||
val sb = StringBuilder()
|
val sb = StringBuilder()
|
||||||
var newlineDetected = false
|
var newlineDetected = false
|
||||||
while (currentChar != '"') {
|
while (currentChar != '"') {
|
||||||
@@ -494,6 +578,10 @@ private class Parser(fromPos: Pos) {
|
|||||||
sb.append('\\'); pos.advance()
|
sb.append('\\'); pos.advance()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
'u' -> {
|
||||||
|
sb.append(loadUnicodeEscape(start))
|
||||||
|
}
|
||||||
|
|
||||||
else -> {
|
else -> {
|
||||||
sb.append('\\').append(currentChar)
|
sb.append('\\').append(currentChar)
|
||||||
pos.advance()
|
pos.advance()
|
||||||
@@ -520,6 +608,279 @@ private class Parser(fromPos: Pos) {
|
|||||||
return Token(result, start, Token.Type.STRING)
|
return Token(result, start, Token.Type.STRING)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private sealed interface StringChunk {
|
||||||
|
data class Literal(val text: String, val pos: Pos) : StringChunk
|
||||||
|
data class Expr(val tokens: List<Token>, val pos: Pos) : StringChunk
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun loadStringTokens(startQuotePos: Pos): Token {
|
||||||
|
if (!interpolationEnabled) return loadStringToken()
|
||||||
|
val tokenPos = currentPos
|
||||||
|
|
||||||
|
val chunks = mutableListOf<StringChunk>()
|
||||||
|
val literal = StringBuilder()
|
||||||
|
var newlineDetected = false
|
||||||
|
var hasInterpolation = false
|
||||||
|
|
||||||
|
fun flushLiteralChunk() {
|
||||||
|
if (literal.isNotEmpty()) {
|
||||||
|
chunks += StringChunk.Literal(literal.toString(), tokenPos)
|
||||||
|
literal.clear()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
while (currentChar != '"') {
|
||||||
|
if (pos.end) throw ScriptError(startQuotePos, "unterminated string started there")
|
||||||
|
when (currentChar) {
|
||||||
|
'\\' -> {
|
||||||
|
pos.advance() ?: raise("unterminated string")
|
||||||
|
when (currentChar) {
|
||||||
|
'n' -> {
|
||||||
|
literal.append('\n'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'r' -> {
|
||||||
|
literal.append('\r'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
't' -> {
|
||||||
|
literal.append('\t'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'"' -> {
|
||||||
|
literal.append('"'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'\\' -> {
|
||||||
|
literal.append('\\'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'u' -> {
|
||||||
|
literal.append(loadUnicodeEscape(tokenPos))
|
||||||
|
}
|
||||||
|
|
||||||
|
'$' -> {
|
||||||
|
// Backslash-escaped dollar is always literal.
|
||||||
|
literal.append('$')
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
literal.append('\\').append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
'$' -> {
|
||||||
|
pos.advance()
|
||||||
|
when {
|
||||||
|
currentChar == '$' -> {
|
||||||
|
// $$ -> literal '$'
|
||||||
|
literal.append('$')
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
currentChar == '{' -> {
|
||||||
|
hasInterpolation = true
|
||||||
|
flushLiteralChunk()
|
||||||
|
val exprStart = pos.toPos()
|
||||||
|
pos.advance() // consume '{'
|
||||||
|
val exprText = readInterpolationExprText(startQuotePos)
|
||||||
|
val exprTokens = parseEmbeddedExpressionTokens(exprText, exprStart)
|
||||||
|
chunks += StringChunk.Expr(exprTokens, exprStart)
|
||||||
|
}
|
||||||
|
|
||||||
|
idFirstChars(currentChar) -> {
|
||||||
|
hasInterpolation = true
|
||||||
|
flushLiteralChunk()
|
||||||
|
val idPos = pos.toPos()
|
||||||
|
val id = loadChars(idNextChars)
|
||||||
|
val idToken = Token(id, idPos, Token.Type.ID)
|
||||||
|
chunks += StringChunk.Expr(listOf(idToken), idPos)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
// Bare '$' before non-interpolation text stays literal.
|
||||||
|
literal.append('$')
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
'\n', '\r' -> {
|
||||||
|
newlineDetected = true
|
||||||
|
literal.append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
literal.append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
pos.advance() // closing quote
|
||||||
|
|
||||||
|
if (!hasInterpolation) {
|
||||||
|
val result = literal.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
|
||||||
|
return Token(result, tokenPos, Token.Type.STRING)
|
||||||
|
}
|
||||||
|
|
||||||
|
flushLiteralChunk()
|
||||||
|
if (chunks.isEmpty()) {
|
||||||
|
return Token("", tokenPos, Token.Type.STRING)
|
||||||
|
}
|
||||||
|
val expanded = mutableListOf<Token>()
|
||||||
|
expanded += Token("(", tokenPos, Token.Type.LPAREN)
|
||||||
|
var emittedPieces = 0
|
||||||
|
for (chunk in chunks) {
|
||||||
|
val pieceTokens = when (chunk) {
|
||||||
|
is StringChunk.Literal -> {
|
||||||
|
if (chunk.text.isEmpty()) emptyList()
|
||||||
|
else listOf(Token(chunk.text, chunk.pos, Token.Type.STRING))
|
||||||
|
}
|
||||||
|
is StringChunk.Expr -> {
|
||||||
|
if (chunk.tokens.isEmpty()) throw ScriptError(chunk.pos, "empty interpolation expression")
|
||||||
|
if (chunk.tokens.size == 1) {
|
||||||
|
chunk.tokens
|
||||||
|
} else {
|
||||||
|
listOf(Token("(", chunk.pos, Token.Type.LPAREN)) +
|
||||||
|
chunk.tokens +
|
||||||
|
listOf(Token(")", chunk.pos, Token.Type.RPAREN))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (pieceTokens.isEmpty()) continue
|
||||||
|
if (emittedPieces > 0) expanded += Token("+", tokenPos, Token.Type.PLUS)
|
||||||
|
expanded += pieceTokens
|
||||||
|
emittedPieces++
|
||||||
|
}
|
||||||
|
if (emittedPieces == 0) {
|
||||||
|
expanded += Token("", tokenPos, Token.Type.STRING)
|
||||||
|
}
|
||||||
|
expanded += Token(")", tokenPos, Token.Type.RPAREN)
|
||||||
|
|
||||||
|
val first = expanded.first()
|
||||||
|
for (i in 1 until expanded.size) bufferedTokens.addLast(expanded[i])
|
||||||
|
return first
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> {
|
||||||
|
val tokens = parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled)
|
||||||
|
if (tokens.isEmpty()) return emptyList()
|
||||||
|
val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens
|
||||||
|
return withoutEof
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun readInterpolationExprText(start: Pos): String {
|
||||||
|
val out = StringBuilder()
|
||||||
|
var depth = 1
|
||||||
|
while (!pos.end) {
|
||||||
|
val ch = currentChar
|
||||||
|
if (ch == '"') {
|
||||||
|
appendQuoted(out, '"')
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (ch == '\'') {
|
||||||
|
appendQuoted(out, '\'')
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (ch == '/' && peekChar() == '/') {
|
||||||
|
out.append('/').append('/')
|
||||||
|
pos.advance()
|
||||||
|
pos.advance()
|
||||||
|
while (!pos.end && currentChar != '\n') {
|
||||||
|
out.append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (ch == '/' && peekChar() == '*') {
|
||||||
|
out.append('/').append('*')
|
||||||
|
pos.advance()
|
||||||
|
pos.advance()
|
||||||
|
var closed = false
|
||||||
|
while (!pos.end) {
|
||||||
|
val c = currentChar
|
||||||
|
if (c == '*' && peekChar() == '/') {
|
||||||
|
out.append('*').append('/')
|
||||||
|
pos.advance()
|
||||||
|
pos.advance()
|
||||||
|
closed = true
|
||||||
|
break
|
||||||
|
}
|
||||||
|
out.append(c)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
if (!closed) throw ScriptError(start, "unterminated block comment in interpolation")
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (ch == '{') {
|
||||||
|
depth++
|
||||||
|
out.append(ch)
|
||||||
|
pos.advance()
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (ch == '}') {
|
||||||
|
depth--
|
||||||
|
if (depth == 0) {
|
||||||
|
pos.advance() // consume closing '}'
|
||||||
|
return out.toString()
|
||||||
|
}
|
||||||
|
out.append(ch)
|
||||||
|
pos.advance()
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
out.append(ch)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
throw ScriptError(start, "unterminated interpolation expression")
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun appendQuoted(out: StringBuilder, quote: Char) {
|
||||||
|
out.append(quote)
|
||||||
|
pos.advance()
|
||||||
|
while (!pos.end) {
|
||||||
|
val c = currentChar
|
||||||
|
out.append(c)
|
||||||
|
pos.advance()
|
||||||
|
if (c == '\\') {
|
||||||
|
if (!pos.end) {
|
||||||
|
out.append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
if (c == quote) return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun peekChar(): Char {
|
||||||
|
if (pos.end) return 0.toChar()
|
||||||
|
val mark = pos.toPos()
|
||||||
|
pos.advance()
|
||||||
|
val result = currentChar
|
||||||
|
pos.resetTo(mark)
|
||||||
|
return result
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun loadUnicodeEscape(start: Pos): Char {
|
||||||
|
// Called when currentChar points to 'u' right after a backslash.
|
||||||
|
if (currentChar != 'u') throw ScriptError(currentPos, "expected unicode escape marker: u")
|
||||||
|
pos.advance() ?: throw ScriptError(start, "unterminated unicode escape")
|
||||||
|
|
||||||
|
var code = 0
|
||||||
|
repeat(4) {
|
||||||
|
val ch = currentChar
|
||||||
|
if (ch !in hexDigits) {
|
||||||
|
throw ScriptError(currentPos, "invalid unicode escape sequence, expected 4 hex digits")
|
||||||
|
}
|
||||||
|
code = (code shl 4) + ch.digitToInt(16)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
|
return code.toChar()
|
||||||
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Load characters from the set until it reaches EOF or invalid character found.
|
* Load characters from the set until it reaches EOF or invalid character found.
|
||||||
* stop at EOF on character filtered by [isValidChar].
|
* stop at EOF on character filtered by [isValidChar].
|
||||||
|
|||||||
@@ -20,15 +20,19 @@ package net.sergeych.lyng
|
|||||||
import kotlinx.coroutines.delay
|
import kotlinx.coroutines.delay
|
||||||
import kotlinx.coroutines.yield
|
import kotlinx.coroutines.yield
|
||||||
import net.sergeych.lyng.Script.Companion.defaultImportManager
|
import net.sergeych.lyng.Script.Companion.defaultImportManager
|
||||||
|
import net.sergeych.lyng.bridge.bind
|
||||||
|
import net.sergeych.lyng.bridge.bindObject
|
||||||
import net.sergeych.lyng.bytecode.CmdFunction
|
import net.sergeych.lyng.bytecode.CmdFunction
|
||||||
import net.sergeych.lyng.bytecode.CmdVm
|
import net.sergeych.lyng.bytecode.CmdVm
|
||||||
import net.sergeych.lyng.miniast.*
|
import net.sergeych.lyng.miniast.*
|
||||||
import net.sergeych.lyng.obj.*
|
import net.sergeych.lyng.obj.*
|
||||||
import net.sergeych.lyng.pacman.ImportManager
|
import net.sergeych.lyng.pacman.ImportManager
|
||||||
|
import net.sergeych.lyng.stdlib_included.observableLyng
|
||||||
import net.sergeych.lyng.stdlib_included.rootLyng
|
import net.sergeych.lyng.stdlib_included.rootLyng
|
||||||
import net.sergeych.lynon.ObjLynonClass
|
import net.sergeych.lynon.ObjLynonClass
|
||||||
import net.sergeych.mp_tools.globalDefer
|
import net.sergeych.mp_tools.globalDefer
|
||||||
import kotlin.math.*
|
import kotlin.math.*
|
||||||
|
import kotlin.random.Random as KRandom
|
||||||
|
|
||||||
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
|
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
|
||||||
class Script(
|
class Script(
|
||||||
@@ -587,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 {
|
val defaultImportManager: ImportManager by lazy {
|
||||||
ImportManager(rootScope, SecurityManager.allowAll).apply {
|
ImportManager(rootScope, SecurityManager.allowAll).apply {
|
||||||
addPackage("lyng.stdlib") { module ->
|
addPackage("lyng.stdlib") { module ->
|
||||||
module.eval(Source("lyng.stdlib", rootLyng))
|
module.eval(Source("lyng.stdlib", rootLyng))
|
||||||
ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator"))
|
ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator"))
|
||||||
|
val seededRandomClass = module.requireClass("SeededRandom")
|
||||||
|
module.bind("SeededRandom") {
|
||||||
|
init { data = KRandom.Default }
|
||||||
|
addFun("nextInt") {
|
||||||
|
val rnd = seededRandomFromThis(requireScope(), thisObj)
|
||||||
|
ObjInt.of(rnd.nextInt().toLong())
|
||||||
|
}
|
||||||
|
addFun("nextFloat") {
|
||||||
|
val rnd = seededRandomFromThis(requireScope(), thisObj)
|
||||||
|
ObjReal(rnd.nextDouble())
|
||||||
|
}
|
||||||
|
addFun("next") {
|
||||||
|
val rnd = seededRandomFromThis(requireScope(), thisObj)
|
||||||
|
val range = requiredArg<ObjRange>(0)
|
||||||
|
sampleRangeValue(requireScope(), rnd, range)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
module.bindObject("Random") {
|
||||||
|
addFun("nextInt") {
|
||||||
|
ObjInt.of(KRandom.Default.nextInt().toLong())
|
||||||
|
}
|
||||||
|
addFun("nextFloat") {
|
||||||
|
ObjReal(KRandom.Default.nextDouble())
|
||||||
|
}
|
||||||
|
addFun("next") {
|
||||||
|
val range = requiredArg<ObjRange>(0)
|
||||||
|
sampleRangeValue(requireScope(), KRandom.Default, range)
|
||||||
|
}
|
||||||
|
addFun("seeded") {
|
||||||
|
val seed = requiredArg<ObjInt>(0).value.toInt()
|
||||||
|
val instance = call(seededRandomClass) as? ObjInstance
|
||||||
|
?: requireScope().raiseIllegalState("SeededRandom() did not return an object instance")
|
||||||
|
instance.kotlinInstanceData = KRandom(seed)
|
||||||
|
instance
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
addPackage("lyng.observable") { module ->
|
||||||
|
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") {
|
addPackage("lyng.buffer") {
|
||||||
it.addConstDoc(
|
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");
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
* you may not use this file except in compliance with the License.
|
* you may not use this file except in compliance with the License.
|
||||||
@@ -12,6 +12,7 @@
|
|||||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
* See the License for the specific language governing permissions and
|
* See the License for the specific language governing permissions and
|
||||||
* limitations under the License.
|
* limitations under the License.
|
||||||
|
*
|
||||||
*/
|
*/
|
||||||
|
|
||||||
package net.sergeych.lyng
|
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)
|
data class WhenCase(val conditions: List<WhenCondition>, val block: Statement)
|
||||||
|
|
||||||
class WhenStatement(
|
class WhenStatement(
|
||||||
|
|||||||
@@ -51,8 +51,9 @@ interface BridgeInstanceContext {
|
|||||||
* Use [LyngClassBridge.bind] to obtain a binder and register implementations.
|
* Use [LyngClassBridge.bind] to obtain a binder and register implementations.
|
||||||
* Bindings must happen before the first instance of the class is created.
|
* 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
|
* Important: members you bind here must be extern in Lyng (explicitly, or
|
||||||
* compiler emits the ABI slots that Kotlin bindings attach to.
|
* implicitly by being inside `extern class` / `extern object`) so the compiler
|
||||||
|
* emits the ABI slots that Kotlin bindings attach to.
|
||||||
*/
|
*/
|
||||||
interface ClassBridgeBinder {
|
interface ClassBridgeBinder {
|
||||||
/** Arbitrary Kotlin-side data attached to the class. */
|
/** Arbitrary Kotlin-side data attached to the class. */
|
||||||
@@ -60,12 +61,54 @@ interface ClassBridgeBinder {
|
|||||||
/** Register an initialization hook that runs for each instance. */
|
/** Register an initialization hook that runs for each instance. */
|
||||||
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
|
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
|
||||||
/** Register an initialization hook with direct access to the instance. */
|
/** 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)
|
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)
|
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)
|
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(
|
fun addVar(
|
||||||
name: String,
|
name: String,
|
||||||
get: suspend (ScopeFacade, Obj) -> Obj,
|
get: suspend (ScopeFacade, Obj) -> Obj,
|
||||||
@@ -77,8 +120,9 @@ interface ClassBridgeBinder {
|
|||||||
* Entry point for Kotlin bindings to declared Lyng classes.
|
* Entry point for Kotlin bindings to declared Lyng classes.
|
||||||
*
|
*
|
||||||
* The workflow is Lyng-first: declare the class and its members in Lyng,
|
* The workflow is Lyng-first: declare the class and its members in Lyng,
|
||||||
* then bind the implementations from Kotlin. Bound members must be marked
|
* then bind the implementations from Kotlin. Bound members must be extern
|
||||||
* `extern` so the compiler emits the ABI slots for Kotlin to attach to.
|
* (explicitly or by enclosing `extern class` / `extern object`) so the compiler
|
||||||
|
* emits the ABI slots for Kotlin to attach to.
|
||||||
*/
|
*/
|
||||||
object LyngClassBridge {
|
object LyngClassBridge {
|
||||||
/**
|
/**
|
||||||
@@ -170,7 +214,7 @@ object LyngObjectBridge {
|
|||||||
/**
|
/**
|
||||||
* Sugar for [LyngClassBridge.bind] on a module scope.
|
* 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(
|
suspend fun ModuleScope.bind(
|
||||||
className: String,
|
className: String,
|
||||||
@@ -180,7 +224,7 @@ suspend fun ModuleScope.bind(
|
|||||||
/**
|
/**
|
||||||
* Sugar for [LyngObjectBridge.bind] on a module scope.
|
* 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(
|
suspend fun ModuleScope.bindObject(
|
||||||
objectName: String,
|
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) {
|
override fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit) {
|
||||||
initHooks.add { scope, inst ->
|
initHooks.add { scope, inst ->
|
||||||
block(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()
|
ensureTemplateNotBuilt()
|
||||||
val target = findMember(name)
|
val target = findMember(name)
|
||||||
val callable = ObjExternCallable.fromBridge {
|
val callable = ObjExternCallable.fromBridge {
|
||||||
impl(this, thisObj, args)
|
impl()
|
||||||
}
|
}
|
||||||
val methodId = cls.ensureMethodIdForBridge(name, target.record)
|
val methodId = cls.ensureMethodIdForBridge(name, target.record)
|
||||||
val newRecord = target.record.copy(
|
val newRecord = target.record.copy(
|
||||||
@@ -255,14 +309,24 @@ private class ClassBridgeBinderImpl(
|
|||||||
replaceMember(target, newRecord)
|
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()
|
ensureTemplateNotBuilt()
|
||||||
val target = findMember(name)
|
val target = findMember(name)
|
||||||
if (target.record.isMutable) {
|
if (target.record.isMutable) {
|
||||||
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
|
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
|
||||||
}
|
}
|
||||||
val getter = ObjExternCallable.fromBridge {
|
val getter = ObjExternCallable.fromBridge {
|
||||||
impl(this, thisObj)
|
impl()
|
||||||
}
|
}
|
||||||
val prop = ObjProperty(name, getter, null)
|
val prop = ObjProperty(name, getter, null)
|
||||||
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
|
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
|
||||||
@@ -287,10 +351,20 @@ private class ClassBridgeBinderImpl(
|
|||||||
replaceMember(target, newRecord)
|
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(
|
override fun addVar(
|
||||||
name: String,
|
name: String,
|
||||||
get: suspend (ScopeFacade, Obj) -> Obj,
|
get: suspend ScopeFacade.() -> Obj,
|
||||||
set: suspend (ScopeFacade, Obj, Obj) -> Unit
|
set: suspend ScopeFacade.(Obj) -> Unit
|
||||||
) {
|
) {
|
||||||
ensureTemplateNotBuilt()
|
ensureTemplateNotBuilt()
|
||||||
val target = findMember(name)
|
val target = findMember(name)
|
||||||
@@ -298,11 +372,11 @@ private class ClassBridgeBinderImpl(
|
|||||||
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
|
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
|
||||||
}
|
}
|
||||||
val getter = ObjExternCallable.fromBridge {
|
val getter = ObjExternCallable.fromBridge {
|
||||||
get(this, thisObj)
|
get()
|
||||||
}
|
}
|
||||||
val setter = ObjExternCallable.fromBridge {
|
val setter = ObjExternCallable.fromBridge {
|
||||||
val value = requiredArg<Obj>(0)
|
val value = requiredArg<Obj>(0)
|
||||||
set(this, thisObj, value)
|
set(value)
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
val prop = ObjProperty(name, getter, setter)
|
val prop = ObjProperty(name, getter, setter)
|
||||||
@@ -328,6 +402,24 @@ private class ClassBridgeBinderImpl(
|
|||||||
replaceMember(target, newRecord)
|
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() {
|
fun commit() {
|
||||||
if (initHooks.isNotEmpty()) {
|
if (initHooks.isNotEmpty()) {
|
||||||
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
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) {
|
override fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit) {
|
||||||
initHooks.add { scope, inst ->
|
initHooks.add { scope, inst ->
|
||||||
block(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 target = findMember(name)
|
||||||
val callable = ObjExternCallable.fromBridge {
|
val callable = ObjExternCallable.fromBridge {
|
||||||
impl(this, thisObj, args)
|
impl()
|
||||||
}
|
}
|
||||||
val methodId = cls.ensureMethodIdForBridge(name, target.record)
|
val methodId = cls.ensureMethodIdForBridge(name, target.record)
|
||||||
val newRecord = target.record.copy(
|
val newRecord = target.record.copy(
|
||||||
@@ -420,13 +522,23 @@ private class ObjectBridgeBinderImpl(
|
|||||||
updateInstanceMember(target, newRecord)
|
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)
|
val target = findMember(name)
|
||||||
if (target.record.isMutable) {
|
if (target.record.isMutable) {
|
||||||
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
|
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
|
||||||
}
|
}
|
||||||
val getter = ObjExternCallable.fromBridge {
|
val getter = ObjExternCallable.fromBridge {
|
||||||
impl(this, thisObj)
|
impl()
|
||||||
}
|
}
|
||||||
val prop = ObjProperty(name, getter, null)
|
val prop = ObjProperty(name, getter, null)
|
||||||
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
|
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
|
||||||
@@ -452,21 +564,31 @@ private class ObjectBridgeBinderImpl(
|
|||||||
updateInstanceMember(target, newRecord)
|
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(
|
override fun addVar(
|
||||||
name: String,
|
name: String,
|
||||||
get: suspend (ScopeFacade, Obj) -> Obj,
|
get: suspend ScopeFacade.() -> Obj,
|
||||||
set: suspend (ScopeFacade, Obj, Obj) -> Unit
|
set: suspend ScopeFacade.(Obj) -> Unit
|
||||||
) {
|
) {
|
||||||
val target = findMember(name)
|
val target = findMember(name)
|
||||||
if (!target.record.isMutable) {
|
if (!target.record.isMutable) {
|
||||||
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
|
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
|
||||||
}
|
}
|
||||||
val getter = ObjExternCallable.fromBridge {
|
val getter = ObjExternCallable.fromBridge {
|
||||||
get(this, thisObj)
|
get()
|
||||||
}
|
}
|
||||||
val setter = ObjExternCallable.fromBridge {
|
val setter = ObjExternCallable.fromBridge {
|
||||||
val value = requiredArg<Obj>(0)
|
val value = requiredArg<Obj>(0)
|
||||||
set(this, thisObj, value)
|
set(value)
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
val prop = ObjProperty(name, getter, setter)
|
val prop = ObjProperty(name, getter, setter)
|
||||||
@@ -493,6 +615,24 @@ private class ObjectBridgeBinderImpl(
|
|||||||
updateInstanceMember(target, newRecord)
|
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() {
|
suspend fun commit() {
|
||||||
if (initHooks.isNotEmpty()) {
|
if (initHooks.isNotEmpty()) {
|
||||||
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
|
||||||
|
|||||||
@@ -1067,18 +1067,9 @@ class BytecodeCompiler(
|
|||||||
updateSlotType(dst, SlotType.OBJ)
|
updateSlotType(dst, SlotType.OBJ)
|
||||||
return CompiledValue(dst, SlotType.OBJ)
|
return CompiledValue(dst, SlotType.OBJ)
|
||||||
}
|
}
|
||||||
if (receiverClass == null && memberName == "negate") {
|
if (memberName == "negate" &&
|
||||||
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
|
(receiverClass == null || isDelegateClass(receiverClass) || receiverClass in setOf(ObjInt.type, ObjReal.type))
|
||||||
val zeroSlot = allocSlot()
|
) {
|
||||||
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
|
|
||||||
updateSlotType(zeroSlot, SlotType.INT)
|
|
||||||
val obj = ensureObjSlot(value)
|
|
||||||
val dst = allocSlot()
|
|
||||||
builder.emit(Opcode.SUB_OBJ, zeroSlot, obj.slot, dst)
|
|
||||||
updateSlotType(dst, SlotType.OBJ)
|
|
||||||
return CompiledValue(dst, SlotType.OBJ)
|
|
||||||
}
|
|
||||||
if (memberName == "negate" && receiverClass in setOf(ObjInt.type, ObjReal.type)) {
|
|
||||||
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
|
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
|
||||||
val zeroSlot = allocSlot()
|
val zeroSlot = allocSlot()
|
||||||
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
|
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
|
||||||
@@ -1095,6 +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) {
|
private fun operatorMemberName(op: BinOp): String? = when (op) {
|
||||||
BinOp.PLUS -> "plus"
|
BinOp.PLUS -> "plus"
|
||||||
BinOp.MINUS -> "minus"
|
BinOp.MINUS -> "minus"
|
||||||
@@ -1142,11 +1138,7 @@ class BytecodeCompiler(
|
|||||||
): CompiledValue? {
|
): CompiledValue? {
|
||||||
val memberName = operatorMemberName(op) ?: return null
|
val memberName = operatorMemberName(op) ?: return null
|
||||||
val receiverClass = resolveReceiverClass(leftRef)
|
val receiverClass = resolveReceiverClass(leftRef)
|
||||||
if (receiverClass == null ||
|
if (receiverClass == null || isDelegateClass(receiverClass)) {
|
||||||
receiverClass.className == "Delegate" ||
|
|
||||||
receiverClass.className == "LazyDelegate" ||
|
|
||||||
receiverClass.implementingNames.contains("Delegate")
|
|
||||||
) {
|
|
||||||
val objOpcode = when (op) {
|
val objOpcode = when (op) {
|
||||||
BinOp.PLUS -> Opcode.ADD_OBJ
|
BinOp.PLUS -> Opcode.ADD_OBJ
|
||||||
BinOp.MINUS -> Opcode.SUB_OBJ
|
BinOp.MINUS -> Opcode.SUB_OBJ
|
||||||
@@ -4345,6 +4337,22 @@ class BytecodeCompiler(
|
|||||||
CompiledValue(neg, SlotType.BOOL)
|
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 dst = allocSlot()
|
||||||
val encodedMethodId = encodeMemberId(receiverClass, methodId) ?: methodId
|
val encodedMethodId = encodeMemberId(receiverClass, methodId) ?: methodId
|
||||||
if (!ref.isOptionalInvoke) {
|
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
|
val encodedCount = encodeCallArgCount(args) ?: return null
|
||||||
setPos(callPos)
|
setPos(callPos)
|
||||||
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
|
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
|
||||||
@@ -4410,7 +4418,7 @@ class BytecodeCompiler(
|
|||||||
Opcode.JMP_IF_TRUE,
|
Opcode.JMP_IF_TRUE,
|
||||||
listOf(CmdBuilder.Operand.IntVal(cmpSlot), CmdBuilder.Operand.LabelRef(nullLabel))
|
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
|
val encodedCount = encodeCallArgCount(args) ?: return null
|
||||||
setPos(callPos)
|
setPos(callPos)
|
||||||
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
|
builder.emit(Opcode.CALL_MEMBER_SLOT, receiver.slot, encodedMethodId, args.base, encodedCount, dst)
|
||||||
@@ -4440,6 +4448,7 @@ class BytecodeCompiler(
|
|||||||
val initClass = when (localTarget?.name) {
|
val initClass = when (localTarget?.name) {
|
||||||
"List" -> ObjList.type
|
"List" -> ObjList.type
|
||||||
"ImmutableList" -> ObjImmutableList.type
|
"ImmutableList" -> ObjImmutableList.type
|
||||||
|
"ObservableList" -> ObjObservableList.type
|
||||||
"Map" -> ObjMap.type
|
"Map" -> ObjMap.type
|
||||||
"ImmutableMap" -> ObjImmutableMap.type
|
"ImmutableMap" -> ObjImmutableMap.type
|
||||||
"Set" -> ObjSet.type
|
"Set" -> ObjSet.type
|
||||||
@@ -4449,7 +4458,7 @@ class BytecodeCompiler(
|
|||||||
val callee = compileRefWithFallback(ref.target, null, refPosOrCurrent(ref.target)) ?: return null
|
val callee = compileRefWithFallback(ref.target, null, refPosOrCurrent(ref.target)) ?: return null
|
||||||
val dst = allocSlot()
|
val dst = allocSlot()
|
||||||
if (!ref.isOptionalInvoke) {
|
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
|
val encodedCount = encodeCallArgCount(args) ?: return null
|
||||||
setPos(callPos)
|
setPos(callPos)
|
||||||
builder.emit(
|
builder.emit(
|
||||||
@@ -4474,7 +4483,7 @@ class BytecodeCompiler(
|
|||||||
Opcode.JMP_IF_TRUE,
|
Opcode.JMP_IF_TRUE,
|
||||||
listOf(CmdBuilder.Operand.IntVal(cmpSlot), CmdBuilder.Operand.LabelRef(nullLabel))
|
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
|
val encodedCount = encodeCallArgCount(args) ?: return null
|
||||||
setPos(callPos)
|
setPos(callPos)
|
||||||
builder.emit(
|
builder.emit(
|
||||||
@@ -4804,9 +4813,26 @@ class BytecodeCompiler(
|
|||||||
|
|
||||||
private data class CallArgs(val base: Int, val count: Int, val planId: Int?)
|
private data class CallArgs(val base: Int, val count: Int, val planId: Int?)
|
||||||
|
|
||||||
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
private fun extensionReceiverTypeNames(receiverClass: ObjClass): Set<String> {
|
||||||
|
val names = LinkedHashSet<String>()
|
||||||
for (cls in receiverClass.mro) {
|
for (cls in receiverClass.mro) {
|
||||||
val candidate = extensionCallableName(cls.className, memberName)
|
names.add(cls.className)
|
||||||
|
for ((knownName, knownClass) in nameObjClass) {
|
||||||
|
if (knownClass !== cls && knownClass.className != cls.className) continue
|
||||||
|
names.add(knownName)
|
||||||
|
names.add(knownName.substringAfterLast('.'))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return names
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun resolveExtensionSlotByReceiverNames(
|
||||||
|
receiverClass: ObjClass,
|
||||||
|
memberName: String,
|
||||||
|
wrapperName: (String, String) -> String
|
||||||
|
): CompiledValue? {
|
||||||
|
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
|
||||||
|
val candidate = wrapperName(receiverName, memberName)
|
||||||
if (allowedScopeNames != null &&
|
if (allowedScopeNames != null &&
|
||||||
!allowedScopeNames.contains(candidate) &&
|
!allowedScopeNames.contains(candidate) &&
|
||||||
!localSlotIndexByName.containsKey(candidate)
|
!localSlotIndexByName.containsKey(candidate)
|
||||||
@@ -4818,32 +4844,39 @@ class BytecodeCompiler(
|
|||||||
return null
|
return null
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private fun resolveUniqueExtensionWrapperSlot(
|
||||||
|
memberName: String,
|
||||||
|
wrapperPrefix: String
|
||||||
|
): CompiledValue? {
|
||||||
|
val suffix = "__$memberName"
|
||||||
|
val candidates = LinkedHashSet<String>()
|
||||||
|
for (name in localSlotIndexByName.keys) {
|
||||||
|
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
|
||||||
|
candidates.add(name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
for (name in scopeSlotIndexByName.keys) {
|
||||||
|
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
|
||||||
|
candidates.add(name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (candidates.size != 1) return null
|
||||||
|
return resolveDirectNameSlot(candidates.first())
|
||||||
|
}
|
||||||
|
|
||||||
|
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
||||||
|
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionCallableName)
|
||||||
|
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext__")
|
||||||
|
}
|
||||||
|
|
||||||
private fun resolveExtensionGetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
private fun resolveExtensionGetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
||||||
for (cls in receiverClass.mro) {
|
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertyGetterName)
|
||||||
val candidate = extensionPropertyGetterName(cls.className, memberName)
|
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_get__")
|
||||||
if (allowedScopeNames != null &&
|
|
||||||
!allowedScopeNames.contains(candidate) &&
|
|
||||||
!localSlotIndexByName.containsKey(candidate)
|
|
||||||
) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
resolveDirectNameSlot(candidate)?.let { return it }
|
|
||||||
}
|
|
||||||
return null
|
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
|
||||||
for (cls in receiverClass.mro) {
|
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertySetterName)
|
||||||
val candidate = extensionPropertySetterName(cls.className, memberName)
|
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_set__")
|
||||||
if (allowedScopeNames != null &&
|
|
||||||
!allowedScopeNames.contains(candidate) &&
|
|
||||||
!localSlotIndexByName.containsKey(candidate)
|
|
||||||
) {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
resolveDirectNameSlot(candidate)?.let { return it }
|
|
||||||
}
|
|
||||||
return null
|
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun compileCallArgsWithReceiver(
|
private fun compileCallArgsWithReceiver(
|
||||||
@@ -4875,10 +4908,14 @@ class BytecodeCompiler(
|
|||||||
return CallArgs(base = argSlots[0], count = argSlots.size, planId = planId)
|
return CallArgs(base = argSlots[0], count = argSlots.size, planId = planId)
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun compileCallArgs(args: List<ParsedArgument>, tailBlock: Boolean): CallArgs? {
|
private fun compileCallArgs(
|
||||||
if (args.isEmpty()) return CallArgs(base = 0, count = 0, planId = null)
|
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 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
|
val specs = if (needPlan) ArrayList<BytecodeConst.CallArgSpec>(args.size) else null
|
||||||
for ((index, arg) in args.withIndex()) {
|
for ((index, arg) in args.withIndex()) {
|
||||||
val compiled = compileArgValue(arg.value) ?: return null
|
val compiled = compileArgValue(arg.value) ?: return null
|
||||||
@@ -4890,11 +4927,17 @@ class BytecodeCompiler(
|
|||||||
specs?.add(BytecodeConst.CallArgSpec(arg.name, arg.isSplat))
|
specs?.add(BytecodeConst.CallArgSpec(arg.name, arg.isSplat))
|
||||||
}
|
}
|
||||||
val planId = if (needPlan) {
|
val planId = if (needPlan) {
|
||||||
builder.addConst(BytecodeConst.CallArgsPlan(tailBlock, specs ?: emptyList()))
|
builder.addConst(
|
||||||
|
BytecodeConst.CallArgsPlan(
|
||||||
|
tailBlock = tailBlock,
|
||||||
|
specs = specs ?: emptyList(),
|
||||||
|
explicitTypeArgs = explicitTypeArgs ?: emptyList()
|
||||||
|
)
|
||||||
|
)
|
||||||
} else {
|
} else {
|
||||||
null
|
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? {
|
private fun compileArgValue(value: Obj): CompiledValue? {
|
||||||
@@ -7326,6 +7369,16 @@ class BytecodeCompiler(
|
|||||||
"Regex" -> ObjRegex.type
|
"Regex" -> ObjRegex.type
|
||||||
"RegexMatch" -> ObjRegexMatch.type
|
"RegexMatch" -> ObjRegexMatch.type
|
||||||
"MapEntry" -> ObjMapEntry.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
|
"Instant" -> ObjInstant.type
|
||||||
"DateTime" -> ObjDateTime.type
|
"DateTime" -> ObjDateTime.type
|
||||||
"Duration" -> ObjDuration.type
|
"Duration" -> ObjDuration.type
|
||||||
@@ -7389,6 +7442,9 @@ class BytecodeCompiler(
|
|||||||
"toImmutableSet" -> ObjImmutableSet.type
|
"toImmutableSet" -> ObjImmutableSet.type
|
||||||
"toMap" -> ObjMap.type
|
"toMap" -> ObjMap.type
|
||||||
"toImmutableMap" -> ObjImmutableMap.type
|
"toImmutableMap" -> ObjImmutableMap.type
|
||||||
|
"observable" -> ObjObservableList.type
|
||||||
|
"beforeChange", "onChange" -> ObjSubscription.type
|
||||||
|
"changes" -> ObjFlow.type
|
||||||
"joinToString" -> ObjString.type
|
"joinToString" -> ObjString.type
|
||||||
"now",
|
"now",
|
||||||
"truncateToSecond",
|
"truncateToSecond",
|
||||||
@@ -7428,7 +7484,7 @@ class BytecodeCompiler(
|
|||||||
if (targetClass == null) return null
|
if (targetClass == null) return null
|
||||||
if (targetClass == ObjDynamic.type) return ObjDynamic.type
|
if (targetClass == ObjDynamic.type) return ObjDynamic.type
|
||||||
classFieldTypesByName[targetClass.className]?.get(name)?.let { cls ->
|
classFieldTypesByName[targetClass.className]?.get(name)?.let { cls ->
|
||||||
if (cls.className == "Delegate" || cls.className == "LazyDelegate" || cls.implementingNames.contains("Delegate")) {
|
if (isDelegateClass(cls)) {
|
||||||
return null
|
return null
|
||||||
}
|
}
|
||||||
return cls
|
return cls
|
||||||
@@ -7515,8 +7571,8 @@ class BytecodeCompiler(
|
|||||||
|
|
||||||
private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) {
|
private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) {
|
||||||
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
|
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
|
||||||
for (cls in receiverClass.mro) {
|
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
|
||||||
val name = extensionCallableName(cls.className, memberName)
|
val name = extensionCallableName(receiverName, memberName)
|
||||||
if (allowedScopeNames == null || allowedScopeNames.contains(name)) {
|
if (allowedScopeNames == null || allowedScopeNames.contains(name)) {
|
||||||
pendingScopeNameRefs.add(name)
|
pendingScopeNameRefs.add(name)
|
||||||
}
|
}
|
||||||
@@ -7525,12 +7581,12 @@ class BytecodeCompiler(
|
|||||||
|
|
||||||
private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) {
|
private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) {
|
||||||
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
|
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
|
||||||
for (cls in receiverClass.mro) {
|
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
|
||||||
val getter = extensionPropertyGetterName(cls.className, memberName)
|
val getter = extensionPropertyGetterName(receiverName, memberName)
|
||||||
if (allowedScopeNames == null || allowedScopeNames.contains(getter)) {
|
if (allowedScopeNames == null || allowedScopeNames.contains(getter)) {
|
||||||
pendingScopeNameRefs.add(getter)
|
pendingScopeNameRefs.add(getter)
|
||||||
}
|
}
|
||||||
val setter = extensionPropertySetterName(cls.className, memberName)
|
val setter = extensionPropertySetterName(receiverName, memberName)
|
||||||
if (allowedScopeNames == null || allowedScopeNames.contains(setter)) {
|
if (allowedScopeNames == null || allowedScopeNames.contains(setter)) {
|
||||||
pendingScopeNameRefs.add(setter)
|
pendingScopeNameRefs.add(setter)
|
||||||
}
|
}
|
||||||
@@ -8450,6 +8506,9 @@ class BytecodeCompiler(
|
|||||||
collectScopeSlotsRef(ref.targetRef)
|
collectScopeSlotsRef(ref.targetRef)
|
||||||
collectScopeSlotsRef(ref.indexRef)
|
collectScopeSlotsRef(ref.indexRef)
|
||||||
}
|
}
|
||||||
|
is ClassOperatorRef -> {
|
||||||
|
collectScopeSlotsRef(ref.target)
|
||||||
|
}
|
||||||
is ListLiteralRef -> {
|
is ListLiteralRef -> {
|
||||||
for (entry in ref.entries()) {
|
for (entry in ref.entries()) {
|
||||||
when (entry) {
|
when (entry) {
|
||||||
|
|||||||
@@ -180,6 +180,10 @@ sealed class BytecodeConst {
|
|||||||
val pattern: ListLiteralRef,
|
val pattern: ListLiteralRef,
|
||||||
val pos: Pos,
|
val pos: Pos,
|
||||||
) : BytecodeConst()
|
) : 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)
|
data class CallArgSpec(val name: String?, val isSplat: Boolean)
|
||||||
}
|
}
|
||||||
@@ -443,6 +443,7 @@ class BytecodeStatement private constructor(
|
|||||||
is WhenEqualsCondition -> WhenEqualsCondition(unwrapDeep(cond.expr), cond.pos)
|
is WhenEqualsCondition -> WhenEqualsCondition(unwrapDeep(cond.expr), cond.pos)
|
||||||
is WhenInCondition -> WhenInCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
|
is WhenInCondition -> WhenInCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
|
||||||
is WhenIsCondition -> WhenIsCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
|
is WhenIsCondition -> WhenIsCondition(unwrapDeep(cond.expr), cond.negated, cond.pos)
|
||||||
|
is WhenNullableCondition -> WhenNullableCondition(cond.negated, cond.pos)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -3784,6 +3784,7 @@ class CmdFrame(
|
|||||||
val exceptionSlot: Int,
|
val exceptionSlot: Int,
|
||||||
val catchIp: Int,
|
val catchIp: Int,
|
||||||
val finallyIp: Int,
|
val finallyIp: Int,
|
||||||
|
val iterDepthAtPush: Int,
|
||||||
var inCatch: Boolean = false
|
var inCatch: Boolean = false
|
||||||
)
|
)
|
||||||
internal val tryStack = ArrayDeque<TryHandler>()
|
internal val tryStack = ArrayDeque<TryHandler>()
|
||||||
@@ -4069,11 +4070,15 @@ class CmdFrame(
|
|||||||
return scope
|
return scope
|
||||||
}
|
}
|
||||||
|
|
||||||
fun handleException(t: Throwable): Boolean {
|
suspend fun handleException(t: Throwable): Boolean {
|
||||||
val handler = tryStack.lastOrNull() ?: return false
|
val handler = tryStack.lastOrNull() ?: return false
|
||||||
|
vmIterDebug(
|
||||||
|
"handleException fn=${fn.name} throwable=${t::class.simpleName} message=${t.message} catchIp=${handler.catchIp} finallyIp=${handler.finallyIp} iterDepth=${iterStack.size}"
|
||||||
|
)
|
||||||
val finallyIp = handler.finallyIp
|
val finallyIp = handler.finallyIp
|
||||||
if (t is ReturnException || t is LoopBreakContinueException) {
|
if (t is ReturnException || t is LoopBreakContinueException) {
|
||||||
if (finallyIp >= 0) {
|
if (finallyIp >= 0) {
|
||||||
|
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:returnOrLoop->finally")
|
||||||
pendingThrowable = t
|
pendingThrowable = t
|
||||||
ip = finallyIp
|
ip = finallyIp
|
||||||
return true
|
return true
|
||||||
@@ -4082,6 +4087,7 @@ class CmdFrame(
|
|||||||
}
|
}
|
||||||
if (handler.inCatch) {
|
if (handler.inCatch) {
|
||||||
if (finallyIp >= 0) {
|
if (finallyIp >= 0) {
|
||||||
|
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:inCatch->finally")
|
||||||
pendingThrowable = t
|
pendingThrowable = t
|
||||||
ip = finallyIp
|
ip = finallyIp
|
||||||
return true
|
return true
|
||||||
@@ -4091,6 +4097,7 @@ class CmdFrame(
|
|||||||
handler.inCatch = true
|
handler.inCatch = true
|
||||||
pendingThrowable = t
|
pendingThrowable = t
|
||||||
if (handler.catchIp >= 0) {
|
if (handler.catchIp >= 0) {
|
||||||
|
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toCatch")
|
||||||
val caughtObj = when (t) {
|
val caughtObj = when (t) {
|
||||||
is ExecutionError -> t.errorObject
|
is ExecutionError -> t.errorObject
|
||||||
else -> ObjUnknownException(ensureScope(), t.message ?: t.toString())
|
else -> ObjUnknownException(ensureScope(), t.message ?: t.toString())
|
||||||
@@ -4100,6 +4107,7 @@ class CmdFrame(
|
|||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
if (finallyIp >= 0) {
|
if (finallyIp >= 0) {
|
||||||
|
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toFinallyNoCatch")
|
||||||
ip = finallyIp
|
ip = finallyIp
|
||||||
return true
|
return true
|
||||||
}
|
}
|
||||||
@@ -4107,7 +4115,7 @@ class CmdFrame(
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun pushTry(exceptionSlot: Int, catchIp: Int, finallyIp: Int) {
|
fun pushTry(exceptionSlot: Int, catchIp: Int, finallyIp: Int) {
|
||||||
tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp))
|
tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp, iterDepthAtPush = iterStack.size))
|
||||||
}
|
}
|
||||||
|
|
||||||
fun popTry() {
|
fun popTry() {
|
||||||
@@ -4164,24 +4172,47 @@ class CmdFrame(
|
|||||||
|
|
||||||
fun pushIterator(iter: Obj) {
|
fun pushIterator(iter: Obj) {
|
||||||
iterStack.addLast(iter)
|
iterStack.addLast(iter)
|
||||||
|
if (iter.objClass.className == "FlowIterator") {
|
||||||
|
vmIterDebug("pushIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fun popIterator() {
|
fun popIterator() {
|
||||||
|
val iter = iterStack.lastOrNull()
|
||||||
|
if (iter != null && iter.objClass.className == "FlowIterator") {
|
||||||
|
vmIterDebug("popIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
|
||||||
|
}
|
||||||
iterStack.removeLastOrNull()
|
iterStack.removeLastOrNull()
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun cancelTopIterator() {
|
suspend fun cancelTopIterator() {
|
||||||
val iter = iterStack.removeLastOrNull() ?: return
|
val iter = iterStack.removeLastOrNull() ?: return
|
||||||
|
vmIterDebug("cancelTopIterator fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
|
||||||
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
|
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun cancelIterators() {
|
suspend fun cancelIterators() {
|
||||||
while (iterStack.isNotEmpty()) {
|
while (iterStack.isNotEmpty()) {
|
||||||
val iter = iterStack.removeLast()
|
val iter = iterStack.removeLast()
|
||||||
|
vmIterDebug("cancelIterators fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
|
||||||
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
|
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
private suspend fun cancelIteratorsToDepth(depth: Int, reason: String) {
|
||||||
|
while (iterStack.size > depth) {
|
||||||
|
val iter = iterStack.removeLast()
|
||||||
|
vmIterDebug(
|
||||||
|
"cancelIteratorsToDepth fn=${fn.name} reason=$reason targetDepth=$depth depthAfter=${iterStack.size} iterClass=${iter.objClass.className}"
|
||||||
|
)
|
||||||
|
try {
|
||||||
|
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
|
||||||
|
} catch (e: Throwable) {
|
||||||
|
vmIterDebug("cancelIteratorsToDepth: cancelIteration failed fn=${fn.name} reason=$reason", e)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fun pushSlotPlan(plan: Map<String, Int>) {
|
fun pushSlotPlan(plan: Map<String, Int>) {
|
||||||
if (scope.hasSlotPlanConflict(plan)) {
|
if (scope.hasSlotPlanConflict(plan)) {
|
||||||
scopeStack.addLast(scope)
|
scopeStack.addLast(scope)
|
||||||
@@ -4699,7 +4730,12 @@ class CmdFrame(
|
|||||||
positional.add(value)
|
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? {
|
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",
|
"private", "protected", "static", "open", "extern", "init", "get", "set", "by", "step",
|
||||||
// control flow and misc
|
// control flow and misc
|
||||||
"if", "else", "when", "while", "do", "for", "try", "catch", "finally",
|
"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]. */
|
/** Maps lexer token type (and sometimes value) to a [HighlightKind]. */
|
||||||
|
|||||||
@@ -47,6 +47,10 @@ object StdlibDocsBootstrap {
|
|||||||
@Suppress("UNUSED_VARIABLE")
|
@Suppress("UNUSED_VARIABLE")
|
||||||
val _immutableSet = net.sergeych.lyng.obj.ObjImmutableSet.type
|
val _immutableSet = net.sergeych.lyng.obj.ObjImmutableSet.type
|
||||||
@Suppress("UNUSED_VARIABLE")
|
@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
|
val _int = net.sergeych.lyng.obj.ObjInt.type
|
||||||
@Suppress("UNUSED_VARIABLE")
|
@Suppress("UNUSED_VARIABLE")
|
||||||
val _real = net.sergeych.lyng.obj.ObjReal.type
|
val _real = net.sergeych.lyng.obj.ObjReal.type
|
||||||
|
|||||||
@@ -646,6 +646,9 @@ open class Obj {
|
|||||||
}
|
}
|
||||||
|
|
||||||
open suspend fun getAt(scope: Scope, index: Obj): Obj {
|
open suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
|
if (hasNonRootIndexerMember("getAt")) {
|
||||||
|
return invokeInstanceMethod(scope, "getAt", Arguments(index))
|
||||||
|
}
|
||||||
if (index is ObjString) {
|
if (index is ObjString) {
|
||||||
return readField(scope, index.value).value
|
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()))
|
suspend fun getAt(scope: Scope, index: Int): Obj = getAt(scope, ObjInt(index.toLong()))
|
||||||
|
|
||||||
open suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
|
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) {
|
if (index is ObjString) {
|
||||||
writeField(scope, index.value, newValue)
|
writeField(scope, index.value, newValue)
|
||||||
return
|
return
|
||||||
@@ -662,6 +675,17 @@ open class Obj {
|
|||||||
scope.raiseNotImplemented("indexing")
|
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 {
|
open suspend fun callOn(scope: Scope): Obj {
|
||||||
scope.raiseNotImplemented()
|
scope.raiseNotImplemented()
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -1,5 +1,5 @@
|
|||||||
/*
|
/*
|
||||||
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
*
|
*
|
||||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
* you may not use this file except in compliance with the License.
|
* you may not use this file except in compliance with the License.
|
||||||
@@ -24,7 +24,8 @@ import kotlinx.coroutines.channels.ReceiveChannel
|
|||||||
import kotlinx.coroutines.channels.SendChannel
|
import kotlinx.coroutines.channels.SendChannel
|
||||||
import kotlinx.coroutines.sync.Mutex
|
import kotlinx.coroutines.sync.Mutex
|
||||||
import kotlinx.coroutines.sync.withLock
|
import kotlinx.coroutines.sync.withLock
|
||||||
import net.sergeych.lyng.*
|
import net.sergeych.lyng.Scope
|
||||||
|
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
|
||||||
import net.sergeych.lyng.miniast.ParamDoc
|
import net.sergeych.lyng.miniast.ParamDoc
|
||||||
import net.sergeych.lyng.miniast.TypeGenericDoc
|
import net.sergeych.lyng.miniast.TypeGenericDoc
|
||||||
import net.sergeych.lyng.miniast.addFnDoc
|
import net.sergeych.lyng.miniast.addFnDoc
|
||||||
@@ -55,7 +56,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
|
|||||||
else
|
else
|
||||||
// Flow consumer is no longer collecting; signal producer to stop
|
// Flow consumer is no longer collecting; signal producer to stop
|
||||||
throw ScriptFlowIsNoMoreCollected()
|
throw ScriptFlowIsNoMoreCollected()
|
||||||
} catch (x: Exception) {
|
} catch (x: Throwable) {
|
||||||
// Any failure to send (including closed channel) should gracefully stop the producer.
|
// Any failure to send (including closed channel) should gracefully stop the producer.
|
||||||
if (x is CancellationException) {
|
if (x is CancellationException) {
|
||||||
// Cancellation is a normal control-flow event
|
// Cancellation is a normal control-flow event
|
||||||
@@ -80,7 +81,7 @@ private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj
|
|||||||
producer.callOn(builderScope)
|
producer.callOn(builderScope)
|
||||||
} catch (x: ScriptFlowIsNoMoreCollected) {
|
} catch (x: ScriptFlowIsNoMoreCollected) {
|
||||||
// premature flow closing, OK
|
// premature flow closing, OK
|
||||||
} catch (x: Exception) {
|
} catch (x: Throwable) {
|
||||||
channel.close(x)
|
channel.close(x)
|
||||||
return@globalLaunch
|
return@globalLaunch
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -45,18 +45,18 @@ class ObjKotlinIterator(val iterator: Iterator<Any?>) : Obj() {
|
|||||||
}
|
}
|
||||||
boundType = cls
|
boundType = cls
|
||||||
LyngClassBridge.bind(cls) {
|
LyngClassBridge.bind(cls) {
|
||||||
addFun("next") { scope, self, _ ->
|
addFun("next") {
|
||||||
when (self) {
|
when (val self = thisObj) {
|
||||||
is ObjKotlinIterator -> self.iterator.next().toObj()
|
is ObjKotlinIterator -> self.iterator.next().toObj()
|
||||||
is ObjKotlinObjIterator -> self.iterator.next()
|
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, _ ->
|
addFun("hasNext") {
|
||||||
when (self) {
|
when (val self = thisObj) {
|
||||||
is ObjKotlinIterator -> self.iterator.hasNext().toObj()
|
is ObjKotlinIterator -> self.iterator.hasNext().toObj()
|
||||||
is ObjKotlinObjIterator -> 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,8 +29,8 @@ import net.sergeych.lynon.LynonDecoder
|
|||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
|
|
||||||
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
open class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||||
private fun shouldTreatAsSingleElement(scope: Scope, other: Obj): Boolean {
|
protected open fun shouldTreatAsSingleElement(scope: Scope, other: Obj): Boolean {
|
||||||
if (!other.isInstanceOf(ObjIterable)) return true
|
if (!other.isInstanceOf(ObjIterable)) return true
|
||||||
val declaredElementType = scope.declaredListElementTypeForValue(this)
|
val declaredElementType = scope.declaredListElementTypeForValue(this)
|
||||||
if (declaredElementType != null && matchesTypeDecl(scope, other, declaredElementType)) {
|
if (declaredElementType != null && matchesTypeDecl(scope, other, declaredElementType)) {
|
||||||
@@ -95,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
|
list[index.toInt()] = newValue
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -149,7 +149,7 @@ 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) {
|
if (other is ObjList) {
|
||||||
list.addAll(other.list)
|
list.addAll(other.list)
|
||||||
} else if (!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable)) {
|
} else if (!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable)) {
|
||||||
@@ -180,7 +180,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
return ObjList(out)
|
return ObjList(out)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun minusAssign(scope: Scope, other: Obj): Obj {
|
open override suspend fun minusAssign(scope: Scope, other: Obj): Obj {
|
||||||
if (shouldTreatAsSingleElement(scope, other)) {
|
if (shouldTreatAsSingleElement(scope, other)) {
|
||||||
list.remove(other)
|
list.remove(other)
|
||||||
return this
|
return this
|
||||||
@@ -221,7 +221,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
override val objClass: ObjClass
|
open override val objClass: ObjClass
|
||||||
get() = type
|
get() = type
|
||||||
|
|
||||||
override suspend fun toKotlin(scope: Scope): Any {
|
override suspend fun toKotlin(scope: Scope): Any {
|
||||||
|
|||||||
@@ -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 args: List<ParsedArgument>,
|
||||||
internal val tailBlock: Boolean,
|
internal val tailBlock: Boolean,
|
||||||
internal val isOptionalInvoke: Boolean,
|
internal val isOptionalInvoke: Boolean,
|
||||||
|
internal val explicitTypeArgs: List<TypeDecl>? = null,
|
||||||
) : ObjRef {
|
) : ObjRef {
|
||||||
override suspend fun get(scope: Scope): ObjRecord = scope.raiseObjRefEvalDisabled()
|
override suspend fun get(scope: Scope): ObjRecord = scope.raiseObjRefEvalDisabled()
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -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 -> {
|
is TypeDecl.Simple, is TypeDecl.Generic, is TypeDecl.Function, is TypeDecl.Ellipsis -> {
|
||||||
val leftClass = resolveTypeDeclClass(scope, l) ?: return false
|
val leftClass = resolveTypeDeclClass(scope, l) ?: return false
|
||||||
val rightClass = resolveTypeDeclClass(scope, r) ?: 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
|
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 source = analysis.source
|
||||||
val out = ArrayList<LyngSemanticSpan>(128)
|
val out = ArrayList<LyngSemanticSpan>(128)
|
||||||
val covered = HashSet<Pair<Int, Int>>()
|
val covered = HashSet<Pair<Int, Int>>()
|
||||||
|
fun isCurrentSource(pos: Pos): Boolean = pos.source === source
|
||||||
|
|
||||||
fun addRange(start: Int, end: Int, kind: LyngSemanticKind) {
|
fun addRange(start: Int, end: Int, kind: LyngSemanticKind) {
|
||||||
if (start < 0 || end <= start || end > analysis.text.length) return
|
if (start < 0 || end <= start || end > analysis.text.length) return
|
||||||
@@ -187,6 +188,7 @@ object LyngLanguageTools {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun addName(pos: Pos, name: String, kind: LyngSemanticKind) {
|
fun addName(pos: Pos, name: String, kind: LyngSemanticKind) {
|
||||||
|
if (!isCurrentSource(pos)) return
|
||||||
val s = source.offsetOf(pos)
|
val s = source.offsetOf(pos)
|
||||||
addRange(s, s + name.length, kind)
|
addRange(s, s + name.length, kind)
|
||||||
}
|
}
|
||||||
@@ -206,7 +208,9 @@ object LyngLanguageTools {
|
|||||||
addTypeSegments(t.returnType)
|
addTypeSegments(t.returnType)
|
||||||
}
|
}
|
||||||
is MiniTypeVar -> {
|
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 -> {
|
is MiniTypeUnion -> {
|
||||||
t.options.forEach { addTypeSegments(it) }
|
t.options.forEach { addTypeSegments(it) }
|
||||||
@@ -262,7 +266,9 @@ object LyngLanguageTools {
|
|||||||
|
|
||||||
mini.imports.forEach { imp ->
|
mini.imports.forEach { imp ->
|
||||||
imp.segments.forEach { seg ->
|
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)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -164,7 +164,7 @@ class BindingTest {
|
|||||||
val ms = Script.newScope()
|
val ms = Script.newScope()
|
||||||
ms.eval("""
|
ms.eval("""
|
||||||
extern class A {
|
extern class A {
|
||||||
fun get1(): String
|
extern fun get1(): String
|
||||||
}
|
}
|
||||||
|
|
||||||
extern fun getA(): A
|
extern fun getA(): A
|
||||||
@@ -184,4 +184,3 @@ class BindingTest {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
@@ -61,39 +61,39 @@ class BridgeBindingTest {
|
|||||||
init { _ ->
|
init { _ ->
|
||||||
data = CounterState(0)
|
data = CounterState(0)
|
||||||
}
|
}
|
||||||
addFun("add") { _, _, args ->
|
addFun("add") {
|
||||||
val a = (args.list[0] as ObjInt).value
|
val a = (args.list[0] as ObjInt).value
|
||||||
val b = (args.list[1] as ObjInt).value
|
val b = (args.list[1] as ObjInt).value
|
||||||
ObjInt.of(a + b)
|
ObjInt.of(a + b)
|
||||||
}
|
}
|
||||||
addVal("status") { _, _ -> ObjString(classData as String) }
|
addVal("status") { ObjString(classData as String) }
|
||||||
addVar(
|
addVar(
|
||||||
"count",
|
"count",
|
||||||
get = { _, instance ->
|
get = {
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
ObjInt.of(st.count)
|
ObjInt.of(st.count)
|
||||||
},
|
},
|
||||||
set = { _, instance, value ->
|
set = { value ->
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
st.count = (value as ObjInt).value
|
st.count = (value as ObjInt).value
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
addFun("secret") { _, _, _ -> ObjInt.of(42) }
|
addFun("secret") { ObjInt.of(42) }
|
||||||
addFun("ping") { _, _, _ -> ObjInt.of(7) }
|
addFun("ping") { ObjInt.of(7) }
|
||||||
}
|
}
|
||||||
|
|
||||||
LyngClassBridge.bind(className = "Bar", module = "bridge.mod", importManager = im) {
|
LyngClassBridge.bind(className = "Bar", module = "bridge.mod", importManager = im) {
|
||||||
initWithInstance { _, instance ->
|
initWithInstance {
|
||||||
(instance as net.sergeych.lyng.obj.ObjInstance).data = CounterState(10)
|
(thisObj as net.sergeych.lyng.obj.ObjInstance).data = CounterState(10)
|
||||||
}
|
}
|
||||||
addVar(
|
addVar(
|
||||||
"count",
|
"count",
|
||||||
get = { _, instance ->
|
get = {
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
ObjInt.of(st.count)
|
ObjInt.of(st.count)
|
||||||
},
|
},
|
||||||
set = { _, instance, value ->
|
set = { value ->
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
st.count = (value as ObjInt).value
|
st.count = (value as ObjInt).value
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
@@ -156,7 +156,7 @@ class BridgeBindingTest {
|
|||||||
|
|
||||||
val bindFailed = try {
|
val bindFailed = try {
|
||||||
LyngClassBridge.bind(className = "Late", module = "bridge.late", importManager = im) {
|
LyngClassBridge.bind(className = "Late", module = "bridge.late", importManager = im) {
|
||||||
addVal("status") { _, _ -> ObjString("late") }
|
addVal("status") { ObjString("late") }
|
||||||
}
|
}
|
||||||
false
|
false
|
||||||
} catch (_: ScriptError) {
|
} catch (_: ScriptError) {
|
||||||
@@ -183,20 +183,20 @@ class BridgeBindingTest {
|
|||||||
init { _ ->
|
init { _ ->
|
||||||
data = CounterState(5)
|
data = CounterState(5)
|
||||||
}
|
}
|
||||||
addFun("add") { _, _, args ->
|
addFun("add") {
|
||||||
val a = (args.list[0] as ObjInt).value
|
val a = (args.list[0] as ObjInt).value
|
||||||
val b = (args.list[1] as ObjInt).value
|
val b = (args.list[1] as ObjInt).value
|
||||||
ObjInt.of(a + b)
|
ObjInt.of(a + b)
|
||||||
}
|
}
|
||||||
addVal("status") { _, _ -> ObjString(classData as String) }
|
addVal("status") { ObjString(classData as String) }
|
||||||
addVar(
|
addVar(
|
||||||
"count",
|
"count",
|
||||||
get = { _, instance ->
|
get = {
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
ObjInt.of(st.count)
|
ObjInt.of(st.count)
|
||||||
},
|
},
|
||||||
set = { _, instance, value ->
|
set = { value ->
|
||||||
val st = (instance as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
val st = (thisObj as net.sergeych.lyng.obj.ObjInstance).data as CounterState
|
||||||
st.count = (value as ObjInt).value
|
st.count = (value as ObjInt).value
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
@@ -231,7 +231,7 @@ class BridgeBindingTest {
|
|||||||
val ms = Script.newScope()
|
val ms = Script.newScope()
|
||||||
ms.eval("""
|
ms.eval("""
|
||||||
extern class A {
|
extern class A {
|
||||||
val field: Int
|
extern val field: Int
|
||||||
}
|
}
|
||||||
|
|
||||||
fun test(a: A) = a.field
|
fun test(a: A) = a.field
|
||||||
|
|||||||
@@ -249,13 +249,13 @@ class MiniAstTest {
|
|||||||
// Doc2
|
// Doc2
|
||||||
extern class C1 {
|
extern class C1 {
|
||||||
// Doc3
|
// Doc3
|
||||||
fun m1()
|
extern fun m1()
|
||||||
}
|
}
|
||||||
|
|
||||||
// Doc4
|
// Doc4
|
||||||
extern object O1 {
|
extern object O1 {
|
||||||
// Doc5
|
// Doc5
|
||||||
val v1: String
|
extern val v1: String
|
||||||
}
|
}
|
||||||
|
|
||||||
// Doc6
|
// Doc6
|
||||||
|
|||||||
@@ -114,7 +114,7 @@ class ObjectExpressionTest {
|
|||||||
eval("""
|
eval("""
|
||||||
val x = object { }
|
val x = object { }
|
||||||
val name = ((x::class as Class).className as String)
|
val name = ((x::class as Class).className as String)
|
||||||
assert(name.startsWith("${'$'}Anon_"))
|
assert(name.startsWith("\${'$'}Anon_"))
|
||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,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()
|
||||||
|
"""
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -30,8 +30,8 @@ import kotlinx.serialization.json.JsonPrimitive
|
|||||||
import kotlinx.serialization.json.encodeToJsonElement
|
import kotlinx.serialization.json.encodeToJsonElement
|
||||||
import net.sergeych.lyng.*
|
import net.sergeych.lyng.*
|
||||||
import net.sergeych.lyng.obj.*
|
import net.sergeych.lyng.obj.*
|
||||||
import net.sergeych.lyng.thisAs
|
|
||||||
import net.sergeych.lyng.pacman.InlineSourcesImportProvider
|
import net.sergeych.lyng.pacman.InlineSourcesImportProvider
|
||||||
|
import net.sergeych.lyng.thisAs
|
||||||
import net.sergeych.mp_tools.globalDefer
|
import net.sergeych.mp_tools.globalDefer
|
||||||
import net.sergeych.tools.bm
|
import net.sergeych.tools.bm
|
||||||
import kotlin.test.*
|
import kotlin.test.*
|
||||||
@@ -3080,11 +3080,11 @@ class ScriptTest {
|
|||||||
"""
|
"""
|
||||||
extern fun hostFunction(a: Int, b: String): String
|
extern fun hostFunction(a: Int, b: String): String
|
||||||
extern class HostClass(name: String) {
|
extern class HostClass(name: String) {
|
||||||
fun doSomething(): Int
|
extern fun doSomething(): Int
|
||||||
val status: String
|
extern val status: String
|
||||||
}
|
}
|
||||||
extern object HostObject {
|
extern object HostObject {
|
||||||
fun getInstance(): HostClass
|
extern fun getInstance(): HostClass
|
||||||
}
|
}
|
||||||
extern enum HostEnum {
|
extern enum HostEnum {
|
||||||
VALUE1, VALUE2
|
VALUE1, VALUE2
|
||||||
@@ -4194,26 +4194,43 @@ class ScriptTest {
|
|||||||
// }
|
// }
|
||||||
|
|
||||||
|
|
||||||
// @Ignore
|
@Test
|
||||||
// @Test
|
fun interpolationTest() = runTest {
|
||||||
// fun interpolationTest() = runTest {
|
val d = '$'
|
||||||
// eval($$$"""
|
eval(
|
||||||
//
|
"""
|
||||||
// val foo = "bar"
|
val foo = "bar"
|
||||||
// val buzz = ["foo", "bar"]
|
val buzz = ["foo", "bar"]
|
||||||
//
|
|
||||||
// // 1. simple interpolation
|
// 1. simple interpolation
|
||||||
// assertEquals( "bar", "$foo" )
|
assertEquals("bar", "${d}foo")
|
||||||
// assertEquals( "bar", "${foo}" )
|
assertEquals("bar", "${d}{foo}")
|
||||||
//
|
|
||||||
// // 2. escaping the dollar sign
|
// 2. escaping / literal dollar forms
|
||||||
// assertEquals( "$", "\$foo"[0] )
|
assertEquals("${d}${d}foo", "\${d}foo")
|
||||||
// assertEquals( "foo, "\$foo"[1..] )
|
assertEquals("${d}${d}foo", "${d}${d}foo")
|
||||||
//
|
assertEquals("\\bar", "\\${d}foo")
|
||||||
// // 3. interpolation with expression
|
|
||||||
// assertEquals( "foo!. bar?", "${buzz[0]+"!"}. ${buzz[1]+"?"}" )
|
// 3. interpolation with expression
|
||||||
// """.trimIndent())
|
assertEquals("foo!. bar?", "${d}{buzz[0] + "!"}. ${d}{buzz[1] + "?"}")
|
||||||
// }
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun interpolationCanBeDisabledByFeatureComment() = runTest {
|
||||||
|
val d = '$'
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
// feature: interpolation: off
|
||||||
|
val name = "lyng"
|
||||||
|
assertEquals("hello, ${d}name!", "hello, ${d}name!")
|
||||||
|
assertEquals("${d}{name}", "${d}{name}")
|
||||||
|
assertEquals("${d}${d}name", "${d}${d}name")
|
||||||
|
assertEquals("\\${d}name", "\\${d}name")
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testInlineArrayLiteral() = runTest {
|
fun testInlineArrayLiteral() = runTest {
|
||||||
|
|||||||
@@ -172,4 +172,73 @@ class StdlibTest {
|
|||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomSeededDeterministic() = runTest {
|
||||||
|
eval("""
|
||||||
|
val a = Random.seeded(123456)
|
||||||
|
val b = Random.seeded(123456)
|
||||||
|
|
||||||
|
for( i in 1..20 ) {
|
||||||
|
assertEquals(a.nextInt(), b.nextInt())
|
||||||
|
assertEquals(a.nextFloat(), b.nextFloat())
|
||||||
|
assertEquals(a.next(1..100), b.next(1..100))
|
||||||
|
}
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomNextFloatBounds() = runTest {
|
||||||
|
eval("""
|
||||||
|
for( i in 1..400 ) {
|
||||||
|
val x = Random.nextFloat()
|
||||||
|
assert(x >= 0.0)
|
||||||
|
assert(x < 1.0)
|
||||||
|
}
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomNextRangeVariants() = runTest {
|
||||||
|
eval("""
|
||||||
|
val rnd = Random.seeded(77)
|
||||||
|
|
||||||
|
for( i in 1..300 ) {
|
||||||
|
val x = rnd.next(10..<20)
|
||||||
|
assert(x in 10..<20)
|
||||||
|
}
|
||||||
|
|
||||||
|
val allowed = [0, 3, 6, 9]
|
||||||
|
for( i in 1..300 ) {
|
||||||
|
val x = rnd.next(0..9 step 3)
|
||||||
|
assert(x in allowed)
|
||||||
|
}
|
||||||
|
|
||||||
|
for( i in 1..300 ) {
|
||||||
|
val ch = rnd.next('a'..<'f')
|
||||||
|
assert(ch in 'a'..<'f')
|
||||||
|
}
|
||||||
|
|
||||||
|
for( i in 1..300 ) {
|
||||||
|
val rf = rnd.next(1.5..<4.5)
|
||||||
|
assert(rf >= 1.5)
|
||||||
|
assert(rf < 4.5)
|
||||||
|
}
|
||||||
|
|
||||||
|
val qAllowed = [0.0, 0.25, 0.5, 0.75, 1.0]
|
||||||
|
for( i in 1..300 ) {
|
||||||
|
val q = rnd.next(0.0..1.0 step 0.25)
|
||||||
|
assert(q in qAllowed)
|
||||||
|
}
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRandomRejectsOpenRange() = runTest {
|
||||||
|
eval("""
|
||||||
|
assertThrows(IllegalArgumentException) { Random.next(1..) }
|
||||||
|
assertThrows(IllegalArgumentException) { Random.next(..10) }
|
||||||
|
assertThrows(IllegalArgumentException) { Random.next(..) }
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -16,11 +16,11 @@
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
import kotlinx.coroutines.test.runTest
|
import kotlinx.coroutines.test.runTest
|
||||||
import net.sergeych.lyng.Script
|
import net.sergeych.lyng.*
|
||||||
import net.sergeych.lyng.ScriptError
|
import net.sergeych.lyng.obj.Obj
|
||||||
import net.sergeych.lyng.eval
|
import net.sergeych.lyng.obj.ObjClass
|
||||||
|
import net.sergeych.lyng.obj.ObjNull
|
||||||
import kotlin.test.Test
|
import kotlin.test.Test
|
||||||
import kotlin.test.assertEquals
|
|
||||||
import kotlin.test.assertFailsWith
|
import kotlin.test.assertFailsWith
|
||||||
import kotlin.test.assertTrue
|
import kotlin.test.assertTrue
|
||||||
|
|
||||||
@@ -28,33 +28,42 @@ class TypesTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testTypeCollection1() = runTest {
|
fun testTypeCollection1() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class Point(x: Real, y: Real)
|
class Point(x: Real, y: Real)
|
||||||
assert(Point(1,2).x == 1)
|
assert(Point(1,2).x == 1)
|
||||||
assert(Point(1,2).y == 2)
|
assert(Point(1,2).y == 2)
|
||||||
assert(Point(1,2) is Point)
|
assert(Point(1,2) is Point)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testTypeCollection2() = runTest {
|
fun testTypeCollection2() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun fn1(x: Real, y: Real): Real { x + y }
|
fun fn1(x: Real, y: Real): Real { x + y }
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testTypeCollection3() = runTest {
|
fun testTypeCollection3() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class Test(a: Int) {
|
class Test(a: Int) {
|
||||||
fun fn1(x: Real, y: Real): Real { x + y }
|
fun fn1(x: Real, y: Real): Real { x + y }
|
||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testExternDeclarations() = runTest {
|
fun testExternDeclarations() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
extern fun foo1(a: String): Void
|
extern fun foo1(a: String): Void
|
||||||
assertThrows { foo1("1") }
|
assertThrows { foo1("1") }
|
||||||
class Test(a: Int) {
|
class Test(a: Int) {
|
||||||
@@ -70,22 +79,26 @@ class TypesTest {
|
|||||||
}
|
}
|
||||||
// println("4")
|
// println("4")
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testUserClassCompareTo() = runTest {
|
fun testUserClassCompareTo() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class Point(val a,b)
|
class Point(val a,b)
|
||||||
|
|
||||||
assertEquals(Point(0,1), Point(0,1) )
|
assertEquals(Point(0,1), Point(0,1) )
|
||||||
assertNotEquals(Point(0,1), Point(1,1) )
|
assertNotEquals(Point(0,1), Point(1,1) )
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testUserClassCompareTo2() = runTest {
|
fun testUserClassCompareTo2() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class Point(val a,b) {
|
class Point(val a,b) {
|
||||||
var c = 0
|
var c = 0
|
||||||
}
|
}
|
||||||
@@ -99,12 +112,14 @@ class TypesTest {
|
|||||||
assertEquals(p1, p2)
|
assertEquals(p1, p2)
|
||||||
assertNotEquals(Point(0,1), Point(1,1) )
|
assertNotEquals(Point(0,1), Point(1,1) )
|
||||||
assertNotEquals(Point(0,1), p3)
|
assertNotEquals(Point(0,1), p3)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testNumericInference() = runTest {
|
fun testNumericInference() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
val x = 1
|
val x = 1
|
||||||
var y = 2.0
|
var y = 2.0
|
||||||
assert( x is Int )
|
assert( x is Int )
|
||||||
@@ -112,11 +127,14 @@ class TypesTest {
|
|||||||
assert( x + y is Real )
|
assert( x + y is Real )
|
||||||
assert( abs(x+y) is Real )
|
assert( abs(x+y) is Real )
|
||||||
assert( abs(x/y) is Real )
|
assert( abs(x/y) is Real )
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testNumericInferenceBug1() = runTest {
|
fun testNumericInferenceBug1() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun findSumLimit(f) {
|
fun findSumLimit(f) {
|
||||||
var sum = 0.0
|
var sum = 0.0
|
||||||
for( n in 1..100 ) {
|
for( n in 1..100 ) {
|
||||||
@@ -143,12 +161,14 @@ class TypesTest {
|
|||||||
val limit = findSumLimit { n -> 1.0/n/n }
|
val limit = findSumLimit { n -> 1.0/n/n }
|
||||||
assert( limit != null )
|
assert( limit != null )
|
||||||
println("Result: "+limit)
|
println("Result: "+limit)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testNullableHints() = runTest {
|
fun testNullableHints() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
// nullable, without type os Object?
|
// nullable, without type os Object?
|
||||||
class N(x=null)
|
class N(x=null)
|
||||||
assertEquals(null, N().x)
|
assertEquals(null, N().x)
|
||||||
@@ -168,7 +188,8 @@ class TypesTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testIsUnionIntersection() = runTest {
|
fun testIsUnionIntersection() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class A
|
class A
|
||||||
class B
|
class B
|
||||||
class C: A, B
|
class C: A, B
|
||||||
@@ -180,7 +201,8 @@ class TypesTest {
|
|||||||
val v = 1
|
val v = 1
|
||||||
assert( v is Int | String | Real )
|
assert( v is Int | String | Real )
|
||||||
assert( !(v is String | Bool) )
|
assert( !(v is String | Bool) )
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -222,51 +244,64 @@ class TypesTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testListLiteralInferenceForBounds() = runTest {
|
fun testListLiteralInferenceForBounds() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun acceptInts<T: Int>(xs: List<T>) { }
|
fun acceptInts<T: Int>(xs: List<T>) { }
|
||||||
acceptInts([1, 2, 3])
|
acceptInts([1, 2, 3])
|
||||||
val base = [1, 2]
|
val base = [1, 2]
|
||||||
acceptInts([...base, 3])
|
acceptInts([...base, 3])
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
eval("""
|
)
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
fun acceptReals<T: Real>(xs: List<T>) { }
|
fun acceptReals<T: Real>(xs: List<T>) { }
|
||||||
acceptReals([1.0, 2.0, 3.0])
|
acceptReals([1.0, 2.0, 3.0])
|
||||||
val base = [1.0, 2.0]
|
val base = [1.0, 2.0]
|
||||||
acceptReals([...base, 3.0])
|
acceptReals([...base, 3.0])
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun acceptInts<T: Int>(xs: List<T>) { }
|
fun acceptInts<T: Int>(xs: List<T>) { }
|
||||||
acceptInts([1, "a"])
|
acceptInts([1, "a"])
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun acceptReals<T: Real>(xs: List<T>) { }
|
fun acceptReals<T: Real>(xs: List<T>) { }
|
||||||
acceptReals([1.0, "a"])
|
acceptReals([1.0, "a"])
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testMapLiteralInferenceForBounds() = runTest {
|
fun testMapLiteralInferenceForBounds() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun acceptMap<T: Int>(m: Map<String, T>) { }
|
fun acceptMap<T: Int>(m: Map<String, T>) { }
|
||||||
acceptMap({ "a": 1, "b": 2 })
|
acceptMap({ "a": 1, "b": 2 })
|
||||||
val base = { "a": 1 }
|
val base = { "a": 1 }
|
||||||
acceptMap({ ...base, "b": 3 })
|
acceptMap({ ...base, "b": 3 })
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
assertFailsWith<net.sergeych.lyng.ScriptError> {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
fun acceptMap<T: Int>(m: Map<String, T>) { }
|
fun acceptMap<T: Int>(m: Map<String, T>) { }
|
||||||
acceptMap({ "a": 1, "b": "x" })
|
acceptMap({ "a": 1, "b": "x" })
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testUnionTypeLists() = runTest {
|
fun testUnionTypeLists() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
fun fMixed<T>(list: List<T>) {
|
fun fMixed<T>(list: List<T>) {
|
||||||
println(list)
|
println(list)
|
||||||
@@ -283,12 +318,14 @@ class TypesTest {
|
|||||||
}
|
}
|
||||||
fMixed([1, "two", true])
|
fMixed([1, "two", true])
|
||||||
fInts([1,2,3])
|
fInts([1,2,3])
|
||||||
""")
|
"""
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testTypeAliases() = runTest {
|
fun testTypeAliases() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
type Num = Int | Real
|
type Num = Int | Real
|
||||||
type AB = A & B
|
type AB = A & B
|
||||||
class A
|
class A
|
||||||
@@ -309,12 +346,14 @@ class TypesTest {
|
|||||||
type IntList<T: Int> = List<T>
|
type IntList<T: Int> = List<T>
|
||||||
fun accept<T: Int>(xs: IntList<T>) { }
|
fun accept<T: Int>(xs: IntList<T>) { }
|
||||||
accept([1,2,3])
|
accept([1,2,3])
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testMultipleReceivers() = runTest {
|
fun testMultipleReceivers() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
class R1(shared,r1="r1")
|
class R1(shared,r1="r1")
|
||||||
class R2(shared,r2="r2")
|
class R2(shared,r2="r2")
|
||||||
|
|
||||||
@@ -341,69 +380,85 @@ class TypesTest {
|
|||||||
assertEquals("r1", r1)
|
assertEquals("r1", r1)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
""")
|
"""
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testLambdaTypes1() = runTest {
|
fun testLambdaTypes1() = runTest {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
// declare: ok
|
// declare: ok
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
var l1: (Int,String)->String
|
var l1: (Int,String)->String
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
// this should be Lyng compile time exception
|
// this should be Lyng compile time exception
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
fun test() {
|
fun test() {
|
||||||
// compiler should detect that l1 us called with arguments that does not match
|
// compiler should detect that l1 us called with arguments that does not match
|
||||||
// declare type (Int,String)->String:
|
// declare type (Int,String)->String:
|
||||||
l1()
|
l1()
|
||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testLambdaTypesEllipsis() = runTest {
|
fun testLambdaTypesEllipsis() = runTest {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
var l2: (Int,Object...,String)->Real
|
var l2: (Int,Object...,String)->Real
|
||||||
var l4: (Int,String...,String)->Real
|
var l4: (Int,String...,String)->Real
|
||||||
var l3: (...)->Int
|
var l3: (...)->Int
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
fun testTooFew() {
|
fun testTooFew() {
|
||||||
l2(1)
|
l2(1)
|
||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
fun testWrongHead() {
|
fun testWrongHead() {
|
||||||
l2("x", "y")
|
l2("x", "y")
|
||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
fun testWrongEllipsis() {
|
fun testWrongEllipsis() {
|
||||||
l4(1, 2, "x")
|
l4(1, 2, "x")
|
||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
fun testOk1() { l2(1, "x") }
|
fun testOk1() { l2(1, "x") }
|
||||||
fun testOk2() { l2(1, 2, 3, "x") }
|
fun testOk2() { l2(1, 2, 3, "x") }
|
||||||
fun testOk3() { l3() }
|
fun testOk3() { l3() }
|
||||||
fun testOk4() { l3(1, true, "x") }
|
fun testOk4() { l3(1, true, "x") }
|
||||||
fun testOk5() { l4(1, "a", "b", "x") }
|
fun testOk5() { l4(1, "a", "b", "x") }
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testSetTyped() = runTest {
|
fun testSetTyped() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
var s = Set<String>()
|
var s = Set<String>()
|
||||||
val typed: Set<String> = s
|
val typed: Set<String> = s
|
||||||
assertEquals(Set(), typed)
|
assertEquals(Set(), typed)
|
||||||
@@ -414,12 +469,14 @@ class TypesTest {
|
|||||||
assertEquals(Set(), s)
|
assertEquals(Set(), s)
|
||||||
s += ["foo", "bar"]
|
s += ["foo", "bar"]
|
||||||
assertEquals(Set("foo", "bar"), s)
|
assertEquals(Set("foo", "bar"), s)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testListTyped() = runTest {
|
fun testListTyped() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
var l = List<String>()
|
var l = List<String>()
|
||||||
val typed: List<String> = l
|
val typed: List<String> = l
|
||||||
assertEquals(List(), typed)
|
assertEquals(List(), typed)
|
||||||
@@ -431,13 +488,15 @@ class TypesTest {
|
|||||||
|
|
||||||
l += ["foo", "bar"]
|
l += ["foo", "bar"]
|
||||||
assertEquals(List("foo", "bar"), l)
|
assertEquals(List("foo", "bar"), l)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testAliasesInGenerics1() = runTest {
|
fun testAliasesInGenerics1() = runTest {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
type IntList<T: Int> = List<T>
|
type IntList<T: Int> = List<T>
|
||||||
type IntMap<K,V> = Map<K,V>
|
type IntMap<K,V> = Map<K,V>
|
||||||
type IntSet<T: Int> = Set<T>
|
type IntSet<T: Int> = Set<T>
|
||||||
@@ -460,13 +519,16 @@ class TypesTest {
|
|||||||
assertEquals(Set("tag1", "tag2", Buffer("tag3")), x.tags)
|
assertEquals(Set("tag1", "tag2", Buffer("tag3")), x.tags)
|
||||||
x.tags += Buffer("tag4")
|
x.tags += Buffer("tag4")
|
||||||
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4")), x.tags)
|
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4")), x.tags)
|
||||||
""")
|
"""
|
||||||
scope.eval("""
|
)
|
||||||
|
scope.eval(
|
||||||
|
"""
|
||||||
assert(x is X)
|
assert(x is X)
|
||||||
x.tags += "42"
|
x.tags += "42"
|
||||||
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4"), "42"), x.tags)
|
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4"), "42"), x.tags)
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
// now this must fail becaise element type does not match the declared:
|
// now this must fail becaise element type does not match the declared:
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval(
|
scope.eval(
|
||||||
@@ -480,7 +542,8 @@ class TypesTest {
|
|||||||
@Test
|
@Test
|
||||||
fun testAliasesInGenericsList1() = runTest {
|
fun testAliasesInGenericsList1() = runTest {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
scope.eval("""
|
scope.eval(
|
||||||
|
"""
|
||||||
import lyng.buffer
|
import lyng.buffer
|
||||||
type Tag = String | Buffer
|
type Tag = String | Buffer
|
||||||
|
|
||||||
@@ -496,12 +559,15 @@ class TypesTest {
|
|||||||
assertEquals(List("tag1", "tag2", Buffer("tag3")), x.tags)
|
assertEquals(List("tag1", "tag2", Buffer("tag3")), x.tags)
|
||||||
x.tags += ["tag4", Buffer("tag5")]
|
x.tags += ["tag4", Buffer("tag5")]
|
||||||
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5")), x.tags)
|
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5")), x.tags)
|
||||||
""")
|
"""
|
||||||
scope.eval("""
|
)
|
||||||
|
scope.eval(
|
||||||
|
"""
|
||||||
assert(x is X)
|
assert(x is X)
|
||||||
x.tags += "42"
|
x.tags += "42"
|
||||||
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5"), "42"), x.tags)
|
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5"), "42"), x.tags)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
assertFailsWith<ScriptError> {
|
assertFailsWith<ScriptError> {
|
||||||
scope.eval(
|
scope.eval(
|
||||||
"""
|
"""
|
||||||
@@ -510,4 +576,212 @@ class TypesTest {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testClassName() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
class X {
|
||||||
|
var x = 1
|
||||||
|
}
|
||||||
|
assert( X::class is Class)
|
||||||
|
assertEquals("Class", X::class.name)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testGenericTypes() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun t<T>(): String =
|
||||||
|
when(T) {
|
||||||
|
null -> "%s is Null"(T::class.name)
|
||||||
|
is Object -> "%s is Object"(T::class.name)
|
||||||
|
else -> throw "It should not happen"
|
||||||
|
}
|
||||||
|
assert( Int is Object)
|
||||||
|
assertEquals( t<Int>(), "Class is Object")
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testGenericNullableTypePredicate() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun isTypeNullable<T>(x: T): Bool = T is nullable
|
||||||
|
type MaybeInt = Int?
|
||||||
|
assert(isTypeNullable<Int?>(null))
|
||||||
|
assert(!isTypeNullable<Int>(1))
|
||||||
|
assert(MaybeInt is nullable)
|
||||||
|
assert(!(Int is nullable))
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testWhenNullableTypeCase() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun describe<T>(x: T): String = when(T) {
|
||||||
|
nullable -> "nullable"
|
||||||
|
else -> "non-null"
|
||||||
|
}
|
||||||
|
fun describeIs<T>(x: T): String = when(T) {
|
||||||
|
is nullable -> "nullable"
|
||||||
|
else -> "non-null"
|
||||||
|
}
|
||||||
|
assertEquals("nullable", describe<Int?>(null))
|
||||||
|
assertEquals("non-null", describe<Int>(1))
|
||||||
|
assertEquals("nullable", describeIs<Int?>(null))
|
||||||
|
assertEquals("non-null", describeIs<Int>(1))
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testIndexer() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
class Greeter {
|
||||||
|
override fun getAt(name) = "Hello, %s!"(name)
|
||||||
|
}
|
||||||
|
assertEquals("Hello, Bob!",Greeter()["Bob"])
|
||||||
|
val g = Greeter()
|
||||||
|
assertEquals("Hello, Bob!",g["Bob"])
|
||||||
|
|
||||||
|
// it should work with objects too:
|
||||||
|
object Polite {
|
||||||
|
override fun getAt(name) = "How do you do, %s?"(name)
|
||||||
|
}
|
||||||
|
|
||||||
|
assertEquals("How do you do, Bob?",Polite["Bob"])
|
||||||
|
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testIndexer2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
class Foo(bar)
|
||||||
|
|
||||||
|
class Greeter {
|
||||||
|
override fun getAt(name): Foo = Foo("Hello, %s!"(name))
|
||||||
|
}
|
||||||
|
assertEquals("Hello, Bob!",Greeter()["Bob"].bar)
|
||||||
|
val g = Greeter()
|
||||||
|
assertEquals("Hello, Bob!",g["Bob"].bar)
|
||||||
|
|
||||||
|
// it should work with objects too:
|
||||||
|
object Polite {
|
||||||
|
override fun getAt(name): Foo? = Foo("How do you do, %s?"(name))
|
||||||
|
}
|
||||||
|
|
||||||
|
assertEquals("How do you do, Bob?",Polite["Bob"].bar)
|
||||||
|
assertEquals("How do you do, Bob?",Polite["Bob"]?.bar)
|
||||||
|
assertEquals("How do you do, Bob?",Polite["Bob"]!!.bar)
|
||||||
|
|
||||||
|
class Greeter2 {
|
||||||
|
override fun getAt(name): Foo? = Foo("How do you do, %s?"(name))
|
||||||
|
}
|
||||||
|
val g2 = Greeter2()
|
||||||
|
assertEquals("How do you do, Bob?",g2["Bob"]?.bar)
|
||||||
|
val g2v: Foo = g2["Bob"]!!
|
||||||
|
assertEquals("How do you do, Bob?",g2v.bar)
|
||||||
|
assertEquals("How do you do, Bob?",Greeter2()["Bob"].bar)
|
||||||
|
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExternGenerics() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
extern fun f<T>(x: T): T
|
||||||
|
extern class Cell<T> {
|
||||||
|
var value: T
|
||||||
|
}
|
||||||
|
"""
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
class ObjFoo : Obj() {
|
||||||
|
|
||||||
|
override val objClass = klass
|
||||||
|
|
||||||
|
var value: Obj = ObjNull
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val klass = object : ObjClass("ObjFoo") {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
return ObjFoo()
|
||||||
|
}
|
||||||
|
}.apply {
|
||||||
|
addProperty("bar", {
|
||||||
|
check(thisObj is ObjFoo)
|
||||||
|
thisAs<ObjFoo>().value
|
||||||
|
}, {
|
||||||
|
thisAs<ObjFoo>().value = args.firstAndOnly()
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExtensionToExternClasses() = runTest {
|
||||||
|
val scope = Script.newScope()
|
||||||
|
scope.addConst("Foo", ObjFoo.klass)
|
||||||
|
scope.eval(
|
||||||
|
"""
|
||||||
|
extern class Foo {
|
||||||
|
var bar
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Foo.foobar() = "foo" + bar
|
||||||
|
|
||||||
|
val f = Foo()
|
||||||
|
f.bar = 42
|
||||||
|
assert( f is Foo )
|
||||||
|
assertEquals(42, f.bar)
|
||||||
|
|
||||||
|
assertEquals("foo42", f.foobar())
|
||||||
|
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExternClassMemberInitializerStillFailsWithoutExplicitExtern() = runTest {
|
||||||
|
val e = assertFailsWith<ScriptError> {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
extern class Cell<T> {
|
||||||
|
var value: T = 1
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
assertTrue(e.message?.contains("extern variable value cannot have an initializer or delegate") == true)
|
||||||
|
}
|
||||||
|
|
||||||
|
// @Test fun nonTrivialOperatorsTest() = runTest {
|
||||||
|
// val s = Script.newScope()
|
||||||
|
// s.eval("""
|
||||||
|
// class Matrix<T>(val rows: Int, val cols: Int,initialValue:T?) {
|
||||||
|
// val data
|
||||||
|
// init {
|
||||||
|
// val v = initalValue?
|
||||||
|
// }
|
||||||
|
// data = List(rows*cols) { initialValue } }
|
||||||
|
// fun getAt(row: Int, col: Int) = data[row*cols+col]
|
||||||
|
// fun setAt(row: Int, col: Int, value: T) { data[row*cols+col] = value }
|
||||||
|
// }
|
||||||
|
// val m = Matrix(1,1)
|
||||||
|
//
|
||||||
|
// """.trimIndent())
|
||||||
|
// }
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,60 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
import kotlinx.coroutines.test.runTest
|
||||||
|
import net.sergeych.lyng.*
|
||||||
|
import net.sergeych.lyng.obj.ObjChar
|
||||||
|
import net.sergeych.lyng.obj.ObjString
|
||||||
|
import kotlin.test.Test
|
||||||
|
import kotlin.test.assertEquals
|
||||||
|
import kotlin.test.assertFailsWith
|
||||||
|
|
||||||
|
class UnicodeEscapeTest {
|
||||||
|
@Test
|
||||||
|
fun parserDecodesUnicodeEscapeInStringLiteral() {
|
||||||
|
val token = parseLyng("\"\\u263A\"".toSource()).first()
|
||||||
|
assertEquals(Token.Type.STRING, token.type)
|
||||||
|
assertEquals("☺", token.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun parserDecodesUnicodeEscapeInCharLiteral() {
|
||||||
|
val token = parseLyng("'\\u263A'".toSource()).first()
|
||||||
|
assertEquals(Token.Type.CHAR, token.type)
|
||||||
|
assertEquals("☺", token.value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun parserRejectsMalformedUnicodeEscapeInStringLiteral() {
|
||||||
|
assertFailsWith<ScriptError> {
|
||||||
|
parseLyng("\"\\u12G4\"".toSource())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun parserRejectsShortUnicodeEscapeInCharLiteral() {
|
||||||
|
assertFailsWith<ScriptError> {
|
||||||
|
parseLyng("'\\u12'".toSource())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun evalDecodesUnicodeEscapes() = runTest {
|
||||||
|
assertEquals(ObjString("☺"), eval("\"\\u263A\""))
|
||||||
|
assertEquals(ObjChar('☺'), eval("'\\u263A'"))
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -201,6 +201,28 @@ class WebsiteSamplesTest {
|
|||||||
assertEquals(12L, (result as ObjInt).value)
|
assertEquals(12L, (result as ObjInt).value)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testNullableTypePredicate() = runTest {
|
||||||
|
val scope = Script.newScope()
|
||||||
|
val result = scope.eval(
|
||||||
|
"""
|
||||||
|
// Type nullability checks
|
||||||
|
fun describe<T>(x: T): String = when(T) {
|
||||||
|
nullable -> "nullable"
|
||||||
|
else -> "non-null"
|
||||||
|
}
|
||||||
|
type MaybeInt = Int?
|
||||||
|
[describe<Int?>(null), describe<Int>(1), Int is nullable, MaybeInt is nullable]
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
assertTrue(result is ObjList)
|
||||||
|
val list = result.list
|
||||||
|
assertEquals("nullable", (list[0] as ObjString).value)
|
||||||
|
assertEquals("non-null", (list[1] as ObjString).value)
|
||||||
|
assertEquals(false, (list[2] as ObjBool).value)
|
||||||
|
assertEquals(true, (list[3] as ObjBool).value)
|
||||||
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testEasyOperatorOverloading() = runTest {
|
fun testEasyOperatorOverloading() = runTest {
|
||||||
val scope = Script.newScope()
|
val scope = Script.newScope()
|
||||||
|
|||||||
@@ -18,8 +18,9 @@
|
|||||||
package net.sergeych.lyng.tools
|
package net.sergeych.lyng.tools
|
||||||
|
|
||||||
import kotlinx.coroutines.test.runTest
|
import kotlinx.coroutines.test.runTest
|
||||||
import net.sergeych.lyng.miniast.MiniClassDecl
|
import net.sergeych.lyng.Pos
|
||||||
import net.sergeych.lyng.miniast.MiniMemberTypeAliasDecl
|
import net.sergeych.lyng.Source
|
||||||
|
import net.sergeych.lyng.miniast.*
|
||||||
import net.sergeych.lyng.stdlib_included.rootLyng
|
import net.sergeych.lyng.stdlib_included.rootLyng
|
||||||
import kotlin.test.Test
|
import kotlin.test.Test
|
||||||
import kotlin.test.assertEquals
|
import kotlin.test.assertEquals
|
||||||
@@ -127,4 +128,48 @@ class LyngLanguageToolsTest {
|
|||||||
val dis = LyngLanguageTools.disassembleSymbol(code, "add")
|
val dis = LyngLanguageTools.disassembleSymbol(code, "add")
|
||||||
assertTrue(!dis.contains("not a compiled body"), "Disassembly should be produced, got: $dis")
|
assertTrue(!dis.contains("not a compiled body"), "Disassembly should be produced, got: $dis")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun languageTools_semanticHighlights_ignore_foreign_sources() {
|
||||||
|
val localSource = Source("local.lyng", "val x = 1")
|
||||||
|
val foreignSource = Source("defs.lyng.d", "val y = 2")
|
||||||
|
val localStart = Pos(localSource, 0, 0)
|
||||||
|
val foreignStart = Pos(foreignSource, 0, 0)
|
||||||
|
|
||||||
|
val mini = MiniScript(
|
||||||
|
range = MiniRange(localStart, localStart),
|
||||||
|
declarations = mutableListOf(
|
||||||
|
MiniValDecl(
|
||||||
|
range = MiniRange(foreignStart, foreignStart),
|
||||||
|
name = "y",
|
||||||
|
mutable = false,
|
||||||
|
type = null,
|
||||||
|
initRange = null,
|
||||||
|
doc = null,
|
||||||
|
nameStart = foreignStart
|
||||||
|
)
|
||||||
|
),
|
||||||
|
imports = mutableListOf(
|
||||||
|
MiniImport(
|
||||||
|
range = MiniRange(foreignStart, foreignStart),
|
||||||
|
segments = listOf(
|
||||||
|
MiniImport.Segment("defs", MiniRange(foreignStart, foreignStart))
|
||||||
|
)
|
||||||
|
)
|
||||||
|
)
|
||||||
|
)
|
||||||
|
val analysis = LyngAnalysisResult(
|
||||||
|
source = localSource,
|
||||||
|
text = localSource.text,
|
||||||
|
mini = mini,
|
||||||
|
binding = null,
|
||||||
|
resolution = null,
|
||||||
|
importedModules = emptyList(),
|
||||||
|
diagnostics = emptyList(),
|
||||||
|
lexicalHighlights = emptyList()
|
||||||
|
)
|
||||||
|
|
||||||
|
val spans = LyngLanguageTools.semanticHighlights(analysis)
|
||||||
|
assertTrue(spans.isEmpty(), "Semantic spans should ignore positions from foreign sources, got $spans")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,22 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.bytecode
|
||||||
|
|
||||||
|
internal actual fun vmIterDebug(message: String, error: Throwable?) {
|
||||||
|
// no-op on JS
|
||||||
|
}
|
||||||
@@ -0,0 +1,46 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.bytecode
|
||||||
|
|
||||||
|
import java.io.File
|
||||||
|
import java.time.Instant
|
||||||
|
|
||||||
|
private val vmIterLogFilePath: String =
|
||||||
|
System.getenv("LYNG_VM_DEBUG_LOG")
|
||||||
|
?.takeIf { it.isNotBlank() }
|
||||||
|
?: "/tmp/lyng_vm_iter_debug.log"
|
||||||
|
|
||||||
|
private val vmIterLogLock = Any()
|
||||||
|
|
||||||
|
internal actual fun vmIterDebug(message: String, error: Throwable?) {
|
||||||
|
runCatching {
|
||||||
|
val line = buildString {
|
||||||
|
append(Instant.now().toString())
|
||||||
|
append(" [vm-iter] ")
|
||||||
|
append(message)
|
||||||
|
append('\n')
|
||||||
|
if (error != null) {
|
||||||
|
append(error.stackTraceToString())
|
||||||
|
append('\n')
|
||||||
|
}
|
||||||
|
}
|
||||||
|
synchronized(vmIterLogLock) {
|
||||||
|
File(vmIterLogFilePath).appendText(line)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -209,7 +209,7 @@ class CompletionEngineLightTest {
|
|||||||
fun inferredTypeFromMemberCall() = runBlocking {
|
fun inferredTypeFromMemberCall() = runBlocking {
|
||||||
val code = """
|
val code = """
|
||||||
extern class MyClass {
|
extern class MyClass {
|
||||||
fun getList(): List<String>
|
extern fun getList(): List<String>
|
||||||
}
|
}
|
||||||
extern val c: MyClass
|
extern val c: MyClass
|
||||||
val x = c.getList()
|
val x = c.getList()
|
||||||
|
|||||||
@@ -0,0 +1,22 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.bytecode
|
||||||
|
|
||||||
|
internal actual fun vmIterDebug(message: String, error: Throwable?) {
|
||||||
|
// no-op on Native
|
||||||
|
}
|
||||||
@@ -0,0 +1,22 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.bytecode
|
||||||
|
|
||||||
|
internal actual fun vmIterDebug(message: String, error: Throwable?) {
|
||||||
|
// no-op on wasmJs
|
||||||
|
}
|
||||||
@@ -1,6 +1,6 @@
|
|||||||
package lyng.stdlib
|
package lyng.stdlib
|
||||||
|
|
||||||
extern fun flow(builder: FlowBuilder.()->Void): Flow
|
extern fun flow(builder: FlowBuilder.()->void): Flow
|
||||||
|
|
||||||
/* Built-in exception type. */
|
/* Built-in exception type. */
|
||||||
extern class Exception
|
extern class Exception
|
||||||
@@ -9,7 +9,7 @@ extern class NotImplementedException
|
|||||||
extern class Delegate
|
extern class Delegate
|
||||||
extern class Iterable<T> {
|
extern class Iterable<T> {
|
||||||
fun iterator(): Iterator<T>
|
fun iterator(): Iterator<T>
|
||||||
fun forEach(action: (T)->Void): Void
|
fun forEach(action: (T)->void): void
|
||||||
fun map<R>(transform: (T)->R): List<R>
|
fun map<R>(transform: (T)->R): List<R>
|
||||||
fun toList(): List<T>
|
fun toList(): List<T>
|
||||||
fun toImmutableList(): ImmutableList<T>
|
fun toImmutableList(): ImmutableList<T>
|
||||||
@@ -22,7 +22,7 @@ extern class Iterable<T> {
|
|||||||
extern class Iterator<T> {
|
extern class Iterator<T> {
|
||||||
fun hasNext(): Bool
|
fun hasNext(): Bool
|
||||||
fun next(): T
|
fun next(): T
|
||||||
fun cancelIteration(): Void
|
fun cancelIteration(): void
|
||||||
fun toList(): List<T>
|
fun toList(): List<T>
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -44,14 +44,14 @@ extern class ImmutableList<T> : Array<T> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
extern class List<T> : Array<T> {
|
extern class List<T> : Array<T> {
|
||||||
fun add(value: T, more...): Void
|
fun add(value: T, more...): void
|
||||||
fun toImmutable(): ImmutableList<T>
|
fun toImmutable(): ImmutableList<T>
|
||||||
}
|
}
|
||||||
|
|
||||||
extern class RingBuffer<T> : Iterable<T> {
|
extern class RingBuffer<T> : Iterable<T> {
|
||||||
val size: Int
|
val size: Int
|
||||||
fun first(): T
|
fun first(): T
|
||||||
fun add(value: T): Void
|
fun add(value: T): void
|
||||||
}
|
}
|
||||||
|
|
||||||
extern class Set<T> : Collection<T> {
|
extern class Set<T> : Collection<T> {
|
||||||
@@ -81,6 +81,20 @@ extern fun abs(x: Object): Real
|
|||||||
extern fun ln(x: Object): Real
|
extern fun ln(x: Object): Real
|
||||||
extern fun pow(x: Object, y: Object): Real
|
extern fun pow(x: Object, y: Object): Real
|
||||||
extern fun sqrt(x: Object): Real
|
extern fun sqrt(x: Object): Real
|
||||||
|
extern fun clamp<T>(value: T, range: Range<T>): T
|
||||||
|
|
||||||
|
class SeededRandom {
|
||||||
|
extern fun nextInt(): Int
|
||||||
|
extern fun nextFloat(): Real
|
||||||
|
extern fun next<T>(range: Range): T
|
||||||
|
}
|
||||||
|
|
||||||
|
extern object Random {
|
||||||
|
extern fun nextInt(): Int
|
||||||
|
extern fun nextFloat(): Real
|
||||||
|
extern fun next<T>(range: Range): T
|
||||||
|
extern fun seeded(seed: Int): SeededRandom
|
||||||
|
}
|
||||||
|
|
||||||
// Last regex match result, updated by =~ / !~.
|
// Last regex match result, updated by =~ / !~.
|
||||||
var $~: Object? = null
|
var $~: Object? = null
|
||||||
@@ -337,17 +351,17 @@ override fun List<T>.toString() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/* Sort list in-place by key selector. */
|
/* Sort list in-place by key selector. */
|
||||||
fun List<T>.sortBy<R>(predicate: (T)->R): Void {
|
fun List<T>.sortBy<R>(predicate: (T)->R): void {
|
||||||
sortWith { a, b -> predicate(a) <=> predicate(b) }
|
sortWith { a, b -> predicate(a) <=> predicate(b) }
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Sort list in-place by natural order. */
|
/* Sort list in-place by natural order. */
|
||||||
fun List<T>.sort(): Void {
|
fun List<T>.sort(): void {
|
||||||
sortWith { a, b -> a <=> b }
|
sortWith { a, b -> a <=> b }
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Print this exception and its stack trace to standard output. */
|
/* Print this exception and its stack trace to standard output. */
|
||||||
fun Exception.printStackTrace(): Void {
|
fun Exception.printStackTrace(): void {
|
||||||
println(this)
|
println(this)
|
||||||
for( entry in stackTrace ) {
|
for( entry in stackTrace ) {
|
||||||
println("\tat "+entry.toString())
|
println("\tat "+entry.toString())
|
||||||
@@ -357,7 +371,7 @@ fun Exception.printStackTrace(): Void {
|
|||||||
/* Compile this string into a regular expression. */
|
/* Compile this string into a regular expression. */
|
||||||
val String.re: Regex get() = Regex(this)
|
val String.re: Regex get() = Regex(this)
|
||||||
|
|
||||||
fun TODO(message: Object?=null): Void {
|
fun TODO(message: Object?=null): void {
|
||||||
throw "not implemented"
|
throw "not implemented"
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -376,12 +390,12 @@ enum DelegateAccess {
|
|||||||
Implementing this interface is optional as Lyng uses dynamic dispatch,
|
Implementing this interface is optional as Lyng uses dynamic dispatch,
|
||||||
but it is recommended for documentation and clarity.
|
but it is recommended for documentation and clarity.
|
||||||
*/
|
*/
|
||||||
interface Delegate<T,ThisRefType=Void> {
|
interface Delegate<T,ThisRefType=void> {
|
||||||
/* Called when a delegated 'val' or 'var' is read. */
|
/* Called when a delegated 'val' or 'var' is read. */
|
||||||
fun getValue(thisRef: ThisRefType, name: String): T = TODO("delegate getter is not implemented")
|
fun getValue(thisRef: ThisRefType, name: String): T = TODO("delegate getter is not implemented")
|
||||||
|
|
||||||
/* Called when a delegated 'var' is written. */
|
/* Called when a delegated 'var' is written. */
|
||||||
fun setValue(thisRef: ThisRefType, name: String, newValue: T): Void = TODO("delegate setter is not implemented")
|
fun setValue(thisRef: ThisRefType, name: String, newValue: T): void = TODO("delegate setter is not implemented")
|
||||||
|
|
||||||
/* Called when a delegated function is invoked. */
|
/* Called when a delegated function is invoked. */
|
||||||
fun invoke(thisRef: ThisRefType, name: String, args...): Object = TODO("delegate invoke is not implemented")
|
fun invoke(thisRef: ThisRefType, name: String, args...): Object = TODO("delegate invoke is not implemented")
|
||||||
|
|||||||
+3
-2
@@ -12,9 +12,10 @@ Current focus
|
|||||||
|
|
||||||
Key recent changes
|
Key recent changes
|
||||||
- Updated AI helper docs to reflect static typing, type expressions, and compile-time-only name resolution.
|
- Updated AI helper docs to reflect static typing, type expressions, and compile-time-only name resolution.
|
||||||
|
- Added stdlib random API: `Random` and deterministic `SeededRandom` with `nextInt`, `nextFloat`, and generic `next(range)`.
|
||||||
|
|
||||||
Known failing tests
|
Known failing tests
|
||||||
- Not checked in this session.
|
- None in :lynglib:jvmTest after Random/SeededRandom integration.
|
||||||
|
|
||||||
Last test run
|
Last test run
|
||||||
- Not checked in this session.
|
- `./gradlew :lynglib:jvmTest` (PASS).
|
||||||
@@ -146,10 +146,22 @@ interface ClassBridgeBinder {
|
|||||||
var classData: Any?
|
var classData: Any?
|
||||||
|
|
||||||
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
|
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
|
||||||
|
fun initWithInstance(block: suspend ScopeFacade.() -> Unit)
|
||||||
|
@Deprecated("Use receiver-form initWithInstance and read thisObj from ScopeFacade")
|
||||||
fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit)
|
fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit)
|
||||||
|
|
||||||
|
fun addFun(name: String, impl: suspend ScopeFacade.() -> Obj)
|
||||||
|
@Deprecated("Use receiver-form addFun and read thisObj/args from ScopeFacade")
|
||||||
fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj)
|
fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj)
|
||||||
|
fun addVal(name: String, impl: suspend ScopeFacade.() -> Obj)
|
||||||
|
@Deprecated("Use receiver-form addVal and read thisObj from ScopeFacade")
|
||||||
fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj)
|
fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj)
|
||||||
|
fun addVar(
|
||||||
|
name: String,
|
||||||
|
get: suspend ScopeFacade.() -> Obj,
|
||||||
|
set: suspend ScopeFacade.(Obj) -> Unit
|
||||||
|
)
|
||||||
|
@Deprecated("Use receiver-form addVar and read thisObj from ScopeFacade")
|
||||||
fun addVar(
|
fun addVar(
|
||||||
name: String,
|
name: String,
|
||||||
get: suspend (ScopeFacade, Obj) -> Obj,
|
get: suspend (ScopeFacade, Obj) -> Obj,
|
||||||
|
|||||||
@@ -4,7 +4,7 @@ This note describes the Lyng-first workflow where a class is declared in Lyng an
|
|||||||
|
|
||||||
## Overview
|
## Overview
|
||||||
|
|
||||||
- Lyng code declares a class and marks members as `extern`.
|
- Lyng code declares a class and marks members as `extern` (or puts them inside `extern class`/`extern object`, where member `extern` is implicit).
|
||||||
- Kotlin binds implementations with `LyngClassBridge.bind(...)`.
|
- Kotlin binds implementations with `LyngClassBridge.bind(...)`.
|
||||||
- Binding must happen **before the first instance is created**.
|
- Binding must happen **before the first instance is created**.
|
||||||
- `bind(className, module, importManager)` requires `module` to resolve class names; use
|
- `bind(className, module, importManager)` requires `module` to resolve class names; use
|
||||||
@@ -12,6 +12,9 @@ This note describes the Lyng-first workflow where a class is declared in Lyng an
|
|||||||
- Kotlin can store two opaque payloads:
|
- Kotlin can store two opaque payloads:
|
||||||
- `instance.data` (per instance)
|
- `instance.data` (per instance)
|
||||||
- `classData` (per class)
|
- `classData` (per class)
|
||||||
|
- `extern class` / `extern object` are pure extern surfaces:
|
||||||
|
- all members in their bodies are implicitly extern (`extern` is optional/redundant);
|
||||||
|
- Lyng member bodies inside extern classes/objects are not supported.
|
||||||
|
|
||||||
## Lyng: declare extern members
|
## Lyng: declare extern members
|
||||||
|
|
||||||
@@ -39,34 +42,35 @@ LyngClassBridge.bind(className = "Foo", module = "bridge.mod", importManager = i
|
|||||||
data = CounterState(0)
|
data = CounterState(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
addFun("add") { _, _, args ->
|
addFun("add") {
|
||||||
val a = (args.list[0] as ObjInt).value
|
val a = (args.list[0] as ObjInt).value
|
||||||
val b = (args.list[1] as ObjInt).value
|
val b = (args.list[1] as ObjInt).value
|
||||||
ObjInt.of(a + b)
|
ObjInt.of(a + b)
|
||||||
}
|
}
|
||||||
|
|
||||||
addVal("status") { _, _ -> ObjString(classData as String) }
|
addVal("status") { ObjString(classData as String) }
|
||||||
|
|
||||||
addVar(
|
addVar(
|
||||||
"count",
|
"count",
|
||||||
get = { _, instance ->
|
get = {
|
||||||
val st = (instance as ObjInstance).data as CounterState
|
val st = (thisObj as ObjInstance).data as CounterState
|
||||||
ObjInt.of(st.count)
|
ObjInt.of(st.count)
|
||||||
},
|
},
|
||||||
set = { _, instance, value ->
|
set = { value ->
|
||||||
val st = (instance as ObjInstance).data as CounterState
|
val st = (thisObj as ObjInstance).data as CounterState
|
||||||
st.count = (value as ObjInt).value
|
st.count = (value as ObjInt).value
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|
||||||
addFun("secret") { _, _, _ -> ObjInt.of(42) }
|
addFun("secret") { ObjInt.of(42) }
|
||||||
addFun("ping") { _, _, _ -> ObjInt.of(7) }
|
addFun("ping") { ObjInt.of(7) }
|
||||||
}
|
}
|
||||||
```
|
```
|
||||||
|
|
||||||
## Notes
|
## Notes
|
||||||
|
|
||||||
- Visibility is respected by usual Lyng access rules; private extern members can be used only within class code.
|
- Visibility is respected by usual Lyng access rules; private extern members can be used only within class code.
|
||||||
- Use `init { scope -> ... }` for receiver-style init, or `initWithInstance { scope, instance -> ... }` for explicit instance access.
|
- Use `init { ... }` / `initWithInstance { ... }` with `ScopeFacade` receiver; access instance via `thisObj`.
|
||||||
- `classData` and `instance.data` are Kotlin-only payloads and do not appear in Lyng reflection.
|
- `classData` and `instance.data` are Kotlin-only payloads and do not appear in Lyng reflection.
|
||||||
- Binding after the first instance of a class is created throws a `ScriptError`.
|
- Binding after the first instance of a class is created throws a `ScriptError`.
|
||||||
|
- If you need Lyng-side helpers for an extern type, add them as extensions, e.g. `fun Foo.helper() = ...`.
|
||||||
@@ -276,6 +276,7 @@ Map inference:
|
|||||||
- `{ "a": 1, "b": "x" }` is `Map<String,Int|String>`.
|
- `{ "a": 1, "b": "x" }` is `Map<String,Int|String>`.
|
||||||
- Empty map literal uses `{:}` (since `{}` is empty callable).
|
- Empty map literal uses `{:}` (since `{}` is empty callable).
|
||||||
- `extern class Map<K=String,V=Object>` so `Map()` is `Map<String,Object>()` unless contextual type overrides.
|
- `extern class Map<K=String,V=Object>` so `Map()` is `Map<String,Object>()` unless contextual type overrides.
|
||||||
|
- `extern class` / `extern object` are declaration-only; members in their bodies are implicitly extern.
|
||||||
|
|
||||||
Flow typing:
|
Flow typing:
|
||||||
- Compiler should narrow types based on control-flow (e.g., `if (x != null)` narrows `x` to non-null inside the branch).
|
- Compiler should narrow types based on control-flow (e.g., `if (x != null)` narrows `x` to non-null inside the branch).
|
||||||
|
|||||||
@@ -0,0 +1,179 @@
|
|||||||
|
# Proposal: Runtime Generic Metadata for Extern Classes (Obj-Centric ABI)
|
||||||
|
|
||||||
|
Status: Draft
|
||||||
|
Date: 2026-03-15
|
||||||
|
Owner: compiler/runtime/bridge
|
||||||
|
|
||||||
|
## Context
|
||||||
|
|
||||||
|
`extern class` declarations are currently allowed to be generic (e.g. `extern class Cell<T>`), and this is already used by stdlib (`Iterable<T>`, `List<T>`, `Map<K,V>`, etc.).
|
||||||
|
|
||||||
|
The open problem is exposing applied generic type arguments to Kotlin-side bindings at runtime.
|
||||||
|
|
||||||
|
Important constraint:
|
||||||
|
- Extern-class values are **not necessarily** `ObjInstance`.
|
||||||
|
- The only hard requirement is that values are `Obj`.
|
||||||
|
|
||||||
|
So the ABI design must be `Obj`-centric and must not assume any specific object implementation layout.
|
||||||
|
|
||||||
|
## Goals
|
||||||
|
|
||||||
|
- Keep `extern class<T>` allowed.
|
||||||
|
- Make runtime generic metadata collection explicit and opt-in.
|
||||||
|
- Support all `Obj` subclasses, including host/custom objects not backed by `ObjInstance`.
|
||||||
|
- Provide a stable Kotlin bridge API for reading applied type args.
|
||||||
|
- Keep default runtime overhead near zero for classes that do not need this feature.
|
||||||
|
|
||||||
|
## Non-goals (phase 1)
|
||||||
|
|
||||||
|
- Full reified method-generic metadata for every call site.
|
||||||
|
- Runtime enforcement of generic bounds from metadata alone.
|
||||||
|
- Backfilling metadata for pre-existing objects created without capture.
|
||||||
|
|
||||||
|
## Proposed ABI Shape
|
||||||
|
|
||||||
|
### 1) Opt-in flag on `ObjClass`
|
||||||
|
|
||||||
|
Add runtime policy to `ObjClass`:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
enum class RuntimeGenericMode {
|
||||||
|
None,
|
||||||
|
CaptureClassTypeArgs
|
||||||
|
}
|
||||||
|
|
||||||
|
open class ObjClass(...) : Obj() {
|
||||||
|
open val runtimeGenericMode: RuntimeGenericMode = RuntimeGenericMode.None
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Default remains `None`.
|
||||||
|
|
||||||
|
### 2) Per-object metadata storage owned by `ObjClass`
|
||||||
|
|
||||||
|
Store metadata keyed by `Obj` identity, not by instance internals:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
open class ObjClass(...) : Obj() {
|
||||||
|
open fun setRuntimeTypeArgs(obj: Obj, args: List<RuntimeTypeRef>)
|
||||||
|
open fun getRuntimeTypeArgs(obj: Obj): List<RuntimeTypeRef>?
|
||||||
|
open fun clearRuntimeTypeArgs(obj: Obj) // optional
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
Default implementation:
|
||||||
|
- class-local identity map keyed by `Obj` references.
|
||||||
|
- no assumptions about object field layout.
|
||||||
|
- works for any `Obj` subtype.
|
||||||
|
|
||||||
|
Implementation note:
|
||||||
|
- JVM: weak identity map preferred to avoid leaks.
|
||||||
|
- JS/Wasm/Native: platform-appropriate identity map strategy; weak where available.
|
||||||
|
|
||||||
|
### 3) Type token format
|
||||||
|
|
||||||
|
Introduce compact runtime token:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
sealed class RuntimeTypeRef {
|
||||||
|
data class Simple(val className: String, val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
data class Generic(val className: String, val args: List<RuntimeTypeRef>, val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
data class Union(val options: List<RuntimeTypeRef>, val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
data class Intersection(val options: List<RuntimeTypeRef>, val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
data class TypeVar(val name: String, val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
data class Unknown(val nullable: Boolean = false) : RuntimeTypeRef()
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
`Unknown` is required so arity is preserved even when inference cannot produce a concrete runtime type.
|
||||||
|
|
||||||
|
### 4) Compiler/runtime collection point
|
||||||
|
|
||||||
|
When constructing/obtaining a value of generic class `C<...>`:
|
||||||
|
- Resolve applied class type arguments (explicit or inferred).
|
||||||
|
- If target class has `runtimeGenericMode == CaptureClassTypeArgs`, call:
|
||||||
|
- `C.setRuntimeTypeArgs(resultObj, resolvedArgsAsRuntimeTypeRefs)`
|
||||||
|
- If mode is `None`, do nothing.
|
||||||
|
|
||||||
|
No assumption about concrete returned object type besides `Obj`.
|
||||||
|
|
||||||
|
### 5) Bridge accessor API
|
||||||
|
|
||||||
|
Add a stable helper on binding context/facade:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
fun typeArgsOf(obj: Obj, asClass: ObjClass): List<RuntimeTypeRef>?
|
||||||
|
fun typeArgOf(obj: Obj, asClass: ObjClass, index: Int): RuntimeTypeRef?
|
||||||
|
```
|
||||||
|
|
||||||
|
Semantics:
|
||||||
|
- Reads metadata stored under `asClass`.
|
||||||
|
- Returns `null` when absent/not captured.
|
||||||
|
- Does not throw on non-`ObjInstance` objects.
|
||||||
|
|
||||||
|
This allows a host binding for `extern class Cell<T>` to inspect `T` safely.
|
||||||
|
|
||||||
|
## Source-Level Policy
|
||||||
|
|
||||||
|
No syntax change required in phase 1.
|
||||||
|
|
||||||
|
How to enable capture:
|
||||||
|
- Kotlin host sets `runtimeGenericMode` for classes that need it.
|
||||||
|
- Optionally add compiler directive later (future work), but not required for MVP.
|
||||||
|
|
||||||
|
## ABI Compatibility
|
||||||
|
|
||||||
|
- Backward compatible by default (`None` mode does not change behavior).
|
||||||
|
- Older runtimes can ignore metadata-related calls if feature not used.
|
||||||
|
- Optional capability flag can be introduced (`GENERIC_RUNTIME_ARGS`) for explicit runtime negotiation.
|
||||||
|
|
||||||
|
## Performance Considerations
|
||||||
|
|
||||||
|
- Zero overhead for classes with `None`.
|
||||||
|
- For capture-enabled classes: one map write per object creation/registration event.
|
||||||
|
- Memory cost proportional to number of live captured objects and type token size.
|
||||||
|
- Prefer weak-key maps where possible to minimize retention risk.
|
||||||
|
|
||||||
|
## Failure Modes and Handling
|
||||||
|
|
||||||
|
- If type args cannot be fully resolved at capture point:
|
||||||
|
- store `Unknown` tokens in unresolved positions.
|
||||||
|
- If an object is produced outside normal constructor flow:
|
||||||
|
- bridge can call `setRuntimeTypeArgs` manually if needed.
|
||||||
|
- If map strategy is unavailable on a platform:
|
||||||
|
- provide best-effort fallback map and document lifetime caveats.
|
||||||
|
|
||||||
|
## Phased Implementation Plan
|
||||||
|
|
||||||
|
### Phase 1 (MVP)
|
||||||
|
- Add `RuntimeGenericMode` on `ObjClass`.
|
||||||
|
- Add `RuntimeTypeRef`.
|
||||||
|
- Add `ObjClass` metadata storage/getters.
|
||||||
|
- Collect class-level generic args for opted-in extern classes.
|
||||||
|
- Add bridge getters and tests with non-`ObjInstance` `Obj` subtype.
|
||||||
|
|
||||||
|
### Phase 2
|
||||||
|
- Inheritance-aware views (querying args for parent extern classes if needed).
|
||||||
|
- Better token normalization/canonicalization.
|
||||||
|
|
||||||
|
### Phase 3
|
||||||
|
- Optional method-level generic call metadata (if a concrete use-case appears).
|
||||||
|
|
||||||
|
## Test Plan (minimum)
|
||||||
|
|
||||||
|
- `extern class Cell<T>` with capture enabled:
|
||||||
|
- `Cell<Int>()` exposes `Int`.
|
||||||
|
- inferred type args captured where available.
|
||||||
|
- Same class with capture disabled:
|
||||||
|
- no metadata returned.
|
||||||
|
- Non-`ObjInstance` host object path:
|
||||||
|
- metadata can be set/read via `ObjClass` API.
|
||||||
|
- Unknown/incomplete inference:
|
||||||
|
- returned args preserve arity via `Unknown`.
|
||||||
|
|
||||||
|
## Open Questions
|
||||||
|
|
||||||
|
- Exact cross-platform weak identity map abstraction location.
|
||||||
|
- Whether to add user-facing Lyng syntax for enabling capture, or keep host-only policy.
|
||||||
|
- Whether parent-generic projection should be materialized at capture time or computed lazily.
|
||||||
|
|
||||||
@@ -1,48 +0,0 @@
|
|||||||
> under cosntruction
|
|
||||||
> note to AI: ignore this file for now
|
|
||||||
|
|
||||||
The problem is, sometimes we want to implement an interface enhancing existing classes. For example, we want ti implement Delegate for Map. We can add extension methods to Map that do the work, but we can add Delegate to the inheritance chain.
|
|
||||||
|
|
||||||
The problem is not trivial: while adding interfaces in other languages is easy, adding the while
|
|
||||||
class with a state to existing one should be done carefully.
|
|
||||||
|
|
||||||
Proposed syntax:
|
|
||||||
|
|
||||||
```lyng
|
|
||||||
extend Map with Delegate {
|
|
||||||
fun getValue(thisRef, key) = this[key]
|
|
||||||
fun setValue(thisRef, key, value) = this[key] = value
|
|
||||||
}
|
|
||||||
```
|
|
||||||
|
|
||||||
And now we can use Map as a Delegate:
|
|
||||||
```lyng
|
|
||||||
val map = { foo: 1. bar: 2 }
|
|
||||||
val foo by map
|
|
||||||
assertEquals(1, foo)
|
|
||||||
```
|
|
||||||
|
|
||||||
The syntax is similar to the one used for inheritance. But while Delegate has no state and it is actually simple. Much harder task is ti implement some class with state (trait):
|
|
||||||
|
|
||||||
```lyng
|
|
||||||
// the class we will use as a trait must have on constructor parameters
|
|
||||||
// or only parameters with default values
|
|
||||||
class MyTraitClass(initValue=100) {
|
|
||||||
private var field
|
|
||||||
fun traitField get() = field + initValue
|
|
||||||
set(value) { field = value }
|
|
||||||
}
|
|
||||||
|
|
||||||
extend Map with MyTraitClass
|
|
||||||
|
|
||||||
assertEquals(100, Map().traitField)
|
|
||||||
val m = Map()
|
|
||||||
m.traitField = 1000
|
|
||||||
assertEquals(1100,m.traitField)
|
|
||||||
```
|
|
||||||
|
|
||||||
We limit extension to module scope level, e.g., not in functions, not in classes, but at the "global level", probably ModuleScope.
|
|
||||||
|
|
||||||
The course of action could be:
|
|
||||||
|
|
||||||
- when constructing a class instance, compiler search in the ModuleScope extensions for it, and if found, add them to MI parent list to the end in the order of appearance in code (e.g. random ;)), them construct the instance as usual.
|
|
||||||
@@ -339,7 +339,7 @@
|
|||||||
<!-- Top-left version ribbon -->
|
<!-- Top-left version ribbon -->
|
||||||
<div class="corner-ribbon bg-danger text-white">
|
<div class="corner-ribbon bg-danger text-white">
|
||||||
<span style="margin-left: -5em">
|
<span style="margin-left: -5em">
|
||||||
v1.5.0-SNAPSHOT!
|
v1.5.1
|
||||||
</span>
|
</span>
|
||||||
</div>
|
</div>
|
||||||
<!-- Fixed top navbar for the whole site -->
|
<!-- Fixed top navbar for the whole site -->
|
||||||
|
|||||||
Loaded 100 of 103 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user