Compare commits

..
7 Commits
Author SHA1 Message Date
sergeych d92309d76c fixed version for site badge 2026-03-19 01:34:23 +03:00
sergeych 767e995a96 RC version bump 2026-03-19 01:33:08 +03:00
sergeych 794553d81d Add stdlib Random API and migrate tetris RNG 2026-03-19 01:30:35 +03:00
sergeych d9d7cafec8 +added console spport for lyngio
+added console support to lyng/jlyng CLI
+added unicode escapes
+created tetris console sample
2026-03-19 01:09:32 +03:00
sergeych 1a080bc53e added AI coding data for Lyng 2026-03-17 14:05:26 +03:00
sergeych a6492bb750 Add support for symbol inclusion via directive and refactor extern classes handling 2026-03-15 09:13:33 +03:00
sergeych d2a47d34a3 fixed extending extern classes (extension methods) 2026-03-15 05:35:29 +03:00
57 changed files with 4706 additions and 190 deletions

No files matched your search

+6
View File
@@ -1,5 +1,11 @@
# 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.
## Kotlin/Wasm generation guardrails
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
- Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks).
+219
View File
@@ -0,0 +1,219 @@
# 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`).
- Numbers: `Int` (`123`, `1_000`), `Real` (`1.2`, `1e3`), hex (`0xFF`).
- Char: `'a'`, escaped chars supported.
- Supported escapes: `\n`, `\r`, `\t`, `\'`, `\\`, `\uXXXX` (4 hex digits).
- Backslash character in a char literal must be written as `'\\'` (forms like `'\'` are invalid).
- Labels:
- statement label: `loop@ for (...) { ... }`
- label reference: `break@loop`, `continue@loop`, `return@fnLabel`
- Keywords/tokens include (contextual in many places):
- declarations: `fun`/`fn`, `val`, `var`, `class`, `object`, `interface`, `enum`, `type`, `init`
- modifiers: `private`, `protected`, `static`, `abstract`, `closed`, `override`, `extern`, `open`
- flow: `if`, `else`, `when`, `for`, `while`, `do`, `try`, `catch`, `finally`, `throw`, `return`, `break`, `continue`
## 3. Literals and Core Expressions
- Scalars: `null`, `true`, `false`, `void`.
- List literal: `[a, b, c]`, spreads with `...`.
- Spread positions: beginning, middle, end are all valid: `[...a]`, `[0, ...a, 4]`, `[head, ...mid, tail]`.
- Spread source must be a `List` at runtime (non-list spread raises an error).
- Map literal: `{ key: value, x:, ...otherMap }`.
- `x:` means shorthand `x: x`.
- Map spread source must be a `Map`.
- Range literals:
- inclusive: `a..b`
- exclusive end: `a..<b`
- open-ended forms are supported (`a..`, `..b`, `..`).
- optional step: `a..b step 2`
- Lambda literal:
- with params: `{ x, y -> x + y }`
- implicit `it`: `{ it + 1 }`
- Ternary conditional is supported: `cond ? thenExpr : elseExpr`.
## 3.1 Splats in Calls and Lambdas
- Declaration-side variadic parameters use ellipsis suffix:
- functions: `fun f(head, tail...) { ... }`
- lambdas: `{ x, rest... -> ... }`
- Call-side splats use `...expr` and are expanded by argument kind:
- positional splat: `f(...[1,2,3])`
- named splat: `f(...{ a: 1, b: 2 })` (map-style)
- Runtime acceptance for splats:
- positional splat accepts `List` and general `Iterable` (iterable is converted to list first).
- named splat accepts `Map` with string keys only.
- Ordering/validation rules (enforced):
- positional argument cannot follow named arguments (except trailing-block parsing case).
- positional splat cannot follow named arguments.
- duplicate named arguments are errors (including duplicates introduced via named splat).
- unknown named parameters are errors.
- variadic parameter itself cannot be passed as a named argument (`fun g(args..., tail)` then `g(args: ...)` is invalid).
- Trailing block + named arguments:
- if the last callable parameter is already provided by name in parentheses, adding a trailing block is invalid.
## 4. Operators (implemented)
- Assignment: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `?=`.
- Logical: `||`, `&&`, unary `!`.
- Bitwise: `|`, `^`, `&`, `~`, shifts `<<`, `>>`.
- Equality/comparison: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, `>=`, `<=>`, `=~`, `!~`.
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family:
- member access: `?.`
- safe index: `?[i]`
- safe invoke: `?(...)`
- safe block invoke: `?{ ... }`
- elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`.
## 5. Declarations
- Variables:
- `val` immutable, `var` mutable.
- top-level/local `val` must be initialized.
- class `val` may be late-initialized, but must be assigned in class body/init before class parse ends.
- destructuring declaration: `val [a, b, rest...] = expr`.
- destructuring declaration details:
- allowed in `val` and `var` declarations.
- supports nested patterns: `val [a, [b, c...], d] = rhs`.
- supports at most one splat (`...`) per pattern level.
- RHS must be a `List`.
- without splat: RHS must have at least as many elements as pattern arity.
- with splat: head/tail elements are bound directly, splat receives a `List`.
- Functions:
- `fun` and `fn` are equivalent.
- full body: `fun f(x) { ... }`
- shorthand: `fun f(x) = expr`.
- generics: `fun f<T>(x: T): T`.
- extension functions: `fun Type.name(...) { ... }`.
- delegated callable: `fun f(...) by delegate`.
- Type aliases:
- `type Name = TypeExpr`
- generic: `type Box<T> = List<T>`
- aliases are expanded structurally.
- Classes/objects/enums/interfaces:
- `interface` is parsed as abstract class synonym.
- `object` supports named singleton and anonymous object expression forms.
- enums support lifted entries: `enum E* { A, B }`.
- multiple inheritance is supported; override is enforced when overriding base members.
- Properties/accessors in class body:
- accessor form supports `get`/`set`, including `private set`/`protected set`.
## 6. Control Flow
- `if` is expression-like.
- `when(value) { ... }` supported.
- branch conditions support equality, `in`, `!in`, `is`, `!is`, and `nullable` predicate.
- `when { ... }` (subject-less) is currently not implemented.
- Loops: `for`, `while`, `do ... while`.
- loop `else` blocks are supported.
- `break value` can return a loop result.
- Exceptions: `try/catch/finally`, `throw`.
## 6.1 Destructuring Assignment (implemented)
- Reassignment form is supported (not only declaration):
- `[x, y] = [y, x]`
- Semantics match destructuring declaration:
- nested patterns allowed.
- at most one splat per pattern level.
- RHS must be a `List`.
- too few RHS elements raises runtime error.
- Targets in pattern are variables parsed from identifier patterns.
## 7. Type System (current behavior)
- Non-null by default (`T`), nullable with `T?`.
- `as` (checked cast), `as?` (safe cast returning `null`), `!!` non-null assertion.
- Type expressions support:
- unions `A | B`
- intersections `A & B`
- function types `(A, B)->R` and receiver form `Receiver.(A)->R`
- variadics in function type via ellipsis (`T...`)
- Generics:
- type params on classes/functions/type aliases
- bounds via `:` with union/intersection expressions
- declaration-site variance via `in` / `out`
- Generic function/class/type syntax examples:
- function: `fun choose<T>(a: T, b: T): T = a`
- class: `class Box<T>(val value: T)`
- alias: `type PairList<T> = List<List<T>>`
- Untyped params default to `Object` (`x`) or `Object?` (`x?` shorthand).
- Untyped `var x` starts as `Unset`; first assignment fixes type tracking in compiler.
## 7.1 Generics Runtime Model and Bounds (AI-critical)
- Lyng generic type information is operational in script execution contexts; do not assume JVM-style full erasure.
- Generic call type arguments can be:
- explicit at call site (`f<Int>(1)` style),
- inferred from runtime values/declared arg types,
- defaulted from type parameter defaults (or `Any` fallback).
- At function execution, generic type parameters are runtime-bound as constants in scope:
- simple non-null class-like types are bound as `ObjClass`,
- complex/nullable/union/intersection forms are bound as `ObjTypeExpr`.
- Practical implication for generated code:
- inside generic code, treat type params as usable type objects in `is`/`in`/type-expression logic (not as purely compile-time placeholders).
- example pattern: `if (value is T) { ... }`.
- Bound syntax (implemented):
- intersection bound: `fun f<T: A & B>(x: T) { ... }`
- union bound: `fun g<T: A | B>(x: T) { ... }`
- Bound checks happen at two points:
- compile-time call checking for resolvable generic calls,
- runtime re-check while binding type params for actual invocation.
- Bound satisfaction is currently class-hierarchy based for class-resolvable parts (including union/intersection combination rules).
- Keep expectations realistic:
- extern-generic runtime ABI for full instance-level generic metadata is still proposal-level (`proposals/extern_generic_runtime_abi.md`), so avoid assuming fully materialized generic-instance metadata everywhere.
## 7.2 Differences vs Java / Kotlin / Scala
- Java:
- Java generics are erased at runtime (except reflection metadata and raw `Class` tokens).
- Lyng generic params in script execution are runtime-bound type objects, so generated code can reason about `T` directly.
- Kotlin:
- Kotlin on JVM is mostly erased; full runtime type access usually needs `inline reified`.
- Lyng generic function execution binds `T` without requiring an inline/reified escape hatch.
- Scala:
- Scala has richer static typing but still runs on JVM erasure model unless carrying explicit runtime evidence (`TypeTag`, etc.).
- Lyng exposes runtime-bound type expressions/classes directly in generic execution scope.
- AI generation rule:
- do not port JVM-language assumptions like “`T` unavailable at runtime unless reified/tagged”.
- in Lyng, prefer direct type-expression-driven branching when useful, but avoid assuming extern object generic args are always introspectable today.
## 8. OOP, Members, and Dispatch
- Multiple inheritance with C3-style linearization behavior is implemented in class machinery.
- Disambiguation helpers are supported:
- qualified this: `this@Base.member()`
- cast view: `(obj as Base).member()`
- On unknown receiver types, compiler allows only Object-safe members:
- `toString`, `toInspectString`, `let`, `also`, `apply`, `run`
- Other members require known receiver type or explicit cast.
## 9. Delegation (`by`)
- Works for `val`, `var`, and `fun`.
- Expected delegate hooks in practice:
- `getValue(thisRef, name)`
- `setValue(thisRef, name, newValue)`
- `invoke(thisRef, name, args...)` for delegated callables
- optional `bind(name, access, thisRef)`
- `@Transient` is recognized for declarations/params and affects serialization/equality behavior.
## 10. Modules and Imports
- `package` and `import module.name` are supported.
- Import form is module-only (no aliasing/selective import syntax in parser).
- Default module ecosystem includes:
- auto-seeded: `lyng.stdlib`
- available by import: `lyng.observable`, `lyng.buffer`, `lyng.serialization`, `lyng.time`
- extra module (when installed): `lyng.io.fs`, `lyng.io.process`
## 11. Current Limitations / Avoid
- No subject-less `when { ... }` yet.
- No regex literal tokenization (`/.../`); use `Regex("...")` or `"...".re`.
- Do not generate runtime name fallback patterns from legacy docs.
+75
View File
@@ -0,0 +1,75 @@
# Lyng Stdlib Reference for AI Agents (Compact)
Purpose: fast overview of what is available by default and what must be imported.
Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/stdlib/lyng/root.lyng`, `lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/observable_lyng.kt`.
## 1. Default Availability
- Normal scripts are auto-seeded with `lyng.stdlib` (default import manager path).
- Root runtime scope also exposes global constants/functions directly.
## 2. Core Global Functions (Root Scope)
- IO/debug: `print`, `println`, `traceScope`.
- Invocation/util: `call`, `run`, `dynamic`, `cached`, `lazy`.
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
- Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
## 3. Core Global Constants/Types
- Values: `Unset`, `π`.
- Primitive/class symbols: `Object`, `Int`, `Real`, `Bool`, `Char`, `String`, `Class`, `Callable`.
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
- Random: singleton `Random` and class `SeededRandom`.
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
- Delegation types: `Delegate`, `DelegateContext`.
- Regex types: `Regex`, `RegexMatch`.
- Also present: `Math.PI` namespace constant.
## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
### 4.1 Extern class declarations
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
- Host iterator bridge: `KotlinIterator<T>`.
- Random APIs: `extern object Random`, `extern class SeededRandom`.
### 4.2 High-use extension APIs
- Iteration/filtering: `forEach`, `filter`, `filterFlow`, `filterNotNull`, `filterFlowNotNull`, `drop`, `dropLast`, `takeLast`.
- Search/predicates: `findFirst`, `findFirstOrNull`, `any`, `all`, `count`, `first`, `last`.
- Mapping/aggregation: `map`, `flatMap`, `flatten`, `sum`, `sumOf`, `minOf`, `maxOf`.
- Ordering: `sorted`, `sortedBy`, `shuffled`, `List.sort`, `List.sortBy`.
- String helper: `joinToString`, `String.re`.
### 4.3 Delegation helpers
- `enum DelegateAccess { Val, Var, Callable }`
- `interface Delegate<T,ThisRefType=void>` with `getValue`, `setValue`, `invoke`, `bind`.
- `class lazy<T,...>` delegate implementation.
- `fun with(self, block)` helper.
### 4.4 Other module-level symbols
- `$~` (last regex match object).
- `TODO(message?)` utility.
- `StackTraceEntry` class.
- `Random.nextInt()`, `Random.nextFloat()`, `Random.next(range)`, `Random.seeded(seed)`.
- `SeededRandom.nextInt()`, `SeededRandom.nextFloat()`, `SeededRandom.next(range)`.
## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.buffer`
- `Buffer`, `MutableBuffer`.
- `import lyng.serialization`
- `Lynon` serialization utilities.
- `import lyng.time`
- `Instant`, `DateTime`, `Duration`, and module `delay`.
## 6. Optional (lyngio) Modules
Requires installing `lyngio` into the import manager from host code.
- `import lyng.io.fs` (filesystem `Path` API)
- `import lyng.io.process` (process execution API)
- `import lyng.io.console` (console capabilities, geometry, ANSI/output, events)
## 7. AI Generation Tips
- Assume `lyng.stdlib` APIs exist in regular script contexts.
- For platform-sensitive code (`fs`, `process`, `console`), gate assumptions and mention required module install.
- Prefer extension-method style (`items.filter { ... }`) and standard scope helpers (`let`/`also`/`apply`/`run`).
+101
View File
@@ -0,0 +1,101 @@
### 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()
```
Interactive sample script in this repo:
```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(): String` — `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 at least:
- `type: String` — `resize`, `keydown`, `keyup`
Additional fields:
- `ConsoleResizeEvent`: `columns`, `rows`
- `ConsoleKeyEvent`: `key`, `code`, `ctrl`, `alt`, `shift`, `meta`
#### Security policy
The module uses `ConsoleAccessPolicy` with operations:
- `WriteText(length)`
- `ReadEvents`
- `SetRawMode(enabled)`
For permissive mode, use `PermitAllConsoleAccessPolicy`.
+17 -9
View File
@@ -6,12 +6,13 @@
1. **Security:** I/O and process execution are sensitive operations. By keeping them in a separate module, we ensure that the Lyng core remains 100% safe by default. You only enable what you explicitly need.
2. **Footprint:** Not every script needs filesystem or process access. Keeping these as a separate module helps minimize the dependency footprint for small embedded projects.
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`) that allow you to control exactly what a script can do.
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`, `ConsoleAccessPolicy`) that allow you to control exactly what a script can do.
#### Included Modules
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
- **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events.
---
@@ -39,8 +40,10 @@ To use `lyngio` modules in your scripts, you must install them into your Lyng sc
import net.sergeych.lyng.Script
import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun runMyScript() {
val scope = Script.newScope()
@@ -48,14 +51,17 @@ suspend fun runMyScript() {
// Install modules with policies
createFs(PermitAllAccessPolicy, scope)
createProcessModule(PermitAllProcessAccessPolicy, scope)
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
// Now scripts can import them
scope.eval("""
import lyng.io.fs
import lyng.io.process
import lyng.io.console
println("Working dir: " + Path(".").readUtf8())
println("OS: " + Platform.details().name)
println("TTY: " + Console.isTty())
""")
}
```
@@ -68,20 +74,22 @@ suspend fun runMyScript() {
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
- **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching.
For more details, see the specific module documentation:
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
- [Process Security Details](lyng.io.process.md#security-policy)
- [Console Module Details](lyng.io.console.md)
---
#### Platform Support Overview
| Platform | lyng.io.fs | lyng.io.process |
| :--- | :---: | :---: |
| **JVM** | ✅ | ✅ |
| **Native (Linux/macOS)** | ✅ | ✅ |
| **Native (Windows)** | ✅ | 🚧 (Planned) |
| **Android** | ✅ | ❌ |
| **NodeJS** | ✅ | ❌ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ |
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console |
| :--- | :---: | :---: | :---: |
| **JVM** | ✅ | ✅ | ✅ (baseline) |
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
| **Android** | ✅ | ❌ | ❌ |
| **NodeJS** | ✅ | ❌ | ❌ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
+23
View File
@@ -110,6 +110,29 @@ For example:
assert( 5.clamp(0..10) == 5 )
>>> void
## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators:
| name | meaning |
|--------------------------|---------|
| Random.nextInt() | random `Int` from full platform range |
| Random.nextFloat() | random `Real` in `[0,1)` |
| Random.next(range) | random value from the given finite range |
| Random.seeded(seed) | creates deterministic generator |
| SeededRandom.nextInt() | deterministic random `Int` |
| SeededRandom.nextFloat() | deterministic random `Real` in `[0,1)` |
| SeededRandom.next(range) | deterministic random value from range |
Examples:
val rng = Random.seeded(1234)
assert( rng.next(1..10) in 1..10 )
assert( rng.next('a'..<'f') in 'a'..<'f' )
assert( rng.next(0.0..<1.0) >= 0.0 )
assert( rng.next(0.0..<1.0) < 1.0 )
>>> void
## Scientific constant
| name | meaning |
+8 -2
View File
@@ -1555,18 +1555,21 @@ The type for the character objects is `Char`.
| \t | 0x07, tabulation |
| \\ | \ slash character |
| \" | " double quote |
| \uXXXX | unicode code point |
Unicode escape form is exactly 4 hex digits, e.g. `"\u263A"` -> `☺`.
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
val s = "\a"
assert(s[0] == '\')
assert(s[0] == '\\')
assert(s[1] == 'a')
>>> void
same as:
val s = "\\a"
assert(s[0] == '\')
assert(s[0] == '\\')
assert(s[1] == 'a')
>>> void
@@ -1581,6 +1584,9 @@ Are the same as in string literals with little difference:
| \t | 0x07, tabulation |
| \\ | \ slash character |
| \' | ' apostrophe |
| \uXXXX | unicode code point |
For char literals, use `'\\'` to represent a single backslash character; `'\'` is invalid.
### Char instance members
+659
View File
@@ -0,0 +1,659 @@
#!/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
* - Q or Escape: quit
*/
import lyng.io.console
val MIN_COLS = 56
val MIN_ROWS = 24
val PANEL_WIDTH = 24
val BOARD_MARGIN_ROWS = 8
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 ROTATION_KICKS = [0, -1, 1, -2, 2]
val ANSI_ESC = "\u001b["
val ANSI_RESET = ANSI_ESC + "0m"
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
}
class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {}
fun clearAndHome() {
Console.clear()
Console.home()
}
fun repeatText(s: String, n: Int): String {
var out: String = ""
var i = 0
while (i < n) {
out += s
i = i + 1
}
out
}
fun maxInt(a: Int, b: Int): Int {
if (a > b) a else b
}
fun minInt(a: Int, b: Int): Int {
if (a < b) a else b
}
fun clampInt(v: Int, lo: Int, hi: Int): Int {
minInt(hi, maxInt(lo, v))
}
fun emptyRow(width: Int): Row {
val r: Row = []
var x = 0
while (x < width) {
r.add(0)
x = x + 1
}
r
}
fun createBoard(width: Int, height: Int): Board {
val b: Board = []
var y = 0
while (y < height) {
b.add(emptyRow(width))
y = y + 1
}
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 {
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 (x < 0 || x >= boardW) return false
if (y >= boardH) return false
if (y >= 0) {
val row = board[y]
if (row[x] != 0) return false
}
}
true
}
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) {
val row = board[y]
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) {
val row = b[y]
var full = true
var x = 0
while (x < boardW) {
if (row[x] == 0) {
full = false
break
}
x = x + 1
}
if (full) {
b.removeAt(y)
b.insertAt(0, emptyRow(boardW))
cleared = cleared + 1
} else {
y = y - 1
}
}
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)) {
return RotateResult(true, nr, nx)
}
}
RotateResult(false, rot, px)
}
fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
val out: List<String> = []
if (pieceId <= 0) {
out.add(" ")
out.add(" ")
out.add(" ")
out.add(" ")
return out
}
val piece: Piece = PIECES[pieceId - 1]
val cells = piece.rotations[0]
var y = 0
while (y < 4) {
var line = ""
var x = 0
while (x < 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 " "
x = x + 1
}
out.add(line)
y = y + 1
}
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("Q/Esc: quit")
val frameLines: List<String> = []
var y = 0
while (y < boardH) {
var line = UNICODE_VERTICAL
var x = 0
while (x < boardW) {
val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y)
val row = board[y]
val b = row[x]
val id = if (a > 0) a else b
line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor)
x = x + 1
}
line += UNICODE_VERTICAL
val p = y
if (p < panel.size) {
line += " " + panel[p]
}
frameLines.add(line)
y = y + 1
}
frameLines.add(bottomBorder)
val prev = prevFrameLines
var i = 0
while (i < frameLines.size) {
val line = frameLines[i]
val old = if (i < prev.size) prev[i] else null
if (old != line) {
Console.moveTo(originRow + i, originCol)
Console.clearLine()
Console.write(line)
}
i = i + 1
}
frameLines
}
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()
println("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
println("Current: %sx%s"(cols, rows))
println("Resize the console window to continue...")
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 = clampInt((cols - PANEL_WIDTH) / 2, BOARD_MIN_W, BOARD_MAX_W)
val boardH = clampInt(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()
var hasResizeEvent = false
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() != "NONE"
Console.enterAltScreen()
Console.setCursorVisible(false)
clearAndHome()
fun applyKeyInput(s: GameState, key: String): Void {
if (key == "__CTRL_C__" || key == "q" || key == "Q" || key == "Escape") {
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)) s.px = s.px - 1
}
else if (key == "ArrowRight" || key == "d" || key == "D") {
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py)) s.px = s.px + 1
}
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)) {
s.py = s.py + 1
s.score = s.score + 1
}
}
else if (key == " ") {
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1)) {
s.py = s.py + 1
s.score = s.score + 2
}
}
}
var inputRunning = true
launch {
while (inputRunning) {
try {
for (ev in Console.events()) {
if (!inputRunning) break
if (ev is ConsoleKeyEvent) {
val ke = ev as ConsoleKeyEvent
if (ke.type == "keydown") {
val key = ke.key
val ctrl = ke.ctrl
gameMutex.withLock {
val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key
applyKeyInput(state, mapped)
}
}
} else if (ev is ConsoleResizeEvent) {
gameMutex.withLock {
hasResizeEvent = true
prevFrameLines = []
}
}
}
} catch (err: Exception) {
// Keep game alive: transient console-event failures should not force quit.
if (!inputRunning) break
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
}
var resized = false
gameMutex.withLock {
resized = hasResizeEvent
hasResizeEvent = false
}
val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH
val contentRows = boardH + 1
val requiredCols = maxInt(MIN_COLS, contentCols)
val requiredRows = maxInt(MIN_ROWS, contentRows)
if (c < requiredCols || r < requiredRows) {
waitForMinimumSize(requiredCols, requiredRows)
clearAndHome()
prevFrameLines = []
return null
}
val originCol = maxInt(1, ((c - contentCols) / 2) + 1)
val originRow = maxInt(1, ((r - contentRows) / 2) + 1)
LoopFrame(resized, originRow, originCol)
}
fun advanceGravity(s: GameState, frame: Int): Int {
s.level = 1 + (s.totalLines / LEVEL_LINES_STEP)
val dropEvery = maxInt(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)) {
s.py = s.py + 1
return nextFrame
}
lockPiece(board, s.pieceId, s.rot, s.px, s.py)
val cleared = clearCompletedLines(board, boardW, boardH)
if (cleared > 0) {
s.totalLines = s.totalLines + cleared
s.score = 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
while (!shouldStop) {
val frameData = pollLoopFrame()
if (frameData == null) {
frame = 0
continue
}
gameMutex.withLock {
if (!state.running || state.gameOver) {
shouldStop = true
} else {
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
if (frameData.resized || movedOrigin) {
clearAndHome()
prevFrameLines = []
}
prevOriginRow = frameData.originRow
prevOriginCol = frameData.originCol
frame = advanceGravity(state, frame)
prevFrameLines = render(
state,
board,
boardW,
boardH,
prevFrameLines,
frameData.originRow,
frameData.originCol,
useColor
)
}
}
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))
}
}
+4 -1
View File
@@ -1,6 +1,7 @@
[versions]
agp = "8.5.2"
clikt = "5.0.3"
mordant = "3.0.2"
kotlin = "2.3.0"
android-minSdk = "24"
android-compileSdk = "34"
@@ -14,6 +15,8 @@ compiler = "3.2.0-alpha11"
[libraries]
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
clikt-markdown = { module = "com.github.ajalt.clikt:clikt-markdown", version.ref = "clikt" }
mordant-core = { module = "com.github.ajalt.mordant:mordant-core", version.ref = "mordant" }
mordant-jvm-jna = { module = "com.github.ajalt.mordant:mordant-jvm-jna", version.ref = "mordant" }
kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
@@ -28,4 +31,4 @@ compiler = { group = "androidx.databinding", name = "compiler", version.ref = "c
[plugins]
androidLibrary = { id = "com.android.library", version.ref = "agp" }
kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.29.0" }
vanniktech-mavenPublish = { id = "com.vanniktech.maven.publish", version = "0.29.0" }
@@ -36,6 +36,7 @@ object LyngAstManager {
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
private val implicitBuiltinNames = setOf("void")
private val includeSymbolsDirective = Regex("""(?im)^\s*//\s*include\s+symbols\s*:\s*(.+?)\s*$""")
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
getAnalysis(file)?.mini
@@ -44,8 +45,8 @@ object LyngAstManager {
fun getCombinedStamp(file: PsiFile): Long = runReadAction {
var combinedStamp = file.viewProvider.modificationStamp
if (!file.name.endsWith(".lyng.d")) {
collectDeclarationFiles(file).forEach { df ->
combinedStamp += df.viewProvider.modificationStamp
collectDeclarationFiles(file).forEach { symbolsFile ->
combinedStamp += symbolsFile.viewProvider.modificationStamp
}
}
combinedStamp
@@ -66,6 +67,22 @@ object LyngAstManager {
currentDir = currentDir.parentDirectory
}
val includeSpecs = includeSymbolsDirective.findAll(file.viewProvider.contents)
.flatMap { it.groupValues[1].split(',').asSequence() }
.map { it.trim() }
.filter { it.isNotEmpty() }
.toList()
val baseDir = file.virtualFile?.parent
if (baseDir != null) {
for (spec in includeSpecs) {
val included = baseDir.findFileByRelativePath(spec) ?: continue
if (included.path == file.virtualFile?.path) continue
if (seen.add(included.path)) {
psiManager.findFile(included)?.let { result.add(it) }
}
}
}
if (result.isNotEmpty()) return@runReadAction result
// Fallback for virtual/light files without a stable parent chain (e.g., tests)
@@ -50,6 +50,18 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
myFixture.addFileToProject("api.lyng.d", defs)
}
private fun addPlainSymbolsFile() {
val defs = """
/** Symbols exposed via include directive */
class PlainDeclared(val name: String) {
fun hello(): String = "ok"
}
fun plainTopFun(x: Int): Int = x + 2
""".trimIndent()
myFixture.addFileToProject("plain_symbols.lyng", defs)
}
fun test_CompletionsIncludeDefinitions() {
addDefinitionsFile()
enableCompletion()
@@ -136,4 +148,35 @@ class LyngDefinitionFilesTest : BasePlatformTestCase() {
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
assertTrue("Should not report unresolved name for void, got=$messages", messages.none { it.contains("unresolved name: void") })
}
fun test_CompletionsIncludePlainLyngViaDirective() {
addPlainSymbolsFile()
enableCompletion()
val code = """
// include symbols: plain_symbols.lyng
val v = plainTop<caret>
""".trimIndent()
myFixture.configureByText("main.lyng", code)
val text = myFixture.editor.document.text
val caret = myFixture.caretOffset
val analysis = LyngAstManager.getAnalysis(myFixture.file)
val engine = runBlocking { CompletionEngineLight.completeSuspend(text, caret, analysis?.mini, analysis?.binding).map { it.name } }
assertTrue("Expected plainTopFun from included .lyng; got=$engine", engine.contains("plainTopFun"))
}
fun test_DiagnosticsIgnorePlainLyngSymbolsViaDirective() {
addPlainSymbolsFile()
val code = """
// include symbols: plain_symbols.lyng
val x = plainTopFun(1)
val y = PlainDeclared("x")
y.hello()
""".trimIndent()
myFixture.configureByText("main.lyng", code)
val analysis = LyngAstManager.getAnalysis(myFixture.file)
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
assertTrue("Should not report unresolved name for plainTopFun", messages.none { it.contains("unresolved name: plainTopFun") })
assertTrue("Should not report unresolved name for PlainDeclared", messages.none { it.contains("unresolved name: PlainDeclared") })
assertTrue("Should not report unresolved member for hello", messages.none { it.contains("unresolved member: hello") })
}
}
+6 -1
View File
@@ -1,5 +1,5 @@
/*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -32,8 +32,10 @@ import net.sergeych.lyng.LyngVersion
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.obj.*
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.mp_tools.globalDefer
import okio.FileSystem
@@ -69,6 +71,9 @@ val baseScopeDefer = globalDefer {
// Install lyng.io.fs module with full access by default for the CLI tool's Scope.
// Scripts still need to `import lyng.io.fs` to use Path API.
createFs(PermitAllAccessPolicy, this)
// Install console access by default for interactive CLI scripts.
// Scripts still need to `import lyng.io.console` to use it.
createConsoleModule(PermitAllConsoleAccessPolicy, this)
}
}
+8
View File
@@ -78,6 +78,7 @@ kotlin {
api(project(":lynglib"))
api(libs.okio)
api(libs.kotlinx.coroutines.core)
api(libs.mordant.core)
}
}
val commonTest by getting {
@@ -94,6 +95,13 @@ kotlin {
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
}
}
val jvmMain by getting {
dependencies {
implementation(libs.mordant.jvm.jna)
implementation("org.jline:jline-reader:3.29.0")
implementation("org.jline:jline-terminal:3.29.0")
}
}
// // For Wasm we use in-memory VFS for now
// val wasmJsMain by getting {
// dependencies {
@@ -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,600 @@
/*
* 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.miniast.*
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
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.ConsoleEvent
import net.sergeych.lyngio.console.ConsoleEventSource
import net.sergeych.lyngio.console.LyngConsole
import net.sergeych.lyngio.console.getSystemConsole
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
import net.sergeych.lyngio.console.security.LyngConsoleSecured
/**
* 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 {
val name = "lyng.io.console"
if (manager.packageNames.contains(name)) return false
manager.addPackage(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) {
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
consoleType.apply {
addClassFnDoc(
name = "isSupported",
doc = "Whether console control API is supported on this platform.",
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
ObjBool(console.isSupported)
}
addClassFnDoc(
name = "isTty",
doc = "Whether current stdout is attached to an interactive TTY.",
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
consoleGuard {
ObjBool(console.isTty())
}
}
addClassFnDoc(
name = "ansiLevel",
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
returns = type("lyng.String"),
moduleName = module.packageName
) {
consoleGuard {
ObjString(console.ansiLevel().name)
}
}
addClassFnDoc(
name = "geometry",
doc = "Current terminal geometry or null.",
returns = type("ConsoleGeometry", nullable = true),
moduleName = module.packageName
) {
consoleGuard {
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
}
}
addClassFnDoc(
name = "details",
doc = "Get consolidated console details.",
returns = type("ConsoleDetails"),
moduleName = module.packageName
) {
consoleGuard {
val tty = console.isTty()
val ansi = console.ansiLevel()
val geometry = console.geometry()
ObjConsoleDetails(
supported = console.isSupported,
isTty = tty,
ansiLevel = ansi.name,
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
)
}
}
addClassFnDoc(
name = "write",
doc = "Write text directly to console output.",
params = listOf(ParamDoc("text", type("lyng.String"))),
moduleName = module.packageName
) {
consoleGuard {
val text = requiredArg<ObjString>(0).value
console.write(text)
ObjVoid
}
}
addClassFnDoc(
name = "flush",
doc = "Flush console output buffer.",
moduleName = module.packageName
) {
consoleGuard {
console.flush()
ObjVoid
}
}
addClassFnDoc(
name = "home",
doc = "Move cursor to home position (1,1).",
moduleName = module.packageName
) {
consoleGuard {
console.write("\u001B[H")
ObjVoid
}
}
addClassFnDoc(
name = "clear",
doc = "Clear the visible screen buffer.",
moduleName = module.packageName
) {
consoleGuard {
console.write("\u001B[2J")
ObjVoid
}
}
addClassFnDoc(
name = "moveTo",
doc = "Move cursor to 1-based row and column.",
params = listOf(
ParamDoc("row", type("lyng.Int")),
ParamDoc("column", type("lyng.Int")),
),
moduleName = module.packageName
) {
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
}
}
addClassFnDoc(
name = "clearLine",
doc = "Clear the current line.",
moduleName = module.packageName
) {
consoleGuard {
console.write("\u001B[2K")
ObjVoid
}
}
addClassFnDoc(
name = "enterAltScreen",
doc = "Switch to terminal alternate screen buffer.",
moduleName = module.packageName
) {
consoleGuard {
console.write("\u001B[?1049h")
ObjVoid
}
}
addClassFnDoc(
name = "leaveAltScreen",
doc = "Return from alternate screen buffer to normal screen.",
moduleName = module.packageName
) {
consoleGuard {
console.write("\u001B[?1049l")
ObjVoid
}
}
addClassFnDoc(
name = "setCursorVisible",
doc = "Show or hide the terminal cursor.",
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
moduleName = module.packageName
) {
consoleGuard {
val visible = requiredArg<ObjBool>(0).value
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
ObjVoid
}
}
addClassFnDoc(
name = "events",
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
returns = type("ConsoleEventStream"),
moduleName = module.packageName
) {
consoleGuard {
console.events().toConsoleEventStream()
}
}
addClassFnDoc(
name = "setRawMode",
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
returns = type("lyng.Bool"),
moduleName = module.packageName
) {
consoleGuard {
val enabled = requiredArg<ObjBool>(0).value
ObjBool(console.setRawMode(enabled))
}
}
}
module.addConstDoc(
name = "Console",
value = consoleType,
doc = "Console runtime API.",
type = type("Console"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleGeometry",
value = ObjConsoleGeometry.type,
doc = "Terminal geometry.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleDetails",
value = ObjConsoleDetails.type,
doc = "Consolidated console capability details.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleEvent",
value = ObjConsoleEvent.type,
doc = "Base class for console events.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleResizeEvent",
value = ObjConsoleResizeEvent.type,
doc = "Terminal resize event.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleKeyEvent",
value = ObjConsoleKeyEvent.typeObj,
doc = "Keyboard event.",
type = type("lyng.Class"),
moduleName = module.packageName
)
module.addConstDoc(
name = "ConsoleEventStream",
value = ObjConsoleEventStream.type,
doc = "Endless iterable stream of console events.",
type = type("lyng.Class"),
moduleName = module.packageName
)
}
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 {
addFnDoc(
name = "iterator",
doc = "Create an iterator over incoming console events.",
returns = type("lyng.Iterator"),
moduleName = "lyng.io.console",
) {
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
val event = source.nextEvent()
if (event == null) {
closeSource()
return false
}
cached = event.toObjEvent()
return true
}
private suspend fun closeSource() {
if (closed) return
closed = true
source.close()
}
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 {
addFnDoc(
name = "hasNext",
doc = "Whether another console event is available.",
returns = type("lyng.Bool"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().hasNext().toObj()
}
addFnDoc(
name = "next",
doc = "Return the next console event.",
returns = type("ConsoleEvent"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().next(requireScope())
}
addFnDoc(
name = "cancelIteration",
doc = "Stop reading console events and release resources.",
returns = type("lyng.Void"),
moduleName = "lyng.io.console",
) {
thisAs<ObjConsoleEventIterator>().closeSource()
ObjVoid
}
}
}
}
private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = "keydown", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = "keyup", key = key, code = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
}
private abstract class ObjConsoleEventBase(
private val eventType: String,
final override val objClass: net.sergeych.lyng.obj.ObjClass,
) : Obj() {
fun eventTypeName(): String = eventType
}
private class ObjConsoleEvent : ObjConsoleEventBase("event", type) {
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
addPropertyDoc(
name = "type",
doc = "Event type string: resize, keydown, keyup.",
type = type("lyng.String"),
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleEventBase).eventTypeName()) }
)
}
}
}
private class ObjConsoleResizeEvent(
val columns: Int,
val rows: Int,
) : ObjConsoleEventBase("resize", type) {
companion object {
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
addPropertyDoc(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() }
)
addPropertyDoc(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() }
)
}
}
}
private class ObjConsoleKeyEvent(
type: String,
val key: String,
val code: String?,
val ctrl: Boolean,
val alt: Boolean,
val shift: Boolean,
val meta: Boolean,
) : ObjConsoleEventBase(type, typeObj) {
companion object {
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
addPropertyDoc(
name = "key",
doc = "Logical key name (e.g. ArrowLeft, a, Escape).",
type = type("lyng.String"),
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) }
)
addPropertyDoc(
name = "code",
doc = "Optional hardware/code identifier.",
type = type("lyng.String", nullable = true),
moduleName = "lyng.io.console",
getter = {
val code = (this.thisObj as ObjConsoleKeyEvent).code
code?.let(::ObjString) ?: ObjNull
}
)
addPropertyDoc(
name = "ctrl",
doc = "Whether Ctrl modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() }
)
addPropertyDoc(
name = "alt",
doc = "Whether Alt modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() }
)
addPropertyDoc(
name = "shift",
doc = "Whether Shift modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() }
)
addPropertyDoc(
name = "meta",
doc = "Whether Meta/Super modifier is pressed.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
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 {
addPropertyDoc(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() }
)
addPropertyDoc(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() }
)
}
}
}
private class ObjConsoleDetails(
val supported: Boolean,
val isTty: Boolean,
val ansiLevel: String,
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 {
addPropertyDoc(
name = "supported",
doc = "Whether console API is supported.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() }
)
addPropertyDoc(
name = "isTty",
doc = "Whether output is connected to a TTY.",
type = type("lyng.Bool"),
moduleName = "lyng.io.console",
getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() }
)
addPropertyDoc(
name = "ansiLevel",
doc = "Detected ANSI color capability level.",
type = type("lyng.String"),
moduleName = "lyng.io.console",
getter = { ObjString((this.thisObj as ObjConsoleDetails).ansiLevel) }
)
addPropertyDoc(
name = "geometry",
doc = "Current terminal geometry or null.",
type = type("ConsoleGeometry", nullable = true),
moduleName = "lyng.io.console",
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,286 @@
/*
* 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 {
var lastWidth = t.updateSize().width
var lastHeight = t.updateSize().height
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
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
}
if (currentSize.width != lastWidth || currentSize.height != lastHeight) {
out.trySend(ConsoleEvent.Resize(currentSize.width, currentSize.height))
lastWidth = currentSize.width
lastHeight = currentSize.height
resizeEvents += 1
}
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 && (resized.width != lastWidth || resized.height != lastHeight)) {
out.trySend(ConsoleEvent.Resize(resized.width, resized.height))
lastWidth = resized.width
lastHeight = resized.height
}
when (ev) {
is KeyboardEvent -> {
keyEvents += 1
lastKeyMark = TimeSource.Monotonic.markNow()
out.trySend(
ConsoleEvent.KeyDown(
key = ev.key,
code = null,
ctrl = ev.ctrl,
alt = ev.alt,
shift = ev.shift,
meta = false,
)
)
}
else -> {
// Mouse/other events are ignored in Lyng console v1.
}
}
// Some terminals silently stop delivering keyboard events while raw reads keep succeeding.
// If we had keys before and then prolonged key inactivity, proactively recycle raw scope.
if (keyEvents > 0L &&
lastKeyMark.elapsedNow() >= 4.seconds &&
lastRawRecoveryMark.elapsedNow() >= 4.seconds
) {
if (rawModeRequested) {
consoleFlowDebug("events: key inactivity detected; forcing raw reset")
val resetOk = forceRawModeReset(t)
if (resetOk) {
consoleFlowDebug("events: raw reset succeeded during inactivity recovery")
lastKeyMark = TimeSource.Monotonic.markNow()
} else {
consoleFlowDebug("events: raw reset failed during inactivity recovery")
}
lastRawRecoveryMark = TimeSource.Monotonic.markNow()
}
}
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
consoleFlowDebug(
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
)
lastHeartbeatMark = TimeSource.Monotonic.markNow()
}
}
} catch (e: CancellationException) {
consoleFlowDebug("events: collector cancelled (normal)")
// normal
} catch (e: ScriptFlowIsNoMoreCollected) {
consoleFlowDebug("events: collector stopped by flow consumer (normal)")
// normal
} catch (e: Exception) {
consoleFlowDebug("events: collector loop failed", e)
// terminate event source loop
} finally {
consoleFlowDebug(
"events: collector ended uptime=${startMark.elapsedNow().inWholeMilliseconds}ms loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested"
)
out.close()
}
}
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
if (timeoutMs <= 0L) {
return out.receiveCatching().getOrNull()
}
return withTimeoutOrNull(timeoutMs.milliseconds) {
out.receiveCatching().getOrNull()
}
}
override suspend fun close() {
sourceState.withLock { running = false }
out.close()
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
val t = terminal ?: return false
return stateMutex.withLock {
if (enabled) {
if (!t.terminalInfo.inputInteractive) return@withLock false
if (rawModeRequested) return@withLock false
val scope = t.enterRawModeOrNull() ?: return@withLock false
rawModeScope = scope
rawModeRequested = true
consoleFlowDebug("setRawMode(true): enabled")
true
} else {
val hadRaw = rawModeRequested || rawModeScope != null
rawModeRequested = false
val scope = rawModeScope
rawModeScope = null
runCatching { scope?.close() }
.onFailure { consoleFlowDebug("setRawMode(false): close failed", it) }
consoleFlowDebug("setRawMode(false): disabled hadRaw=$hadRaw")
hadRaw
}
}
}
}
@@ -0,0 +1,23 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console
/**
* Get the system default console implementation.
*/
expect fun getSystemConsole(): LyngConsole
@@ -0,0 +1,55 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console.security
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
/**
* Primitive console operations for access control decisions.
*/
sealed interface ConsoleAccessOp {
data class WriteText(val length: Int) : ConsoleAccessOp
data object ReadEvents : ConsoleAccessOp
data class SetRawMode(val enabled: Boolean) : ConsoleAccessOp
}
class ConsoleAccessDeniedException(
val op: ConsoleAccessOp,
val reasonDetail: String? = null,
) : IllegalStateException("Console access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
/**
* Policy interface that decides whether a specific console operation is allowed.
*/
interface ConsoleAccessPolicy {
suspend fun check(op: ConsoleAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
suspend fun require(op: ConsoleAccessOp, ctx: AccessContext = AccessContext()) {
val res = check(op, ctx)
if (!res.isAllowed()) throw ConsoleAccessDeniedException(op, res.reason)
}
}
object PermitAllConsoleAccessPolicy : ConsoleAccessPolicy {
override suspend fun check(op: ConsoleAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Allow)
}
@@ -0,0 +1,68 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.console.security
import net.sergeych.lyngio.console.*
import net.sergeych.lyngio.fs.security.AccessContext
/**
* Decorator that applies a [ConsoleAccessPolicy] to a delegate [LyngConsole].
*/
class LyngConsoleSecured(
private val delegate: LyngConsole,
private val policy: ConsoleAccessPolicy,
private val ctx: AccessContext = AccessContext(),
) : LyngConsole {
override val isSupported: Boolean
get() = delegate.isSupported
override suspend fun isTty(): Boolean = delegate.isTty()
override suspend fun geometry(): ConsoleGeometry? = delegate.geometry()
override suspend fun ansiLevel(): ConsoleAnsiLevel = delegate.ansiLevel()
override suspend fun write(text: String) {
policy.require(ConsoleAccessOp.WriteText(text.length), ctx)
delegate.write(text)
}
override suspend fun flush() {
delegate.flush()
}
override fun events(): ConsoleEventSource {
val source = delegate.events()
return object : ConsoleEventSource {
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
policy.require(ConsoleAccessOp.ReadEvents, ctx)
return source.nextEvent(timeoutMs)
}
override suspend fun close() {
source.close()
}
}
}
override suspend fun setRawMode(enabled: Boolean): Boolean {
policy.require(ConsoleAccessOp.SetRawMode(enabled), ctx)
return delegate.setRawMode(enabled)
}
}
@@ -0,0 +1,264 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyngio.docs
import net.sergeych.lyng.miniast.BuiltinDocRegistry
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.type
object ConsoleBuiltinDocs {
private var registered = false
fun ensure() {
if (registered) return
BuiltinDocRegistry.module("lyng.io.console") {
classDoc(
name = "Console",
doc = "Console runtime API."
) {
method(
name = "isSupported",
doc = "Whether console control API is supported on this platform.",
returns = type("lyng.Bool"),
isStatic = true
)
method(
name = "isTty",
doc = "Whether stdout is attached to an interactive TTY.",
returns = type("lyng.Bool"),
isStatic = true
)
method(
name = "ansiLevel",
doc = "Detected ANSI color capability: NONE, BASIC16, ANSI256, TRUECOLOR.",
returns = type("lyng.String"),
isStatic = true
)
method(
name = "geometry",
doc = "Current terminal geometry or null.",
returns = type("ConsoleGeometry", nullable = true),
isStatic = true
)
method(
name = "details",
doc = "Get consolidated console details.",
returns = type("ConsoleDetails"),
isStatic = true
)
method(
name = "write",
doc = "Write text directly to console output.",
params = listOf(ParamDoc("text", type("lyng.String"))),
isStatic = true
)
method(
name = "flush",
doc = "Flush console output buffer.",
isStatic = true
)
method(
name = "home",
doc = "Move cursor to home position (1,1).",
isStatic = true
)
method(
name = "clear",
doc = "Clear the visible screen buffer.",
isStatic = true
)
method(
name = "moveTo",
doc = "Move cursor to 1-based row and column.",
params = listOf(
ParamDoc("row", type("lyng.Int")),
ParamDoc("column", type("lyng.Int")),
),
isStatic = true
)
method(
name = "clearLine",
doc = "Clear the current line.",
isStatic = true
)
method(
name = "enterAltScreen",
doc = "Switch to terminal alternate screen buffer.",
isStatic = true
)
method(
name = "leaveAltScreen",
doc = "Return from alternate screen buffer to normal screen.",
isStatic = true
)
method(
name = "setCursorVisible",
doc = "Show or hide the terminal cursor.",
params = listOf(ParamDoc("visible", type("lyng.Bool"))),
isStatic = true
)
method(
name = "events",
doc = "Endless iterable console event source (resize, keydown, keyup). Use in a loop, often inside launch.",
returns = type("ConsoleEventStream"),
isStatic = true
)
method(
name = "setRawMode",
doc = "Enable or disable raw keyboard mode. Returns true if mode changed.",
params = listOf(ParamDoc("enabled", type("lyng.Bool"))),
returns = type("lyng.Bool"),
isStatic = true
)
}
classDoc(
name = "ConsoleEventStream",
doc = "Endless iterable stream of console events."
) {
method(
name = "iterator",
doc = "Create an iterator over incoming console events.",
returns = type("lyng.Iterator")
)
}
classDoc(
name = "ConsoleGeometry",
doc = "Terminal geometry."
) {
field(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int")
)
field(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int")
)
}
classDoc(
name = "ConsoleDetails",
doc = "Consolidated console capability details."
) {
field(
name = "supported",
doc = "Whether console API is supported.",
type = type("lyng.Bool")
)
field(
name = "isTty",
doc = "Whether output is attached to a TTY.",
type = type("lyng.Bool")
)
field(
name = "ansiLevel",
doc = "Detected ANSI color capability.",
type = type("lyng.String")
)
field(
name = "geometry",
doc = "Current geometry or null.",
type = type("ConsoleGeometry", nullable = true)
)
}
classDoc(
name = "ConsoleEvent",
doc = "Base class for console events."
) {
field(
name = "type",
doc = "Event kind string.",
type = type("lyng.String")
)
}
classDoc(
name = "ConsoleResizeEvent",
doc = "Resize event."
) {
field(
name = "type",
doc = "Event kind string: resize.",
type = type("lyng.String")
)
field(
name = "columns",
doc = "Terminal width in character cells.",
type = type("lyng.Int")
)
field(
name = "rows",
doc = "Terminal height in character cells.",
type = type("lyng.Int")
)
}
classDoc(
name = "ConsoleKeyEvent",
doc = "Keyboard event."
) {
field(
name = "type",
doc = "Event kind string: keydown or keyup.",
type = type("lyng.String")
)
field(
name = "key",
doc = "Logical key name.",
type = type("lyng.String")
)
field(
name = "code",
doc = "Optional hardware code.",
type = type("lyng.String", nullable = true)
)
field(
name = "ctrl",
doc = "Ctrl modifier state.",
type = type("lyng.Bool")
)
field(
name = "alt",
doc = "Alt modifier state.",
type = type("lyng.Bool")
)
field(
name = "shift",
doc = "Shift modifier state.",
type = type("lyng.Bool")
)
field(
name = "meta",
doc = "Meta modifier state.",
type = type("lyng.Bool")
)
}
valDoc(
name = "Console",
doc = "Console runtime API.",
type = type("Console")
)
valDoc(name = "ConsoleGeometry", doc = "Terminal geometry class.", type = type("lyng.Class"))
valDoc(name = "ConsoleDetails", doc = "Console details class.", type = type("lyng.Class"))
valDoc(name = "ConsoleEvent", doc = "Base console event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleResizeEvent", doc = "Resize event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleKeyEvent", doc = "Keyboard event class.", type = type("lyng.Class"))
valDoc(name = "ConsoleEventStream", doc = "Iterable console event stream class.", type = type("lyng.Class"))
}
registered = true
}
}
@@ -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,496 @@
/*
* 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.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-r26-force-rebuild-on-noop-recovery-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 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
fun emitResize() {
val size = runCatching { activeTerm.size }.getOrNull() ?: return
out.trySend(ConsoleEvent.Resize(size.columns, size.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.hashCode() == prevReader.hashCode()) {
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()} -> forcing terminal rebuild")
if (!tryRebuildTerminal()) {
consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader")
}
} else {
consoleFlowDebug("jline-events: reader recovered oldReader=${prevReader.hashCode()} newReader=${reader.hashCode()}")
}
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 (_: InterruptedException) {
break
} catch (e: Throwable) {
readFailures.incrementAndGet()
consoleFlowDebug("jline-events: blocking read failed", e)
try {
Thread.sleep(50)
} catch (_: InterruptedException) {
break
}
}
}
}
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
if (requested && keyCodesRead.get() > 0L && idleMs >= 1400L) {
val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L
if (sinceRecoveryMs >= 1200L) {
recoveryRequested.set(true)
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() {
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 = 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 String)
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
}
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych"
version = "1.5.0-SNAPSHOT"
version = "1.5.0-RC"
// 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
}
@@ -1120,7 +1120,16 @@ class Compiler(
if (implicitType != null) {
resolutionSink?.referenceMember(name, pos, implicitType)
val ids = resolveImplicitThisMemberIds(name, pos, implicitType)
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, implicitType)
val inClassContext = codeContexts.any { ctx -> ctx is CodeContext.ClassBody }
val currentImplicitType = currentImplicitThisTypeName()
val preferredType = when {
inClassContext -> implicitType
// Extension receiver aliases (extern class name -> host runtime class) can fail strict
// variant casts; keep current receiver untyped but preserve non-current receivers.
implicitType == currentImplicitType -> null
else -> implicitType
}
return ImplicitThisMemberRef(name, pos, ids.fieldId, ids.methodId, preferredType)
}
if (classCtx != null && classCtx.classScopeMembers.contains(name)) {
resolutionSink?.referenceMember(name, pos, classCtx.name)
@@ -4779,6 +4788,11 @@ class Compiler(
if (payload != null) return payload
}
val receiverClass = resolveReceiverClassForMember(ref.receiver)
classMethodReturnClass(receiverClass, ref.name)?.let { return it }
inferFieldReturnClass(receiverClass, ref.name)?.let { return it }
if (receiverClass != null && isClassScopeCallableMember(receiverClass.className, ref.name)) {
resolveClassByName("${receiverClass.className}.${ref.name}")?.let { return it }
}
return inferMethodCallReturnClass(ref.name)
}
@@ -306,17 +306,41 @@ private class Parser(fromPos: Pos) {
'\'' -> {
val start = pos.toPos()
var value = currentChar
pos.advance()
if (currentChar == '\\') {
value = currentChar
pos.advance()
value = when (value) {
'n' -> '\n'
'r' -> '\r'
't' -> '\t'
'\'', '\\' -> value
else -> throw ScriptError(currentPos, "unsupported escape character: $value")
if (pos.end) throw ScriptError(start, "unterminated character literal")
value = when (currentChar) {
'n' -> {
pos.advance()
'\n'
}
'r' -> {
pos.advance()
'\r'
}
't' -> {
pos.advance()
'\t'
}
'\'' -> {
pos.advance()
'\''
}
'\\' -> {
pos.advance()
'\\'
}
'u' -> loadUnicodeEscape(start)
else -> throw ScriptError(currentPos, "unsupported escape character: $currentChar")
}
} else {
pos.advance()
}
if (currentChar != '\'') throw ScriptError(currentPos, "expected end of character literal: '")
pos.advance()
@@ -494,6 +518,10 @@ private class Parser(fromPos: Pos) {
sb.append('\\'); pos.advance()
}
'u' -> {
sb.append(loadUnicodeEscape(start))
}
else -> {
sb.append('\\').append(currentChar)
pos.advance()
@@ -520,6 +548,23 @@ private class Parser(fromPos: Pos) {
return Token(result, start, Token.Type.STRING)
}
private fun loadUnicodeEscape(start: Pos): Char {
// Called when currentChar points to 'u' right after a backslash.
if (currentChar != 'u') throw ScriptError(currentPos, "expected unicode escape marker: u")
pos.advance() ?: throw ScriptError(start, "unterminated unicode escape")
var code = 0
repeat(4) {
val ch = currentChar
if (ch !in hexDigits) {
throw ScriptError(currentPos, "invalid unicode escape sequence, expected 4 hex digits")
}
code = (code shl 4) + ch.digitToInt(16)
pos.advance()
}
return code.toChar()
}
/**
* Load characters from the set until it reaches EOF or invalid character found.
* stop at EOF on character filtered by [isValidChar].
@@ -20,6 +20,8 @@ package net.sergeych.lyng
import kotlinx.coroutines.delay
import kotlinx.coroutines.yield
import net.sergeych.lyng.Script.Companion.defaultImportManager
import net.sergeych.lyng.bridge.bind
import net.sergeych.lyng.bridge.bindObject
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.*
@@ -30,6 +32,7 @@ import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer
import kotlin.math.*
import kotlin.random.Random as KRandom
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
class Script(
@@ -588,11 +591,97 @@ class Script(
}
}
private fun seededRandomFromThis(scope: Scope, thisObj: Obj): KRandom {
val instance = thisObj as? ObjInstance
?: scope.raiseIllegalState("SeededRandom method requires instance receiver")
val stored = instance.kotlinInstanceData
if (stored is KRandom) return stored
return KRandom.Default.also { instance.kotlinInstanceData = it }
}
private suspend fun sampleRangeValue(scope: Scope, random: KRandom, range: ObjRange): Obj {
if (range.start == null || range.start.isNull || range.end == null || range.end.isNull) {
scope.raiseIllegalArgument("Random.next(range) requires a finite range")
}
val start = range.start
val end = range.end
// Real ranges without explicit step are sampled continuously.
if (!range.hasExplicitStep &&
start is Numeric &&
end is Numeric &&
(start !is ObjInt || end !is ObjInt)
) {
val from = start.doubleValue
val to = end.doubleValue
if (from > to || (!range.isEndInclusive && from == to)) {
scope.raiseIllegalArgument("Random.next(range) got an empty numeric range")
}
if (from == to) return ObjReal(from)
val upperExclusive = if (range.isEndInclusive) to.nextUp() else to
if (upperExclusive <= from) {
scope.raiseIllegalArgument("Random.next(range) got an empty numeric range")
}
return ObjReal(random.nextDouble(from, upperExclusive))
}
// Discrete sampling for stepped ranges and integer/char ranges.
var picked: Obj? = null
var count = 0L
range.enumerate(scope) { value ->
count += 1
if (random.nextLong(count) == 0L) {
picked = value
}
true
}
if (count <= 0L || picked == null) {
scope.raiseIllegalArgument("Random.next(range) got an empty range")
}
return picked
}
val defaultImportManager: ImportManager by lazy {
ImportManager(rootScope, SecurityManager.allowAll).apply {
addPackage("lyng.stdlib") { module ->
module.eval(Source("lyng.stdlib", rootLyng))
ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator"))
val seededRandomClass = module.requireClass("SeededRandom")
module.bind("SeededRandom") {
init { data = KRandom.Default }
addFun("nextInt") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
ObjInt.of(rnd.nextInt().toLong())
}
addFun("nextFloat") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
ObjReal(rnd.nextDouble())
}
addFun("next") {
val rnd = seededRandomFromThis(requireScope(), thisObj)
val range = requiredArg<ObjRange>(0)
sampleRangeValue(requireScope(), rnd, range)
}
}
module.bindObject("Random") {
addFun("nextInt") {
ObjInt.of(KRandom.Default.nextInt().toLong())
}
addFun("nextFloat") {
ObjReal(KRandom.Default.nextDouble())
}
addFun("next") {
val range = requiredArg<ObjRange>(0)
sampleRangeValue(requireScope(), KRandom.Default, range)
}
addFun("seeded") {
val seed = requiredArg<ObjInt>(0).value.toInt()
val instance = call(seededRandomClass) as? ObjInstance
?: requireScope().raiseIllegalState("SeededRandom() did not return an object instance")
instance.kotlinInstanceData = KRandom(seed)
instance
}
}
}
addPackage("lyng.observable") { module ->
module.addConst("Observable", ObjObservable)
@@ -1067,18 +1067,9 @@ class BytecodeCompiler(
updateSlotType(dst, SlotType.OBJ)
return CompiledValue(dst, SlotType.OBJ)
}
if (receiverClass == null && memberName == "negate") {
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
val zeroSlot = allocSlot()
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
updateSlotType(zeroSlot, SlotType.INT)
val obj = ensureObjSlot(value)
val dst = allocSlot()
builder.emit(Opcode.SUB_OBJ, zeroSlot, obj.slot, dst)
updateSlotType(dst, SlotType.OBJ)
return CompiledValue(dst, SlotType.OBJ)
}
if (memberName == "negate" && receiverClass in setOf(ObjInt.type, ObjReal.type)) {
if (memberName == "negate" &&
(receiverClass == null || isDelegateClass(receiverClass) || receiverClass in setOf(ObjInt.type, ObjReal.type))
) {
val zeroId = builder.addConst(BytecodeConst.IntVal(0))
val zeroSlot = allocSlot()
builder.emit(Opcode.CONST_INT, zeroId, zeroSlot)
@@ -1095,6 +1086,11 @@ class BytecodeCompiler(
)
}
private fun isDelegateClass(receiverClass: ObjClass): Boolean =
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
private fun operatorMemberName(op: BinOp): String? = when (op) {
BinOp.PLUS -> "plus"
BinOp.MINUS -> "minus"
@@ -1142,11 +1138,7 @@ class BytecodeCompiler(
): CompiledValue? {
val memberName = operatorMemberName(op) ?: return null
val receiverClass = resolveReceiverClass(leftRef)
if (receiverClass == null ||
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
) {
if (receiverClass == null || isDelegateClass(receiverClass)) {
val objOpcode = when (op) {
BinOp.PLUS -> Opcode.ADD_OBJ
BinOp.MINUS -> Opcode.SUB_OBJ
@@ -4821,9 +4813,26 @@ class BytecodeCompiler(
private data class CallArgs(val base: Int, val count: Int, val planId: Int?)
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
private fun extensionReceiverTypeNames(receiverClass: ObjClass): Set<String> {
val names = LinkedHashSet<String>()
for (cls in receiverClass.mro) {
val candidate = extensionCallableName(cls.className, memberName)
names.add(cls.className)
for ((knownName, knownClass) in nameObjClass) {
if (knownClass !== cls && knownClass.className != cls.className) continue
names.add(knownName)
names.add(knownName.substringAfterLast('.'))
}
}
return names
}
private fun resolveExtensionSlotByReceiverNames(
receiverClass: ObjClass,
memberName: String,
wrapperName: (String, String) -> String
): CompiledValue? {
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val candidate = wrapperName(receiverName, memberName)
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
@@ -4835,32 +4844,39 @@ class BytecodeCompiler(
return null
}
private fun resolveUniqueExtensionWrapperSlot(
memberName: String,
wrapperPrefix: String
): CompiledValue? {
val suffix = "__$memberName"
val candidates = LinkedHashSet<String>()
for (name in localSlotIndexByName.keys) {
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
candidates.add(name)
}
}
for (name in scopeSlotIndexByName.keys) {
if (name.startsWith(wrapperPrefix) && name.endsWith(suffix)) {
candidates.add(name)
}
}
if (candidates.size != 1) return null
return resolveDirectNameSlot(candidates.first())
}
private fun resolveExtensionCallableSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionCallableName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext__")
}
private fun resolveExtensionGetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
for (cls in receiverClass.mro) {
val candidate = extensionPropertyGetterName(cls.className, memberName)
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertyGetterName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_get__")
}
private fun resolveExtensionSetterSlot(receiverClass: ObjClass, memberName: String): CompiledValue? {
for (cls in receiverClass.mro) {
val candidate = extensionPropertySetterName(cls.className, memberName)
if (allowedScopeNames != null &&
!allowedScopeNames.contains(candidate) &&
!localSlotIndexByName.containsKey(candidate)
) {
continue
}
resolveDirectNameSlot(candidate)?.let { return it }
}
return null
return resolveExtensionSlotByReceiverNames(receiverClass, memberName, ::extensionPropertySetterName)
?: resolveUniqueExtensionWrapperSlot(memberName, "__ext_set__")
}
private fun compileCallArgsWithReceiver(
@@ -7468,7 +7484,7 @@ class BytecodeCompiler(
if (targetClass == null) return null
if (targetClass == ObjDynamic.type) return ObjDynamic.type
classFieldTypesByName[targetClass.className]?.get(name)?.let { cls ->
if (cls.className == "Delegate" || cls.className == "LazyDelegate" || cls.implementingNames.contains("Delegate")) {
if (isDelegateClass(cls)) {
return null
}
return cls
@@ -7555,8 +7571,8 @@ class BytecodeCompiler(
private fun queueExtensionCallableNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) {
val name = extensionCallableName(cls.className, memberName)
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val name = extensionCallableName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(name)) {
pendingScopeNameRefs.add(name)
}
@@ -7565,12 +7581,12 @@ class BytecodeCompiler(
private fun queueExtensionPropertyNames(receiverClass: ObjClass, memberName: String) {
if (!useScopeSlots && globalSlotInfo.isEmpty()) return
for (cls in receiverClass.mro) {
val getter = extensionPropertyGetterName(cls.className, memberName)
for (receiverName in extensionReceiverTypeNames(receiverClass)) {
val getter = extensionPropertyGetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(getter)) {
pendingScopeNameRefs.add(getter)
}
val setter = extensionPropertySetterName(cls.className, memberName)
val setter = extensionPropertySetterName(receiverName, memberName)
if (allowedScopeNames == null || allowedScopeNames.contains(setter)) {
pendingScopeNameRefs.add(setter)
}
@@ -3784,6 +3784,7 @@ class CmdFrame(
val exceptionSlot: Int,
val catchIp: Int,
val finallyIp: Int,
val iterDepthAtPush: Int,
var inCatch: Boolean = false
)
internal val tryStack = ArrayDeque<TryHandler>()
@@ -4069,11 +4070,15 @@ class CmdFrame(
return scope
}
fun handleException(t: Throwable): Boolean {
suspend fun handleException(t: Throwable): Boolean {
val handler = tryStack.lastOrNull() ?: return false
vmIterDebug(
"handleException fn=${fn.name} throwable=${t::class.simpleName} message=${t.message} catchIp=${handler.catchIp} finallyIp=${handler.finallyIp} iterDepth=${iterStack.size}"
)
val finallyIp = handler.finallyIp
if (t is ReturnException || t is LoopBreakContinueException) {
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:returnOrLoop->finally")
pendingThrowable = t
ip = finallyIp
return true
@@ -4082,6 +4087,7 @@ class CmdFrame(
}
if (handler.inCatch) {
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:inCatch->finally")
pendingThrowable = t
ip = finallyIp
return true
@@ -4091,6 +4097,7 @@ class CmdFrame(
handler.inCatch = true
pendingThrowable = t
if (handler.catchIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toCatch")
val caughtObj = when (t) {
is ExecutionError -> t.errorObject
else -> ObjUnknownException(ensureScope(), t.message ?: t.toString())
@@ -4100,6 +4107,7 @@ class CmdFrame(
return true
}
if (finallyIp >= 0) {
cancelIteratorsToDepth(handler.iterDepthAtPush, "handleException:toFinallyNoCatch")
ip = finallyIp
return true
}
@@ -4107,7 +4115,7 @@ class CmdFrame(
}
fun pushTry(exceptionSlot: Int, catchIp: Int, finallyIp: Int) {
tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp))
tryStack.addLast(TryHandler(exceptionSlot, catchIp, finallyIp, iterDepthAtPush = iterStack.size))
}
fun popTry() {
@@ -4164,24 +4172,47 @@ class CmdFrame(
fun pushIterator(iter: Obj) {
iterStack.addLast(iter)
if (iter.objClass.className == "FlowIterator") {
vmIterDebug("pushIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
}
}
fun popIterator() {
val iter = iterStack.lastOrNull()
if (iter != null && iter.objClass.className == "FlowIterator") {
vmIterDebug("popIterator fn=${fn.name} depth=${iterStack.size} iterClass=${iter.objClass.className}")
}
iterStack.removeLastOrNull()
}
suspend fun cancelTopIterator() {
val iter = iterStack.removeLastOrNull() ?: return
vmIterDebug("cancelTopIterator fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
}
suspend fun cancelIterators() {
while (iterStack.isNotEmpty()) {
val iter = iterStack.removeLast()
vmIterDebug("cancelIterators fn=${fn.name} depthAfter=${iterStack.size} iterClass=${iter.objClass.className}")
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
}
}
private suspend fun cancelIteratorsToDepth(depth: Int, reason: String) {
while (iterStack.size > depth) {
val iter = iterStack.removeLast()
vmIterDebug(
"cancelIteratorsToDepth fn=${fn.name} reason=$reason targetDepth=$depth depthAfter=${iterStack.size} iterClass=${iter.objClass.className}"
)
try {
iter.invokeInstanceMethod(ensureScope(), "cancelIteration") { ObjVoid }
} catch (e: Throwable) {
vmIterDebug("cancelIteratorsToDepth: cancelIteration failed fn=${fn.name} reason=$reason", e)
}
}
}
fun pushSlotPlan(plan: Map<String, Int>) {
if (scope.hasSlotPlanConflict(plan)) {
scopeStack.addLast(scope)
@@ -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)
@@ -1,5 +1,5 @@
/*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -24,7 +24,8 @@ import kotlinx.coroutines.channels.ReceiveChannel
import kotlinx.coroutines.channels.SendChannel
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.*
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.TypeGenericDoc
import net.sergeych.lyng.miniast.addFnDoc
@@ -55,7 +56,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
else
// Flow consumer is no longer collecting; signal producer to stop
throw ScriptFlowIsNoMoreCollected()
} catch (x: Exception) {
} catch (x: Throwable) {
// Any failure to send (including closed channel) should gracefully stop the producer.
if (x is CancellationException) {
// Cancellation is a normal control-flow event
@@ -80,7 +81,7 @@ private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj
producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK
} catch (x: Exception) {
} catch (x: Throwable) {
channel.close(x)
return@globalLaunch
}
@@ -172,4 +172,73 @@ class StdlibTest {
""".trimIndent())
}
@Test
fun testRandomSeededDeterministic() = runTest {
eval("""
val a = Random.seeded(123456)
val b = Random.seeded(123456)
for( i in 1..20 ) {
assertEquals(a.nextInt(), b.nextInt())
assertEquals(a.nextFloat(), b.nextFloat())
assertEquals(a.next(1..100), b.next(1..100))
}
""".trimIndent())
}
@Test
fun testRandomNextFloatBounds() = runTest {
eval("""
for( i in 1..400 ) {
val x = Random.nextFloat()
assert(x >= 0.0)
assert(x < 1.0)
}
""".trimIndent())
}
@Test
fun testRandomNextRangeVariants() = runTest {
eval("""
val rnd = Random.seeded(77)
for( i in 1..300 ) {
val x = rnd.next(10..<20)
assert(x in 10..<20)
}
val allowed = [0, 3, 6, 9]
for( i in 1..300 ) {
val x = rnd.next(0..9 step 3)
assert(x in allowed)
}
for( i in 1..300 ) {
val ch = rnd.next('a'..<'f')
assert(ch in 'a'..<'f')
}
for( i in 1..300 ) {
val rf = rnd.next(1.5..<4.5)
assert(rf >= 1.5)
assert(rf < 4.5)
}
val qAllowed = [0.0, 0.25, 0.5, 0.75, 1.0]
for( i in 1..300 ) {
val q = rnd.next(0.0..1.0 step 0.25)
assert(q in qAllowed)
}
""".trimIndent())
}
@Test
fun testRandomRejectsOpenRange() = runTest {
eval("""
assertThrows(IllegalArgumentException) { Random.next(1..) }
assertThrows(IllegalArgumentException) { Random.next(..10) }
assertThrows(IllegalArgumentException) { Random.next(..) }
""".trimIndent())
}
}
+210 -82
View File
@@ -16,9 +16,10 @@
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.eval
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjNull
import kotlin.test.Test
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
@@ -27,33 +28,42 @@ class TypesTest {
@Test
fun testTypeCollection1() = runTest {
eval("""
eval(
"""
class Point(x: Real, y: Real)
assert(Point(1,2).x == 1)
assert(Point(1,2).y == 2)
assert(Point(1,2) is Point)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testTypeCollection2() = runTest {
eval("""
eval(
"""
fun fn1(x: Real, y: Real): Real { x + y }
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testTypeCollection3() = runTest {
eval("""
eval(
"""
class Test(a: Int) {
fun fn1(x: Real, y: Real): Real { x + y }
}
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testExternDeclarations() = runTest {
eval("""
eval(
"""
extern fun foo1(a: String): Void
assertThrows { foo1("1") }
class Test(a: Int) {
@@ -69,22 +79,26 @@ class TypesTest {
}
// println("4")
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testUserClassCompareTo() = runTest {
eval("""
eval(
"""
class Point(val a,b)
assertEquals(Point(0,1), Point(0,1) )
assertNotEquals(Point(0,1), Point(1,1) )
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testUserClassCompareTo2() = runTest {
eval("""
eval(
"""
class Point(val a,b) {
var c = 0
}
@@ -98,12 +112,14 @@ class TypesTest {
assertEquals(p1, p2)
assertNotEquals(Point(0,1), Point(1,1) )
assertNotEquals(Point(0,1), p3)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testNumericInference() = runTest {
eval("""
eval(
"""
val x = 1
var y = 2.0
assert( x is Int )
@@ -111,11 +127,14 @@ class TypesTest {
assert( x + y is Real )
assert( abs(x+y) is Real )
assert( abs(x/y) is Real )
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testNumericInferenceBug1() = runTest {
eval("""
eval(
"""
fun findSumLimit(f) {
var sum = 0.0
for( n in 1..100 ) {
@@ -142,12 +161,14 @@ class TypesTest {
val limit = findSumLimit { n -> 1.0/n/n }
assert( limit != null )
println("Result: "+limit)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testNullableHints() = runTest {
eval("""
eval(
"""
// nullable, without type os Object?
class N(x=null)
assertEquals(null, N().x)
@@ -167,7 +188,8 @@ class TypesTest {
@Test
fun testIsUnionIntersection() = runTest {
eval("""
eval(
"""
class A
class B
class C: A, B
@@ -179,7 +201,8 @@ class TypesTest {
val v = 1
assert( v is Int | String | Real )
assert( !(v is String | Bool) )
""".trimIndent())
""".trimIndent()
)
}
@Test
@@ -221,51 +244,64 @@ class TypesTest {
@Test
fun testListLiteralInferenceForBounds() = runTest {
eval("""
eval(
"""
fun acceptInts<T: Int>(xs: List<T>) { }
acceptInts([1, 2, 3])
val base = [1, 2]
acceptInts([...base, 3])
""".trimIndent())
eval("""
""".trimIndent()
)
eval(
"""
fun acceptReals<T: Real>(xs: List<T>) { }
acceptReals([1.0, 2.0, 3.0])
val base = [1.0, 2.0]
acceptReals([...base, 3.0])
""".trimIndent())
""".trimIndent()
)
assertFailsWith<net.sergeych.lyng.ScriptError> {
eval("""
eval(
"""
fun acceptInts<T: Int>(xs: List<T>) { }
acceptInts([1, "a"])
""".trimIndent())
""".trimIndent()
)
}
assertFailsWith<net.sergeych.lyng.ScriptError> {
eval("""
eval(
"""
fun acceptReals<T: Real>(xs: List<T>) { }
acceptReals([1.0, "a"])
""".trimIndent())
""".trimIndent()
)
}
}
@Test
fun testMapLiteralInferenceForBounds() = runTest {
eval("""
eval(
"""
fun acceptMap<T: Int>(m: Map<String, T>) { }
acceptMap({ "a": 1, "b": 2 })
val base = { "a": 1 }
acceptMap({ ...base, "b": 3 })
""".trimIndent())
""".trimIndent()
)
assertFailsWith<net.sergeych.lyng.ScriptError> {
eval("""
eval(
"""
fun acceptMap<T: Int>(m: Map<String, T>) { }
acceptMap({ "a": 1, "b": "x" })
""".trimIndent())
""".trimIndent()
)
}
}
@Test
fun testUnionTypeLists() = runTest {
eval("""
eval(
"""
fun fMixed<T>(list: List<T>) {
println(list)
@@ -282,12 +318,14 @@ class TypesTest {
}
fMixed([1, "two", true])
fInts([1,2,3])
""")
"""
)
}
@Test
fun testTypeAliases() = runTest {
eval("""
eval(
"""
type Num = Int | Real
type AB = A & B
class A
@@ -308,12 +346,14 @@ class TypesTest {
type IntList<T: Int> = List<T>
fun accept<T: Int>(xs: IntList<T>) { }
accept([1,2,3])
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testMultipleReceivers() = runTest {
eval("""
eval(
"""
class R1(shared,r1="r1")
class R2(shared,r2="r2")
@@ -340,69 +380,85 @@ class TypesTest {
assertEquals("r1", r1)
}
}
""")
"""
)
}
@Test
fun testLambdaTypes1() = runTest {
val scope = Script.newScope()
// declare: ok
scope.eval("""
scope.eval(
"""
var l1: (Int,String)->String
""".trimIndent())
""".trimIndent()
)
// this should be Lyng compile time exception
assertFailsWith<ScriptError> {
scope.eval("""
scope.eval(
"""
fun test() {
// compiler should detect that l1 us called with arguments that does not match
// declare type (Int,String)->String:
l1()
}
""".trimIndent())
""".trimIndent()
)
}
}
@Test
fun testLambdaTypesEllipsis() = runTest {
val scope = Script.newScope()
scope.eval("""
scope.eval(
"""
var l2: (Int,Object...,String)->Real
var l4: (Int,String...,String)->Real
var l3: (...)->Int
""".trimIndent())
""".trimIndent()
)
assertFailsWith<ScriptError> {
scope.eval("""
scope.eval(
"""
fun testTooFew() {
l2(1)
}
""".trimIndent())
""".trimIndent()
)
}
assertFailsWith<ScriptError> {
scope.eval("""
scope.eval(
"""
fun testWrongHead() {
l2("x", "y")
}
""".trimIndent())
""".trimIndent()
)
}
assertFailsWith<ScriptError> {
scope.eval("""
scope.eval(
"""
fun testWrongEllipsis() {
l4(1, 2, "x")
}
""".trimIndent())
""".trimIndent()
)
}
scope.eval("""
scope.eval(
"""
fun testOk1() { l2(1, "x") }
fun testOk2() { l2(1, 2, 3, "x") }
fun testOk3() { l3() }
fun testOk4() { l3(1, true, "x") }
fun testOk5() { l4(1, "a", "b", "x") }
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testSetTyped() = runTest {
eval("""
eval(
"""
var s = Set<String>()
val typed: Set<String> = s
assertEquals(Set(), typed)
@@ -413,12 +469,14 @@ class TypesTest {
assertEquals(Set(), s)
s += ["foo", "bar"]
assertEquals(Set("foo", "bar"), s)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testListTyped() = runTest {
eval("""
eval(
"""
var l = List<String>()
val typed: List<String> = l
assertEquals(List(), typed)
@@ -430,13 +488,15 @@ class TypesTest {
l += ["foo", "bar"]
assertEquals(List("foo", "bar"), l)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testAliasesInGenerics1() = runTest {
val scope = Script.newScope()
scope.eval("""
scope.eval(
"""
type IntList<T: Int> = List<T>
type IntMap<K,V> = Map<K,V>
type IntSet<T: Int> = Set<T>
@@ -459,13 +519,16 @@ class TypesTest {
assertEquals(Set("tag1", "tag2", Buffer("tag3")), x.tags)
x.tags += Buffer("tag4")
assertEquals(Set("tag1", "tag2", Buffer("tag3"), Buffer("tag4")), x.tags)
""")
scope.eval("""
"""
)
scope.eval(
"""
assert(x is X)
x.tags += "42"
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:
assertFailsWith<ScriptError> {
scope.eval(
@@ -479,7 +542,8 @@ class TypesTest {
@Test
fun testAliasesInGenericsList1() = runTest {
val scope = Script.newScope()
scope.eval("""
scope.eval(
"""
import lyng.buffer
type Tag = String | Buffer
@@ -495,12 +559,15 @@ class TypesTest {
assertEquals(List("tag1", "tag2", Buffer("tag3")), x.tags)
x.tags += ["tag4", Buffer("tag5")]
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5")), x.tags)
""")
scope.eval("""
"""
)
scope.eval(
"""
assert(x is X)
x.tags += "42"
assertEquals(List("tag1", "tag2", Buffer("tag3"), "tag4", Buffer("tag5"), "42"), x.tags)
""".trimIndent())
""".trimIndent()
)
assertFailsWith<ScriptError> {
scope.eval(
"""
@@ -512,18 +579,21 @@ class TypesTest {
@Test
fun testClassName() = runTest {
eval("""
eval(
"""
class X {
var x = 1
}
assert( X::class is Class)
assertEquals("Class", X::class.name)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testGenericTypes() = runTest {
eval("""
eval(
"""
fun t<T>(): String =
when(T) {
null -> "%s is Null"(T::class.name)
@@ -532,24 +602,28 @@ class TypesTest {
}
assert( Int is Object)
assertEquals( t<Int>(), "Class is Object")
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testGenericNullableTypePredicate() = runTest {
eval("""
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())
""".trimIndent()
)
}
@Test
fun testWhenNullableTypeCase() = runTest {
eval("""
eval(
"""
fun describe<T>(x: T): String = when(T) {
nullable -> "nullable"
else -> "non-null"
@@ -562,11 +636,14 @@ class TypesTest {
assertEquals("non-null", describe<Int>(1))
assertEquals("nullable", describeIs<Int?>(null))
assertEquals("non-null", describeIs<Int>(1))
""".trimIndent())
""".trimIndent()
)
}
@Test fun testIndexer() = runTest {
eval("""
@Test
fun testIndexer() = runTest {
eval(
"""
class Greeter {
override fun getAt(name) = "Hello, %s!"(name)
}
@@ -581,11 +658,14 @@ class TypesTest {
assertEquals("How do you do, Bob?",Polite["Bob"])
""".trimIndent())
""".trimIndent()
)
}
@Test fun testIndexer2() = runTest {
eval("""
@Test
fun testIndexer2() = runTest {
eval(
"""
class Foo(bar)
class Greeter {
@@ -613,17 +693,65 @@ class TypesTest {
assertEquals("How do you do, Bob?",g2v.bar)
assertEquals("How do you do, Bob?",Greeter2()["Bob"].bar)
""".trimIndent())
""".trimIndent()
)
}
@Test
fun testExternGenerics() = runTest {
eval("""
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
@@ -0,0 +1,60 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.ObjChar
import net.sergeych.lyng.obj.ObjString
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class UnicodeEscapeTest {
@Test
fun parserDecodesUnicodeEscapeInStringLiteral() {
val token = parseLyng("\"\\u263A\"".toSource()).first()
assertEquals(Token.Type.STRING, token.type)
assertEquals("☺", token.value)
}
@Test
fun parserDecodesUnicodeEscapeInCharLiteral() {
val token = parseLyng("'\\u263A'".toSource()).first()
assertEquals(Token.Type.CHAR, token.type)
assertEquals("☺", token.value)
}
@Test
fun parserRejectsMalformedUnicodeEscapeInStringLiteral() {
assertFailsWith<ScriptError> {
parseLyng("\"\\u12G4\"".toSource())
}
}
@Test
fun parserRejectsShortUnicodeEscapeInCharLiteral() {
assertFailsWith<ScriptError> {
parseLyng("'\\u12'".toSource())
}
}
@Test
fun evalDecodesUnicodeEscapes() = runTest {
assertEquals(ObjString("☺"), eval("\"\\u263A\""))
assertEquals(ObjChar('☺'), eval("'\\u263A'"))
}
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on JS
}
@@ -0,0 +1,46 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
import java.io.File
import java.time.Instant
private val vmIterLogFilePath: String =
System.getenv("LYNG_VM_DEBUG_LOG")
?.takeIf { it.isNotBlank() }
?: "/tmp/lyng_vm_iter_debug.log"
private val vmIterLogLock = Any()
internal actual fun vmIterDebug(message: String, error: Throwable?) {
runCatching {
val line = buildString {
append(Instant.now().toString())
append(" [vm-iter] ")
append(message)
append('\n')
if (error != null) {
append(error.stackTraceToString())
append('\n')
}
}
synchronized(vmIterLogLock) {
File(vmIterLogFilePath).appendText(line)
}
}
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on Native
}
@@ -0,0 +1,22 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.bytecode
internal actual fun vmIterDebug(message: String, error: Throwable?) {
// no-op on wasmJs
}
+40 -27
View File
@@ -8,22 +8,22 @@ extern class IllegalArgumentException
extern class NotImplementedException
extern class Delegate
extern class Iterable<T> {
extern fun iterator(): Iterator<T>
extern fun forEach(action: (T)->void): void
extern fun map<R>(transform: (T)->R): List<R>
extern fun toList(): List<T>
extern fun toImmutableList(): ImmutableList<T>
extern val toSet: Set<T>
extern val toImmutableSet: ImmutableSet<T>
extern val toMap: Map<Object,Object>
extern val toImmutableMap: ImmutableMap<Object,Object>
fun iterator(): Iterator<T>
fun forEach(action: (T)->void): void
fun map<R>(transform: (T)->R): List<R>
fun toList(): List<T>
fun toImmutableList(): ImmutableList<T>
val toSet: Set<T>
val toImmutableSet: ImmutableSet<T>
val toMap: Map<Object,Object>
val toImmutableMap: ImmutableMap<Object,Object>
}
extern class Iterator<T> {
extern fun hasNext(): Bool
extern fun next(): T
extern fun cancelIteration(): void
extern fun toList(): List<T>
fun hasNext(): Bool
fun next(): T
fun cancelIteration(): void
fun toList(): List<T>
}
// Host-provided iterator wrapper for Kotlin collections.
@@ -33,47 +33,47 @@ class KotlinIterator<T> : Iterator<T> {
}
extern class Collection<T> : Iterable<T> {
extern val size: Int
val size: Int
}
extern class Array<T> : Collection<T> {
}
extern class ImmutableList<T> : Array<T> {
extern fun toMutable(): List<T>
fun toMutable(): List<T>
}
extern class List<T> : Array<T> {
extern fun add(value: T, more...): void
extern fun toImmutable(): ImmutableList<T>
fun add(value: T, more...): void
fun toImmutable(): ImmutableList<T>
}
extern class RingBuffer<T> : Iterable<T> {
extern val size: Int
extern fun first(): T
extern fun add(value: T): void
val size: Int
fun first(): T
fun add(value: T): void
}
extern class Set<T> : Collection<T> {
extern fun toImmutable(): ImmutableSet<T>
fun toImmutable(): ImmutableSet<T>
}
extern class ImmutableSet<T> : Collection<T> {
extern fun toMutable(): Set<T>
fun toMutable(): Set<T>
}
extern class Map<K,V> : Collection<MapEntry<K,V>> {
extern fun toImmutable(): ImmutableMap<K,V>
fun toImmutable(): ImmutableMap<K,V>
}
extern class ImmutableMap<K,V> : Collection<MapEntry<K,V>> {
extern fun getOrNull(key: K): V?
extern fun toMutable(): Map<K,V>
fun getOrNull(key: K): V?
fun toMutable(): Map<K,V>
}
extern class MapEntry<K,V> : Array<Object> {
extern val key: K
extern val value: V
val key: K
val value: V
}
// Built-in math helpers (implemented in host runtime).
@@ -82,6 +82,19 @@ extern fun ln(x: Object): Real
extern fun pow(x: Object, y: Object): Real
extern fun sqrt(x: Object): Real
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 =~ / !~.
var $~: Object? = null
+3 -2
View File
@@ -12,9 +12,10 @@ Current focus
Key recent changes
- 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
- Not checked in this session.
- None in :lynglib:jvmTest after Random/SeededRandom integration.
Last test run
- Not checked in this session.
- `./gradlew :lynglib:jvmTest` (PASS).
+1 -1
View File
@@ -339,7 +339,7 @@
<!-- Top-left version ribbon -->
<div class="corner-ribbon bg-danger text-white">
<span style="margin-left: -5em">
v1.5.0-SNAPSHOT!
v1.5.0-RC
</span>
</div>
<!-- Fixed top navbar for the whole site -->