Compare commits
1 Commits
master
...
heroic_att
| Author | SHA1 | Date | |
|---|---|---|---|
| f9ae00b7f4 |
41
AGENTS.md
41
AGENTS.md
@ -1,41 +0,0 @@
|
||||
# AI Agent Notes
|
||||
|
||||
## Canonical AI References
|
||||
- Use `docs/ai_language_reference.md` as the primary, compiler-verified Lyng language reference for code generation.
|
||||
- For generics-heavy code generation, follow `docs/ai_language_reference.md` section `7.1 Generics Runtime Model and Bounds` and `7.2 Differences vs Java / Kotlin / Scala`.
|
||||
- Use `docs/ai_stdlib_reference.md` for default runtime/module APIs and stdlib surface.
|
||||
- Treat `LYNG_AI_SPEC.md` and older docs as secondary if they conflict with the two files above.
|
||||
- Prefer the shortest clear loop: use `for` for straightforward iteration/ranges; use `while` only when loop state/condition is irregular or changes in ways `for` cannot express cleanly.
|
||||
- In Lyng code, slice strings with range indexing (`text[a..<b]`, `text[..<n]`, `text[n..]`) and avoid Java/Kotlin-style `substring(...)`.
|
||||
|
||||
## Lyng-First API Declarations
|
||||
- Use `.lyng` declarations as the single source of truth for Lyng-facing API docs and types (especially module extern declarations).
|
||||
- Prefer defining Lyng entities (enums/classes/type shapes) in `.lyng` files; only define them in Kotlin when there is Kotlin/platform-specific implementation detail that cannot be expressed in Lyng.
|
||||
- Avoid hardcoding Lyng API documentation in Kotlin registrars when it can be declared in `.lyng`; Kotlin-side docs should be fallback/bridge only.
|
||||
- For mixed pluggable modules (Lyng + Kotlin), embed module `.lyng` sources as generated Kotlin string literals, evaluate them into module scope during registration, then attach Kotlin implementations/bindings.
|
||||
|
||||
## Kotlin/Wasm generation guardrails
|
||||
- Avoid creating suspend lambdas for compiler runtime statements. Prefer explicit `object : Statement()` with `override suspend fun execute(...)`.
|
||||
- Do not use `statement { ... }` or other inline suspend lambdas in compiler hot paths (e.g., parsing/var declarations, initializer thunks).
|
||||
- If you need a wrapper for delegated properties, check for `getValue` explicitly and return a concrete `Statement` object when missing; avoid `onNotFoundResult` lambdas.
|
||||
- If wasmJs browser tests hang, first run `:lynglib:wasmJsNodeTest` and look for wasm compilation errors; hangs usually mean module instantiation failed.
|
||||
- Do not increase test timeouts to mask wasm generation errors; fix the invalid IR instead.
|
||||
|
||||
## Type inference notes (notes/new_lyng_type_system_spec.md)
|
||||
- Nullability is Kotlin-style: `T` non-null, `T?` nullable, `!!` asserts non-null.
|
||||
- `void` is a singleton of class `Void` (syntax sugar for return type).
|
||||
- Object members are always allowed even on unknown types; non-Object members require explicit casts. Remove `inspect` from Object and use `toInspectString()` instead.
|
||||
- Type expression checks: `x is T` is value instance check; `T1 is T2` is type-subset; `A in T` means `A` is subset of `T`; `==` is structural type equality.
|
||||
- Type aliases: `type Name = TypeExpr` (generic allowed) expand to their underlying type expressions; no nominal distinctness.
|
||||
- Bounds and variance: `T: A & B` / `T: A | B` for bounds; declaration-site variance with `out` / `in`.
|
||||
- Do not reintroduce bytecode fallback opcodes (e.g., `GET_NAME`, `EVAL_*`, `CALL_FALLBACK`) or runtime name-resolution fallbacks; all symbol resolution must stay compile-time only.
|
||||
|
||||
## Bytecode frame-first migration plan
|
||||
- Treat frame slots as the only storage for locals/temps by default; avoid pre-creating scope slot mappings for compiled functions.
|
||||
- Create closure references only when a capture is detected; use a direct frame+slot reference (foreign slot ref) instead of scope slots.
|
||||
- Keep Scope as a lazy reflection facade: resolve name -> slot only on demand for Kotlin interop (no eager name mapping on every call).
|
||||
- Avoid PUSH_SCOPE/POP_SCOPE in bytecode for loops/functions unless dynamic name access or Kotlin reflection is requested.
|
||||
|
||||
## ABI proposal notes
|
||||
- Runtime generic metadata for generic extern classes is tracked in `proposals/extern_generic_runtime_abi.md`.
|
||||
- Keep this design `Obj`-centric: do not assume extern-class values are `ObjInstance`; collection must be enabled on `ObjClass`.
|
||||
39
CHANGELOG.md
39
CHANGELOG.md
@ -1,31 +1,6 @@
|
||||
## 1.5.0-SNAPSHOT
|
||||
## Changelog
|
||||
|
||||
### Language Features
|
||||
- Added `return` statement with local and non-local exit support (`return@label`).
|
||||
- Support for `abstract` classes, methods, and variables.
|
||||
- Introduced `interface` as a synonym for `abstract class`.
|
||||
- Multiple Inheritance (MI) completed and enabled by default (C3 MRO).
|
||||
- Class properties with custom accessors (`get`, `set`).
|
||||
- Restricted setter visibility (`private set`, `protected set`).
|
||||
- Late-initialized `val` fields in classes with `Unset` protection.
|
||||
- Named arguments (`name: value`) and named splats (`...Map`).
|
||||
- Assign-if-null operator `?=`.
|
||||
- Refined `protected` visibility rules and `closed` modifier.
|
||||
- Transient attribute `@Transient` for serialization and equality.
|
||||
- Unified Delegation model for `val`, `var`, and `fun`.
|
||||
- Singleton objects (`object`) and object expressions.
|
||||
|
||||
### Standard Library
|
||||
- Added `with(self, block)` for scoped execution.
|
||||
- Added `clamp()` function and extension.
|
||||
- Improved `Exception` and `StackTraceEntry` reporting.
|
||||
|
||||
### Tooling and IDE
|
||||
- **CLI**: Added `fmt` as a first-class subcommand for code formatting.
|
||||
- **IDEA Plugin**: Lightweight autocompletion (experimental), improved docs, and Grazie integration.
|
||||
- **Highlighters**: Updated TextMate bundle and website highlighters for new syntax.
|
||||
|
||||
### Detailed Changes:
|
||||
### Unreleased
|
||||
|
||||
- Language: Refined `protected` visibility rules
|
||||
- Ancestor classes can now access `protected` members of their descendants, provided the ancestor also defines or inherits a member with the same name (indicating an override of a member known to the ancestor).
|
||||
@ -134,6 +109,16 @@
|
||||
|
||||
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO.
|
||||
|
||||
Notes:
|
||||
- Existing single-inheritance code continues to work; resolution reduces to the single base.
|
||||
- If code previously relied on non-deterministic parent set iteration, C3 MRO provides a predictable order; disambiguate explicitly if needed using `this@Type`/casts.
|
||||
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
## Unreleased
|
||||
|
||||
- CLI: Added `fmt` as a first-class Clikt subcommand.
|
||||
- Default behavior: formats files to stdout (no in-place edits by default).
|
||||
- Options:
|
||||
|
||||
@ -1,10 +1,9 @@
|
||||
# Lyng Language AI Specification (V1.5.0-SNAPSHOT)
|
||||
# Lyng Language AI Specification (V1.3)
|
||||
|
||||
High-density specification for LLMs. Reference this for all Lyng code generation.
|
||||
|
||||
## 1. Core Philosophy & Syntax
|
||||
- **Everything is an Expression**: Blocks, `if`, `when`, `for`, `while`, `do-while` return their last expression (or `void`).
|
||||
- **Static Types + Inference**: Every declaration has a compile-time type (explicit or inferred). Types are Kotlin‑style: non‑null by default, nullable with `?`.
|
||||
- **Loops with `else`**: `for`, `while`, and `do-while` support an optional `else` block.
|
||||
- `else` executes **only if** the loop finishes normally (without a `break`).
|
||||
- `break <value>` exits the loop and sets its return value.
|
||||
@ -14,14 +13,12 @@ High-density specification for LLMs. Reference this for all Lyng code generation
|
||||
3. Result of the last iteration (if loop finished normally and no `else`).
|
||||
4. `void` (if loop body never executed and no `else`).
|
||||
- **Implicit Coroutines**: All functions are coroutines. No `async/await`. Use `launch { ... }` (returns `Deferred`) or `flow { ... }`.
|
||||
- **Functions**: Use `fun` or the short form `fn`. Function declarations are expressions returning a callable.
|
||||
- **Variables**: `val` (read-only), `var` (mutable). Supports late-init `val` in classes (must be assigned in `init` or body).
|
||||
- **Serialization**: Use `@Transient` attribute before `val`/`var` or constructor parameters to exclude them from Lynon/JSON serialization. Transient fields are also ignored during `==` structural equality checks.
|
||||
- **Null Safety**: `?` (nullable type), `?.` (safe access), `?( )` (safe invoke), `?{ }` (safe block invoke), `?[ ]` (safe index), `?:` or `??` (elvis), `?=` (assign-if-null).
|
||||
- **Equality**: `==` (equals), `!=` (not equals), `===` (ref identity), `!==` (ref not identity).
|
||||
- **Comparison**: `<`, `>`, `<=`, `>=`, `<=>` (shuttle/spaceship, returns -1, 0, 1).
|
||||
- **Destructuring**: `val [a, b, rest...] = list`. Supports nested `[a, [b, c]]` and splats.
|
||||
- **Compile-Time Resolution Only**: All names/members must resolve at compile time. No runtime name lookup or fallback opcodes.
|
||||
|
||||
## 2. Object-Oriented Programming (OOP)
|
||||
- **Multiple Inheritance**: Supported with **C3 MRO** (Python-style). Diamond-safe.
|
||||
@ -40,27 +37,6 @@ High-density specification for LLMs. Reference this for all Lyng code generation
|
||||
- **Disambiguation**: `this@Base.member()` or `(obj as Base).member()`. `as` returns a qualified view.
|
||||
- **Abstract/Interface**: `interface` is a synonym for `abstract class`. Both support state and constructors.
|
||||
- **Extensions**: `fun Class.ext()` or `val Class.ext get = ...`. Scope-isolated.
|
||||
- **Member Access**: Object members (`toString`, `toInspectString`, `let`, `also`, `apply`, `run`) are allowed on unknown types; all other members require a statically known receiver type or explicit cast.
|
||||
|
||||
## 2.1 Type System (2026)
|
||||
- **Root Type**: Everything is an `Object` (root of the hierarchy).
|
||||
- **Nullability**: Non-null by default (`T`), nullable with `T?`, `!!` asserts non-null.
|
||||
- **Untyped params**: `fun foo(x)` -> `x: Object`, `fun foo(x?)` -> `x: Object?`.
|
||||
- **Untyped vars**: `var x` is `Unset` until first assignment locks the type (including nullability).
|
||||
- `val x = null` -> type `Null`; `var x = null` -> type `Object?`.
|
||||
- **Inference**:
|
||||
- List literals infer union element types; empty list defaults to `List<Object>` unless constrained.
|
||||
- Map literals infer key/value types; empty map defaults to `Map<Object, Object>` unless constrained.
|
||||
- Mixed numeric ops promote `Int` + `Real` to `Real`.
|
||||
- **Type aliases**: `type Name = TypeExpr` (generic allowed). Aliases expand to their underlying type expressions (no nominal distinctness).
|
||||
- **Generics**: Bounds with `T: A & B` or `T: A | B`; variance uses `out`/`in` (declaration‑site only).
|
||||
- **Casts**: `as` is a runtime-checked cast; `as?` is safe-cast returning `null`. If the value is nullable, `as T` implies `!!`.
|
||||
|
||||
## 2.2 Type Expressions and Checks
|
||||
- **Value checks**: `x is T` (runtime instance check).
|
||||
- **Type checks**: `T1 is T2` and `A in T` are subset checks between type expressions (compile-time where possible).
|
||||
- **Type equality**: `T1 == T2` is structural (unions/intersections are order‑insensitive).
|
||||
- **Compile-time enforcement**: Bounds are checked at call sites; runtime checks only appear when the compile‑time type is too general.
|
||||
|
||||
## 3. Delegation (`by`)
|
||||
Unified model for `val`, `var`, and `fun`.
|
||||
@ -87,11 +63,11 @@ Delegate Methods:
|
||||
- **Collections**: `List` ( `[a, b]` ), `Map` ( `Map(k => v)` ), `Set` ( `Set(a, b)` ). `MapEntry` ( `k => v` ).
|
||||
|
||||
## 5. Patterns & Shorthands
|
||||
- **Map Literals**: `{ key: value, identifier: }` (identifier shorthand `x:` is `x: x`). Empty map is `{:}`.
|
||||
- **Map Literals**: `{ key: value, identifier: }` (identifier shorthand `x:` is `x: x`). Empty map is `Map()`.
|
||||
- **Named Arguments**: `fun(y: 10, x: 5)`. Shorthand: `Point(x:, y:)`.
|
||||
- **Varargs & Splats**: `fun f(args...)`, `f(...otherList)`.
|
||||
- **Labels**: `loop@ for(x in list) { if(x == 0) break@loop }`.
|
||||
- **Dynamic**: `val d = dynamic { get { name -> ... } }` allows `d.anyName` via explicit dynamic handler (not implicit fallback).
|
||||
- **Dynamic**: `val d = dynamic { get { name -> ... } }` allows `d.anyName`.
|
||||
|
||||
## 6. Operators & Methods to Overload
|
||||
| Op | Method | Op | Method |
|
||||
|
||||
20
README.md
20
README.md
@ -25,16 +25,6 @@ Point(x:, y:).dist() //< 5
|
||||
fun swapEnds(first, args..., last, f) {
|
||||
f( last, ...args, first)
|
||||
}
|
||||
|
||||
class A {
|
||||
class B(x?)
|
||||
object Inner { val foo = "bar" }
|
||||
enum E* { One, Two }
|
||||
}
|
||||
val ab = A.B()
|
||||
assertEquals(null, ab.x)
|
||||
assertEquals("bar", A.Inner.foo)
|
||||
assertEquals(A.E.One, A.One)
|
||||
```
|
||||
|
||||
- extremely simple Kotlin integration on any platform (JVM, JS, WasmJS, Lunux, MacOS, iOS, Windows)
|
||||
@ -48,7 +38,6 @@ assertEquals(A.E.One, A.One)
|
||||
|
||||
- [Language home](https://lynglang.com)
|
||||
- [introduction and tutorial](docs/tutorial.md) - start here please
|
||||
- [What's New in 1.5](docs/whats_new_1_5.md)
|
||||
- [Testing and Assertions](docs/Testing.md)
|
||||
- [Filesystem and Processes (lyngio)](docs/lyngio.md)
|
||||
- [Return Statement](docs/return_statement.md)
|
||||
@ -56,7 +45,6 @@ assertEquals(A.E.One, A.One)
|
||||
- [Samples directory](docs/samples)
|
||||
- [Formatter (core + CLI + IDE)](docs/formatter.md)
|
||||
- [Books directory](docs)
|
||||
- [AI agent guidance](AGENTS.md)
|
||||
|
||||
## Integration in Kotlin multiplatform
|
||||
|
||||
@ -64,7 +52,7 @@ assertEquals(A.E.One, A.One)
|
||||
|
||||
```kotlin
|
||||
// update to current please:
|
||||
val lyngVersion = "1.5.0-SNAPSHOT"
|
||||
val lyngVersion = "0.6.1-SNAPSHOT"
|
||||
|
||||
repositories {
|
||||
// ...
|
||||
@ -177,7 +165,7 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
|
||||
|
||||
# Language Roadmap
|
||||
|
||||
We are now at **v1.5.0-SNAPSHOT** (stable development cycle): basic optimization performed, battery included: standard library is 90% here, initial
|
||||
We are now at **v1.0**: basic optimization performed, battery included: standard library is 90% here, initial
|
||||
support in HTML, popular editors, and IDEA; tools to syntax highlight and format code are ready. It was released closed to schedule.
|
||||
|
||||
Ready features:
|
||||
@ -217,7 +205,7 @@ Ready features:
|
||||
|
||||
All of this is documented in the [language site](https://lynglang.com) and locally [docs/language.md](docs/tutorial.md). the current nightly builds published on the site and in the private maven repository.
|
||||
|
||||
## plan: towards v2.0 Next Generation
|
||||
## plan: towards v1.5 Enhancing
|
||||
|
||||
- [x] site with integrated interpreter to give a try
|
||||
- [x] kotlin part public API good docs, integration focused
|
||||
@ -243,4 +231,4 @@ __Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, d
|
||||
|
||||
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
|
||||
|
||||
[parallelism]: docs/parallelism.md
|
||||
[parallelism]: docs/parallelism.md
|
||||
@ -20,12 +20,13 @@
|
||||
set -e
|
||||
echo "publishing all artifacts"
|
||||
echo
|
||||
./gradlew publishToMavenLocal site:jsBrowserDistribution publish buildInstallablePlugin :lyng:linkReleaseExecutableLinuxX64 :lyng:installJvmDist --parallel
|
||||
./gradlew publishToMavenLocal
|
||||
./gradlew publish
|
||||
|
||||
#echo
|
||||
#echo "Creating plugin"
|
||||
#echo
|
||||
#./gradlew buildInstallablePlugin
|
||||
echo
|
||||
echo "Creating plugin"
|
||||
echo
|
||||
./gradlew buildInstallablePlugin
|
||||
|
||||
echo
|
||||
echo "building CLI tools"
|
||||
|
||||
@ -35,27 +35,3 @@ tasks.register<Exec>("generateDocs") {
|
||||
description = "Generates a single-file documentation HTML using bin/generate_docs.sh"
|
||||
commandLine("./bin/generate_docs.sh")
|
||||
}
|
||||
|
||||
// Sample generator task for .lyng.d definition files (not wired into build).
|
||||
// Usage: ./gradlew generateLyngDefsSample
|
||||
tasks.register("generateLyngDefsSample") {
|
||||
group = "lyng"
|
||||
description = "Generate a sample .lyng.d file under build/generated/lyng/defs"
|
||||
outputs.dir(layout.buildDirectory.dir("generated/lyng/defs"))
|
||||
doLast {
|
||||
val outDir = layout.buildDirectory.dir("generated/lyng/defs").get().asFile
|
||||
outDir.mkdirs()
|
||||
val outFile = outDir.resolve("sample.lyng.d")
|
||||
outFile.writeText(
|
||||
"""
|
||||
/** Generated API */
|
||||
extern fun ping(): Int
|
||||
|
||||
/** Generated class */
|
||||
class Generated(val name: String) {
|
||||
fun greet(): String = "hi " + name
|
||||
}
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,7 +0,0 @@
|
||||
# Bytecode Migration Plan (Archived)
|
||||
|
||||
Status: completed.
|
||||
|
||||
Historical reference:
|
||||
- `notes/archive/bytecode_migration_plan.md` (full plan)
|
||||
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
|
||||
@ -1,8 +1,8 @@
|
||||
# Array
|
||||
|
||||
It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
|
||||
Array therefore implements [Iterable] too. Well known implementations of `Array` are
|
||||
[List] and [ImmutableList].
|
||||
Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
|
||||
[List].
|
||||
|
||||
Array adds the following methods:
|
||||
|
||||
@ -35,4 +35,3 @@ To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families,
|
||||
[Collection]: Collection.md
|
||||
[Iterable]: Iterable.md
|
||||
[List]: List.md
|
||||
[ImmutableList]: ImmutableList.md
|
||||
|
||||
@ -1,280 +0,0 @@
|
||||
# Lyng Bytecode VM Spec v0 (Draft)
|
||||
|
||||
This document describes a register-like (3-address) bytecode for Lyng with
|
||||
dynamic slot width (8/16/32-bit slot IDs), a slot-tail argument model, and
|
||||
typed lanes for Obj/Int/Real/Bool. The VM is intended to run as a suspendable
|
||||
interpreter and fall back to the existing AST execution when needed.
|
||||
|
||||
## 1) Frame & Slot Model
|
||||
|
||||
### Frame metadata
|
||||
- localCount: number of local slots for this function (fixed at compile time).
|
||||
- argCount: number of arguments passed at call time.
|
||||
- scopeSlotNames: optional debug names for scope slots (locals/params), aligned to slot mapping.
|
||||
- argBase = localCount.
|
||||
|
||||
### Slot layout
|
||||
slots[0 .. localCount-1] locals
|
||||
slots[localCount .. localCount+argCount-1] arguments
|
||||
|
||||
### Typed lanes
|
||||
- slotType[]: UNKNOWN/OBJ/INT/REAL/BOOL
|
||||
- objSlots[], intSlots[], realSlots[], boolSlots[]
|
||||
- A slot is a logical index; active lane is selected by slotType.
|
||||
|
||||
### Parameter access
|
||||
- param i => slot localCount + i
|
||||
- variadic extra => slot localCount + declaredParamCount + k
|
||||
|
||||
### Debug metadata (optional)
|
||||
- scopeSlotNames: array sized scopeSlotCount, each entry nullable.
|
||||
- Intended for disassembly/debug tooling; VM semantics do not depend on it.
|
||||
|
||||
### Constant pool extras
|
||||
- SlotPlan: map of name -> slot index, used by PUSH_SCOPE to pre-allocate and map loop locals.
|
||||
- CallArgsPlan: ordered argument specs (name/splat) + tailBlock flag, used when argCount has the plan flag set.
|
||||
|
||||
## 2) Slot ID Width
|
||||
|
||||
Per frame, select:
|
||||
- 8-bit if localCount + argCount < 256
|
||||
- 16-bit if < 65536
|
||||
- 32-bit otherwise
|
||||
|
||||
The decoder uses a dedicated loop per width. All slot operands are expanded to
|
||||
Int internally.
|
||||
|
||||
## 3) CALL Semantics (Model A)
|
||||
|
||||
Instruction:
|
||||
CALL_DIRECT fnId, argBase, argCount, dst
|
||||
|
||||
Behavior:
|
||||
- Allocate a callee frame sized localCount + argCount.
|
||||
- Copy caller slots [argBase .. argBase+argCount-1] into callee slots
|
||||
[localCount .. localCount+argCount-1].
|
||||
- Callee returns via RET slot or RET_VOID.
|
||||
- Caller stores return value to dst.
|
||||
|
||||
Other calls:
|
||||
- CALL_VIRTUAL recvSlot, methodId, argBase, argCount, dst
|
||||
- CALL_FALLBACK stmtId, argBase, argCount, dst
|
||||
- CALL_SLOT calleeSlot, argBase, argCount, dst
|
||||
|
||||
## 4) Binary Encoding Layout
|
||||
|
||||
All instructions are:
|
||||
[opcode:U8] [operands...]
|
||||
|
||||
Operand widths:
|
||||
- slotId: S = 1/2/4 bytes (per frame slot width)
|
||||
- constId: K = 2 bytes (U16), extend to 4 if needed
|
||||
- ip: I = 2 bytes (U16) or 4 bytes (U32) per function size
|
||||
- fnId/methodId/stmtId: F/M/T = 2 bytes (U16) unless extended
|
||||
- argCount: C = 2 bytes (U16), extend to 4 if needed
|
||||
|
||||
Endianness: little-endian for multi-byte operands.
|
||||
|
||||
Common operand patterns:
|
||||
- S: one slot
|
||||
- SS: two slots
|
||||
- SSS: three slots
|
||||
- K S: constId + dst slot
|
||||
- S I: slot + jump target
|
||||
- I: jump target
|
||||
- F S C S: fnId, argBase slot, argCount, dst slot
|
||||
|
||||
Arg count flag:
|
||||
- If high bit of C is set (0x8000), the low 15 bits encode a CallArgsPlan constId.
|
||||
- When not set, C is the raw positional count and tailBlockMode=false.
|
||||
|
||||
## 5) Opcode Table
|
||||
|
||||
Note: Any opcode can be compiled to FALLBACK if not implemented in a VM pass.
|
||||
|
||||
### Data movement
|
||||
- NOP
|
||||
- MOVE_OBJ S -> S
|
||||
- MOVE_INT S -> S
|
||||
- MOVE_REAL S -> S
|
||||
- MOVE_BOOL S -> S
|
||||
- BOX_OBJ S -> S
|
||||
- CONST_OBJ K -> S
|
||||
- CONST_INT K -> S
|
||||
- CONST_REAL K -> S
|
||||
- CONST_BOOL K -> S
|
||||
- CONST_NULL -> S
|
||||
|
||||
### Numeric conversions
|
||||
- INT_TO_REAL S -> S
|
||||
- REAL_TO_INT S -> S
|
||||
- BOOL_TO_INT S -> S
|
||||
- INT_TO_BOOL S -> S
|
||||
|
||||
### Arithmetic: INT
|
||||
- ADD_INT S, S -> S
|
||||
- SUB_INT S, S -> S
|
||||
- MUL_INT S, S -> S
|
||||
- DIV_INT S, S -> S
|
||||
- MOD_INT S, S -> S
|
||||
- NEG_INT S -> S
|
||||
- INC_INT S
|
||||
- DEC_INT S
|
||||
|
||||
### Arithmetic: REAL
|
||||
- ADD_REAL S, S -> S
|
||||
- SUB_REAL S, S -> S
|
||||
- MUL_REAL S, S -> S
|
||||
- DIV_REAL S, S -> S
|
||||
- NEG_REAL S -> S
|
||||
|
||||
### Arithmetic: OBJ
|
||||
- ADD_OBJ S, S -> S
|
||||
- SUB_OBJ S, S -> S
|
||||
- MUL_OBJ S, S -> S
|
||||
- DIV_OBJ S, S -> S
|
||||
- MOD_OBJ S, S -> S
|
||||
|
||||
### Bitwise: INT
|
||||
- AND_INT S, S -> S
|
||||
- OR_INT S, S -> S
|
||||
- XOR_INT S, S -> S
|
||||
- SHL_INT S, S -> S
|
||||
- SHR_INT S, S -> S
|
||||
- USHR_INT S, S -> S
|
||||
- INV_INT S -> S
|
||||
|
||||
### Comparisons (typed)
|
||||
- CMP_EQ_INT S, S -> S
|
||||
- CMP_NEQ_INT S, S -> S
|
||||
- CMP_LT_INT S, S -> S
|
||||
- CMP_LTE_INT S, S -> S
|
||||
- CMP_GT_INT S, S -> S
|
||||
- CMP_GTE_INT S, S -> S
|
||||
- CMP_EQ_REAL S, S -> S
|
||||
- CMP_NEQ_REAL S, S -> S
|
||||
- CMP_LT_REAL S, S -> S
|
||||
- CMP_LTE_REAL S, S -> S
|
||||
- CMP_GT_REAL S, S -> S
|
||||
- CMP_GTE_REAL S, S -> S
|
||||
- CMP_EQ_BOOL S, S -> S
|
||||
- CMP_NEQ_BOOL S, S -> S
|
||||
|
||||
### Mixed numeric comparisons
|
||||
- CMP_EQ_INT_REAL S, S -> S
|
||||
- CMP_EQ_REAL_INT S, S -> S
|
||||
- CMP_LT_INT_REAL S, S -> S
|
||||
- CMP_LT_REAL_INT S, S -> S
|
||||
- CMP_LTE_INT_REAL S, S -> S
|
||||
- CMP_LTE_REAL_INT S, S -> S
|
||||
- CMP_GT_INT_REAL S, S -> S
|
||||
- CMP_GT_REAL_INT S, S -> S
|
||||
- CMP_GTE_INT_REAL S, S -> S
|
||||
- CMP_GTE_REAL_INT S, S -> S
|
||||
- CMP_NEQ_INT_REAL S, S -> S
|
||||
- CMP_NEQ_REAL_INT S, S -> S
|
||||
- CMP_EQ_OBJ S, S -> S
|
||||
- CMP_NEQ_OBJ S, S -> S
|
||||
- CMP_REF_EQ_OBJ S, S -> S
|
||||
- CMP_REF_NEQ_OBJ S, S -> S
|
||||
- CMP_LT_OBJ S, S -> S
|
||||
- CMP_LTE_OBJ S, S -> S
|
||||
- CMP_GT_OBJ S, S -> S
|
||||
- CMP_GTE_OBJ S, S -> S
|
||||
|
||||
### Boolean ops
|
||||
- NOT_BOOL S -> S
|
||||
- AND_BOOL S, S -> S
|
||||
- OR_BOOL S, S -> S
|
||||
|
||||
### Control flow
|
||||
- JMP I
|
||||
- JMP_IF_TRUE S, I
|
||||
- JMP_IF_FALSE S, I
|
||||
- RET S
|
||||
- RET_VOID
|
||||
- PUSH_SCOPE K
|
||||
- POP_SCOPE
|
||||
|
||||
### Scope setup
|
||||
- PUSH_SCOPE uses const `SlotPlan` (name -> slot index) to create a child scope and apply slot mapping.
|
||||
- POP_SCOPE restores the parent scope.
|
||||
|
||||
### Calls
|
||||
- CALL_DIRECT F, S, C, S
|
||||
- CALL_VIRTUAL S, M, S, C, S
|
||||
- CALL_FALLBACK T, S, C, S
|
||||
- CALL_SLOT S, S, C, S
|
||||
|
||||
### Object access (optional, later)
|
||||
- GET_FIELD S, M -> S
|
||||
- SET_FIELD S, M, S
|
||||
- GET_INDEX S, S -> S
|
||||
- SET_INDEX S, S, S
|
||||
|
||||
### Fallback
|
||||
- EVAL_FALLBACK T -> S
|
||||
|
||||
## 6) Const Pool Encoding (v0)
|
||||
|
||||
Each const entry is encoded as:
|
||||
[tag:U8] [payload...]
|
||||
|
||||
Tags:
|
||||
- 0x00: NULL
|
||||
- 0x01: BOOL (payload: U8 0/1)
|
||||
- 0x02: INT (payload: S64, little-endian)
|
||||
- 0x03: REAL (payload: F64, IEEE-754, little-endian)
|
||||
- 0x04: STRING (payload: U32 length + UTF-8 bytes)
|
||||
- 0x05: OBJ_REF (payload: U32 index into external Obj table)
|
||||
|
||||
Notes:
|
||||
- OBJ_REF is reserved for embedding prebuilt Obj handles if needed.
|
||||
- Strings use UTF-8; length is bytes, not chars.
|
||||
|
||||
## 7) Function Header (binary container)
|
||||
|
||||
Suggested layout for a bytecode function blob:
|
||||
- magic: U32 ("LYBC")
|
||||
- version: U16 (0x0001)
|
||||
- slotWidth: U8 (1,2,4)
|
||||
- ipWidth: U8 (2,4)
|
||||
- constIdWidth: U8 (2,4)
|
||||
- localCount: U32
|
||||
- codeSize: U32 (bytes)
|
||||
- constCount: U32
|
||||
- constPool: [const entries...]
|
||||
- code: [bytecode...]
|
||||
|
||||
Const pool entries use the encoding described in section 6.
|
||||
|
||||
## 8) Sample Bytecode (illustrative)
|
||||
|
||||
Example Lyng:
|
||||
val x = 2
|
||||
val y = 3
|
||||
val z = x + y
|
||||
|
||||
Assume:
|
||||
- localCount = 3 (x,y,z)
|
||||
- argCount = 0
|
||||
- slot width = 1 byte
|
||||
- const pool: [INT 2, INT 3]
|
||||
|
||||
Bytecode:
|
||||
CONST_INT k0 -> s0
|
||||
CONST_INT k1 -> s1
|
||||
ADD_INT s0, s1 -> s2
|
||||
RET_VOID
|
||||
|
||||
Encoded (opcode values symbolic):
|
||||
[OP_CONST_INT][k0][s0]
|
||||
[OP_CONST_INT][k1][s1]
|
||||
[OP_ADD_INT][s0][s1][s2]
|
||||
[OP_RET_VOID]
|
||||
|
||||
## 9) Notes
|
||||
|
||||
- Mixed-mode is allowed: compiler can emit FALLBACK ops for unsupported nodes.
|
||||
- The VM must be suspendable; on suspension, store ip + minimal operand state.
|
||||
- Source mapping uses a separate ip->Pos table, not part of core bytecode.
|
||||
@ -6,13 +6,6 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
|
||||
val size
|
||||
}
|
||||
|
||||
`Collection` is a read/traversal contract shared by mutable and immutable collections.
|
||||
Concrete collection classes:
|
||||
|
||||
- Mutable: [List], [Set], [Map]
|
||||
- Immutable: [ImmutableList], [ImmutableSet], [ImmutableMap]
|
||||
- Observable mutable lists (opt-in module): [ObservableList]
|
||||
|
||||
| name | description |
|
||||
|------------------------|------------------------------------------------------|
|
||||
|
||||
@ -23,9 +16,4 @@ See [List], [Set], [Iterable] and [Efficient Iterables in Kotlin Interop](Effici
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
[List]: List.md
|
||||
[Set]: Set.md
|
||||
[Map]: Map.md
|
||||
[ImmutableList]: ImmutableList.md
|
||||
[ImmutableSet]: ImmutableSet.md
|
||||
[ImmutableMap]: ImmutableMap.md
|
||||
[ObservableList]: ObservableList.md
|
||||
[Set]: Set.md
|
||||
@ -1,37 +0,0 @@
|
||||
# ImmutableList built-in class
|
||||
|
||||
`ImmutableList` is an immutable, indexable list value.
|
||||
It implements [Array], therefore [Collection] and [Iterable].
|
||||
|
||||
Use it when API contracts require a list that cannot be mutated through aliases.
|
||||
|
||||
## Creating
|
||||
|
||||
val a = ImmutableList(1,2,3)
|
||||
val b = [1,2,3].toImmutable()
|
||||
val c = (1..3).toImmutableList()
|
||||
>>> void
|
||||
|
||||
## Converting
|
||||
|
||||
val i = ImmutableList(1,2,3)
|
||||
val m = i.toMutable()
|
||||
m += 4
|
||||
assertEquals( ImmutableList(1,2,3), i )
|
||||
assertEquals( [1,2,3,4], m )
|
||||
>>> void
|
||||
|
||||
## Members
|
||||
|
||||
| name | meaning |
|
||||
|---------------|-----------------------------------------|
|
||||
| `size` | number of elements |
|
||||
| `[index]` | element access by index |
|
||||
| `[Range]` | immutable slice |
|
||||
| `+` | append element(s), returns new immutable list |
|
||||
| `-` | remove element(s), returns new immutable list |
|
||||
| `toMutable()` | create mutable copy |
|
||||
|
||||
[Array]: Array.md
|
||||
[Collection]: Collection.md
|
||||
[Iterable]: Iterable.md
|
||||
@ -1,36 +0,0 @@
|
||||
# ImmutableMap built-in class
|
||||
|
||||
`ImmutableMap` is an immutable map of key-value pairs.
|
||||
It implements [Collection] and [Iterable] of [MapEntry].
|
||||
|
||||
## Creating
|
||||
|
||||
val a = ImmutableMap("a" => 1, "b" => 2)
|
||||
val b = Map("a" => 1, "b" => 2).toImmutable()
|
||||
val c = ["a" => 1, "b" => 2].toImmutableMap
|
||||
>>> void
|
||||
|
||||
## Converting
|
||||
|
||||
val i = ImmutableMap("a" => 1)
|
||||
val m = i.toMutable()
|
||||
m["a"] = 2
|
||||
assertEquals( 1, i["a"] )
|
||||
assertEquals( 2, m["a"] )
|
||||
>>> void
|
||||
|
||||
## Members
|
||||
|
||||
| name | meaning |
|
||||
|-----------------|------------------------------------------|
|
||||
| `size` | number of entries |
|
||||
| `[key]` | get value by key, or `null` if absent |
|
||||
| `getOrNull(key)`| same as `[key]` |
|
||||
| `keys` | list of keys |
|
||||
| `values` | list of values |
|
||||
| `+` | merge (rightmost wins), returns new immutable map |
|
||||
| `toMutable()` | create mutable copy |
|
||||
|
||||
[Collection]: Collection.md
|
||||
[Iterable]: Iterable.md
|
||||
[MapEntry]: Map.md
|
||||
@ -1,34 +0,0 @@
|
||||
# ImmutableSet built-in class
|
||||
|
||||
`ImmutableSet` is an immutable set of unique elements.
|
||||
It implements [Collection] and [Iterable].
|
||||
|
||||
## Creating
|
||||
|
||||
val a = ImmutableSet(1,2,3)
|
||||
val b = Set(1,2,3).toImmutable()
|
||||
val c = [1,2,3].toImmutableSet
|
||||
>>> void
|
||||
|
||||
## Converting
|
||||
|
||||
val i = ImmutableSet(1,2,3)
|
||||
val m = i.toMutable()
|
||||
m += 4
|
||||
assertEquals( ImmutableSet(1,2,3), i )
|
||||
assertEquals( Set(1,2,3,4), m )
|
||||
>>> void
|
||||
|
||||
## Members
|
||||
|
||||
| name | meaning |
|
||||
|---------------|-----------------------------------------------------|
|
||||
| `size` | number of elements |
|
||||
| `contains(x)` | membership test |
|
||||
| `+`, `union` | union, returns new immutable set |
|
||||
| `-`, `subtract` | subtraction, returns new immutable set |
|
||||
| `*`, `intersect` | intersection, returns new immutable set |
|
||||
| `toMutable()` | create mutable copy |
|
||||
|
||||
[Collection]: Collection.md
|
||||
[Iterable]: Iterable.md
|
||||
@ -108,8 +108,8 @@ You can also use flow variations that return a cold `Flow` instead of a `List`,
|
||||
Find the minimum or maximum value of a function applied to each element:
|
||||
|
||||
val source = ["abc", "de", "fghi"]
|
||||
assertEquals(2, source.minOf { (it as String).length })
|
||||
assertEquals(4, source.maxOf { (it as String).length })
|
||||
assertEquals(2, source.minOf { it.length })
|
||||
assertEquals(4, source.maxOf { it.length })
|
||||
>>> void
|
||||
|
||||
## flatten and flatMap
|
||||
@ -147,15 +147,12 @@ Search for the first element that satisfies the given predicate:
|
||||
| fun/method | description |
|
||||
|------------------------|---------------------------------------------------------------------------------|
|
||||
| toList() | create a list from iterable |
|
||||
| toImmutableList() | create an immutable list from iterable |
|
||||
| toSet() | create a set from iterable |
|
||||
| toImmutableSet | create an immutable set from iterable |
|
||||
| contains(i) | check that iterable contains `i` |
|
||||
| `i in iterable` | same as `contains(i)` |
|
||||
| isEmpty() | check iterable is empty |
|
||||
| forEach(f) | call f for each element |
|
||||
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
|
||||
| toImmutableMap | create an immutable map from list of key-value pairs |
|
||||
| any(p) | true if any element matches predicate `p` |
|
||||
| all(p) | true if all elements match predicate `p` |
|
||||
| map(f) | create a list of values returned by `f` called for each element of the iterable |
|
||||
@ -209,20 +206,16 @@ For high-performance Kotlin-side interop and custom iterable implementation deta
|
||||
|
||||
## Implemented in classes:
|
||||
|
||||
- [List], [ImmutableList], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [ImmutableSet], [Map], [ImmutableMap], [RingBuffer]
|
||||
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
|
||||
|
||||
[Collection]: Collection.md
|
||||
|
||||
[List]: List.md
|
||||
[ImmutableList]: ImmutableList.md
|
||||
|
||||
[Flow]: parallelism.md#flow
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
[Set]: Set.md
|
||||
[ImmutableSet]: ImmutableSet.md
|
||||
[Map]: Map.md
|
||||
[ImmutableMap]: ImmutableMap.md
|
||||
|
||||
[RingBuffer]: RingBuffer.md
|
||||
[RingBuffer]: RingBuffer.md
|
||||
50
docs/List.md
50
docs/List.md
@ -1,8 +1,6 @@
|
||||
# List built-in class
|
||||
|
||||
Mutable list of any objects.
|
||||
For immutable list values, see [ImmutableList].
|
||||
For observable mutable lists and change hooks, see [ObservableList].
|
||||
|
||||
It's class in Lyng is `List`:
|
||||
|
||||
@ -181,50 +179,6 @@ for `sort()` will be `sort { a, b -> a <=> b }
|
||||
|
||||
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
|
||||
|
||||
## Observable list hooks
|
||||
|
||||
Observable hooks are provided by module `lyng.observable` and are opt-in:
|
||||
|
||||
import lyng.observable
|
||||
|
||||
val src = [1,2,3]
|
||||
val xs = src.observable()
|
||||
assert(xs is ObservableList<Int>)
|
||||
|
||||
var before = 0
|
||||
var after = 0
|
||||
xs.beforeChange { before++ }
|
||||
xs.onChange { after++ }
|
||||
|
||||
xs += 4
|
||||
xs[0] = 100
|
||||
assertEquals([100,2,3,4], xs)
|
||||
assertEquals(2, before)
|
||||
assertEquals(2, after)
|
||||
>>> void
|
||||
|
||||
`beforeChange` runs before mutation commit and may reject it by throwing exception (typically `ChangeRejectionException` from the same module):
|
||||
|
||||
import lyng.observable
|
||||
val xs = [1,2].observable()
|
||||
xs.beforeChange { throw ChangeRejectionException("read only") }
|
||||
assertThrows(ChangeRejectionException) { xs += 3 }
|
||||
assertEquals([1,2], xs)
|
||||
>>> void
|
||||
|
||||
`changes()` returns `Flow<ListChange<T>>` of committed events:
|
||||
|
||||
import lyng.observable
|
||||
val xs = [10,20].observable()
|
||||
val it = xs.changes().iterator()
|
||||
xs += 30
|
||||
assert(it.hasNext())
|
||||
val e = it.next()
|
||||
assert(e is ListInsert<Int>)
|
||||
assertEquals([30], (e as ListInsert<Int>).values)
|
||||
it.cancelIteration()
|
||||
>>> void
|
||||
|
||||
## Member inherited from Array
|
||||
|
||||
| name | meaning | type |
|
||||
@ -242,6 +196,4 @@ Observable hooks are provided by module `lyng.observable` and are opt-in:
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
[ImmutableList]: ImmutableList.md
|
||||
[ObservableList]: ObservableList.md
|
||||
[Iterable]: Iterable.md
|
||||
@ -3,7 +3,6 @@
|
||||
Map is a mutable collection of key-value pairs, where keys are unique. You can create maps in two ways:
|
||||
- with the constructor `Map(...)` or `.toMap()` helpers; and
|
||||
- with map literals using braces: `{ "key": value, id: expr, id: }`.
|
||||
For immutable map values, see [ImmutableMap].
|
||||
|
||||
When constructing from a list, each list item must be a [Collection] with exactly 2 elements, for example, a [List].
|
||||
|
||||
@ -95,8 +94,7 @@ Or iterate its key-value pairs that are instances of [MapEntry] class:
|
||||
|
||||
val map = Map( ["foo", 1], ["bar", "buzz"], [42, "answer"] )
|
||||
for( entry in map ) {
|
||||
val e: MapEntry = entry as MapEntry
|
||||
println("map[%s] = %s"(e.key, e.value))
|
||||
println("map[%s] = %s"(entry.key, entry.value))
|
||||
}
|
||||
void
|
||||
>>> map[foo] = 1
|
||||
@ -177,5 +175,4 @@ Notes:
|
||||
- Spreads inside map literals and `+`/`+=` merges allow any objects as keys.
|
||||
- When you need computed or non-string keys, use the constructor form `Map(...)`, map literals with computed keys (if supported), or build entries with `=>` and then merge.
|
||||
|
||||
[Collection](Collection.md)
|
||||
[ImmutableMap]: ImmutableMap.md
|
||||
[Collection](Collection.md)
|
||||
95
docs/OOP.md
95
docs/OOP.md
@ -9,7 +9,7 @@ Lyng supports first class OOP constructs, based on classes with multiple inherit
|
||||
The class clause looks like
|
||||
|
||||
class Point(x,y)
|
||||
assertEquals("Point", Point.className)
|
||||
assert( Point is Class )
|
||||
>>> void
|
||||
|
||||
It creates new `Class` with two fields. Here is the more practical sample:
|
||||
@ -113,48 +113,6 @@ val handler = object {
|
||||
- **Serialization**: Anonymous objects are **not serializable**. Attempting to encode an anonymous object via `Lynon` will throw a `SerializationException`. This is because their class definition is transient and cannot be safely restored in a different session or process.
|
||||
- **Type Identity**: Every object expression creates a unique anonymous class. Two identical object expressions will result in two different classes with distinct type identities.
|
||||
|
||||
## Nested Declarations
|
||||
|
||||
Lyng allows classes, objects, enums, and type aliases to be declared inside another class. These declarations live in the **class namespace** (not the instance), so they do not capture an outer instance and are accessed with a qualifier.
|
||||
|
||||
```lyng
|
||||
class A {
|
||||
class B(x?)
|
||||
object Inner { val foo = "bar" }
|
||||
type Alias = B
|
||||
enum E { One, Two }
|
||||
}
|
||||
|
||||
val ab = A.B()
|
||||
assertEquals(ab.x, null)
|
||||
assertEquals(A.Inner.foo, "bar")
|
||||
```
|
||||
|
||||
Rules:
|
||||
- **Qualified access**: use `Outer.Inner` for nested classes/objects/enums/aliases. Inside `Outer` you can refer to them by unqualified name unless shadowed.
|
||||
- **No inner semantics**: nested declarations do not capture an instance of the outer class. They are resolved at compile time.
|
||||
- **Visibility**: `private` restricts a nested declaration to the declaring class body (not visible from outside or subclasses).
|
||||
- **Reflection name**: a nested class reports `Outer.Inner` (e.g., `A.B::class.name` is `"A.B"`).
|
||||
- **Type aliases**: behave as aliases of the qualified nested type and are expanded by the type system.
|
||||
|
||||
### Lifted Enum Entries
|
||||
|
||||
Enums can optionally lift their entries into the surrounding class namespace using `*`:
|
||||
|
||||
```lyng
|
||||
class A {
|
||||
enum E* { One, Two }
|
||||
}
|
||||
|
||||
assertEquals(A.One, A.E.One)
|
||||
assertEquals(A.Two, A.E.Two)
|
||||
```
|
||||
|
||||
Notes:
|
||||
- `E*` exposes entries in `A` as if they were direct members (`A.One`).
|
||||
- If a name would conflict with an existing class member, compilation fails (no implicit fallback).
|
||||
- Without `*`, use the normal `A.E.One` form.
|
||||
|
||||
## Properties
|
||||
|
||||
Properties allow you to define member accessors that look like fields but execute code when read or written. Unlike regular fields, properties in Lyng do **not** have automatic backing fields; they are pure accessors.
|
||||
@ -376,10 +334,11 @@ Functions defined inside a class body are methods, and unless declared
|
||||
`private` are available to be called from outside the class:
|
||||
|
||||
class Point(x,y) {
|
||||
// private method:
|
||||
private fun d2() { x*x + y*y }
|
||||
// public method declaration:
|
||||
fun length() { sqrt(d2()) }
|
||||
|
||||
// private method:
|
||||
private fun d2() {x*x + y*y}
|
||||
}
|
||||
val p = Point(3,4)
|
||||
// private called from inside public: OK
|
||||
@ -978,7 +937,7 @@ You can mark a field or a method as static. This is borrowed from Java as more p
|
||||
|
||||
static fun exclamation() {
|
||||
// here foo is a regular var:
|
||||
Value.foo.x + "!"
|
||||
foo.x + "!"
|
||||
}
|
||||
}
|
||||
assertEquals( Value.foo.x, "foo" )
|
||||
@ -989,16 +948,24 @@ You can mark a field or a method as static. This is borrowed from Java as more p
|
||||
assertEquals( "bar!", Value.exclamation() )
|
||||
>>> void
|
||||
|
||||
Static fields can be accessed from static methods via the class qualifier:
|
||||
As usual, private statics are not accessible from the outside:
|
||||
|
||||
class Test {
|
||||
static var data = "foo"
|
||||
static fun getData() { Test.data }
|
||||
// private, inacessible from outside protected data:
|
||||
private static var data = null
|
||||
|
||||
// the interface to access and change it:
|
||||
static fun getData() { data }
|
||||
static fun setData(value) { data = value }
|
||||
}
|
||||
|
||||
assertEquals( "foo", Test.getData() )
|
||||
Test.data = "bar"
|
||||
assertEquals("bar", Test.getData() )
|
||||
// no direct access:
|
||||
assertThrows { Test.data }
|
||||
|
||||
// accessible with the interface:
|
||||
assertEquals( null, Test.getData() )
|
||||
Test.setData("fubar")
|
||||
assertEquals("fubar", Test.getData() )
|
||||
>>> void
|
||||
|
||||
# Extending classes
|
||||
@ -1007,13 +974,25 @@ It sometimes happen that the class is missing some particular functionality that
|
||||
|
||||
## Extension methods
|
||||
|
||||
For example, we want to create an extension method that would test if a value can be interpreted as an integer:
|
||||
For example, we want to create an extension method that would test if some object of unknown type contains something that can be interpreted as an integer. In this case we _extend_ class `Object`, as it is the parent class for any instance of any type:
|
||||
|
||||
fun Int.isInteger() { true }
|
||||
fun Real.isInteger() { this.toInt() == this }
|
||||
fun String.isInteger() { (this.toReal() as Real).isInteger() }
|
||||
fun Object.isInteger() {
|
||||
when(this) {
|
||||
// already Int?
|
||||
is Int -> true
|
||||
|
||||
// Let's test:
|
||||
// real, but with no declimal part?
|
||||
is Real -> toInt() == this
|
||||
|
||||
// string with int or real reuusig code above
|
||||
is String -> toReal().isInteger()
|
||||
|
||||
// otherwise, no:
|
||||
else -> false
|
||||
}
|
||||
}
|
||||
|
||||
// Let's test:
|
||||
assert( 12.isInteger() == true )
|
||||
assert( 12.1.isInteger() == false )
|
||||
assert( "5".isInteger() )
|
||||
@ -1115,7 +1094,7 @@ The same we can provide writable dynamic fields (var-type), adding set method:
|
||||
// mutable field
|
||||
"bar" -> storedValueForBar
|
||||
|
||||
else -> throw SymbolNotFound()
|
||||
else -> throw SymbolNotFoundException()
|
||||
}
|
||||
}
|
||||
set { name, value ->
|
||||
|
||||
@ -1,70 +0,0 @@
|
||||
# ObservableList module
|
||||
|
||||
`ObservableList` lives in explicit module `lyng.observable`.
|
||||
|
||||
Import it first:
|
||||
|
||||
import lyng.observable
|
||||
>>> void
|
||||
|
||||
Create from a regular mutable list:
|
||||
|
||||
import lyng.observable
|
||||
val xs = [1,2,3].observable()
|
||||
assert(xs is ObservableList<Int>)
|
||||
assertEquals([1,2,3], xs)
|
||||
>>> void
|
||||
|
||||
## Hook flow
|
||||
|
||||
Event order is:
|
||||
1. `beforeChange(change)` listeners
|
||||
2. mutation commit
|
||||
3. `onChange(change)` listeners
|
||||
4. `changes()` flow emission
|
||||
|
||||
Rejection is done by throwing in `beforeChange`.
|
||||
|
||||
import lyng.observable
|
||||
val xs = [1,2].observable()
|
||||
xs.beforeChange {
|
||||
throw ChangeRejectionException("no mutation")
|
||||
}
|
||||
assertThrows(ChangeRejectionException) { xs += 3 }
|
||||
assertEquals([1,2], xs)
|
||||
>>> void
|
||||
|
||||
## Subscriptions
|
||||
|
||||
`beforeChange` and `onChange` return `Subscription`.
|
||||
Call `cancel()` to unsubscribe.
|
||||
|
||||
import lyng.observable
|
||||
val xs = [1].observable()
|
||||
var hits = 0
|
||||
val sub = xs.onChange { hits++ }
|
||||
xs += 2
|
||||
sub.cancel()
|
||||
xs += 3
|
||||
assertEquals(1, hits)
|
||||
>>> void
|
||||
|
||||
## Change events
|
||||
|
||||
`changes()` returns `Flow<ListChange<T>>` with concrete event classes:
|
||||
- `ListInsert`
|
||||
- `ListSet`
|
||||
- `ListRemove`
|
||||
- `ListClear`
|
||||
- `ListReorder`
|
||||
|
||||
import lyng.observable
|
||||
val xs = [10,20].observable()
|
||||
val it = xs.changes().iterator()
|
||||
xs[1] = 200
|
||||
val ev = it.next()
|
||||
assert(ev is ListSet<Int>)
|
||||
assertEquals(20, (ev as ListSet<Int>).oldValue)
|
||||
assertEquals(200, ev.newValue)
|
||||
it.cancelIteration()
|
||||
>>> void
|
||||
@ -45,11 +45,10 @@ are equal or within another, taking into account the end-inclusiveness:
|
||||
assert( (1..<3) in (1..3) )
|
||||
>>> void
|
||||
|
||||
## Ranges are iterable
|
||||
## Finite Ranges are iterable
|
||||
|
||||
Finite ranges are [Iterable] and can be used in loops and list conversions.
|
||||
Open-ended ranges are iterable only with an explicit `step`, and open-start
|
||||
ranges are never iterable.
|
||||
So given a range with both ends, you can assume it is [Iterable]. This automatically let
|
||||
use finite ranges in loops and convert it to lists:
|
||||
|
||||
assert( [-2, -1, 0, 1] == (-2..1).toList() )
|
||||
>>> void
|
||||
@ -63,8 +62,6 @@ In spite of this you can use ranges in for loops:
|
||||
>>> 3
|
||||
>>> void
|
||||
|
||||
The loop variable is read-only inside the loop body (behaves like a `val`).
|
||||
|
||||
but
|
||||
|
||||
for( i in 1..<3 )
|
||||
@ -73,26 +70,6 @@ but
|
||||
>>> 2
|
||||
>>> void
|
||||
|
||||
### Stepped ranges
|
||||
|
||||
Use `step` to change the iteration increment. The range bounds still define membership,
|
||||
so iteration ends when the next value is no longer in the range.
|
||||
|
||||
assert( [1,3,5] == (1..5 step 2).toList() )
|
||||
assert( [1,3] == (1..<5 step 2).toList() )
|
||||
assert( ['a','c','e'] == ('a'..'e' step 2).toList() )
|
||||
>>> void
|
||||
|
||||
Real ranges require an explicit step:
|
||||
|
||||
assert( [0,0.25,0.5,0.75,1.0] == (0.0..1.0 step 0.25).toList() )
|
||||
>>> void
|
||||
|
||||
Open-ended ranges require an explicit step to iterate:
|
||||
|
||||
(0.. step 1).take(3).toList()
|
||||
>>> [0,1,2]
|
||||
|
||||
## Character ranges
|
||||
|
||||
You can use Char as both ends of the closed range:
|
||||
@ -121,7 +98,6 @@ Exclusive end char ranges are supported too:
|
||||
| isEndInclusive | true for '..' | Bool |
|
||||
| isOpen | at any end | Bool |
|
||||
| isIntRange | both start and end are Int | Bool |
|
||||
| step | explicit iteration step | Any? |
|
||||
| start | | Any? |
|
||||
| end | | Any? |
|
||||
| size | for finite ranges, see above | Long |
|
||||
@ -129,4 +105,4 @@ Exclusive end char ranges are supported too:
|
||||
|
||||
Ranges are also used with the `clamp(value, range)` function and the `value.clamp(range)` extension method to limit values within boundaries.
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
[Iterable]: Iterable.md
|
||||
@ -24,14 +24,13 @@ counterpart, _not match_ operator `!~`:
|
||||
|
||||
When you need to find groups, and more detailed match information, use `Regex.find`:
|
||||
|
||||
val result: RegexMatch? = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
|
||||
val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
|
||||
assert( result != null )
|
||||
val match: RegexMatch = result as RegexMatch
|
||||
assertEquals( 12 ..< 17, match.range )
|
||||
assertEquals( "abc123", match[0] )
|
||||
assertEquals( "1", match[1] )
|
||||
assertEquals( "2", match[2] )
|
||||
assertEquals( "3", match[3] )
|
||||
assertEquals( 12 .. 17, result.range )
|
||||
assertEquals( "abc123", result[0] )
|
||||
assertEquals( "1", result[1] )
|
||||
assertEquals( "2", result[2] )
|
||||
assertEquals( "3", result[3] )
|
||||
>>> void
|
||||
|
||||
Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
|
||||
@ -40,12 +39,11 @@ index range and groups matches as indexes.
|
||||
Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
|
||||
|
||||
assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
|
||||
val match2: RegexMatch = $~ as RegexMatch
|
||||
assertEquals( 12 ..< 17, match2.range )
|
||||
assertEquals( "abc123", match2[0] )
|
||||
assertEquals( "1", match2[1] )
|
||||
assertEquals( "2", match2[2] )
|
||||
assertEquals( "3", match2[3] )
|
||||
assertEquals( 12 .. 17, $~.range )
|
||||
assertEquals( "abc123", $~[0] )
|
||||
assertEquals( "1", $~[1] )
|
||||
assertEquals( "2", $~[2] )
|
||||
assertEquals( "3", $~[3] )
|
||||
>>> void
|
||||
|
||||
This is often more readable than calling `find`.
|
||||
@ -61,7 +59,7 @@ string can be either left or right operator, but not both:
|
||||
|
||||
Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
|
||||
|
||||
assert( "cd" == ("abcdef"[ "c.".re ] as RegexMatch).value )
|
||||
assert( "cd" == "abcdef"[ "c.".re ].value )
|
||||
>>> void
|
||||
|
||||
|
||||
@ -90,3 +88,4 @@ Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!
|
||||
[List]: List.md
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
|
||||
10
docs/Set.md
10
docs/Set.md
@ -1,8 +1,7 @@
|
||||
# Set built-in class
|
||||
# List built-in class
|
||||
|
||||
Mutable set of any objects: a group of different objects, no repetitions.
|
||||
Sets are not ordered, order of appearance does not matter.
|
||||
For immutable set values, see [ImmutableSet].
|
||||
|
||||
val set = Set(1,2,3, "foo")
|
||||
assert( 1 in set )
|
||||
@ -27,8 +26,8 @@ no indexing. Use [set.toList] as needed.
|
||||
|
||||
// intersection
|
||||
assertEquals( Set(1,4), Set(3, 1, 4).intersect(Set(2, 4, 1)) )
|
||||
// or simple (intersection)
|
||||
assertEquals( Set(1,4), Set(3, 1, 4).intersect(Set(2, 4, 1)) )
|
||||
// or simple
|
||||
assertEquals( Set(1,4), Set(3, 1, 4) * Set(2, 4, 1) )
|
||||
|
||||
// To find collection elements not present in another collection, use the
|
||||
// subtract() or `-`:
|
||||
@ -92,5 +91,4 @@ Sets are only equal when contains exactly same elements, order, as was said, is
|
||||
Also, it inherits methods from [Iterable].
|
||||
|
||||
|
||||
[Range]: Range.md
|
||||
[ImmutableSet]: ImmutableSet.md
|
||||
[Range]: Range.md
|
||||
@ -105,7 +105,6 @@ arguments list in almost arbitrary ways. For example:
|
||||
var result = ""
|
||||
for( a in args ) result += a
|
||||
}
|
||||
// loop variables are read-only inside the loop body
|
||||
|
||||
assertEquals(
|
||||
"4231",
|
||||
@ -154,10 +153,9 @@ Function annotation can have more args specified at call time. There arguments m
|
||||
@Registered("bar")
|
||||
fun foo2() { "called foo2" }
|
||||
|
||||
val fooFn: Callable = registered["foo"] as Callable
|
||||
val barFn: Callable = registered["bar"] as Callable
|
||||
assertEquals(fooFn(), "called foo")
|
||||
assertEquals(barFn(), "called foo2")
|
||||
assertEquals(registered["foo"](), "called foo")
|
||||
assertEquals(registered["bar"](), "called foo2")
|
||||
>>> void
|
||||
|
||||
[parallelism]: parallelism.md
|
||||
|
||||
|
||||
@ -1,219 +0,0 @@
|
||||
# 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.
|
||||
@ -1,15 +0,0 @@
|
||||
# AI notes: avoid Kotlin/Wasm invalid IR with suspend lambdas
|
||||
|
||||
## Do
|
||||
- Prefer explicit `object : Statement()` with `override suspend fun execute(...)` when building compiler statements.
|
||||
- Keep `Statement` objects non-lambda, especially in compiler hot paths like parsing/var declarations.
|
||||
- If you need conditional behavior, return early in `execute` instead of wrapping `parseExpression()` with `statement(...) { ... }`.
|
||||
- When wasmJs tests hang in the browser, first check `wasmJsNodeTest` for a compile error; hangs often mean module instantiation failed.
|
||||
|
||||
## Don't
|
||||
- Do not create suspend lambdas inside `Statement` factories (`statement { ... }`) for wasm targets.
|
||||
- Do not "fix" hangs by increasing browser timeouts; it masks invalid wasm generation.
|
||||
|
||||
## Debugging tips
|
||||
- Look for `$invokeCOROUTINE$` in wasm function names when mapping failures.
|
||||
- If node test logs a wasm compile error, the browser hang is likely the same root cause.
|
||||
@ -1,75 +0,0 @@
|
||||
# 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`).
|
||||
@ -34,18 +34,13 @@ Valid examples:
|
||||
|
||||
Ellipsis are used to declare variadic arguments. It basically means "all the arguments available here". It means, ellipsis argument could be in any part of the list, being, end or middle, but there could be only one ellipsis argument and it must not have default value, its default value is always `[]`, en empty list.
|
||||
|
||||
Ellipsis can also appear in **function types** to denote a variadic position:
|
||||
|
||||
var f: (Int, Object..., String)->Real
|
||||
var anyArgs: (...)->Int // shorthand for (Object...)->Int
|
||||
|
||||
Ellipsis argument receives what is left from arguments after processing regular one that could be before or after.
|
||||
|
||||
Ellipsis could be a first argument:
|
||||
|
||||
fun testCountArgs(data...,size) {
|
||||
assert(size is Int)
|
||||
assertEquals(size, (data as List).size)
|
||||
assertEquals(size, data.size)
|
||||
}
|
||||
testCountArgs( 1, 2, "three", 3)
|
||||
>>> void
|
||||
@ -54,7 +49,7 @@ Ellipsis could also be a last one:
|
||||
|
||||
fun testCountArgs(size, data...) {
|
||||
assert(size is Int)
|
||||
assertEquals(size, (data as List).size)
|
||||
assertEquals(size, data.size)
|
||||
}
|
||||
testCountArgs( 3, 10, 2, "three")
|
||||
>>> void
|
||||
@ -63,7 +58,7 @@ Or in the middle:
|
||||
|
||||
fun testCountArgs(size, data..., textToReturn) {
|
||||
assert(size is Int)
|
||||
assertEquals(size, (data as List).size)
|
||||
assertEquals(size, data.size)
|
||||
textToReturn
|
||||
}
|
||||
testCountArgs( 3, 10, 2, "three", "All OK")
|
||||
|
||||
@ -4,7 +4,7 @@ Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows,
|
||||
|
||||
- add Lyng to your build
|
||||
- create a runtime and execute scripts
|
||||
- declare extern globals in Lyng and bind them from Kotlin
|
||||
- define functions and variables from Kotlin
|
||||
- read variable values back in Kotlin
|
||||
- call Lyng functions from Kotlin
|
||||
- create your own packages and import them in Lyng
|
||||
@ -65,74 +65,30 @@ val run2 = script.execute(scope)
|
||||
|
||||
`Scope.eval("...")` is a shortcut that compiles and executes on the given scope.
|
||||
|
||||
### 3) Preferred: bind extern globals from Kotlin
|
||||
### 3) Define variables from Kotlin
|
||||
|
||||
For module-level APIs, the default workflow is:
|
||||
|
||||
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
|
||||
2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
|
||||
To expose data to Lyng, add constants (read‑only) or mutable variables to the scope. All values in Lyng are `Obj` instances; the core types live in `net.sergeych.lyng.obj`.
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
// Read‑only constant
|
||||
scope.addConst("pi", ObjReal(3.14159))
|
||||
|
||||
val im = Script.defaultImportManager.copy()
|
||||
im.addPackage("my.api") { module ->
|
||||
module.eval("""
|
||||
extern fun globalFun(v: Int): Int
|
||||
extern var globalProp: String
|
||||
extern val globalVersion: String
|
||||
""".trimIndent())
|
||||
// Mutable variable: create or update
|
||||
scope.addOrUpdateItem("counter", ObjInt(0))
|
||||
|
||||
val binder = module.globalBinder()
|
||||
|
||||
binder.bindGlobalFun1<Int>("globalFun") { v ->
|
||||
ObjInt.of((v + 1).toLong())
|
||||
}
|
||||
|
||||
var prop = "initial"
|
||||
binder.bindGlobalVar(
|
||||
name = "globalProp",
|
||||
get = { prop },
|
||||
set = { prop = it }
|
||||
)
|
||||
|
||||
binder.bindGlobalVar(
|
||||
name = "globalVersion",
|
||||
get = { "1.0.0" } // readonly: setter omitted
|
||||
)
|
||||
}
|
||||
// Use it from Lyng
|
||||
scope.eval("counter = counter + 1")
|
||||
```
|
||||
|
||||
Usage from Lyng:
|
||||
|
||||
```lyng
|
||||
import my.api
|
||||
|
||||
assertEquals(42, globalFun(41))
|
||||
assertEquals("initial", globalProp)
|
||||
globalProp = "changed"
|
||||
assertEquals("changed", globalProp)
|
||||
assertEquals("1.0.0", globalVersion)
|
||||
```
|
||||
|
||||
For custom argument handling and full runtime access:
|
||||
Tip: Lyng values can be converted back to Kotlin with `toKotlin(scope)`:
|
||||
|
||||
```kotlin
|
||||
binder.bindGlobalFun("sum3") {
|
||||
requireExactCount(3)
|
||||
ObjInt.of((int(0) + int(1) + int(2)).toLong())
|
||||
}
|
||||
|
||||
binder.bindGlobalFunRaw("echoRaw") { _, args ->
|
||||
args.firstAndOnly()
|
||||
}
|
||||
val current = (scope.eval("counter")).toKotlin(scope) // Any? (e.g., Int/Double/String/List)
|
||||
```
|
||||
|
||||
### 4) Low-level: direct functions/variables from Kotlin
|
||||
### 4) Add Kotlin‑backed functions
|
||||
|
||||
Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3.
|
||||
Use `Scope.addFn`/`addVoidFn` to register functions implemented in Kotlin. Inside the lambda, use `this.args` to access arguments and return an `Obj`.
|
||||
|
||||
```kotlin
|
||||
// A function returning value
|
||||
@ -158,17 +114,6 @@ scope.eval("val y = inc(41); log('Answer:', y)")
|
||||
|
||||
You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`.
|
||||
|
||||
Scope-backed Kotlin lambdas receive a `ScopeFacade` (not a full `Scope`). For migration and convenience, these utilities are available on the facade:
|
||||
|
||||
- Access: `args`, `pos`, `thisObj`, `get(name)`
|
||||
- Invocation: `call(...)`, `resolve(...)`, `assign(...)`, `toStringOf(...)`, `inspect(...)`, `trace(...)`
|
||||
- Args helpers: `requiredArg<T>()`, `requireOnlyArg<T>()`, `requireExactCount(...)`, `requireNoArgs()`, `thisAs<T>()`
|
||||
- Errors: `raiseError(...)`, `raiseClassCastError(...)`, `raiseIllegalArgument(...)`, `raiseIllegalState(...)`, `raiseNoSuchElement(...)`,
|
||||
`raiseSymbolNotFound(...)`, `raiseNotImplemented(...)`, `raiseNPE()`, `raiseIndexOutOfBounds(...)`, `raiseIllegalAssignment(...)`,
|
||||
`raiseUnset(...)`, `raiseNotFound(...)`, `raiseAssertionFailed(...)`, `raiseIllegalOperation(...)`, `raiseIterationFinished()`
|
||||
|
||||
If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
|
||||
|
||||
### 5) Add Kotlin‑backed fields
|
||||
|
||||
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
|
||||
@ -237,158 +182,6 @@ instance.value = 42
|
||||
println(instance.value) // -> 42
|
||||
```
|
||||
|
||||
### 6.5) Preferred: bind Kotlin implementations to declared Lyng classes
|
||||
|
||||
For extensions and libraries, the **preferred** workflow is Lyng‑first: declare the class and its members in Lyng, then bind the Kotlin implementations using the bridge.
|
||||
|
||||
This keeps Lyng semantics (visibility, overrides, type checks) in Lyng, while Kotlin supplies the behavior.
|
||||
|
||||
Pure extern declarations use the simplified rule set:
|
||||
- `extern class` / `extern object` are declaration-only ABI surfaces.
|
||||
- Every member in their body is implicitly extern (you may still write `extern`, but it is redundant).
|
||||
- Plain Lyng member implementations inside `extern class` / `extern object` are not allowed.
|
||||
- Put Lyng behavior into regular classes or extension methods.
|
||||
|
||||
```lyng
|
||||
// Lyng side (in a module)
|
||||
class Counter {
|
||||
extern var value: Int
|
||||
extern fun inc(by: Int): Int
|
||||
}
|
||||
```
|
||||
|
||||
Note: members of `extern class` / `extern object` are treated as extern by default, so the compiler emits ABI slots that Kotlin bindings attach to. This applies to functions and properties bound via `addFun` / `addVal` / `addVar`.
|
||||
|
||||
Example of pure extern class declaration:
|
||||
|
||||
```lyng
|
||||
extern class HostCounter {
|
||||
var value: Int
|
||||
fun inc(by: Int): Int
|
||||
}
|
||||
```
|
||||
|
||||
If you need Lyng-side convenience behavior, add it as an extension:
|
||||
|
||||
```lyng
|
||||
fun HostCounter.bump() = inc(1)
|
||||
```
|
||||
|
||||
```kotlin
|
||||
// Kotlin side (binding)
|
||||
val moduleScope = Script.newScope() // or an existing module scope
|
||||
moduleScope.eval("class Counter { extern var value: Int; extern fun inc(by: Int): Int }")
|
||||
|
||||
moduleScope.bind("Counter") {
|
||||
addVar(
|
||||
name = "value",
|
||||
get = { thisObj.readField(this, "value").value },
|
||||
set = { v -> thisObj.writeField(this, "value", v) }
|
||||
)
|
||||
addFun("inc") {
|
||||
val by = args.requiredArg<ObjInt>(0).value
|
||||
val current = thisObj.readField(this, "value").value as ObjInt
|
||||
val next = ObjInt(current.value + by)
|
||||
thisObj.writeField(this, "value", next)
|
||||
next
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Notes:
|
||||
|
||||
- Binding must happen **before** the first instance is created.
|
||||
- Use [LyngClassBridge] to bind by name/module, or by an already resolved `ObjClass`.
|
||||
- Use `ObjInstance.data` / `ObjClass.classData` to attach Kotlin‑side state when needed.
|
||||
|
||||
### 6.5a) Bind Kotlin implementations to declared Lyng objects
|
||||
|
||||
For `extern object` declarations, bind implementations to the singleton instance using `ModuleScope.bindObject`.
|
||||
This mirrors class binding but targets an already created object instance.
|
||||
As with class binding, you must first add/evaluate the Lyng declaration into that module scope, then bind Kotlin handlers.
|
||||
|
||||
```kotlin
|
||||
// Kotlin side (binding)
|
||||
val moduleScope = importManager.createModuleScope(Pos.builtIn, "bridge.obj")
|
||||
|
||||
// 1) Seed the module with the Lyng declaration first
|
||||
moduleScope.eval("""
|
||||
extern object HostObject {
|
||||
extern fun add(a: Int, b: Int): Int
|
||||
extern val status: String
|
||||
extern var count: Int
|
||||
}
|
||||
""".trimIndent())
|
||||
|
||||
// 2) Then bind Kotlin implementations to that declared object
|
||||
moduleScope.bindObject("HostObject") {
|
||||
classData = "OK"
|
||||
init { _ -> data = 0L }
|
||||
addFun("add") {
|
||||
val a = args.requiredArg<ObjInt>(0).value
|
||||
val b = args.requiredArg<ObjInt>(1).value
|
||||
ObjInt.of(a + b)
|
||||
}
|
||||
addVal("status") { ObjString(classData as String) }
|
||||
addVar(
|
||||
"count",
|
||||
get = { ObjInt.of((thisObj as ObjInstance).data as Long) },
|
||||
set = { value -> (thisObj as ObjInstance).data = (value as ObjInt).value }
|
||||
)
|
||||
}
|
||||
```
|
||||
|
||||
Notes:
|
||||
|
||||
- Required order: declare/eval Lyng object in the module first, then call `bindObject(...)`.
|
||||
This is the pattern covered by `BridgeBindingTest.testExternObjectBinding`.
|
||||
- Members must be extern (explicitly, or implicitly via `extern object`) so the compiler emits ABI slots for Kotlin bindings.
|
||||
- You can also bind by name/module via `LyngObjectBridge.bind(...)`.
|
||||
|
||||
Minimal `extern fun` example:
|
||||
|
||||
```kotlin
|
||||
val moduleScope = importManager.createModuleScope(Pos.builtIn, "bridge.ping")
|
||||
|
||||
moduleScope.eval("""
|
||||
extern object HostObject {
|
||||
extern fun ping(): Int
|
||||
}
|
||||
""".trimIndent())
|
||||
|
||||
moduleScope.bindObject("HostObject") {
|
||||
addFun("ping") { ObjInt.of(7) }
|
||||
}
|
||||
```
|
||||
|
||||
### 6.6) Preferred: Kotlin reflection bridge for call‑by‑name
|
||||
|
||||
For Kotlin code that needs dynamic access to Lyng variables, functions, or members, use the bridge resolver.
|
||||
It provides explicit, cached handles and predictable lookup rules.
|
||||
|
||||
```kotlin
|
||||
val scope = Script.newScope()
|
||||
scope.eval("""
|
||||
val x = 40
|
||||
fun add(a, b) = a + b
|
||||
class Box { var value = 1 }
|
||||
""")
|
||||
|
||||
val resolver = scope.resolver()
|
||||
|
||||
// Read a top‑level value
|
||||
val x = resolver.resolveVal("x").get(scope)
|
||||
|
||||
// Call a function by name (cached inside the resolver)
|
||||
val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2)))
|
||||
|
||||
// Member access
|
||||
val box = scope.eval("Box()")
|
||||
val valueHandle = resolver.resolveMemberVar(box, "value")
|
||||
valueHandle.set(scope, ObjInt(10))
|
||||
val value = valueHandle.get(scope)
|
||||
```
|
||||
|
||||
### 7) Read variable values back in Kotlin
|
||||
|
||||
The simplest approach: evaluate an expression that yields the value and convert it.
|
||||
@ -449,9 +242,6 @@ Key concepts:
|
||||
Register a Kotlin‑built package:
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.bridge.*
|
||||
import net.sergeych.lyng.obj.ObjInt
|
||||
|
||||
val scope = Script.newScope()
|
||||
|
||||
// Access the import manager behind this scope
|
||||
@ -459,19 +249,11 @@ val im: ImportManager = scope.importManager
|
||||
|
||||
// Register a package "my.tools"
|
||||
im.addPackage("my.tools") { module: ModuleScope ->
|
||||
module.eval(
|
||||
"""
|
||||
extern val version: String
|
||||
extern fun triple(x: Int): Int
|
||||
""".trimIndent()
|
||||
)
|
||||
val binder = module.globalBinder()
|
||||
binder.bindGlobalVar(
|
||||
name = "version",
|
||||
get = { "1.0" }
|
||||
)
|
||||
binder.bindGlobalFun1<Int>("triple") { x ->
|
||||
ObjInt.of((x * 3).toLong())
|
||||
// Expose symbols inside the module scope
|
||||
module.addConst("version", ObjString("1.0"))
|
||||
module.addFn<ObjInt>("triple") {
|
||||
val x = args.firstAndOnly() as ObjInt
|
||||
ObjInt(x.value * 3)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
146
docs/generics.md
146
docs/generics.md
@ -1,146 +0,0 @@
|
||||
# Generics and type expressions
|
||||
|
||||
This document covers generics, bounds, unions/intersections, and the rules for type expressions in Lyng.
|
||||
|
||||
# Generic parameters
|
||||
|
||||
Declare type parameters with `<...>` on functions and classes:
|
||||
|
||||
fun id<T>(x: T): T = x
|
||||
class Box<T>(val value: T)
|
||||
|
||||
Type arguments are usually inferred at call sites:
|
||||
|
||||
val b = Box(10) // Box<Int>
|
||||
val s = id("ok") // T is String
|
||||
|
||||
# Bounds
|
||||
|
||||
Use `:` to set bounds. Bounds may be unions (`|`) or intersections (`&`):
|
||||
|
||||
fun sum<T: Int | Real>(x: T, y: T) = x + y
|
||||
class Named<T: Iterable & Comparable>(val data: T)
|
||||
|
||||
Bounds are checked at compile time. For union bounds, the argument must fit at least one option. For intersection bounds, it must fit all options.
|
||||
|
||||
# Variance
|
||||
|
||||
Generic types are invariant by default. You can specify declaration-site variance:
|
||||
|
||||
class Source<out T>(val value: T)
|
||||
class Sink<in T> { fun accept(x: T) { ... } }
|
||||
|
||||
`out` makes the type covariant (produced), `in` makes it contravariant (consumed).
|
||||
|
||||
# Type aliases
|
||||
|
||||
Type aliases name type expressions (including unions/intersections):
|
||||
|
||||
type Num = Int | Real
|
||||
type AB = A & B
|
||||
|
||||
Aliases can be generic and can use bounds and defaults:
|
||||
|
||||
type Maybe<T> = T?
|
||||
type IntList<T: Int> = List<T>
|
||||
|
||||
Aliases expand to their underlying type expressions. They can be used anywhere a type expression is expected.
|
||||
|
||||
# Inference rules
|
||||
|
||||
- Literals set obvious types (`1` is `Int`, `1.0` is `Real`, etc.).
|
||||
- Empty list literals default to `List<Object>` unless constrained by context.
|
||||
- Non-empty list literals infer element type as a union of element types.
|
||||
- Map literals infer key and value types; named keys are `String`.
|
||||
|
||||
Examples:
|
||||
|
||||
val a = [1, 2, 3] // List<Int>
|
||||
val b = [1, "two", true] // List<Int | String | Bool>
|
||||
val c: List<Int> = [] // List<Int>
|
||||
|
||||
val m1 = { "a": 1, "b": 2 } // Map<String, Int>
|
||||
val m2 = { "a": 1, "b": "x" } // Map<String, Int | String>
|
||||
val m3 = { ...m1, "c": true } // Map<String, Int | Bool>
|
||||
|
||||
Map spreads carry key/value types when possible.
|
||||
|
||||
Spreads propagate element type when possible:
|
||||
|
||||
val base = [1, 2]
|
||||
val mix = [...base, 3] // List<Int>
|
||||
|
||||
# Type expressions
|
||||
|
||||
Type expressions include simple types, generics, unions, and intersections:
|
||||
|
||||
Int
|
||||
List<String>
|
||||
Int | String
|
||||
Iterable & Comparable
|
||||
|
||||
These type expressions can appear in casts and `is` checks.
|
||||
|
||||
# `is`, `in`, and `==` with type expressions
|
||||
|
||||
There are two categories of `is` checks:
|
||||
|
||||
1) Value checks: `x is T`
|
||||
- `x` is a value, `T` is a type expression.
|
||||
- This is a runtime instance check.
|
||||
|
||||
2) Type checks: `T1 is T2`
|
||||
- both sides are type expressions (class objects or unions/intersections).
|
||||
- This is a *type-subset* check: every value of `T1` must fit in `T2`.
|
||||
|
||||
Exact type expression equality uses `==` and is structural (union/intersection order does not matter).
|
||||
|
||||
Includes checks use `in` with type expressions:
|
||||
|
||||
A in T
|
||||
|
||||
This means `A` is a subset of `T` (the same relation as `A is T`).
|
||||
|
||||
Examples (T = A | B):
|
||||
|
||||
T == A // false
|
||||
T is A // false
|
||||
A in T // true
|
||||
B in T // true
|
||||
T is A | B // true
|
||||
|
||||
# Nullability checks for types
|
||||
|
||||
Use `is nullable` to check whether a type expression accepts `null`:
|
||||
|
||||
T is nullable
|
||||
T !is nullable
|
||||
|
||||
This works with concrete and generic types:
|
||||
|
||||
fun describe<T>(x: T): String = when (T) {
|
||||
nullable -> "nullable"
|
||||
else -> "non-null"
|
||||
}
|
||||
|
||||
Equivalent legacy form:
|
||||
|
||||
null is T
|
||||
|
||||
# Practical examples
|
||||
|
||||
fun acceptInts<T: Int>(xs: List<T>) { }
|
||||
acceptInts([1, 2, 3])
|
||||
// acceptInts([1, "a"]) -> compile-time error
|
||||
|
||||
fun f<T>(list: List<T>) {
|
||||
assert( T is Int | String | Bool )
|
||||
assert( !(T is Int) )
|
||||
assert( Int in T )
|
||||
}
|
||||
f([1, "two", true])
|
||||
|
||||
# Notes
|
||||
|
||||
- `T` is reified as a type expression when needed (e.g., union/intersection). When it is a single class, `T` is that class object.
|
||||
- Type expression checks are compile-time where possible; runtime checks only happen for `is` on values and explicit casts.
|
||||
@ -9,12 +9,9 @@ should be compatible with other IDEA flavors, notably [OpenIDE](https://openide.
|
||||
- reformat code (indents, spaces)
|
||||
- reformat on paste
|
||||
- smart enter key
|
||||
- `.lyng.d` definition files (merged into analysis for completion, navigation, Quick Docs, and error checking)
|
||||
|
||||
Features are configurable via the plugin settings page, in system settings.
|
||||
|
||||
See `docs/lyng_d_files.md` for `.lyng.d` syntax and examples.
|
||||
|
||||
> Recommended for IntelliJ-based IDEs: While IntelliJ can import TextMate bundles
|
||||
> (Settings/Preferences → Editor → TextMate Bundles), the native Lyng plugin provides
|
||||
> better support (formatting, smart enter, background analysis, etc.). Prefer installing
|
||||
@ -29,4 +26,4 @@ See `docs/lyng_d_files.md` for `.lyng.d` syntax and examples.
|
||||
|
||||
### [Download plugin v0.0.2-SNAPSHOT](https://lynglang.com/distributables/lyng-idea-0.0.2-SNAPSHOT.zip)
|
||||
|
||||
Your ideas and bugreports are welcome on the [project gitea page](https://gitea.sergeych.net/SergeychWorks/lyng/issues)
|
||||
Your ideas and bugreports are welcome on the [project gitea page](https://gitea.sergeych.net/SergeychWorks/lyng/issues)
|
||||
@ -1,112 +0,0 @@
|
||||
### lyng.io.console
|
||||
|
||||
`lyng.io.console` provides optional rich console support for terminal applications.
|
||||
|
||||
> **Note:** this module is part of `lyngio`. It must be explicitly installed into the import manager by host code.
|
||||
>
|
||||
> **CLI note:** the `lyng` CLI now installs `lyng.io.console` in its base scope by default, so scripts can simply `import lyng.io.console`.
|
||||
|
||||
#### Install in host
|
||||
|
||||
```kotlin
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.io.console.createConsoleModule
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
|
||||
suspend fun initScope() {
|
||||
val scope = Script.newScope()
|
||||
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
|
||||
}
|
||||
```
|
||||
|
||||
#### Use in Lyng script
|
||||
|
||||
```lyng
|
||||
import lyng.io.console
|
||||
|
||||
println("supported = " + Console.isSupported())
|
||||
println("tty = " + Console.isTty())
|
||||
println("ansi = " + Console.ansiLevel())
|
||||
println("geometry = " + Console.geometry())
|
||||
|
||||
Console.write("hello\n")
|
||||
Console.home()
|
||||
Console.clear()
|
||||
Console.moveTo(1, 1)
|
||||
Console.clearLine()
|
||||
Console.enterAltScreen()
|
||||
Console.leaveAltScreen()
|
||||
Console.setCursorVisible(true)
|
||||
Console.flush()
|
||||
```
|
||||
|
||||
#### Tetris sample
|
||||
|
||||
The repository includes a full interactive Tetris sample that demonstrates:
|
||||
|
||||
- alternate screen rendering
|
||||
- raw keyboard input
|
||||
- resize handling
|
||||
- typed console events
|
||||
|
||||
|
||||
|
||||
Run it from the project root in a real TTY:
|
||||
|
||||
```bash
|
||||
lyng examples/tetris_console.lyng
|
||||
```
|
||||
|
||||
#### API
|
||||
|
||||
- `Console.isSupported(): Bool` — whether console control is available on this platform/runtime.
|
||||
- `Console.isTty(): Bool` — whether output is attached to a TTY.
|
||||
- `Console.ansiLevel(): ConsoleAnsiLevel` — `NONE`, `BASIC16`, `ANSI256`, `TRUECOLOR`.
|
||||
- `Console.geometry(): ConsoleGeometry?` — `{columns, rows}` as typed object or `null`.
|
||||
- `Console.details(): ConsoleDetails` — consolidated capability object.
|
||||
- `Console.write(text: String)` — writes to console output.
|
||||
- `Console.flush()` — flushes buffered output.
|
||||
- `Console.home()` — moves cursor to top-left.
|
||||
- `Console.clear()` — clears visible screen.
|
||||
- `Console.moveTo(row: Int, column: Int)` — moves cursor to 1-based row/column.
|
||||
- `Console.clearLine()` — clears current line.
|
||||
- `Console.enterAltScreen()` — switch to alternate screen buffer.
|
||||
- `Console.leaveAltScreen()` — return to normal screen buffer.
|
||||
- `Console.setCursorVisible(visible: Bool)` — shows/hides cursor.
|
||||
- `Console.events(): ConsoleEventStream` — endless iterable source of typed events: `ConsoleResizeEvent`, `ConsoleKeyEvent`.
|
||||
- `Console.setRawMode(enabled: Bool): Bool` — requests raw input mode, returns `true` if changed.
|
||||
|
||||
#### Event Iteration
|
||||
|
||||
Use events from a loop, typically in a separate coroutine:
|
||||
|
||||
```lyng
|
||||
launch {
|
||||
for (ev in Console.events()) {
|
||||
if (ev is ConsoleKeyEvent) {
|
||||
// handle key
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
#### Event format
|
||||
|
||||
`Console.events()` emits `ConsoleEvent` with:
|
||||
|
||||
- `type: ConsoleEventType` — `UNKNOWN`, `RESIZE`, `KEY_DOWN`, `KEY_UP`
|
||||
|
||||
Additional fields:
|
||||
|
||||
- `ConsoleResizeEvent`: `columns`, `rows`
|
||||
- `ConsoleKeyEvent`: `key`, `code`, `ctrl`, `alt`, `shift`, `meta`
|
||||
|
||||
#### Security policy
|
||||
|
||||
The module uses `ConsoleAccessPolicy` with operations:
|
||||
|
||||
- `WriteText(length)`
|
||||
- `ReadEvents`
|
||||
- `SetRawMode(enabled)`
|
||||
|
||||
For permissive mode, use `PermitAllConsoleAccessPolicy`.
|
||||
@ -1,116 +0,0 @@
|
||||
# `.lyng.d` Definition Files
|
||||
|
||||
`.lyng.d` files declare Lyng symbols for tooling without shipping runtime implementations. The IntelliJ IDEA plugin merges
|
||||
all `*.lyng.d` files from the current directory and its parent directories into the active file’s analysis, enabling:
|
||||
|
||||
- completion
|
||||
- navigation
|
||||
- error checking for declared symbols
|
||||
- Quick Docs for declarations defined in `.lyng.d`
|
||||
|
||||
Place `*.lyng.d` files next to the code they describe (or in a parent folder). The plugin will pick them up automatically.
|
||||
|
||||
## Writing `.lyng.d` Files
|
||||
|
||||
You can declare any language-level symbol in a `.lyng.d` file. Use doc comments before declarations to make Quick Docs
|
||||
work in the IDE. The doc parser accepts standard comments (`/** ... */` or `// ...`) and supports tags like `@param`.
|
||||
|
||||
### Full Example
|
||||
|
||||
```lyng
|
||||
/** Library entry point */
|
||||
extern fun connect(url: String, timeoutMs: Int = 5000): Client
|
||||
|
||||
/** Type alias with generics */
|
||||
type NameMap = Map<String, String>
|
||||
|
||||
/** Multiple inheritance via interfaces */
|
||||
interface A { abstract fun a(): Int }
|
||||
interface B { abstract fun b(): Int }
|
||||
|
||||
/** A concrete class implementing both */
|
||||
class Multi(name: String) : A, B {
|
||||
/** Public field */
|
||||
val id: Int = 0
|
||||
|
||||
/** Mutable property with accessors */
|
||||
var size: Int
|
||||
get() = 0
|
||||
set(v) { }
|
||||
|
||||
/** Instance method */
|
||||
fun a(): Int = 1
|
||||
fun b(): Int = 2
|
||||
}
|
||||
|
||||
/** Nullable and dynamic types */
|
||||
extern val dynValue: dynamic
|
||||
extern var dynVar: dynamic?
|
||||
|
||||
/** Delegated property */
|
||||
class LazyBox(val create) {
|
||||
fun getValue(thisRef, name) = create()
|
||||
}
|
||||
|
||||
val cached by LazyBox { 42 }
|
||||
|
||||
/** Delegated function */
|
||||
object RpcDelegate {
|
||||
fun invoke(thisRef, name, args...) = Unset
|
||||
}
|
||||
|
||||
fun remoteCall by RpcDelegate
|
||||
|
||||
/** Singleton object */
|
||||
object Settings {
|
||||
val version: String = "1.0"
|
||||
}
|
||||
|
||||
/** Class with documented members */
|
||||
class Client {
|
||||
/** Returns a greeting. */
|
||||
fun greet(name: String): String = "hi " + name
|
||||
}
|
||||
```
|
||||
|
||||
See a runnable sample file in `docs/samples/definitions.lyng.d`.
|
||||
|
||||
Notes:
|
||||
- Use real bodies if the declaration is not `extern` or `abstract`.
|
||||
- If you need purely declarative stubs, prefer `extern` members (see `embedding.md`).
|
||||
|
||||
## Doc Comment Format
|
||||
|
||||
Doc comments are picked up when they immediately precede a declaration.
|
||||
|
||||
```lyng
|
||||
/**
|
||||
* A sample function.
|
||||
* @param name user name
|
||||
* @return greeting string
|
||||
*/
|
||||
fun greet(name: String): String = "hi " + name
|
||||
```
|
||||
|
||||
## Generating `.lyng.d` Files
|
||||
|
||||
You can generate `.lyng.d` as part of your build. A common approach is to write a Gradle task that emits a file from a
|
||||
template or a Kotlin data model.
|
||||
|
||||
Example (pseudo-code):
|
||||
|
||||
```kotlin
|
||||
tasks.register("generateLyngDefs") {
|
||||
doLast {
|
||||
val out = file("src/main/lyng/api.lyng.d")
|
||||
out.writeText(
|
||||
"""
|
||||
/** Generated API */
|
||||
fun ping(): Int
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Place the generated file in your source tree, and the IDE will load it automatically.
|
||||
@ -6,13 +6,12 @@
|
||||
|
||||
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`, `ConsoleAccessPolicy`) that allow you to control exactly what a script can do.
|
||||
3. **Control:** `lyngio` provides fine-grained security policies (`FsAccessPolicy`, `ProcessAccessPolicy`) 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.
|
||||
|
||||
---
|
||||
|
||||
@ -40,10 +39,8 @@ 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()
|
||||
@ -51,17 +48,14 @@ 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())
|
||||
""")
|
||||
}
|
||||
```
|
||||
@ -74,22 +68,20 @@ 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 | lyng.io.console |
|
||||
| :--- | :---: | :---: | :---: |
|
||||
| **JVM** | ✅ | ✅ | ✅ (baseline) |
|
||||
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 |
|
||||
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 |
|
||||
| **Android** | ✅ | ❌ | ❌ |
|
||||
| **NodeJS** | ✅ | ❌ | ❌ |
|
||||
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ |
|
||||
| Platform | lyng.io.fs | lyng.io.process |
|
||||
| :--- | :---: | :---: |
|
||||
| **JVM** | ✅ | ✅ |
|
||||
| **Native (Linux/macOS)** | ✅ | ✅ |
|
||||
| **Native (Windows)** | ✅ | 🚧 (Planned) |
|
||||
| **Android** | ✅ | ❌ |
|
||||
| **NodeJS** | ✅ | ❌ |
|
||||
| **Browser / Wasm** | ✅ (In-memory) | ❌ |
|
||||
|
||||
23
docs/math.md
23
docs/math.md
@ -110,29 +110,6 @@ 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 |
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
|
||||
Before kotlin 2.0, there was an excellent library, kotlinx.datetime, which was widely used everywhere, also in Lyng and its dependencies.
|
||||
|
||||
When Kotlin 2.0 was released, or soon after, JetBrains made a perplexing decision to remove `Instant` and `Clock` from kotlinx.datetime and replace it with _yet experimental_ analogs in `kotlin.time`.
|
||||
When kotlin 2.0 was released, or soon after, JetBrains made an exptic decision to remove `Instant` and `Clock` from kotlinx.datetime and replace it with _yet experimental_ analogs in `kotlin.time`.
|
||||
|
||||
The problem is, these were not quite the same (these weren't `@Serializable`!), so people didn't migrate with ease. Okay, then JetBrains decided to not only deprecate it but also make them unusable on Apple targets. It sort of split auditories of many published libraries to those who hate JetBrains and Apple and continue to use 1.9-2.0 compatible versions that no longer work with Kotlin 2.2 on Apple targets (but work pretty well with earlier Kotlin or on other platforms).
|
||||
|
||||
@ -12,14 +12,14 @@ Later JetBrains added serializers for their new `Instant` and `Clock` types, but
|
||||
|
||||
## Solution
|
||||
|
||||
We hereby publish a new version of Lyng, 1.0.8-SNAPSHOT, which uses `kotlin.time.Instant` and `kotlin.time.Clock` instead of `kotlinx.datetime.Instant` and `kotlinx.datetime.Clock`. It is in other aspects compatible also with Lynon encoded binaries. You might need to migrate your code to use `kotlin.time` types. (LocalDateTime/TimeZone still come from `kotlinx.datetime`.)
|
||||
We hereby publish a new version of Lyng, 1.0.8-SNAPSHOT, which uses `ktlin.time.Instant` and `kotlin.time.Clock` instead of `kotlinx.datetime.Instant` and `kotlinx.datetime.Clock; it is in other aspects compatible also with Lynon encoded binaries. Still you might need to migrate your code to use `kotlinx.datetime` types.
|
||||
|
||||
So, if you are getting errors with new version, please do:
|
||||
So, if you are getting errors with new version, plase do:
|
||||
|
||||
- upgrade to Kotlin 2.2
|
||||
- upgrade to Lyng 1.0.8-SNAPSHOT
|
||||
- replace in your code imports (or other uses) of `kotlinx.datetime.Clock` to `kotlin.time.Clock` and `kotlinx.datetime.Instant` to `kotlin.time.Instant`.
|
||||
- replace in your code imports (or other uses) of`kotlinx.datetime.Clock` to `kotlin.time.Clock` and `kotlinx.datetime.Instant` to `kotlin.time.Instant`.
|
||||
|
||||
This should solve the problem and hopefully we'll see no more such "brilliant" ideas from IDEA ideologspersons.
|
||||
This should solve the problem and hopefully we'll see no more suh a brillant ideas from IDEA ideologspersons.
|
||||
|
||||
Sorry for inconvenience and send a ray of hate to JetBrains ;)
|
||||
Sorry for inconvenicence and send a ray of hate to JetBrains ;)
|
||||
@ -49,7 +49,7 @@ Suppose we have a resource, that could be used concurrently, a counter in our ca
|
||||
delay(100)
|
||||
counter = c + 1
|
||||
}
|
||||
}.forEach { (it as Deferred).await() }
|
||||
}.forEach { it.await() }
|
||||
assert(counter < 50) { "counter is "+counter }
|
||||
>>> void
|
||||
|
||||
@ -64,12 +64,13 @@ Using [Mutex] makes it all working:
|
||||
launch {
|
||||
// slow increment:
|
||||
mutex.withLock {
|
||||
val c = counter ?: 0
|
||||
val c = counter
|
||||
delay(10)
|
||||
counter = c + 1
|
||||
}
|
||||
}
|
||||
}.forEach { (it as Deferred).await() }
|
||||
assert(counter in 1..4)
|
||||
}.forEach { it.await() }
|
||||
assertEquals(4, counter)
|
||||
>>> void
|
||||
|
||||
now everything works as expected: `mutex.withLock` makes them all be executed in sequence, not in parallel.
|
||||
@ -223,14 +224,17 @@ Future work: introduce thread‑safe pooling (e.g., per‑thread pools or confin
|
||||
|
||||
### Closures inside coroutine helpers (launch/flow)
|
||||
|
||||
Closures executed by `launch { ... }` and `flow { ... }` use **compile‑time resolution** just like any other Lyng code:
|
||||
Closures executed by `launch { ... }` and `flow { ... }` resolve names using the `ClosureScope` rules:
|
||||
|
||||
- **Captured locals are slots**: outer locals are resolved at compile time and captured as frame‑slot references, so they remain visible across suspension points.
|
||||
- **Members are statically resolved**: member access requires a statically known receiver type or an explicit cast (except `Object` members).
|
||||
- **No runtime fallbacks**: there is no dynamic name lookup or “search parent scopes” at runtime for missing symbols.
|
||||
1. **Current frame locals and arguments**: Variables defined within the current closure execution.
|
||||
2. **Captured lexical ancestry**: Outer local variables captured at the site where the closure was defined (the "lexical environment").
|
||||
3. **Captured receiver members**: If the closure was defined within a class or explicitly bound to an object, it checks members of that object (`this`), following MRO and respecting visibility.
|
||||
4. **Caller environment**: Falls back to the calling context (e.g., the caller's `this` or local variables).
|
||||
5. **Global/Module fallbacks**: Final check for module-level constants and global functions.
|
||||
|
||||
Implications:
|
||||
- Global helpers like `delay(ms)` and `yield()` must be imported/known at compile time.
|
||||
- If you need dynamic access, use explicit helpers (e.g., `dynamic { ... }`) rather than relying on scope resolution.
|
||||
- Outer locals (e.g., `counter`) stay visible across suspension points.
|
||||
- Global helpers like `delay(ms)` and `yield()` are available from inside closures.
|
||||
- If you write your own async helpers, execute user lambdas under `ClosureScope(callScope, capturedCreatorScope)` and avoid manual ancestry walking.
|
||||
|
||||
See also: [Scopes and Closures: compile-time resolution](scopes_and_closures.md)
|
||||
See also: [Scopes and Closures: resolution and safety](scopes_and_closures.md)
|
||||
|
||||
@ -1,65 +0,0 @@
|
||||
/**
|
||||
* Sample .lyng.d file for IDE support.
|
||||
* Demonstrates declarations and doc comments.
|
||||
*/
|
||||
|
||||
/** Simple function with default and named parameters. */
|
||||
extern fun connect(url: String, timeoutMs: Int = 5000): Client
|
||||
|
||||
/** Type alias with generics. */
|
||||
type NameMap = Map<String, String>
|
||||
|
||||
/** Multiple inheritance via interfaces. */
|
||||
interface A { abstract fun a(): Int }
|
||||
interface B { abstract fun b(): Int }
|
||||
|
||||
/** A concrete class implementing both. */
|
||||
class Multi(name: String) : A, B {
|
||||
/** Public field. */
|
||||
val id: Int = 0
|
||||
|
||||
/** Mutable property with accessors. */
|
||||
var size: Int
|
||||
get() = 0
|
||||
set(v) { }
|
||||
|
||||
/** Instance method. */
|
||||
fun a(): Int = 1
|
||||
fun b(): Int = 2
|
||||
}
|
||||
|
||||
/** Nullable and dynamic types. */
|
||||
extern val dynValue: dynamic
|
||||
extern var dynVar: dynamic?
|
||||
|
||||
/** Delegated property provider. */
|
||||
class LazyBox(val create) {
|
||||
fun getValue(thisRef, name) = create()
|
||||
}
|
||||
|
||||
/** Delegated property using provider. */
|
||||
val cached by LazyBox { 42 }
|
||||
|
||||
/** Delegated function. */
|
||||
object RpcDelegate {
|
||||
fun invoke(thisRef, name, args...) = Unset
|
||||
}
|
||||
|
||||
/** Remote function proxy. */
|
||||
fun remoteCall by RpcDelegate
|
||||
|
||||
/** Singleton object. */
|
||||
object Settings {
|
||||
/** Version string. */
|
||||
val version: String = "1.0"
|
||||
}
|
||||
|
||||
/**
|
||||
* Client API entry.
|
||||
* @param name user name
|
||||
* @return greeting string
|
||||
*/
|
||||
class Client {
|
||||
/** Returns a greeting. */
|
||||
fun greet(name: String): String = "hi " + name
|
||||
}
|
||||
@ -4,21 +4,15 @@
|
||||
test the Lyng way. It is not meant to be effective.
|
||||
*/
|
||||
|
||||
fun naiveCountHappyNumbers(): Int {
|
||||
fun naiveCountHappyNumbers() {
|
||||
var count = 0
|
||||
for( n1 in 0..9 ) {
|
||||
for( n2 in 0..9 ) {
|
||||
for( n3 in 0..9 ) {
|
||||
for( n4 in 0..9 ) {
|
||||
for( n5 in 0..9 ) {
|
||||
for( n6 in 0..9 ) {
|
||||
for( n1 in 0..9 )
|
||||
for( n2 in 0..9 )
|
||||
for( n3 in 0..9 )
|
||||
for( n4 in 0..9 )
|
||||
for( n5 in 0..9 )
|
||||
for( n6 in 0..9 )
|
||||
if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
count
|
||||
}
|
||||
|
||||
@ -34,3 +28,4 @@ for( r in 1..900 ) {
|
||||
assert( found == 55252 )
|
||||
delay(0.05)
|
||||
}
|
||||
|
||||
|
||||
@ -1,23 +1,23 @@
|
||||
// Sample: Operator Overloading in Lyng
|
||||
|
||||
class Vector<T>(val x: T, val y: T) {
|
||||
class Vector(val x, val y) {
|
||||
// Overload +
|
||||
fun plus(other: Vector<U>) = Vector(x + other.x, y + other.y)
|
||||
fun plus(other) = Vector(x + other.x, y + other.y)
|
||||
|
||||
// Overload -
|
||||
fun minus(other: Vector<U>) = Vector(x - other.x, y - other.y)
|
||||
fun minus(other) = Vector(x - other.x, y - other.y)
|
||||
|
||||
// Overload unary -
|
||||
fun negate() = Vector(-x, -y)
|
||||
|
||||
// Overload ==
|
||||
fun equals(other) {
|
||||
if (other is Vector<U>) x == other.x && y == other.y
|
||||
if (other is Vector) x == other.x && y == other.y
|
||||
else false
|
||||
}
|
||||
|
||||
// Overload * (scalar multiplication)
|
||||
fun mul(scalar: Int | Real) = Vector(x * scalar, y * scalar)
|
||||
fun mul(scalar) = Vector(x * scalar, y * scalar)
|
||||
|
||||
override fun toString() = "Vector(${x}, ${y})"
|
||||
}
|
||||
|
||||
@ -13,6 +13,7 @@ fun findSumLimit(f) {
|
||||
println("limit reached after "+n+" rounds")
|
||||
break sum
|
||||
}
|
||||
n++
|
||||
}
|
||||
else {
|
||||
println("limit not reached")
|
||||
|
||||
@ -1,10 +0,0 @@
|
||||
fun describe<T>(x: T): String = when (T) {
|
||||
nullable -> "nullable"
|
||||
else -> "non-null"
|
||||
}
|
||||
|
||||
type MaybeInt = Int?
|
||||
assert(MaybeInt is nullable)
|
||||
assert(!(Int is nullable))
|
||||
assertEquals("nullable", describe<Int?>(null))
|
||||
assertEquals("non-null", describe<Int>(1))
|
||||
@ -1,18 +1,92 @@
|
||||
# Scopes and Closures: compile-time resolution
|
||||
# Scopes and Closures: resolution and safety
|
||||
|
||||
Attention to AI: name lookup in runtime `Scope` is legacy. The bytecode compiler uses **compile-time name/member resolution only**.
|
||||
This page documents how name resolution works with `ClosureScope`, how to avoid recursion pitfalls, and how to safely capture and execute callbacks that need access to outer locals.
|
||||
|
||||
This page documents the **current** rules: static name resolution, closure captures, and the limited role of runtime `Scope` in Kotlin interop and explicit dynamic helpers.
|
||||
## Why this matters
|
||||
Name lookup across nested scopes and closures can accidentally form recursive resolution paths or hide expected symbols (outer locals, module/global functions). The rules below ensure predictable resolution and prevent infinite recursion.
|
||||
|
||||
## Current rules (bytecode compiler)
|
||||
- **All names resolve at compile time**: locals, parameters, captures, members, imports, and module globals must be known when compiling. Missing symbols are compile-time errors.
|
||||
- **No runtime fallbacks**: there is no dynamic name lookup, no fallback opcodes, and no “search parent scopes” at runtime for missing names.
|
||||
- **Object members on unknown types only**: `toString`, `toInspectString`, `let`, `also`, `apply`, `run` are allowed on unknown types; all other members require a statically known receiver type or an explicit cast.
|
||||
- **Closures capture slots**: lambdas and nested functions capture **frame slots** directly. Captures are resolved at compile time and compiled to slot references.
|
||||
- **Scope is a reflection facade**: `Scope` is used only for Kotlin interop or explicit dynamic helpers. It must **not** be used for general symbol resolution in compiled Lyng code.
|
||||
## Resolution order in ClosureScope
|
||||
When evaluating an identifier `name` inside a closure, `ClosureScope.get(name)` resolves in this order:
|
||||
|
||||
## Explicit dynamic access (opt-in only)
|
||||
Dynamic name access is available only via explicit helpers (e.g., `dynamic { get { name -> ... } }`). It is **not** a fallback for normal member or variable access.
|
||||
1. **Current frame locals and arguments**: Variables defined within the current closure execution.
|
||||
2. **Captured lexical ancestry**: Outer local variables captured at the site where the closure was defined (the "lexical environment").
|
||||
3. **Captured receiver members**: If the closure was defined within a class or explicitly bound to an object, it checks members of that object (`this`). This includes both instance fields/methods and class-level static members, following the MRO (C3) and respecting visibility rules (private members are only visible if the closure was defined in their class).
|
||||
4. **Caller environment**: If not found lexically, it falls back to the calling context (e.g., the DSL's `this` or the caller's local variables).
|
||||
5. **Global/Module fallbacks**: Final check for module-level constants and global functions.
|
||||
|
||||
## Legacy interpreter behavior (reference only)
|
||||
The old runtime `Scope`-based resolution order (locals → captured → `this` → caller → globals) is obsolete for bytecode compilation. Keep it only for legacy interpreter paths and tooling that explicitly opts into it.
|
||||
This ensures that closures primarily interact with their defining environment (lexical capture) while still being able to participate in DSL-style calling contexts.
|
||||
|
||||
## Use raw‑chain helpers for ancestry walks
|
||||
When authoring new scope types or advanced lookups, avoid calling virtual `get` while walking parents. Instead, use the non‑dispatch helpers on `Scope`:
|
||||
|
||||
- `chainLookupIgnoreClosure(name)`
|
||||
- Walk raw `parent` chain and check only per‑frame locals/bindings/slots.
|
||||
- Ignores overridden `get` (e.g., in `ClosureScope`). Cycle‑safe.
|
||||
- `chainLookupWithMembers(name)`
|
||||
- Like above, but after locals/bindings it also checks each frame’s `thisObj` members.
|
||||
- Ignores overridden `get`. Cycle‑safe.
|
||||
- `baseGetIgnoreClosure(name)`
|
||||
- For the current frame only: check locals/bindings, then walk raw parents (locals/bindings), then fallback to this frame’s `thisObj` members.
|
||||
|
||||
These helpers avoid ping‑pong recursion and make structural cycles harmless (lookups terminate).
|
||||
|
||||
## Preventing structural cycles
|
||||
- Don’t construct parent chains that can point back to a descendant.
|
||||
- A debug‑time guard throws if assigning a parent would create a cycle; keep it enabled for development builds.
|
||||
- Even with a cycle, chain helpers break out via a small `visited` set keyed by `frameId`.
|
||||
|
||||
## Capturing lexical environments for callbacks
|
||||
For dynamic objects or custom builders, capture the creator’s lexical scope so callbacks can see outer locals/parameters:
|
||||
|
||||
1. Use `snapshotForClosure()` on the caller scope to capture locals/bindings/slots and parent.
|
||||
2. Store this snapshot and run callbacks under `ClosureScope(callScope, captured)`.
|
||||
|
||||
Kotlin sketch:
|
||||
```kotlin
|
||||
val captured = scope.snapshotForClosure()
|
||||
val execScope = ClosureScope(currentCallScope, captured)
|
||||
callback.execute(execScope)
|
||||
```
|
||||
|
||||
This ensures expressions like `contractName` used inside dynamic `get { name -> ... }` resolve to outer variables defined at the creation site.
|
||||
|
||||
## Closures in coroutines (launch/flow)
|
||||
- The closure frame still prioritizes its own locals/args.
|
||||
- Outer locals declared before suspension points remain visible through slot‑aware ancestry lookups.
|
||||
- Global functions like `delay(ms)` and `yield()` are resolved via module/root fallbacks from within closures.
|
||||
|
||||
Tip: If a closure unexpectedly cannot see an outer local, check whether an intermediate runtime helper introduced an extra call frame; the built‑in lookup already traverses caller ancestry, so prefer the standard helpers rather than custom dispatch.
|
||||
|
||||
## Local variable references and missing symbols
|
||||
- Unqualified identifier resolution first prefers locals/bindings/slots before falling back to `this` members.
|
||||
- If neither locals nor members contain the symbol, missing field lookups map to `SymbolNotFound` (compatibility alias for `SymbolNotDefinedException`).
|
||||
|
||||
## Performance notes
|
||||
- The `visited` sets used for cycle detection are tiny and short‑lived; in typical scripts the overhead is negligible.
|
||||
- If profiling shows hotspots, consider limiting ancestry depth in your custom helpers or using small fixed arrays instead of hash sets—only for extremely hot code paths.
|
||||
|
||||
## Practical Example: `cached`
|
||||
|
||||
The `cached` function (defined in `lyng.stdlib`) is a classic example of using closures to maintain state. It wraps a builder into a zero-argument function that computes once and remembers the result:
|
||||
|
||||
```lyng
|
||||
fun cached(builder) {
|
||||
var calculated = false
|
||||
var value = null
|
||||
{ // This lambda captures `calculated`, `value`, and `builder`
|
||||
if( !calculated ) {
|
||||
value = builder()
|
||||
calculated = true
|
||||
}
|
||||
value
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Because Lyng now correctly isolates closures for each evaluation of a lambda literal, using `cached` inside a class instance works as expected: each instance maintains its own private `calculated` and `value` state, even if they share the same property declaration.
|
||||
|
||||
## Dos and Don’ts
|
||||
- Do use `chainLookupIgnoreClosure` / `chainLookupWithMembers` for ancestry traversals.
|
||||
- Do maintain the resolution order above for predictable behavior.
|
||||
- Don’t call virtual `get` while walking parents; it risks recursion across scope types.
|
||||
- Don’t attach instance scopes to transient/pool frames; bind to a stable parent scope instead.
|
||||
|
||||
@ -17,7 +17,7 @@ It is as simple as:
|
||||
assertEquals( text, Lynon.decode(encodedBits) )
|
||||
|
||||
// compression was used automatically
|
||||
assert( text.length > (encodedBits.toBuffer() as Buffer).size )
|
||||
assert( text.length > encodedBits.toBuffer().size )
|
||||
>>> void
|
||||
|
||||
Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields.
|
||||
|
||||
275
docs/tutorial.md
275
docs/tutorial.md
@ -10,11 +10,10 @@ __Other documents to read__ maybe after this one:
|
||||
- [OOP notes](OOP.md), [exception handling](exceptions_handling.md)
|
||||
- [math in Lyng](math.md), [the `when` statement](when.md), [return statement](return_statement.md)
|
||||
- [Testing and Assertions](Testing.md)
|
||||
- [Generics and type expressions](generics.md)
|
||||
- [time](time.md) and [parallelism](parallelism.md)
|
||||
- [parallelism] - multithreaded code, coroutines, etc.
|
||||
- Some class
|
||||
references: [List], [ImmutableList], [Set], [ImmutableSet], [Map], [ImmutableMap], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
|
||||
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
|
||||
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
|
||||
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
|
||||
|
||||
@ -107,23 +106,6 @@ Singleton objects are declared using the `object` keyword. They define a class a
|
||||
|
||||
Logger.log("Hello singleton!")
|
||||
|
||||
## Nested Declarations (short)
|
||||
|
||||
Classes, objects, and enums can be declared inside another class. They live in the class namespace (no outer instance capture), so you access them with a qualifier:
|
||||
|
||||
class A {
|
||||
class B(x?)
|
||||
object Inner { val foo = "bar" }
|
||||
enum E* { One, Two }
|
||||
}
|
||||
|
||||
val ab = A.B()
|
||||
assertEquals(ab.x, null)
|
||||
assertEquals(A.Inner.foo, "bar")
|
||||
assertEquals(A.One, A.E.One)
|
||||
|
||||
See [OOP notes](OOP.md#nested-declarations) for rules, visibility, and enum lifting details.
|
||||
|
||||
## Delegation (briefly)
|
||||
|
||||
You can delegate properties and functions to other objects using the `by` keyword. This is perfect for patterns like `lazy` initialization.
|
||||
@ -229,8 +211,9 @@ Naturally, assignment returns its value:
|
||||
rvalue means you cant assign the result if the assignment
|
||||
|
||||
var x
|
||||
// compile-time error: can't assign to rvalue
|
||||
(x = 11) = 5
|
||||
assertThrows { (x = 11) = 5 }
|
||||
void
|
||||
>>> void
|
||||
|
||||
This also prevents chain assignments so use parentheses:
|
||||
|
||||
@ -241,36 +224,24 @@ This also prevents chain assignments so use parentheses:
|
||||
|
||||
## Nullability
|
||||
|
||||
Nullability is part of the type. `String` is non-null, `String?` is nullable. Use `!!` to assert non-null and throw
|
||||
`NullReferenceException` if the value is `null`.
|
||||
|
||||
When the value is `null`, it might throws `NullReferenceException`, the name is somewhat a tradition. To avoid it
|
||||
one can check it against null or use _null coalescing_. The null coalescing means, if the operand (left) is null,
|
||||
the operation won't be performed and the result will be null. Here is the difference:
|
||||
|
||||
class Sample {
|
||||
var field = 1
|
||||
fun method() { 2 }
|
||||
var list = [1, 2, 3]
|
||||
}
|
||||
|
||||
val ref: Sample? = null
|
||||
val list: List<Int>? = null
|
||||
// direct access throws NullReferenceException:
|
||||
// ref.field
|
||||
// ref.method()
|
||||
// ref.list[1]
|
||||
// list[1]
|
||||
|
||||
val ref = null
|
||||
assertThrows { ref.field }
|
||||
assertThrows { ref.method() }
|
||||
assertThrows { ref.array[1] }
|
||||
assertThrows { ref[1] }
|
||||
assertThrows { ref() }
|
||||
|
||||
assert( ref?.field == null )
|
||||
assert( ref?.method() == null )
|
||||
assert( ref?.list?[1] == null )
|
||||
assert( list?[1] == null )
|
||||
assert( ref?.array?[1] == null )
|
||||
assert( ref?[1] == null )
|
||||
assert( ref?() == null )
|
||||
>>> void
|
||||
|
||||
Note: `?.` is still a typed operation. The receiver must have a compile-time type that declares the member; if the
|
||||
receiver is `Object`, cast it first or declare a more specific type.
|
||||
|
||||
There is also "elvis operator", null-coalesce infix operator '?:' that returns rvalue if lvalue is `null`:
|
||||
|
||||
null ?: "nothing"
|
||||
@ -327,8 +298,8 @@ Much like let, but it does not alter returned value:
|
||||
|
||||
While it is not altering return value, the source object could be changed:
|
||||
also
|
||||
class Point(var x: Int, var y: Int)
|
||||
val p: Point = Point(1,2).also { it.x++ }
|
||||
class Point(x,y)
|
||||
val p = Point(1,2).also { it.x++ }
|
||||
assertEquals(p.x, 2)
|
||||
>>> void
|
||||
|
||||
@ -336,9 +307,9 @@ also
|
||||
|
||||
It works much like `also`, but is executed in the context of the source object:
|
||||
|
||||
class Point(var x: Int, var y: Int)
|
||||
class Point(x,y)
|
||||
// see the difference: apply changes this to newly created Point:
|
||||
val p = Point(1,2).apply { this@Point.x++; this@Point.y++ }
|
||||
val p = Point(1,2).apply { x++; y++ }
|
||||
assertEquals(p, Point(2,3))
|
||||
>>> void
|
||||
|
||||
@ -346,7 +317,7 @@ It works much like `also`, but is executed in the context of the source object:
|
||||
|
||||
Sets `this` to the first argument and executes the block. Returns the value returned by the block:
|
||||
|
||||
class Point(var x: Int, var y: Int)
|
||||
class Point(x,y)
|
||||
val p = Point(1,2)
|
||||
val sum = with(p) { x + y }
|
||||
assertEquals(3, sum)
|
||||
@ -454,6 +425,8 @@ Almost the same, using `val`:
|
||||
val foo = 1
|
||||
foo += 1 // this will throw exception
|
||||
|
||||
# Constants
|
||||
|
||||
Same as in kotlin:
|
||||
|
||||
val HalfPi = π / 2
|
||||
@ -461,163 +434,6 @@ Same as in kotlin:
|
||||
Note using greek characters in identifiers! All letters allowed, but remember who might try to read your script, most
|
||||
likely will know some English, the rest is the pure uncertainty.
|
||||
|
||||
# Types and inference
|
||||
|
||||
Lyng uses Kotlin-style static types with inference. You can always write explicit types, but in most places the compiler
|
||||
can infer them from literals, defaults, and flow analysis.
|
||||
|
||||
## Type annotations
|
||||
|
||||
Use `:` to specify a type:
|
||||
|
||||
var x: Int = 10
|
||||
val label: String = "count"
|
||||
fun clamp(x: Int, min: Int, max: Int): Int { ... }
|
||||
|
||||
`Object` is the top type. If you omit a type and there is no default value, the parameter is `Object` by default:
|
||||
|
||||
fun show(x) { println(x) } // x is Object
|
||||
|
||||
For nullable types, add `?`:
|
||||
|
||||
fun showMaybe(x: Object?) { ... }
|
||||
fun parseInt(s: String?): Int? { ... }
|
||||
|
||||
There is also a nullable shorthand for untyped parameters and constructor args: `x?` means `x: Object?`.
|
||||
It cannot be combined with an explicit type annotation.
|
||||
|
||||
class A(x?) { ... } // x: Object?
|
||||
fun f(x?) { x == null } // x: Object?
|
||||
|
||||
Type aliases name type expressions and can be generic:
|
||||
|
||||
type Num = Int | Real
|
||||
type Maybe<T> = T?
|
||||
|
||||
Aliases expand to their underlying type expressions. See `docs/generics.md` for details.
|
||||
|
||||
`void` is a singleton value of the class `Void`. `Void` can be used as an explicit return type:
|
||||
|
||||
fun log(msg): Void { println(msg); void }
|
||||
|
||||
`Null` is the class of `null`. It is a singleton type and mostly useful for type inference results.
|
||||
|
||||
For type expressions, you can check nullability directly:
|
||||
|
||||
T is nullable
|
||||
T !is nullable
|
||||
|
||||
This is especially useful in generic code and in `when` over a type parameter:
|
||||
|
||||
fun describe<T>(x: T): String = when (T) {
|
||||
nullable -> "nullable"
|
||||
else -> "non-null"
|
||||
}
|
||||
|
||||
## Type inference
|
||||
|
||||
The compiler infers types from:
|
||||
|
||||
- literals: `1` is `Int`, `1.0` is `Real`, `"s"` is `String`, `'c'` is `Char`
|
||||
- defaults: `fun f(x=1, name="n")` infers `x: Int`, `name: String`
|
||||
- assignments: `val x = call()` uses the return type of `call`
|
||||
- returns and branches: the result type of a block is the last expression, and if any branch is nullable,
|
||||
the inferred type becomes nullable
|
||||
- numeric ops: `Int` and `Real` stay `Int` when both sides are `Int`, and promote to `Real` on mixed arithmetic
|
||||
|
||||
Examples:
|
||||
|
||||
fun inc(x=0) = x + 1 // (Int)->Int
|
||||
fun maybe(flag) { if(flag) 1 else null } // ()->Int?
|
||||
|
||||
Function types are written as `(T1, T2, ...)->R`. You can include ellipsis in function *types* to
|
||||
express a variadic position:
|
||||
|
||||
var fmt: (String, Object...)->String
|
||||
var f: (Int, Object..., String)->Real
|
||||
var anyArgs: (...)->Int // shorthand for (Object...)->Int
|
||||
|
||||
Untyped locals are allowed, but their type is fixed on the first assignment:
|
||||
|
||||
var x
|
||||
x = 1 // x becomes Int
|
||||
x = "one" // compile-time error
|
||||
|
||||
var y = null // y is Object?
|
||||
val z = null // z is Null
|
||||
|
||||
Empty list/map literals default to `List<Object>` and `Map<Object,Object>` until a more specific type is known:
|
||||
|
||||
val xs = [] // List<Object>
|
||||
val ys: List<Int> = [] // List<Int>
|
||||
|
||||
Map literals infer key/value types from entries; named keys are `String`. See `docs/generics.md` for details.
|
||||
|
||||
## Flow analysis
|
||||
|
||||
Lyng uses flow analysis to narrow types inside branches:
|
||||
|
||||
fun len(x: String?): Int {
|
||||
if( x == null ) return 0
|
||||
// x is String (non-null) in this branch
|
||||
return x.length
|
||||
}
|
||||
|
||||
`is` checks and `when` branches also narrow types:
|
||||
|
||||
fun kind(x: Object) {
|
||||
if( x is Int ) return "int"
|
||||
if( x is String ) return "string"
|
||||
return "other"
|
||||
}
|
||||
|
||||
Narrowing is local to the branch; after the branch, the original type is restored.
|
||||
|
||||
## Casts and unknown types
|
||||
|
||||
Use `as` for explicit casts. The compiler inserts casts only when it can be valid and necessary. If a cast fails at
|
||||
runtime, it throws `ClassCastException`. If the value is nullable, `as T` implies a non-null assertion.
|
||||
|
||||
Member access is resolved at compile time. Only members of `Object` are available on unknown types; non-Object members
|
||||
require an explicit cast:
|
||||
|
||||
fun f(x) { // x is Object
|
||||
x.toString() // ok (Object member)
|
||||
x.size() // compile-time error
|
||||
(x as List).size() // ok
|
||||
}
|
||||
|
||||
This avoids runtime name-resolution fallbacks; all symbols must be known at compile time.
|
||||
|
||||
## Generics and bounds
|
||||
|
||||
Generic parameters are declared with `<...>`:
|
||||
|
||||
fun id<T>(x: T): T = x
|
||||
class Box<T>(val value: T)
|
||||
|
||||
Bounds use `:` and can combine with `&` (intersection) and `|` (union):
|
||||
|
||||
fun sum<T: Int | Real>(x: T, y: T) = x + y
|
||||
class Named<T: Iterable & Comparable>(val data: T)
|
||||
|
||||
Type arguments are usually inferred from call sites:
|
||||
|
||||
val b = Box(10) // Box<Int>
|
||||
val s = id("ok") // T is String
|
||||
|
||||
See [Generics and type expressions](generics.md) for bounds, unions/intersections, and type-checking rules.
|
||||
|
||||
## Variance
|
||||
|
||||
Generic types are invariant by default, so `List<Int>` is not a `List<Object>`.
|
||||
Use declaration-site variance when you need it:
|
||||
|
||||
class Source<out T>(val value: T)
|
||||
class Sink<in T> { fun accept(x: T) { ... } }
|
||||
|
||||
`out` makes the type covariant (only produced), `in` makes it contravariant (only consumed).
|
||||
|
||||
# Defining functions
|
||||
|
||||
fun check(amount) {
|
||||
@ -659,9 +475,8 @@ There are default parameters in Lyng:
|
||||
It is possible to define also vararg using ellipsis:
|
||||
|
||||
fun sum(args...) {
|
||||
val list = args as List
|
||||
var result = list[0]
|
||||
for( i in 1 ..< list.size ) result += list[i]
|
||||
var result = args[0]
|
||||
for( i in 1 ..< args.size ) result += args[i]
|
||||
}
|
||||
sum(10,20,30)
|
||||
>>> 60
|
||||
@ -754,11 +569,6 @@ one could be with ellipsis that means "the rest pf arguments as List":
|
||||
assert( { a, b...-> [a,...b] }(100, 1, 2, 3) == [100, 1, 2, 3])
|
||||
void
|
||||
|
||||
Type-annotated lambdas can use variadic *function types* as well:
|
||||
|
||||
val f: (Int, Object..., String)->Real = { a, rest..., b -> 0.0 }
|
||||
val anyArgs: (...)->Int = { -> 0 }
|
||||
|
||||
### Using lambda as the parameter
|
||||
|
||||
See also: [Testing and Assertions](Testing.md)
|
||||
@ -769,7 +579,6 @@ See also: [Testing and Assertions](Testing.md)
|
||||
var result = []
|
||||
for( x in iterable ) result += transform(x)
|
||||
}
|
||||
// loop variables are read-only inside the loop body
|
||||
assert( [11, 21, 31] == mapValues( [1,2,3], { it*10+1 }))
|
||||
>>> void
|
||||
|
||||
@ -797,7 +606,6 @@ Lyng has built-in mutable array class `List` with simple literals:
|
||||
|
||||
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
|
||||
many collection based methods are implemented there.
|
||||
For immutable list values, use `list.toImmutable()` and [ImmutableList].
|
||||
|
||||
Lists can contain any type of objects, lists too:
|
||||
|
||||
@ -806,7 +614,7 @@ Lists can contain any type of objects, lists too:
|
||||
assert( list is Array ) // general interface
|
||||
assert(list.size == 3)
|
||||
// second element is a list too:
|
||||
assert((list[1] as List).size == 2)
|
||||
assert(list[1].size == 2)
|
||||
>>> void
|
||||
|
||||
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
|
||||
@ -980,7 +788,6 @@ Set are unordered collection of unique elements, see [Set]. Sets are [Iterable]
|
||||
>>> void
|
||||
|
||||
Please see [Set] for detailed description.
|
||||
For immutable set values, use `set.toImmutable()` and [ImmutableSet].
|
||||
|
||||
# Maps
|
||||
|
||||
@ -1041,7 +848,6 @@ Notes:
|
||||
- When you need computed (expression) keys or non-string keys, use `Map(...)` constructor with entries, e.g. `Map( ("a" + "b") => 1 )`, then merge with a literal if needed: `{ base: } + (computedKey => 42)`.
|
||||
|
||||
Please see the [Map] reference for a deeper guide.
|
||||
For immutable map values, use `map.toImmutable()` and [ImmutableMap].
|
||||
|
||||
# Flow control operators
|
||||
|
||||
@ -1256,8 +1062,8 @@ ends normally, without breaks. It allows override loop result value, for example
|
||||
to not calculate it in every iteration. For example, consider this naive prime number
|
||||
test function (remember function return it's last expression result):
|
||||
|
||||
fun naive_is_prime(candidate: Int) {
|
||||
val x = candidate
|
||||
fun naive_is_prime(candidate) {
|
||||
val x = if( candidate !is Int) candidate.toInt() else candidate
|
||||
var divisor = 1
|
||||
while( ++divisor < x/2 || divisor == 2 ) {
|
||||
if( x % divisor == 0 ) break false
|
||||
@ -1332,9 +1138,8 @@ For loop are intended to traverse collections, and all other objects that suppor
|
||||
size and index access, like lists:
|
||||
|
||||
var letters = 0
|
||||
val words: List<String> = ["hello", "world"]
|
||||
for( w in words) {
|
||||
letters += (w as String).length
|
||||
for( w in ["hello", "wolrd"]) {
|
||||
letters += w.length
|
||||
}
|
||||
"total letters: "+letters
|
||||
>>> "total letters: 10"
|
||||
@ -1525,7 +1330,7 @@ than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
||||
var result = null // here we will store the result
|
||||
>>> null
|
||||
|
||||
# Built-in types
|
||||
# Integral data types
|
||||
|
||||
| type | description | literal samples |
|
||||
|--------|---------------------------------|---------------------|
|
||||
@ -1535,7 +1340,6 @@ than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
||||
| Char | single unicode character | `'S'`, `'\n'` |
|
||||
| String | unicode string, no limits | "hello" (see below) |
|
||||
| List | mutable list | [1, "two", 3] |
|
||||
| Object | top type for all values | |
|
||||
| Void | no value could exist, singleton | void |
|
||||
| Null | missing value, singleton | null |
|
||||
| Fn | callable type | |
|
||||
@ -1555,21 +1359,18 @@ 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
|
||||
|
||||
@ -1584,9 +1385,6 @@ 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
|
||||
|
||||
@ -1664,13 +1462,13 @@ Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There
|
||||
|
||||
Extraction:
|
||||
|
||||
("abcd42def"[ "\d+".re ] as RegexMatch).value
|
||||
"abcd42def"[ "\d+".re ].value
|
||||
>>> "42"
|
||||
|
||||
Part match:
|
||||
|
||||
assert( "abc foo def" =~ "f[oO]+".re )
|
||||
assert( "foo" == ($~ as RegexMatch).value )
|
||||
assert( "foo" == $~.value )
|
||||
>>> void
|
||||
|
||||
Repeating the fragment:
|
||||
@ -1771,7 +1569,6 @@ Lambda avoid unnecessary execution if assertion is not failed. for example:
|
||||
| π | See [math](math.md) |
|
||||
|
||||
[List]: List.md
|
||||
[ImmutableList]: ImmutableList.md
|
||||
|
||||
[Testing]: Testing.md
|
||||
|
||||
@ -1788,10 +1585,8 @@ Lambda avoid unnecessary execution if assertion is not failed. for example:
|
||||
[string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
|
||||
|
||||
[Set]: Set.md
|
||||
[ImmutableSet]: ImmutableSet.md
|
||||
|
||||
[Map]: Map.md
|
||||
[ImmutableMap]: ImmutableMap.md
|
||||
|
||||
[Buffer]: Buffer.md
|
||||
|
||||
@ -1924,7 +1719,7 @@ You can add new methods and properties to existing classes without modifying the
|
||||
|
||||
### Extension properties
|
||||
|
||||
val Int.isEven get() = this % 2 == 0
|
||||
val Int.isEven = this % 2 == 0
|
||||
4.isEven
|
||||
>>> true
|
||||
|
||||
@ -1936,4 +1731,4 @@ Example with custom accessors:
|
||||
|
||||
Extension members are **scope-isolated**: they are visible only in the scope where they are defined and its children. This prevents name collisions and improves security.
|
||||
|
||||
To get details on OOP in Lyng, see [OOP notes](OOP.md).
|
||||
To get details on OOP in Lyng, see [OOP notes](OOP.md).
|
||||
@ -1,27 +0,0 @@
|
||||
# Wasm generation hang in wasmJs browser tests
|
||||
|
||||
## Summary
|
||||
The wasmJs browser test runner hung after commit 5f819dc. The root cause was invalid WebAssembly generated by the Kotlin/Wasm backend when certain compiler paths emitted suspend lambdas for `Statement` execution. The invalid module failed to instantiate in the browser, and Karma kept the browser connected but never ran tests.
|
||||
|
||||
## Symptoms
|
||||
- `:lynglib:wasmJsBrowserTest` hangs indefinitely in ChromeHeadless.
|
||||
- `:lynglib:wasmJsNodeTest` fails with a WebAssembly compile error similar to:
|
||||
- `struct.set expected type (ref null XXXX), found global.get of type (ref null YYYY)`
|
||||
- The failing function name in the wasm name section looks like:
|
||||
- `net.sergeych.lyng.$invokeCOROUTINE$.doResume`
|
||||
|
||||
## Root cause
|
||||
The delegation/var-declaration changes introduced compiler-generated suspend lambdas inside `Statement` construction (e.g., `statement { ... }` wrappers). Kotlin/Wasm generates extra coroutine state for those suspend lambdas, which in this case produced invalid wasm IR (mismatched GC reference types). The browser loader then waits forever because the module fails to instantiate.
|
||||
|
||||
## Fix
|
||||
Avoid suspend-lambda `Statement` construction in compiler code paths. Replace `statement { ... }` and other anonymous suspend lambdas with explicit `object : Statement()` implementations and move logic into `override suspend fun execute(...)`. This keeps the resulting wasm IR valid while preserving behavior.
|
||||
|
||||
## Where it was fixed
|
||||
- `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt`
|
||||
- `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Scope.kt`
|
||||
|
||||
## Verification
|
||||
- `./gradlew :lynglib:wasmJsNodeTest --info`
|
||||
- `./gradlew :lynglib:wasmJsBrowserTest --info`
|
||||
|
||||
Both tests finish quickly after the change.
|
||||
@ -1,7 +1,6 @@
|
||||
# What's New in Lyng
|
||||
|
||||
This document highlights the latest additions and improvements to the Lyng language and its ecosystem.
|
||||
For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
|
||||
|
||||
## Language Features
|
||||
|
||||
@ -102,31 +101,13 @@ Singleton objects are declared using the `object` keyword. They provide a conven
|
||||
|
||||
```lyng
|
||||
object Config {
|
||||
val version = "1.5.0-SNAPSHOT"
|
||||
val version = "1.2.3"
|
||||
fun show() = println("Config version: " + version)
|
||||
}
|
||||
|
||||
Config.show()
|
||||
```
|
||||
|
||||
### Nested Declarations and Lifted Enums
|
||||
You can now declare classes, objects, enums, and type aliases inside another class. These nested declarations live in the class namespace (no outer instance capture) and are accessed with a qualifier.
|
||||
|
||||
```lyng
|
||||
class A {
|
||||
class B(x?)
|
||||
object Inner { val foo = "bar" }
|
||||
enum E* { One, Two }
|
||||
}
|
||||
|
||||
val ab = A.B()
|
||||
assertEquals(ab.x, null)
|
||||
assertEquals(A.Inner.foo, "bar")
|
||||
assertEquals(A.One, A.E.One)
|
||||
```
|
||||
|
||||
The `*` on `enum E*` lifts entries into the enclosing class namespace (compile-time error on ambiguity).
|
||||
|
||||
### Object Expressions
|
||||
You can now create anonymous objects that inherit from classes or interfaces using the `object : Base { ... }` syntax. These expressions capture their lexical scope and support multiple inheritance.
|
||||
|
||||
@ -243,12 +224,3 @@ You can enable it in **Settings | Lyng Formatter | Enable Lyng autocompletion**.
|
||||
|
||||
### Kotlin API: Exception Handling
|
||||
The `Obj.getLyngExceptionMessageWithStackTrace()` extension method has been added to simplify retrieving detailed error information from Lyng exception objects in Kotlin. Additionally, `getLyngExceptionMessage()` and `raiseAsExecutionError()` now accept an optional `Scope`, making it easier to use them when a scope is not immediately available.
|
||||
|
||||
### Kotlin API: Bridge Reflection and Class Binding (Preferred Extensions)
|
||||
Lyng now provides a public Kotlin reflection bridge and a Lyng‑first class binding workflow. This is the **preferred** way to write Kotlin extensions and library integrations:
|
||||
|
||||
- **Bridge resolver**: explicit handles for values, vars, and callables with predictable lookup rules.
|
||||
- **Class bridge binding**: declare extern surfaces in Lyng (`extern` members, or members inside `extern class/object`) and bind the implementations in Kotlin before the first instance is created.
|
||||
- **Extern declaration rule**: `extern class` / `extern object` are declaration-only; all members in their bodies are implicitly extern.
|
||||
|
||||
See **Embedding Lyng** for full samples and usage details.
|
||||
|
||||
@ -1,133 +0,0 @@
|
||||
# What's New in Lyng 1.3 (vs 1.2.* / master)
|
||||
|
||||
This is a programmer-focused summary of what changed since the 1.2.* line on `master`. It highlights new language and type-system features, runtime/IDE improvements, and how to migrate code safely.
|
||||
|
||||
## Highlights
|
||||
|
||||
- Generics are now a first-class part of the type system, with bounds, variance, unions, and intersections.
|
||||
- Type aliases and type-expression checks (`T1 is T2`, `A in T`) enable richer static modeling.
|
||||
- Nested declarations inside classes, plus lifted enum entries via `enum E*`.
|
||||
- Stepped ranges (`step`) including iterable open-ended and real ranges.
|
||||
- Runtime and compiler speedups: more bytecode coverage, direct slot access, call-site caching.
|
||||
|
||||
## Language and type system
|
||||
|
||||
### Generics, bounds, and variance
|
||||
|
||||
You can declare generic functions/classes with `<...>`, restrict them with bounds, and control variance.
|
||||
|
||||
```lyng
|
||||
fun id<T>(x: T): T = x
|
||||
class Box<out T>(val value: T)
|
||||
|
||||
fun sum<T: Int | Real>(x: T, y: T) = x + y
|
||||
class Named<T: Iterable & Comparable>(val data: T)
|
||||
```
|
||||
|
||||
### Type aliases and type expressions
|
||||
|
||||
Type aliases can name any type expression, including unions and intersections.
|
||||
|
||||
```lyng
|
||||
type Num = Int | Real
|
||||
type Maybe<T> = T?
|
||||
```
|
||||
|
||||
Type expressions can be checked directly:
|
||||
|
||||
```lyng
|
||||
fun f<T>(xs: List<T>) {
|
||||
assert( T is Int | String | Bool ) // type-subset check
|
||||
assert( Int in T ) // same relation as `Int is T`
|
||||
}
|
||||
```
|
||||
|
||||
Value checks remain `x is T`. Type expression equality uses `==` and is structural.
|
||||
|
||||
### Nullable shorthand for parameters
|
||||
|
||||
Untyped parameters and constructor args can use `x?` as shorthand for `x: Object?`:
|
||||
|
||||
```lyng
|
||||
class A(x?) { ... }
|
||||
fun f(x?) { x == null }
|
||||
```
|
||||
|
||||
### List/map literal inference
|
||||
|
||||
The compiler now infers element and key/value types from literals and spreads. Mixed element types produce unions.
|
||||
|
||||
```lyng
|
||||
val a = [1, 2, 3] // List<Int>
|
||||
val b = [1, "two", true] // List<Int | String | Bool>
|
||||
val m = { "a": 1, "b": "x" } // Map<String, Int | String>
|
||||
```
|
||||
|
||||
### Compile-time member access only
|
||||
|
||||
Member access is resolved at compile time. On unknown types, only `Object` members are visible; other members require an explicit cast.
|
||||
|
||||
```lyng
|
||||
fun f(x) { // x: Object
|
||||
x.toString() // ok
|
||||
x.size() // compile-time error
|
||||
(x as List).size()
|
||||
}
|
||||
```
|
||||
|
||||
This removes runtime name-resolution fallbacks and makes errors deterministic.
|
||||
|
||||
### Nested declarations and lifted enums
|
||||
|
||||
Classes, objects, enums, and type aliases can be declared inside another class and accessed by qualifier. Enums can lift entries into the outer namespace with `*`.
|
||||
|
||||
```lyng
|
||||
class A {
|
||||
class B(x?)
|
||||
object Inner { val foo = "bar" }
|
||||
type Alias = B
|
||||
enum E* { One, Two }
|
||||
}
|
||||
|
||||
val b = A.B()
|
||||
assertEquals(A.One, A.E.One)
|
||||
```
|
||||
|
||||
### Stepped ranges
|
||||
|
||||
Ranges now support `step`, and open-ended/real ranges are iterable only with an explicit step.
|
||||
|
||||
```lyng
|
||||
(1..5 step 2).toList() // [1,3,5]
|
||||
(0.0..1.0 step 0.25).toList() // [0,0.25,0.5,0.75,1.0]
|
||||
(0.. step 1).take(3).toList() // [0,1,2]
|
||||
```
|
||||
|
||||
## Tooling and performance
|
||||
|
||||
- Bytecode compiler/VM coverage expanded (loops, expressions, calls), improving execution speed and consistency.
|
||||
- Direct frame-slot access and scoped slot addressing reduce lookup overhead, including in closures.
|
||||
- Call-site caching and numeric fast paths reduce hot-loop overhead.
|
||||
- IDE tooling updated for the new type system and nested declarations; MiniAst-based completion work continues.
|
||||
|
||||
## Migration guide (from 1.2.*)
|
||||
|
||||
1) Replace dynamic member access on unknown types
|
||||
- If you relied on runtime name resolution, add explicit casts or annotate types so the compiler can resolve members.
|
||||
|
||||
2) Adopt new type-system constructs where helpful
|
||||
- Consider `type` aliases for complex unions/intersections.
|
||||
- Prefer generic signatures over `Object` when the API is parametric.
|
||||
|
||||
3) Update range iteration where needed
|
||||
- Use `step` for open-ended or real ranges you want to iterate.
|
||||
|
||||
4) Nullable shorthand is optional
|
||||
- If you used untyped nullable params, you can keep `x` (Object) or switch to `x?` (Object?) for clarity.
|
||||
|
||||
## References
|
||||
|
||||
- `docs/generics.md`
|
||||
- `docs/Range.md`
|
||||
- `docs/OOP.md`
|
||||
- `docs/BytecodeSpec.md`
|
||||
@ -1,145 +0,0 @@
|
||||
# What's New in Lyng 1.5 (vs 1.3.* / master)
|
||||
|
||||
This document summarizes the significant changes and new features introduced in the 1.5 development cycle.
|
||||
|
||||
## Principal changes
|
||||
|
||||
### JIT compiler and compile-time types and symbols.
|
||||
|
||||
This major improvement gives the following big advantages:
|
||||
|
||||
- **Blazing Fast execution**: several times faster! (three to six times speedup in different scenarios).
|
||||
- **Better IDE support**: autocompletion, early error detection, types check.
|
||||
- **Error safety**: all symbols and types are checked at bound at compile-time. Many errors are detected earlier. Also, no risk that external or caller code would shadow some internally used symbols (especially in closures and inheritance).
|
||||
|
||||
In particular, it means no slow and flaky runtime lookups. Once compiled, code guarantees that it will always call the symbol known at compile-time; runtime name lookup though does not guarantee it and can be source of hard to trace bugs.
|
||||
|
||||
### New stable API to create Kotlin extensions
|
||||
|
||||
The API is fixed and will be kept with further Lyng core changes. It is now the recommended way to write Lyng extensions in Kotlin. It is much simpler and more elegant than the internal one. See [Kotlin Bridge Binding](../notes/kotlin_bridge_binding.md).
|
||||
|
||||
Extern declaration clarification:
|
||||
- `extern class` / `extern object` are pure extern surfaces.
|
||||
- Members inside them are implicitly extern (`extern` on a member is optional/redundant).
|
||||
- Lyng method/property bodies for these declarations should be implemented as extensions instead.
|
||||
|
||||
### Smart types system
|
||||
|
||||
- **Deep inference**: The compiler analyzes types of symbols along the execution path and in many cases eliminates unnecessary casts or type specifications.
|
||||
- **Union and intersection types**: `A & B`, `A | B`.
|
||||
- **Generics**: Generic types are first-class citizens with support for [bounds and variance](generics.md). Type params are erased by default and are reified only when needed (e.g., `T::class`, `T is ...`, `as T`, or in extern-facing APIs), which enables checks like `A in T` when `T` is reified.
|
||||
- **Inner classes and enums**: Full support for nested declarations, including [Enums with lifting](OOP.md#lifted-enum-entries).
|
||||
|
||||
## Other highlights
|
||||
|
||||
- **The `return` Statement**: Added support for local and non-local returns using labels.
|
||||
- **Abstract Classes and Interfaces**: Full support for `abstract` members and the `interface` keyword.
|
||||
- **Singleton Objects**: Define singletons using the `object` keyword or use anonymous object expressions.
|
||||
- **Multiple Inheritance**: Enhanced multi-inheritance with predictable [C3 MRO resolution](OOP.md#multiple-inheritance-and-mro).
|
||||
- **Unified Delegation**: Powerful delegation model for `val`, `var`, and `fun` members. See [Delegation](delegation.md).
|
||||
- **Class Properties with Accessors**: Define `val` and `var` properties with custom `get()` and `set()`.
|
||||
- **Restricted Setter Visibility**: Use `private set` and `protected set` on fields and properties.
|
||||
- **Late-initialized `val`**: Support for `val` fields that are initialized in `init` blocks or class bodies.
|
||||
- **Transient Members**: Use `@Transient` to exclude members from serialization and equality checks.
|
||||
- **Named Arguments and Splats**: Improved call-site readability with `name: value` and map-based splats.
|
||||
- **Refined Visibility**: Improved `protected` access and `closed` modifier for better encapsulation.
|
||||
|
||||
## Language Features
|
||||
|
||||
### The `return` Statement
|
||||
You can now exit from the innermost enclosing callable (function or lambda) using `return`. Lyng also supports non-local returns to outer scopes using labels. See [Return Statement](return_statement.md).
|
||||
|
||||
```lyng
|
||||
fun findFirst<T>(list: Iterable<T>, predicate: (T)->Bool): T? {
|
||||
list.forEach {
|
||||
if (predicate(it)) return@findFirst it
|
||||
}
|
||||
null
|
||||
}
|
||||
```
|
||||
|
||||
### Abstract Classes and Interfaces
|
||||
Lyng now supports the `abstract` modifier for classes and their members. `interface` is introduced as a synonym for `abstract class`, allowing for rich multi-inheritance patterns.
|
||||
|
||||
```lyng
|
||||
interface Shape {
|
||||
abstract val area: Real
|
||||
fun describe() = "Area: %g"(area)
|
||||
}
|
||||
|
||||
class Circle(val radius: Real) : Shape {
|
||||
override val area get = Math.PI * radius * radius
|
||||
}
|
||||
```
|
||||
|
||||
### Class Properties with Accessors
|
||||
Properties can now have custom getters and setters. They do not have automatic backing fields, making them perfect for computed values or delegation.
|
||||
|
||||
```lyng
|
||||
class Rectangle(var width: Real, var height: Real) {
|
||||
val area: Real get() = width * height
|
||||
|
||||
var squareSize: Real
|
||||
get() = area
|
||||
set(v) {
|
||||
width = sqrt(v)
|
||||
height = width
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Singleton Objects
|
||||
Declare singletons or anonymous objects easily.
|
||||
|
||||
```lyng
|
||||
object Database {
|
||||
val connection = "connected"
|
||||
}
|
||||
|
||||
val runner = object : Runnable {
|
||||
override fun run() = println("Running!")
|
||||
}
|
||||
```
|
||||
|
||||
### Named Arguments and Named Splats
|
||||
Improve call-site clarity by specifying argument names. You can also expand a Map into named arguments using the splat operator.
|
||||
|
||||
```lyng
|
||||
fun configure(timeout: Int, retry: Int = 3) { ... }
|
||||
|
||||
configure(timeout: 5000, retry: 5)
|
||||
val options = Map("timeout": 1000, "retry": 1)
|
||||
configure(...options)
|
||||
```
|
||||
|
||||
### Modern Operators
|
||||
The `?=` operator allows for concise "assign if null" logic.
|
||||
|
||||
```lyng
|
||||
var cache: Map? = null
|
||||
cache ?= Map("status": "ok") // Only assigns if cache is null
|
||||
```
|
||||
|
||||
## Tooling and IDE
|
||||
|
||||
- **IDEA Plugin**: Significant improvements to autocompletion, documentation tooltips, and natural language support (Grazie integration).
|
||||
- **CLI**: The `lyng fmt` command is now a first-class tool for formatting code with various options like `--check` and `--in-place`.
|
||||
- **Performance**: Ongoing optimizations in the bytecode VM and compiler for faster execution and smaller footprint.
|
||||
|
||||
## Standard Library
|
||||
- **`with(self, block)`**: Scoped execution with a dedicated `self`.
|
||||
- **`clamp(value, min, max)`**: Easily restrict values to a range.
|
||||
|
||||
## Migration Guide (from 1.3.*)
|
||||
|
||||
1. **Check Visibility**: Refined `protected` and `private` rules may catch previously undetected invalid accesses.
|
||||
2. **Override Keyword**: Ensure all members that override ancestor declarations are marked with the `override` keyword (now mandatory).
|
||||
3. **Return in Shorthand**: Remember that `return` is forbidden in `=` shorthand functions; use block syntax if you need early exit.
|
||||
4. **Empty Map Literals**: Use `Map()` or `{:}` for empty maps, as `{}` is now strictly a block/lambda.
|
||||
|
||||
## References
|
||||
- [Object Oriented Programming](OOP.md)
|
||||
- [Generics](generics.md)
|
||||
- [Return Statement](return_statement.md)
|
||||
- [Delegation](delegation.md)
|
||||
- [Tutorial](tutorial.md)
|
||||
@ -1,814 +0,0 @@
|
||||
#!/usr/bin/env lyng
|
||||
|
||||
/*
|
||||
* Lyng Console Tetris (interactive sample)
|
||||
*
|
||||
* Controls:
|
||||
* - Left/Right arrows or A/D: move
|
||||
* - Up arrow or W: rotate
|
||||
* - Down arrow or S: soft drop
|
||||
* - Space: hard drop
|
||||
* - P or Escape: pause
|
||||
* - Q: quit
|
||||
|
||||
Tsted to score:
|
||||
sergeych@sergeych-XPS-17-9720:~$ ~/dev/lyng/examples/tetris_console.lyng
|
||||
Bye.
|
||||
Score: 435480
|
||||
Lines: 271
|
||||
Level: 28
|
||||
Ssergeych@sergeych-XPS-17-9720:~$
|
||||
*/
|
||||
|
||||
import lyng.io.console
|
||||
import lyng.io.fs
|
||||
|
||||
val MIN_COLS = 56
|
||||
val MIN_ROWS = 24
|
||||
val PANEL_WIDTH = 24
|
||||
val BOARD_MARGIN_ROWS = 5
|
||||
val BOARD_MIN_W = 10
|
||||
val BOARD_MAX_W = 16
|
||||
val BOARD_MIN_H = 16
|
||||
val BOARD_MAX_H = 28
|
||||
val LEVEL_LINES_STEP = 10
|
||||
val DROP_FRAMES_BASE = 15
|
||||
val DROP_FRAMES_MIN = 3
|
||||
val FRAME_DELAY_MS = 35
|
||||
val RESIZE_WAIT_MS = 250
|
||||
val MAX_PENDING_INPUTS = 64
|
||||
val ROTATION_KICKS = [0, -1, 1, -2, 2]
|
||||
val ANSI_ESC = "\u001b["
|
||||
val ANSI_RESET = ANSI_ESC + "0m"
|
||||
val ERROR_LOG_PATH = "/tmp/lyng_tetris_errors.log"
|
||||
val UNICODE_BLOCK = "██"
|
||||
val UNICODE_TOP_LEFT = "┌"
|
||||
val UNICODE_TOP_RIGHT = "┐"
|
||||
val UNICODE_BOTTOM_LEFT = "└"
|
||||
val UNICODE_BOTTOM_RIGHT = "┘"
|
||||
val UNICODE_HORIZONTAL = "──"
|
||||
val UNICODE_VERTICAL = "│"
|
||||
val UNICODE_DOT = "· "
|
||||
|
||||
type Cell = List<Int>
|
||||
type Rotation = List<Cell>
|
||||
type Rotations = List<Rotation>
|
||||
type Row = List<Int>
|
||||
type Board = List<Row>
|
||||
|
||||
class Piece(val name: String, val rotations: Rotations) {}
|
||||
class RotateResult(val ok: Bool, val rot: Int, val px: Int) {}
|
||||
class GameState(
|
||||
pieceId0: Int,
|
||||
nextId0: Int,
|
||||
next2Id0: Int,
|
||||
px0: Int,
|
||||
py0: Int,
|
||||
) {
|
||||
var pieceId = pieceId0
|
||||
var nextId = nextId0
|
||||
var next2Id = next2Id0
|
||||
var rot = 0
|
||||
var px = px0
|
||||
var py = py0
|
||||
var score = 0
|
||||
var totalLines = 0
|
||||
var level = 1
|
||||
var running = true
|
||||
var gameOver = false
|
||||
var paused = false
|
||||
}
|
||||
class LoopFrame(val resized: Bool, val originRow: Int, val originCol: Int) {}
|
||||
|
||||
fun clearAndHome() {
|
||||
Console.clear()
|
||||
Console.home()
|
||||
}
|
||||
|
||||
fun logError(message: String, err: Object?): Void {
|
||||
try {
|
||||
var details = ""
|
||||
if (err != null) {
|
||||
try {
|
||||
details = ": " + err
|
||||
} catch (_: Object) {
|
||||
details = ": <error-format-failed>"
|
||||
}
|
||||
}
|
||||
Path(ERROR_LOG_PATH).appendUtf8(message + details + "\n")
|
||||
} catch (_: Object) {
|
||||
// Never let logging errors affect gameplay.
|
||||
}
|
||||
}
|
||||
|
||||
fun repeatText(s: String, n: Int): String {
|
||||
var out: String = ""
|
||||
for (i in 0..<n) {
|
||||
out += s
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fun max<T>(a: T, b: T): T = if (a > b) a else b
|
||||
|
||||
fun emptyRow(width: Int): Row {
|
||||
val r: Row = []
|
||||
for (x in 0..<width) {
|
||||
r.add(0)
|
||||
}
|
||||
r
|
||||
}
|
||||
|
||||
fun createBoard(width: Int, height: Int): Board {
|
||||
val b: Board = []
|
||||
for (y in 0..<height) {
|
||||
b.add(emptyRow(width))
|
||||
}
|
||||
b
|
||||
}
|
||||
|
||||
fun colorize(text: String, sgr: String, useColor: Bool): String {
|
||||
if (!useColor) return text
|
||||
ANSI_ESC + sgr + "m" + text + ANSI_RESET
|
||||
}
|
||||
|
||||
fun blockText(pieceId: Int, useColor: Bool): String {
|
||||
if (pieceId <= 0) return " "
|
||||
val sgr = when (pieceId) {
|
||||
1 -> "36" // I
|
||||
2 -> "33" // O
|
||||
3 -> "35" // T
|
||||
4 -> "32" // S
|
||||
5 -> "31" // Z
|
||||
6 -> "34" // J
|
||||
7 -> "93" // L
|
||||
else -> "37"
|
||||
}
|
||||
colorize(UNICODE_BLOCK, sgr, useColor)
|
||||
}
|
||||
|
||||
fun emptyCellText(useColor: Bool): String {
|
||||
colorize(UNICODE_DOT, "90", useColor)
|
||||
}
|
||||
|
||||
fun canPlace(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): Bool {
|
||||
try {
|
||||
if (pieceId < 1 || pieceId > 7) return false
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
if (rot < 0 || rot >= piece.rotations.size) return false
|
||||
val cells = piece.rotations[rot]
|
||||
|
||||
for (cell in cells) {
|
||||
val x = px + cell[0]
|
||||
val y = py + cell[1]
|
||||
|
||||
if (x < 0 || x >= boardW) return false
|
||||
if (y >= boardH) return false
|
||||
|
||||
if (y >= 0) {
|
||||
if (y >= board.size) return false
|
||||
val row = board[y]
|
||||
if (row == null) return false
|
||||
if (row[x] != 0) return false
|
||||
}
|
||||
}
|
||||
true
|
||||
} catch (_: Object) {
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
fun lockPiece(board: Board, pieceId: Int, rot: Int, px: Int, py: Int): Void {
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val cells = piece.rotations[rot]
|
||||
|
||||
for (cell in cells) {
|
||||
val x = px + cell[0]
|
||||
val y = py + cell[1]
|
||||
|
||||
if (y >= 0 && y < board.size) {
|
||||
val row = board[y]
|
||||
if (row != null) {
|
||||
row[x] = pieceId
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun clearCompletedLines(board: Board, boardW: Int, boardH: Int): Int {
|
||||
val b = board
|
||||
var y = boardH - 1
|
||||
var cleared = 0
|
||||
|
||||
while (y >= 0) {
|
||||
if (y >= b.size) {
|
||||
y--
|
||||
continue
|
||||
}
|
||||
val row = b[y]
|
||||
if (row == null) {
|
||||
b.removeAt(y)
|
||||
b.insertAt(0, emptyRow(boardW))
|
||||
cleared++
|
||||
continue
|
||||
}
|
||||
var full = true
|
||||
for (x in 0..<boardW) {
|
||||
if (row[x] == 0) {
|
||||
full = false
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if (full) {
|
||||
b.removeAt(y)
|
||||
b.insertAt(0, emptyRow(boardW))
|
||||
cleared++
|
||||
} else {
|
||||
y--
|
||||
}
|
||||
}
|
||||
|
||||
cleared
|
||||
}
|
||||
|
||||
fun activeCellId(pieceId: Int, rot: Int, px: Int, py: Int, x: Int, y: Int): Int {
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val cells = piece.rotations[rot]
|
||||
|
||||
for (cell in cells) {
|
||||
val ax = px + cell[0]
|
||||
val ay = py + cell[1]
|
||||
if (ax == x && ay == y) return pieceId
|
||||
}
|
||||
|
||||
0
|
||||
}
|
||||
|
||||
fun tryRotateCw(board: Board, boardW: Int, boardH: Int, pieceId: Int, rot: Int, px: Int, py: Int): RotateResult {
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val rotations = piece.rotations.size
|
||||
val nr = (rot + 1) % rotations
|
||||
for (kx in ROTATION_KICKS) {
|
||||
val nx = px + kx
|
||||
if (canPlace(board, boardW, boardH, pieceId, nr, nx, py) == true) {
|
||||
return RotateResult(true, nr, nx)
|
||||
}
|
||||
}
|
||||
RotateResult(false, rot, px)
|
||||
}
|
||||
|
||||
fun nextPreviewLines(pieceId: Int, useColor: Bool): List<String> {
|
||||
val out: List<String> = []
|
||||
if (pieceId <= 0) {
|
||||
for (i in 0..<4) {
|
||||
out.add(" ")
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
val piece: Piece = PIECES[pieceId - 1]
|
||||
val cells = piece.rotations[0]
|
||||
|
||||
for (y in 0..<4) {
|
||||
var line = ""
|
||||
for (x in 0..<4) {
|
||||
var filled = false
|
||||
for (cell in cells) {
|
||||
if (cell[0] == x && cell[1] == y) {
|
||||
filled = true
|
||||
break
|
||||
}
|
||||
}
|
||||
line += if (filled) blockText(pieceId, useColor) else " "
|
||||
}
|
||||
out.add(line)
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fun render(
|
||||
state: GameState,
|
||||
board: Board,
|
||||
boardW: Int,
|
||||
boardH: Int,
|
||||
prevFrameLines: List<String>,
|
||||
originRow: Int,
|
||||
originCol: Int,
|
||||
useColor: Bool,
|
||||
): List<String> {
|
||||
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, boardW) + UNICODE_BOTTOM_RIGHT
|
||||
|
||||
val panel: List<String> = []
|
||||
val nextPiece: Piece = PIECES[state.nextId - 1]
|
||||
val next2Piece: Piece = PIECES[state.next2Id - 1]
|
||||
val nextName = nextPiece.name
|
||||
val next2Name = next2Piece.name
|
||||
val preview = nextPreviewLines(state.nextId, useColor)
|
||||
|
||||
panel.add("Lyng Tetris")
|
||||
panel.add("")
|
||||
panel.add("Score: " + state.score)
|
||||
panel.add("Lines: " + state.totalLines)
|
||||
panel.add("Level: " + state.level)
|
||||
panel.add("")
|
||||
panel.add("Next: " + nextName)
|
||||
panel.add("")
|
||||
for (pl in preview) panel.add(pl)
|
||||
panel.add("After: " + next2Name)
|
||||
panel.add("")
|
||||
panel.add("Keys:")
|
||||
panel.add("A/D or arrows")
|
||||
panel.add("W/Up: rotate")
|
||||
panel.add("S/Down: drop")
|
||||
panel.add("Space: hard drop")
|
||||
panel.add("P/Esc: pause")
|
||||
panel.add("Q: quit")
|
||||
|
||||
val frameLines: List<String> = []
|
||||
|
||||
for (y in 0..<boardH) {
|
||||
var line = UNICODE_VERTICAL
|
||||
|
||||
for (x in 0..<boardW) {
|
||||
val a = activeCellId(state.pieceId, state.rot, state.px, state.py, x, y)
|
||||
val row = if (y < board.size) board[y] else null
|
||||
val b = if (row == null) 0 else row[x]
|
||||
val id = if (a > 0) a else b
|
||||
line += if (id > 0) blockText(id, useColor) else emptyCellText(useColor)
|
||||
}
|
||||
|
||||
line += UNICODE_VERTICAL
|
||||
|
||||
if (y < panel.size) {
|
||||
line += " " + panel[y]
|
||||
}
|
||||
|
||||
frameLines.add(line)
|
||||
}
|
||||
|
||||
frameLines.add(bottomBorder)
|
||||
|
||||
for (i in 0..<frameLines.size) {
|
||||
val line = frameLines[i]
|
||||
val old = if (i < prevFrameLines.size) prevFrameLines[i] else null
|
||||
if (old != line) {
|
||||
Console.moveTo(originRow + i, originCol)
|
||||
Console.clearLine()
|
||||
Console.write(line)
|
||||
}
|
||||
}
|
||||
frameLines
|
||||
}
|
||||
|
||||
fun fitLine(line: String, width: Int): String {
|
||||
val maxLen = if (width > 0) width else 0
|
||||
if (maxLen <= 0) return ""
|
||||
if (line.size >= maxLen) return line[..<maxLen]
|
||||
line + repeatText(" ", maxLen - line.size)
|
||||
}
|
||||
|
||||
fun renderPauseOverlay(
|
||||
originRow: Int,
|
||||
originCol: Int,
|
||||
boardW: Int,
|
||||
boardH: Int,
|
||||
): Void {
|
||||
val contentWidth = boardW * 2 + 2 + 3 + PANEL_WIDTH
|
||||
val contentHeight = boardH + 1
|
||||
|
||||
val lines: List<String> = []
|
||||
lines.add("PAUSED")
|
||||
lines.add("")
|
||||
lines.add("Any key: continue game")
|
||||
lines.add("Esc: exit game")
|
||||
lines.add("")
|
||||
lines.add("Move: A/D or arrows")
|
||||
lines.add("Rotate: W or Up")
|
||||
lines.add("Drop: S/Down, Space hard drop")
|
||||
|
||||
var innerWidth = 0
|
||||
for (line in lines) {
|
||||
if (line.size > innerWidth) innerWidth = line.size
|
||||
}
|
||||
innerWidth += 4
|
||||
val maxInner = max(12, contentWidth - 2)
|
||||
if (innerWidth > maxInner) innerWidth = maxInner
|
||||
if (innerWidth % 2 != 0) innerWidth--
|
||||
|
||||
val boxWidth = innerWidth + 2
|
||||
val boxHeight = lines.size + 2
|
||||
|
||||
val left = originCol + max(0, (contentWidth - boxWidth) / 2)
|
||||
val top = originRow + max(0, (contentHeight - boxHeight) / 2)
|
||||
|
||||
val topBorder = UNICODE_TOP_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_TOP_RIGHT
|
||||
val bottomBorder = UNICODE_BOTTOM_LEFT + repeatText(UNICODE_HORIZONTAL, innerWidth / 2) + UNICODE_BOTTOM_RIGHT
|
||||
|
||||
Console.moveTo(top, left)
|
||||
Console.write(topBorder)
|
||||
|
||||
for (i in 0..<lines.size) {
|
||||
Console.moveTo(top + 1 + i, left)
|
||||
Console.write(UNICODE_VERTICAL + fitLine(" " + lines[i], innerWidth) + UNICODE_VERTICAL)
|
||||
}
|
||||
|
||||
Console.moveTo(top + boxHeight - 1, left)
|
||||
Console.write(bottomBorder)
|
||||
}
|
||||
|
||||
fun waitForMinimumSize(minCols: Int, minRows: Int): Object {
|
||||
while (true) {
|
||||
val g = Console.geometry()
|
||||
val cols = g?.columns ?: 0
|
||||
val rows = g?.rows ?: 0
|
||||
|
||||
if (cols >= minCols && rows >= minRows) return g
|
||||
|
||||
clearAndHome()
|
||||
val lines: List<String> = []
|
||||
lines.add("Lyng Tetris needs at least %sx%s terminal size."(minCols, minRows))
|
||||
lines.add("Current: %sx%s"(cols, rows))
|
||||
lines.add("Resize the console window to continue.")
|
||||
|
||||
val visibleLines = if (rows < lines.size) rows else lines.size
|
||||
if (visibleLines > 0) {
|
||||
val startRow = max(1, ((rows - visibleLines) / 2) + 1)
|
||||
for (i in 0..<visibleLines) {
|
||||
val line = lines[i]
|
||||
val startCol = max(1, ((cols - line.size) / 2) + 1)
|
||||
Console.moveTo(startRow + i, startCol)
|
||||
Console.clearLine()
|
||||
Console.write(line)
|
||||
}
|
||||
Console.flush()
|
||||
}
|
||||
delay(RESIZE_WAIT_MS)
|
||||
}
|
||||
}
|
||||
|
||||
fun scoreForLines(cleared: Int, level: Int): Int {
|
||||
when (cleared) {
|
||||
1 -> 100 * level
|
||||
2 -> 300 * level
|
||||
3 -> 500 * level
|
||||
4 -> 800 * level
|
||||
else -> 0
|
||||
}
|
||||
}
|
||||
|
||||
// Classic 7 tetrominoes, minimal rotations per piece.
|
||||
fun cell(x: Int, y: Int): Cell { [x, y] }
|
||||
fun rot(a: Cell, b: Cell, c: Cell, d: Cell): Rotation {
|
||||
val r: Rotation = []
|
||||
r.add(a)
|
||||
r.add(b)
|
||||
r.add(c)
|
||||
r.add(d)
|
||||
r
|
||||
}
|
||||
|
||||
val PIECES: List<Piece> = []
|
||||
|
||||
val iRots: Rotations = []
|
||||
iRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(3,1)))
|
||||
iRots.add(rot(cell(2,0), cell(2,1), cell(2,2), cell(2,3)))
|
||||
PIECES.add(Piece("I", iRots))
|
||||
|
||||
val oRots: Rotations = []
|
||||
oRots.add(rot(cell(1,0), cell(2,0), cell(1,1), cell(2,1)))
|
||||
PIECES.add(Piece("O", oRots))
|
||||
|
||||
val tRots: Rotations = []
|
||||
tRots.add(rot(cell(1,0), cell(0,1), cell(1,1), cell(2,1)))
|
||||
tRots.add(rot(cell(1,0), cell(1,1), cell(2,1), cell(1,2)))
|
||||
tRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(1,2)))
|
||||
tRots.add(rot(cell(1,0), cell(0,1), cell(1,1), cell(1,2)))
|
||||
PIECES.add(Piece("T", tRots))
|
||||
|
||||
val sRots: Rotations = []
|
||||
sRots.add(rot(cell(1,0), cell(2,0), cell(0,1), cell(1,1)))
|
||||
sRots.add(rot(cell(1,0), cell(1,1), cell(2,1), cell(2,2)))
|
||||
PIECES.add(Piece("S", sRots))
|
||||
|
||||
val zRots: Rotations = []
|
||||
zRots.add(rot(cell(0,0), cell(1,0), cell(1,1), cell(2,1)))
|
||||
zRots.add(rot(cell(2,0), cell(1,1), cell(2,1), cell(1,2)))
|
||||
PIECES.add(Piece("Z", zRots))
|
||||
|
||||
val jRots: Rotations = []
|
||||
jRots.add(rot(cell(0,0), cell(0,1), cell(1,1), cell(2,1)))
|
||||
jRots.add(rot(cell(1,0), cell(2,0), cell(1,1), cell(1,2)))
|
||||
jRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(2,2)))
|
||||
jRots.add(rot(cell(1,0), cell(1,1), cell(0,2), cell(1,2)))
|
||||
PIECES.add(Piece("J", jRots))
|
||||
|
||||
val lRots: Rotations = []
|
||||
lRots.add(rot(cell(2,0), cell(0,1), cell(1,1), cell(2,1)))
|
||||
lRots.add(rot(cell(1,0), cell(1,1), cell(1,2), cell(2,2)))
|
||||
lRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(0,2)))
|
||||
lRots.add(rot(cell(0,0), cell(1,0), cell(1,1), cell(1,2)))
|
||||
PIECES.add(Piece("L", lRots))
|
||||
|
||||
if (!Console.isSupported()) {
|
||||
println("Console API is not supported in this runtime.")
|
||||
void
|
||||
} else if (!Console.isTty()) {
|
||||
println("This sample needs an interactive terminal (TTY).")
|
||||
void
|
||||
} else {
|
||||
waitForMinimumSize(MIN_COLS, MIN_ROWS)
|
||||
|
||||
val g0 = Console.geometry()
|
||||
val cols = g0?.columns ?: MIN_COLS
|
||||
val rows = g0?.rows ?: MIN_ROWS
|
||||
|
||||
val boardW = clamp((cols - PANEL_WIDTH) / 2, BOARD_MIN_W..BOARD_MAX_W)
|
||||
val boardH = clamp(rows - BOARD_MARGIN_ROWS, BOARD_MIN_H..BOARD_MAX_H)
|
||||
|
||||
val board: Board = createBoard(boardW, boardH)
|
||||
|
||||
fun nextPieceId() {
|
||||
Random.next(1..7)
|
||||
}
|
||||
|
||||
val state: GameState = GameState(
|
||||
nextPieceId(),
|
||||
nextPieceId(),
|
||||
nextPieceId(),
|
||||
(boardW / 2) - 2,
|
||||
-1,
|
||||
)
|
||||
var prevFrameLines: List<String> = []
|
||||
|
||||
val gameMutex: Mutex = Mutex()
|
||||
var forceRedraw = false
|
||||
val pendingInputs: List<String> = []
|
||||
|
||||
val rawModeEnabled = Console.setRawMode(true)
|
||||
if (!rawModeEnabled) {
|
||||
println("Raw keyboard mode is not available in this terminal/runtime.")
|
||||
println("Use jlyng in an interactive terminal with raw input support.")
|
||||
void
|
||||
} else {
|
||||
val useColor = Console.ansiLevel() != ConsoleAnsiLevel.NONE
|
||||
Console.enterAltScreen()
|
||||
Console.setCursorVisible(false)
|
||||
clearAndHome()
|
||||
|
||||
fun resetActivePiece(s: GameState): Void {
|
||||
s.pieceId = nextPieceId()
|
||||
s.rot = 0
|
||||
s.px = (boardW / 2) - 2
|
||||
s.py = -1
|
||||
}
|
||||
|
||||
fun applyKeyInput(s: GameState, key: String): Void {
|
||||
try {
|
||||
if (key == "__CTRL_C__") {
|
||||
s.running = false
|
||||
}
|
||||
else if (s.paused) {
|
||||
if (key == "Escape") {
|
||||
s.running = false
|
||||
} else {
|
||||
s.paused = false
|
||||
forceRedraw = true
|
||||
}
|
||||
}
|
||||
else if (key == "p" || key == "P" || key == "Escape") {
|
||||
s.paused = true
|
||||
forceRedraw = true
|
||||
}
|
||||
else if (key == "q" || key == "Q") {
|
||||
s.running = false
|
||||
}
|
||||
else if (key == "ArrowLeft" || key == "a" || key == "A") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px - 1, s.py) == true) s.px--
|
||||
}
|
||||
else if (key == "ArrowRight" || key == "d" || key == "D") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px + 1, s.py) == true) s.px++
|
||||
}
|
||||
else if (key == "ArrowUp" || key == "w" || key == "W") {
|
||||
val rr: RotateResult = tryRotateCw(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)
|
||||
if (rr.ok) {
|
||||
s.rot = rr.rot
|
||||
s.px = rr.px
|
||||
}
|
||||
}
|
||||
else if (key == "ArrowDown" || key == "s" || key == "S") {
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
s.score++
|
||||
}
|
||||
}
|
||||
else if (key == " ") {
|
||||
while (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
s.score += 2
|
||||
}
|
||||
}
|
||||
} catch (inputErr: Object) {
|
||||
logError("applyKeyInput recovered after error", inputErr)
|
||||
resetActivePiece(s)
|
||||
}
|
||||
}
|
||||
|
||||
var inputRunning = true
|
||||
launch {
|
||||
while (inputRunning) {
|
||||
try {
|
||||
for (ev in Console.events()) {
|
||||
if (!inputRunning) break
|
||||
|
||||
// Isolate per-event failures so one bad event does not unwind the stream.
|
||||
try {
|
||||
if (ev is ConsoleKeyEvent) {
|
||||
val ke = ev as ConsoleKeyEvent
|
||||
if (ke.type == ConsoleEventType.KEY_DOWN) {
|
||||
var key = ""
|
||||
var ctrl = false
|
||||
try {
|
||||
key = ke.key
|
||||
} catch (keyErr: Object) {
|
||||
logError("Input key read error", keyErr)
|
||||
}
|
||||
try {
|
||||
ctrl = ke.ctrl == true
|
||||
} catch (_: Object) {
|
||||
ctrl = false
|
||||
}
|
||||
if (key == "") {
|
||||
logError("Dropped key event with empty/null key", null)
|
||||
continue
|
||||
}
|
||||
val mapped = if (ctrl && (key == "c" || key == "C")) "__CTRL_C__" else key
|
||||
val mm: Mutex = gameMutex
|
||||
mm.withLock {
|
||||
if (pendingInputs.size >= MAX_PENDING_INPUTS) {
|
||||
pendingInputs.removeAt(0)
|
||||
}
|
||||
pendingInputs.add(mapped)
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (eventErr: Object) {
|
||||
// Keep the input stream alive; report for diagnostics.
|
||||
logError("Input event error", eventErr)
|
||||
}
|
||||
}
|
||||
} catch (err: Object) {
|
||||
// Recover stream-level failures by recreating event stream in next loop turn.
|
||||
if (!inputRunning) break
|
||||
logError("Input stream recovered after error", err)
|
||||
Console.setRawMode(true)
|
||||
delay(50)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun pollLoopFrame(): LoopFrame? {
|
||||
val g = Console.geometry()
|
||||
val c = g?.columns ?: 0
|
||||
val r = g?.rows ?: 0
|
||||
if (c < MIN_COLS || r < MIN_ROWS) {
|
||||
waitForMinimumSize(MIN_COLS, MIN_ROWS)
|
||||
clearAndHome()
|
||||
prevFrameLines = []
|
||||
return null
|
||||
}
|
||||
|
||||
val contentCols = boardW * 2 + 2 + 3 + PANEL_WIDTH
|
||||
val contentRows = boardH + 1
|
||||
val requiredCols = max(MIN_COLS, contentCols)
|
||||
val requiredRows = max(MIN_ROWS, contentRows)
|
||||
if (c < requiredCols || r < requiredRows) {
|
||||
waitForMinimumSize(requiredCols, requiredRows)
|
||||
clearAndHome()
|
||||
prevFrameLines = []
|
||||
return null
|
||||
}
|
||||
|
||||
val originCol = max(1, ((c - contentCols) / 2) + 1)
|
||||
val originRow = max(1, ((r - contentRows) / 2) + 1)
|
||||
LoopFrame(false, originRow, originCol)
|
||||
}
|
||||
|
||||
fun advanceGravity(s: GameState, frame: Int): Int {
|
||||
s.level = 1 + (s.totalLines / LEVEL_LINES_STEP)
|
||||
val dropEvery = max(DROP_FRAMES_MIN, DROP_FRAMES_BASE - s.level)
|
||||
|
||||
var nextFrame = frame + 1
|
||||
if (nextFrame < dropEvery) return nextFrame
|
||||
nextFrame = 0
|
||||
|
||||
if (canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py + 1) == true) {
|
||||
s.py++
|
||||
return nextFrame
|
||||
}
|
||||
|
||||
lockPiece(board, s.pieceId, s.rot, s.px, s.py)
|
||||
|
||||
val cleared = clearCompletedLines(board, boardW, boardH)
|
||||
if (cleared > 0) {
|
||||
s.totalLines += cleared
|
||||
s.score += scoreForLines(cleared, s.level)
|
||||
}
|
||||
|
||||
s.pieceId = s.nextId
|
||||
s.nextId = s.next2Id
|
||||
s.next2Id = nextPieceId()
|
||||
s.rot = 0
|
||||
s.px = (boardW / 2) - 2
|
||||
s.py = -1
|
||||
|
||||
if (!canPlace(board, boardW, boardH, s.pieceId, s.rot, s.px, s.py)) {
|
||||
s.gameOver = true
|
||||
}
|
||||
nextFrame
|
||||
}
|
||||
|
||||
try {
|
||||
if (!canPlace(board, boardW, boardH, state.pieceId, state.rot, state.px, state.py)) {
|
||||
state.gameOver = true
|
||||
}
|
||||
|
||||
var frame = 0
|
||||
var shouldStop = false
|
||||
var prevOriginRow = -1
|
||||
var prevOriginCol = -1
|
||||
var prevPaused = false
|
||||
while (!shouldStop) {
|
||||
val frameData = pollLoopFrame()
|
||||
if (frameData == null) {
|
||||
frame = 0
|
||||
prevPaused = false
|
||||
continue
|
||||
}
|
||||
|
||||
val mm: Mutex = gameMutex
|
||||
mm.withLock {
|
||||
if (pendingInputs.size > 0) {
|
||||
val toApply: List<String> = []
|
||||
while (pendingInputs.size > 0) {
|
||||
val k = pendingInputs[0]
|
||||
pendingInputs.removeAt(0)
|
||||
toApply.add(k)
|
||||
}
|
||||
for (k in toApply) {
|
||||
applyKeyInput(state, k)
|
||||
if (!state.running || state.gameOver) break
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!state.running || state.gameOver) {
|
||||
shouldStop = true
|
||||
} else {
|
||||
val localForceRedraw = forceRedraw
|
||||
forceRedraw = false
|
||||
val movedOrigin = frameData.originRow != prevOriginRow || frameData.originCol != prevOriginCol
|
||||
if (frameData.resized || movedOrigin || localForceRedraw) {
|
||||
clearAndHome()
|
||||
prevFrameLines = []
|
||||
}
|
||||
prevOriginRow = frameData.originRow
|
||||
prevOriginCol = frameData.originCol
|
||||
if (!state.paused) {
|
||||
frame = advanceGravity(state, frame)
|
||||
}
|
||||
prevFrameLines = render(
|
||||
state,
|
||||
board,
|
||||
boardW,
|
||||
boardH,
|
||||
prevFrameLines,
|
||||
frameData.originRow,
|
||||
frameData.originCol,
|
||||
useColor
|
||||
)
|
||||
if (state.paused && (!prevPaused || frameData.resized || movedOrigin)) {
|
||||
renderPauseOverlay(frameData.originRow, frameData.originCol, boardW, boardH)
|
||||
}
|
||||
prevPaused = state.paused
|
||||
}
|
||||
Console.flush()
|
||||
delay(FRAME_DELAY_MS)
|
||||
}
|
||||
} finally {
|
||||
inputRunning = false
|
||||
Console.setRawMode(false)
|
||||
Console.setCursorVisible(true)
|
||||
Console.leaveAltScreen()
|
||||
Console.flush()
|
||||
}
|
||||
|
||||
if (state.gameOver) {
|
||||
println("Game over.")
|
||||
} else {
|
||||
println("Bye.")
|
||||
}
|
||||
println("Score: %s"(state.score))
|
||||
println("Lines: %s"(state.totalLines))
|
||||
println("Level: %s"(state.level))
|
||||
}
|
||||
}
|
||||
@ -37,6 +37,4 @@ kotlin.native.cacheKind.linuxX64=none
|
||||
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
|
||||
android.experimental.lint.migrateToK2=false
|
||||
android.lint.useK2Uast=false
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||
|
||||
org.gradle.parallel=true
|
||||
kotlin.mpp.applyDefaultHierarchyTemplate=true
|
||||
@ -1,7 +1,6 @@
|
||||
[versions]
|
||||
agp = "8.5.2"
|
||||
clikt = "5.0.3"
|
||||
mordant = "3.0.2"
|
||||
kotlin = "2.3.0"
|
||||
android-minSdk = "24"
|
||||
android-compileSdk = "34"
|
||||
@ -15,8 +14,6 @@ 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" }
|
||||
@ -31,4 +28,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" }
|
||||
@ -35,7 +35,12 @@ import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.SupervisorJob
|
||||
import kotlinx.coroutines.launch
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Script
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.idea.LyngIcons
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.getLyngExceptionMessageWithStackTrace
|
||||
|
||||
class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
|
||||
@ -53,9 +58,7 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
val isLyng = psiFile?.name?.endsWith(".lyng") == true
|
||||
e.presentation.isEnabledAndVisible = isLyng
|
||||
if (isLyng) {
|
||||
e.presentation.isEnabled = false
|
||||
e.presentation.text = "Run '${psiFile.name}' (disabled)"
|
||||
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
|
||||
e.presentation.text = "Run '${psiFile.name}'"
|
||||
} else {
|
||||
e.presentation.text = "Run Lyng Script"
|
||||
}
|
||||
@ -64,6 +67,7 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
override fun actionPerformed(e: AnActionEvent) {
|
||||
val project = e.project ?: return
|
||||
val psiFile = getPsiFile(e) ?: return
|
||||
val text = psiFile.text
|
||||
val fileName = psiFile.name
|
||||
|
||||
val (console, toolWindow) = getConsoleAndToolWindow(project)
|
||||
@ -71,9 +75,40 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
|
||||
|
||||
toolWindow.show {
|
||||
scope.launch {
|
||||
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
try {
|
||||
val lyngScope = Script.newScope()
|
||||
lyngScope.addFn("print") {
|
||||
val sb = StringBuilder()
|
||||
for ((i, arg) in args.list.withIndex()) {
|
||||
if (i > 0) sb.append(" ")
|
||||
sb.append(arg.toString(this).value)
|
||||
}
|
||||
console.print(sb.toString(), ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
ObjVoid
|
||||
}
|
||||
lyngScope.addFn("println") {
|
||||
val sb = StringBuilder()
|
||||
for ((i, arg) in args.list.withIndex()) {
|
||||
if (i > 0) sb.append(" ")
|
||||
sb.append(arg.toString(this).value)
|
||||
}
|
||||
console.print(sb.toString() + "\n", ConsoleViewContentType.NORMAL_OUTPUT)
|
||||
ObjVoid
|
||||
}
|
||||
|
||||
console.print("--- Running $fileName ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
val result = lyngScope.eval(Source(fileName, text))
|
||||
console.print("\n--- Finished with result: ${result.inspect(lyngScope)} ---\n", ConsoleViewContentType.SYSTEM_OUTPUT)
|
||||
} catch (t: Throwable) {
|
||||
console.print("\n--- Error ---\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
if( t is ExecutionError ) {
|
||||
val m = t.errorObject.getLyngExceptionMessageWithStackTrace()
|
||||
console.print(m, ConsoleViewContentType.ERROR_OUTPUT)
|
||||
}
|
||||
else
|
||||
console.print(t.message ?: t.toString(), ConsoleViewContentType.ERROR_OUTPUT)
|
||||
console.print("\n", ConsoleViewContentType.ERROR_OUTPUT)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -25,13 +25,15 @@ import com.intellij.openapi.progress.ProgressManager
|
||||
import com.intellij.openapi.util.Key
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiFile
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.binding.Binder
|
||||
import net.sergeych.lyng.binding.SymbolKind
|
||||
import net.sergeych.lyng.highlight.HighlightKind
|
||||
import net.sergeych.lyng.highlight.SimpleLyngHighlighter
|
||||
import net.sergeych.lyng.highlight.offsetOf
|
||||
import net.sergeych.lyng.idea.highlight.LyngHighlighterColors
|
||||
import net.sergeych.lyng.idea.util.LyngAstManager
|
||||
import net.sergeych.lyng.tools.LyngDiagnosticSeverity
|
||||
import net.sergeych.lyng.tools.LyngLanguageTools
|
||||
import net.sergeych.lyng.tools.LyngSemanticKind
|
||||
import net.sergeych.lyng.miniast.*
|
||||
|
||||
/**
|
||||
* ExternalAnnotator that runs Lyng MiniAst on the document text in background
|
||||
@ -41,8 +43,8 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
data class Input(val text: String, val modStamp: Long, val previousSpans: List<Span>?, val file: PsiFile)
|
||||
|
||||
data class Span(val start: Int, val end: Int, val key: com.intellij.openapi.editor.colors.TextAttributesKey)
|
||||
data class Diag(val start: Int, val end: Int, val message: String, val severity: HighlightSeverity)
|
||||
data class Result(val modStamp: Long, val spans: List<Span>, val diagnostics: List<Diag> = emptyList())
|
||||
data class Error(val start: Int, val end: Int, val message: String)
|
||||
data class Result(val modStamp: Long, val spans: List<Span>, val error: Error? = null)
|
||||
|
||||
override fun collectInformation(file: PsiFile): Input? {
|
||||
val doc: Document = file.viewProvider.document ?: return null
|
||||
@ -57,48 +59,224 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
if (collectedInfo == null) return null
|
||||
ProgressManager.checkCanceled()
|
||||
val text = collectedInfo.text
|
||||
val analysis = LyngAstManager.getAnalysis(collectedInfo.file)
|
||||
val tokens = try { SimpleLyngHighlighter().highlight(text) } catch (_: Throwable) { emptyList() }
|
||||
|
||||
// Use LyngAstManager to get the (potentially merged) Mini-AST
|
||||
val mini = LyngAstManager.getMiniAst(collectedInfo.file)
|
||||
?: return Result(collectedInfo.modStamp, collectedInfo.previousSpans ?: emptyList())
|
||||
val mini = analysis.mini
|
||||
|
||||
|
||||
ProgressManager.checkCanceled()
|
||||
|
||||
val source = Source(collectedInfo.file.name, text)
|
||||
|
||||
val out = ArrayList<Span>(256)
|
||||
val diags = ArrayList<Diag>()
|
||||
|
||||
fun isFollowedByParenOrBlock(rangeEnd: Int): Boolean {
|
||||
var i = rangeEnd
|
||||
while (i < text.length) {
|
||||
val ch = text[i]
|
||||
if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') { i++; continue }
|
||||
return ch == '(' || ch == '{'
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
fun putRange(start: Int, end: Int, key: com.intellij.openapi.editor.colors.TextAttributesKey) {
|
||||
if (start in 0..end && end <= text.length && start < end) out += Span(start, end, key)
|
||||
}
|
||||
|
||||
fun keyForKind(kind: LyngSemanticKind): com.intellij.openapi.editor.colors.TextAttributesKey? = when (kind) {
|
||||
LyngSemanticKind.Function -> LyngHighlighterColors.FUNCTION
|
||||
LyngSemanticKind.Class, LyngSemanticKind.Enum, LyngSemanticKind.TypeAlias -> LyngHighlighterColors.TYPE
|
||||
LyngSemanticKind.Value -> LyngHighlighterColors.VALUE
|
||||
LyngSemanticKind.Variable -> LyngHighlighterColors.VARIABLE
|
||||
LyngSemanticKind.Parameter -> LyngHighlighterColors.PARAMETER
|
||||
LyngSemanticKind.TypeRef -> LyngHighlighterColors.TYPE
|
||||
LyngSemanticKind.EnumConstant -> LyngHighlighterColors.ENUM_CONSTANT
|
||||
fun putName(startPos: net.sergeych.lyng.Pos, name: String, key: com.intellij.openapi.editor.colors.TextAttributesKey) {
|
||||
val s = source.offsetOf(startPos)
|
||||
putRange(s, (s + name.length).coerceAtMost(text.length), key)
|
||||
}
|
||||
fun putMiniRange(r: MiniRange, key: com.intellij.openapi.editor.colors.TextAttributesKey) {
|
||||
val s = source.offsetOf(r.start)
|
||||
val e = source.offsetOf(r.end)
|
||||
putRange(s, e, key)
|
||||
}
|
||||
|
||||
// Semantic highlights from shared tooling
|
||||
LyngLanguageTools.semanticHighlights(analysis).forEach { span ->
|
||||
keyForKind(span.kind)?.let { putRange(span.range.start, span.range.endExclusive, it) }
|
||||
// Declarations
|
||||
mini.declarations.forEach { d ->
|
||||
if (d.nameStart.source != source) return@forEach
|
||||
when (d) {
|
||||
is MiniFunDecl -> putName(d.nameStart, d.name, LyngHighlighterColors.FUNCTION_DECLARATION)
|
||||
is MiniClassDecl -> putName(d.nameStart, d.name, LyngHighlighterColors.TYPE)
|
||||
is MiniValDecl -> putName(
|
||||
d.nameStart,
|
||||
d.name,
|
||||
if (d.mutable) LyngHighlighterColors.VARIABLE else LyngHighlighterColors.VALUE
|
||||
)
|
||||
is MiniEnumDecl -> putName(d.nameStart, d.name, LyngHighlighterColors.TYPE)
|
||||
}
|
||||
}
|
||||
|
||||
// Imports: each segment as namespace/path
|
||||
mini?.imports?.forEach { imp ->
|
||||
imp.segments.forEach { seg ->
|
||||
if (seg.range.start.source === analysis.source && seg.range.end.source === analysis.source) {
|
||||
val start = analysis.source.offsetOf(seg.range.start)
|
||||
val end = analysis.source.offsetOf(seg.range.end)
|
||||
putRange(start, end, LyngHighlighterColors.NAMESPACE)
|
||||
mini.imports.forEach { imp ->
|
||||
if (imp.range.start.source != source) return@forEach
|
||||
imp.segments.forEach { seg -> putMiniRange(seg.range, LyngHighlighterColors.NAMESPACE) }
|
||||
}
|
||||
|
||||
// Parameters
|
||||
fun addParams(params: List<MiniParam>) {
|
||||
params.forEach { p ->
|
||||
if (p.nameStart.source == source)
|
||||
putName(p.nameStart, p.name, LyngHighlighterColors.PARAMETER)
|
||||
}
|
||||
}
|
||||
mini.declarations.forEach { d ->
|
||||
when (d) {
|
||||
is MiniFunDecl -> addParams(d.params)
|
||||
is MiniClassDecl -> d.members.filterIsInstance<MiniMemberFunDecl>().forEach { addParams(it.params) }
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
|
||||
// Type name segments (including generics base & args)
|
||||
fun addTypeSegments(t: MiniTypeRef?) {
|
||||
when (t) {
|
||||
is MiniTypeName -> t.segments.forEach { seg ->
|
||||
if (seg.range.start.source != source) return@forEach
|
||||
val s = source.offsetOf(seg.range.start)
|
||||
putRange(s, (s + seg.name.length).coerceAtMost(text.length), LyngHighlighterColors.TYPE)
|
||||
}
|
||||
is MiniGenericType -> {
|
||||
addTypeSegments(t.base)
|
||||
t.args.forEach { addTypeSegments(it) }
|
||||
}
|
||||
is MiniFunctionType -> {
|
||||
t.receiver?.let { addTypeSegments(it) }
|
||||
t.params.forEach { addTypeSegments(it) }
|
||||
addTypeSegments(t.returnType)
|
||||
}
|
||||
is MiniTypeVar -> { /* name is in range; could be highlighted as TYPE as well */
|
||||
if (t.range.start.source == source)
|
||||
putMiniRange(t.range, LyngHighlighterColors.TYPE)
|
||||
}
|
||||
null -> {}
|
||||
}
|
||||
}
|
||||
fun addDeclTypeSegments(d: MiniDecl) {
|
||||
if (d.nameStart.source != source) return
|
||||
when (d) {
|
||||
is MiniFunDecl -> {
|
||||
addTypeSegments(d.returnType)
|
||||
d.params.forEach { addTypeSegments(it.type) }
|
||||
addTypeSegments(d.receiver)
|
||||
}
|
||||
is MiniValDecl -> {
|
||||
addTypeSegments(d.type)
|
||||
addTypeSegments(d.receiver)
|
||||
}
|
||||
is MiniClassDecl -> {
|
||||
d.ctorFields.forEach { addTypeSegments(it.type) }
|
||||
d.classFields.forEach { addTypeSegments(it.type) }
|
||||
for (m in d.members) {
|
||||
when (m) {
|
||||
is MiniMemberFunDecl -> {
|
||||
addTypeSegments(m.returnType)
|
||||
m.params.forEach { addTypeSegments(it.type) }
|
||||
}
|
||||
is MiniMemberValDecl -> {
|
||||
addTypeSegments(m.type)
|
||||
}
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
}
|
||||
is MiniEnumDecl -> {}
|
||||
}
|
||||
}
|
||||
mini.declarations.forEach { d -> addDeclTypeSegments(d) }
|
||||
|
||||
ProgressManager.checkCanceled()
|
||||
|
||||
// Semantic usages via Binder (best-effort)
|
||||
try {
|
||||
val binding = Binder.bind(text, mini)
|
||||
|
||||
// Map declaration ranges to avoid duplicating them as usages
|
||||
val declKeys = HashSet<Pair<Int, Int>>(binding.symbols.size * 2)
|
||||
binding.symbols.forEach { sym -> declKeys += (sym.declStart to sym.declEnd) }
|
||||
|
||||
fun keyForKind(k: SymbolKind) = when (k) {
|
||||
SymbolKind.Function -> LyngHighlighterColors.FUNCTION
|
||||
SymbolKind.Class, SymbolKind.Enum -> LyngHighlighterColors.TYPE
|
||||
SymbolKind.Parameter -> LyngHighlighterColors.PARAMETER
|
||||
SymbolKind.Value -> LyngHighlighterColors.VALUE
|
||||
SymbolKind.Variable -> LyngHighlighterColors.VARIABLE
|
||||
}
|
||||
|
||||
// Track covered ranges to not override later heuristics
|
||||
val covered = HashSet<Pair<Int, Int>>()
|
||||
|
||||
binding.references.forEach { ref ->
|
||||
val key = ref.start to ref.end
|
||||
if (!declKeys.contains(key)) {
|
||||
val sym = binding.symbols.firstOrNull { it.id == ref.symbolId }
|
||||
if (sym != null) {
|
||||
val color = keyForKind(sym.kind)
|
||||
putRange(ref.start, ref.end, color)
|
||||
covered += key
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Heuristics on top of binder: function call-sites and simple name-based roles
|
||||
ProgressManager.checkCanceled()
|
||||
|
||||
// Build simple name -> role map for top-level vals/vars and parameters
|
||||
val nameRole = HashMap<String, com.intellij.openapi.editor.colors.TextAttributesKey>(8)
|
||||
mini.declarations.forEach { d ->
|
||||
when (d) {
|
||||
is MiniValDecl -> nameRole[d.name] =
|
||||
if (d.mutable) LyngHighlighterColors.VARIABLE else LyngHighlighterColors.VALUE
|
||||
|
||||
is MiniFunDecl -> d.params.forEach { p -> nameRole[p.name] = LyngHighlighterColors.PARAMETER }
|
||||
is MiniClassDecl -> {
|
||||
d.members.forEach { m ->
|
||||
if (m is MiniMemberFunDecl) {
|
||||
m.params.forEach { p -> nameRole[p.name] = LyngHighlighterColors.PARAMETER }
|
||||
}
|
||||
}
|
||||
}
|
||||
else -> {}
|
||||
}
|
||||
}
|
||||
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.Identifier) {
|
||||
val start = s.range.start
|
||||
val end = s.range.endExclusive
|
||||
val key = start to end
|
||||
if (key !in covered && key !in declKeys) {
|
||||
// Call-site detection first so it wins over var/param role
|
||||
if (isFollowedByParenOrBlock(end)) {
|
||||
putRange(start, end, LyngHighlighterColors.FUNCTION)
|
||||
covered += key
|
||||
} else {
|
||||
// Simple role by known names
|
||||
val ident = try {
|
||||
text.substring(start, end)
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
if (ident != null) {
|
||||
val roleKey = nameRole[ident]
|
||||
if (roleKey != null) {
|
||||
putRange(start, end, roleKey)
|
||||
covered += key
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
// Must rethrow cancellation; otherwise ignore binder failures (best-effort)
|
||||
if (e is com.intellij.openapi.progress.ProcessCanceledException) throw e
|
||||
}
|
||||
|
||||
// Add annotation/label coloring using token highlighter
|
||||
run {
|
||||
analysis.lexicalHighlights.forEach { s ->
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.Label) {
|
||||
val start = s.range.start
|
||||
val end = s.range.endExclusive
|
||||
@ -124,7 +302,7 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
text.substring(wStart, wEnd)
|
||||
} else null
|
||||
|
||||
if (prevWord in setOf("return", "break", "continue")) {
|
||||
if (prevWord in setOf("return", "break", "continue") || isFollowedByParenOrBlock(end)) {
|
||||
putRange(start, end, LyngHighlighterColors.LABEL)
|
||||
} else {
|
||||
putRange(start, end, LyngHighlighterColors.ANNOTATION)
|
||||
@ -137,13 +315,17 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
}
|
||||
}
|
||||
|
||||
analysis.diagnostics.forEach { d ->
|
||||
val range = d.range ?: return@forEach
|
||||
val severity = if (d.severity == LyngDiagnosticSeverity.Warning) HighlightSeverity.WARNING else HighlightSeverity.ERROR
|
||||
diags += Diag(range.start, range.endExclusive, d.message, severity)
|
||||
tokens.forEach { s ->
|
||||
if (s.kind == HighlightKind.EnumConstant) {
|
||||
val start = s.range.start
|
||||
val end = s.range.endExclusive
|
||||
if (start in 0..end && end <= text.length && start < end) {
|
||||
putRange(start, end, LyngHighlighterColors.ENUM_CONSTANT)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Result(collectedInfo.modStamp, out, diags)
|
||||
return Result(collectedInfo.modStamp, out, null)
|
||||
}
|
||||
|
||||
|
||||
@ -164,12 +346,13 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
.create()
|
||||
}
|
||||
|
||||
// Show errors and warnings
|
||||
result.diagnostics.forEach { d ->
|
||||
val start = d.start.coerceIn(0, (doc?.textLength ?: 0))
|
||||
val end = d.end.coerceIn(start, (doc?.textLength ?: start))
|
||||
// Show syntax error if present
|
||||
val err = result.error
|
||||
if (err != null) {
|
||||
val start = err.start.coerceIn(0, (doc?.textLength ?: 0))
|
||||
val end = err.end.coerceIn(start, (doc?.textLength ?: start))
|
||||
if (end > start) {
|
||||
holder.newAnnotation(d.severity, d.message)
|
||||
holder.newAnnotation(HighlightSeverity.ERROR, err.message)
|
||||
.range(TextRange(start, end))
|
||||
.create()
|
||||
}
|
||||
@ -190,5 +373,30 @@ class LyngExternalAnnotator : ExternalAnnotator<LyngExternalAnnotator.Input, Lyn
|
||||
return -1
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Make the error highlight a bit wider than a single character so it is easier to see and click.
|
||||
* Strategy:
|
||||
* - If the offset points inside an identifier-like token (letters/digits/underscore), expand to the full token.
|
||||
* - Otherwise select a small range starting at the offset with a minimum width, but not crossing the line end.
|
||||
*/
|
||||
private fun expandErrorRange(text: String, rawStart: Int): Pair<Int, Int> {
|
||||
if (text.isEmpty()) return 0 to 0
|
||||
val len = text.length
|
||||
val start = rawStart.coerceIn(0, len)
|
||||
fun isWord(ch: Char) = ch == '_' || ch.isLetterOrDigit()
|
||||
|
||||
if (start < len && isWord(text[start])) {
|
||||
var s = start
|
||||
var e = start
|
||||
while (s > 0 && isWord(text[s - 1])) s--
|
||||
while (e < len && isWord(text[e])) e++
|
||||
return s to e
|
||||
}
|
||||
|
||||
// Not inside a word: select a short, visible range up to EOL
|
||||
val lineEnd = text.indexOf('\n', start).let { if (it == -1) len else it }
|
||||
val minWidth = 4
|
||||
val end = (start + minWidth).coerceAtMost(lineEnd).coerceAtLeast((start + 1).coerceAtMost(lineEnd))
|
||||
return start to end
|
||||
}
|
||||
}
|
||||
|
||||
@ -96,10 +96,9 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
log.info("[LYNG_DEBUG] Completion: caret=$caret prefix='${prefix}' memberDotPos=${memberDotPos} file='${file.name}'")
|
||||
}
|
||||
|
||||
// Build analysis (cached) for both global and member contexts to enable local class/val inference
|
||||
val analysis = LyngAstManager.getAnalysis(file)
|
||||
val mini = analysis?.mini
|
||||
val binding = analysis?.binding
|
||||
// Build MiniAst (cached) for both global and member contexts to enable local class/val inference
|
||||
val mini = LyngAstManager.getMiniAst(file)
|
||||
val binding = LyngAstManager.getBinding(file)
|
||||
|
||||
// Delegate computation to the shared engine to keep behavior in sync with tests
|
||||
val engineItems = try {
|
||||
@ -122,7 +121,6 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
fromText.forEach { add(it) }
|
||||
add("lyng.stdlib")
|
||||
}.toList()
|
||||
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, memberDotPos, imported, binding)
|
||||
|
||||
// Try inferring return/receiver class around the dot
|
||||
val inferred =
|
||||
@ -137,7 +135,7 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
|
||||
if (inferred != null) {
|
||||
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback inferred receiver/return class='$inferred' — offering its members")
|
||||
offerMembers(emit, imported, inferred, staticOnly = staticOnly, sourceText = text, mini = mini)
|
||||
offerMembers(emit, imported, inferred, sourceText = text, mini = mini)
|
||||
return
|
||||
} else {
|
||||
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback could not infer class; keeping list empty (no globals after dot)")
|
||||
@ -162,8 +160,6 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
.withIcon(AllIcons.Nodes.Class)
|
||||
Kind.Enum -> LookupElementBuilder.create(ci.name)
|
||||
.withIcon(AllIcons.Nodes.Enum)
|
||||
Kind.TypeAlias -> LookupElementBuilder.create(ci.name)
|
||||
.withIcon(AllIcons.Nodes.Class)
|
||||
Kind.Value -> LookupElementBuilder.create(ci.name)
|
||||
.withIcon(AllIcons.Nodes.Variable)
|
||||
.let { b -> if (!ci.typeText.isNullOrBlank()) b.withTypeText(ci.typeText, true) else b }
|
||||
@ -296,9 +292,6 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
}
|
||||
is MiniEnumDecl -> LookupElementBuilder.create(name)
|
||||
.withIcon(AllIcons.Nodes.Enum)
|
||||
is MiniTypeAliasDecl -> LookupElementBuilder.create(name)
|
||||
.withIcon(AllIcons.Nodes.Class)
|
||||
.withTypeText(typeOf(d.target), true)
|
||||
}
|
||||
emit(builder)
|
||||
}
|
||||
@ -376,7 +369,6 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
when (m) {
|
||||
is MiniMemberFunDecl -> if (!m.isStatic) continue
|
||||
is MiniMemberValDecl -> if (!m.isStatic) continue
|
||||
is MiniMemberTypeAliasDecl -> if (!m.isStatic) continue
|
||||
is MiniInitDecl -> continue
|
||||
}
|
||||
}
|
||||
@ -466,16 +458,6 @@ class LyngCompletionContributor : CompletionContributor() {
|
||||
emit(builder)
|
||||
}
|
||||
}
|
||||
is MiniMemberTypeAliasDecl -> {
|
||||
val builder = LookupElementBuilder.create(name)
|
||||
.withIcon(AllIcons.Nodes.Class)
|
||||
.withTypeText(typeOf(rep.target), true)
|
||||
if (groupPriority != 0.0) {
|
||||
emit(PrioritizedLookupElement.withPriority(builder, groupPriority))
|
||||
} else {
|
||||
emit(builder)
|
||||
}
|
||||
}
|
||||
is MiniInitDecl -> {}
|
||||
}
|
||||
}
|
||||
|
||||
@ -24,14 +24,11 @@ import com.intellij.openapi.editor.Editor
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.PsiElement
|
||||
import com.intellij.psi.PsiFile
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.highlight.offsetOf
|
||||
import net.sergeych.lyng.idea.LyngLanguage
|
||||
import net.sergeych.lyng.idea.util.LyngAstManager
|
||||
import net.sergeych.lyng.idea.util.TextCtx
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.tools.LyngLanguageTools
|
||||
import net.sergeych.lyng.tools.LyngSymbolInfo
|
||||
|
||||
/**
|
||||
* Quick Docs backed by MiniAst: when caret is on an identifier that corresponds
|
||||
@ -69,59 +66,9 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
if (DEBUG_LOG) log.info("[LYNG_DEBUG] QuickDoc: ident='$ident' at ${idRange.startOffset}..${idRange.endOffset} in ${file.name}")
|
||||
|
||||
// 1. Get merged mini-AST from Manager (handles local + .lyng.d merged declarations)
|
||||
val analysis = LyngAstManager.getAnalysis(file) ?: return null
|
||||
val mini = analysis.mini ?: return null
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: return null
|
||||
val miniSource = mini.range.start.source
|
||||
val imported = analysis.importedModules.ifEmpty { DocLookupUtils.canonicalImportedModules(mini, text) }
|
||||
|
||||
// Single-source quick doc lookup
|
||||
LyngLanguageTools.docAt(analysis, offset)?.let { info ->
|
||||
val enriched = if (info.doc == null) {
|
||||
findDocInDeclarationFiles(file, info.target.containerName, info.target.name)
|
||||
?.let { info.copy(doc = it) } ?: info
|
||||
} else {
|
||||
info
|
||||
}
|
||||
renderDocFromInfo(enriched)?.let { return it }
|
||||
}
|
||||
|
||||
// Fallback: resolve references against merged MiniAst (including .lyng.d) when binder cannot
|
||||
run {
|
||||
val dotPos = DocLookupUtils.findDotLeft(text, idRange.startOffset)
|
||||
if (dotPos != null) {
|
||||
val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported, analysis.binding)
|
||||
?: DocLookupUtils.guessReceiverClass(text, dotPos, imported, mini)
|
||||
if (receiverClass != null) {
|
||||
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported, receiverClass, ident, mini)
|
||||
if (resolved != null) {
|
||||
val owner = resolved.first
|
||||
val member = resolved.second
|
||||
val withDoc = if (member.doc == null) {
|
||||
findDocInDeclarationFiles(file, owner, member.name)?.let { doc ->
|
||||
when (member) {
|
||||
is MiniMemberFunDecl -> member.copy(doc = doc)
|
||||
is MiniMemberValDecl -> member.copy(doc = doc)
|
||||
is MiniMemberTypeAliasDecl -> member.copy(doc = doc)
|
||||
else -> member
|
||||
}
|
||||
} ?: member
|
||||
} else {
|
||||
member
|
||||
}
|
||||
return when (withDoc) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, withDoc)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, withDoc)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, withDoc)
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
mini.declarations.firstOrNull { it.name == ident }?.let { decl ->
|
||||
return renderDeclDoc(decl, text, mini, imported)
|
||||
}
|
||||
}
|
||||
}
|
||||
val imported = DocLookupUtils.canonicalImportedModules(mini, text)
|
||||
|
||||
// Try resolve to: function param at position, function/class/val declaration at position
|
||||
// 1) Use unified declaration detection
|
||||
@ -144,7 +91,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return when (m) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(d.name, m)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(d.name, m)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(d.name, m)
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
@ -251,7 +197,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return when (m) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(cls.name, m)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(cls.name, m)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(cls.name, m)
|
||||
else -> null
|
||||
}
|
||||
}
|
||||
@ -362,19 +307,16 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
}
|
||||
if (DEBUG_LOG) log.info("[LYNG_DEBUG] QuickDoc: memberCtx dotPos=${dotPos} chBeforeDot='${if (dotPos > 0) text[dotPos - 1] else ' '}' classGuess=${className} imports=${importedModules}")
|
||||
if (className != null) {
|
||||
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini)?.let { (owner, member) ->
|
||||
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] QuickDoc: literal/call '$ident' resolved to $owner.${member.name}")
|
||||
return when (member) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, member)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
|
||||
is MiniInitDecl -> null
|
||||
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
}
|
||||
}
|
||||
log.info("[LYNG_DEBUG] QuickDoc: resolve failed for ${className}.${ident}")
|
||||
@ -412,7 +354,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
// And classes/enums
|
||||
docs.filterIsInstance<MiniClassDecl>().firstOrNull { it.name == ident }?.let { return renderDeclDoc(it, text, mini, imported) }
|
||||
docs.filterIsInstance<MiniEnumDecl>().firstOrNull { it.name == ident }?.let { return renderDeclDoc(it, text, mini, imported) }
|
||||
docs.filterIsInstance<MiniTypeAliasDecl>().firstOrNull { it.name == ident }?.let { return renderDeclDoc(it, text, mini, imported) }
|
||||
}
|
||||
// Defensive fallback: if nothing found and it's a well-known stdlib function, render minimal inline docs
|
||||
if (ident == "println" || ident == "print") {
|
||||
@ -426,20 +367,16 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
val lhs = previousWordBefore(text, idRange.startOffset)
|
||||
if (lhs != null && hasDotBetween(text, lhs.endOffset, idRange.startOffset)) {
|
||||
val className = text.substring(lhs.startOffset, lhs.endOffset)
|
||||
val dotPos = findDotLeft(text, idRange.startOffset)
|
||||
val staticOnly = dotPos?.let { DocLookupUtils.isStaticReceiver(mini, text, it, importedModules, analysis.binding) } ?: false
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini)?.let { (owner, member) ->
|
||||
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Inheritance resolved $className.$ident to $owner.${member.name}")
|
||||
return when (member) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, member)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
|
||||
is MiniInitDecl -> null
|
||||
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -453,19 +390,16 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
else -> DocLookupUtils.guessClassFromCallBefore(text, dotPos, importedModules, mini)
|
||||
}
|
||||
if (guessed != null) {
|
||||
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, guessed, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, guessed, ident, mini)?.let { (owner, member) ->
|
||||
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Heuristic '$guessed.$ident' resolved via inheritance to $owner.${member.name}")
|
||||
return when (member) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, member)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
|
||||
is MiniInitDecl -> null
|
||||
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -473,19 +407,16 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
run {
|
||||
val candidates = listOf("String", "Iterable", "Iterator", "List", "Collection", "Array", "Dict", "Regex")
|
||||
for (c in candidates) {
|
||||
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, c, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
|
||||
DocLookupUtils.resolveMemberWithInheritance(importedModules, c, ident, mini)?.let { (owner, member) ->
|
||||
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Candidate '$c.$ident' resolved via inheritance to $owner.${member.name}")
|
||||
return when (member) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, member)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
|
||||
is MiniInitDecl -> null
|
||||
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -500,7 +431,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return when (m) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc("String", m)
|
||||
is MiniMemberValDecl -> renderMemberValDoc("String", m)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc("String", m)
|
||||
is MiniInitDecl -> null
|
||||
}
|
||||
}
|
||||
@ -511,13 +441,11 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return when (member) {
|
||||
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
|
||||
is MiniMemberValDecl -> renderMemberValDoc(owner, member)
|
||||
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
|
||||
is MiniInitDecl -> null
|
||||
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -584,7 +512,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
is MiniFunDecl -> "function ${d.name}${signatureOf(d)}"
|
||||
is MiniClassDecl -> "class ${d.name}"
|
||||
is MiniEnumDecl -> "enum ${d.name} { ${d.entries.joinToString(", ")} }"
|
||||
is MiniTypeAliasDecl -> "type ${d.name}${typeAliasSuffix(d)}"
|
||||
is MiniValDecl -> {
|
||||
val t = d.type ?: DocLookupUtils.inferTypeRefForVal(d, text, imported, mini)
|
||||
val typeStr = if (t == null) ": Object?" else typeOf(t)
|
||||
@ -597,73 +524,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun renderDocFromInfo(info: LyngSymbolInfo): String? {
|
||||
val kind = when (info.target.kind) {
|
||||
net.sergeych.lyng.binding.SymbolKind.Function -> "function"
|
||||
net.sergeych.lyng.binding.SymbolKind.Class -> "class"
|
||||
net.sergeych.lyng.binding.SymbolKind.Enum -> "enum"
|
||||
net.sergeych.lyng.binding.SymbolKind.TypeAlias -> "type"
|
||||
net.sergeych.lyng.binding.SymbolKind.Value -> "val"
|
||||
net.sergeych.lyng.binding.SymbolKind.Variable -> "var"
|
||||
net.sergeych.lyng.binding.SymbolKind.Parameter -> "parameter"
|
||||
}
|
||||
val title = info.signature ?: "$kind ${info.target.name}"
|
||||
if (title.isBlank() && info.doc == null) return null
|
||||
val sb = StringBuilder()
|
||||
sb.append(renderTitle(title))
|
||||
sb.append(renderDocBody(info.doc))
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun findDocInDeclarationFiles(file: PsiFile, container: String?, name: String): MiniDoc? {
|
||||
val declFiles = LyngAstManager.getDeclarationFiles(file)
|
||||
if (declFiles.isEmpty()) return null
|
||||
|
||||
fun findInMini(mini: MiniScript): MiniDoc? {
|
||||
if (container == null) {
|
||||
mini.declarations.firstOrNull { it.name == name }?.let { return it.doc }
|
||||
return null
|
||||
}
|
||||
val cls = mini.declarations.filterIsInstance<MiniClassDecl>().firstOrNull { it.name == container } ?: return null
|
||||
cls.members.firstOrNull { it.name == name }?.let { return it.doc }
|
||||
cls.ctorFields.firstOrNull { it.name == name }?.let { return null }
|
||||
cls.classFields.firstOrNull { it.name == name }?.let { return null }
|
||||
return null
|
||||
}
|
||||
|
||||
for (df in declFiles) {
|
||||
val mini = LyngAstManager.getMiniAst(df)
|
||||
?: run {
|
||||
try {
|
||||
val res = runBlocking {
|
||||
LyngLanguageTools.analyze(df.text, df.name)
|
||||
}
|
||||
res.mini
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
}
|
||||
if (mini != null) {
|
||||
val doc = findInMini(mini)
|
||||
if (doc != null) return doc
|
||||
}
|
||||
// Text fallback: parse preceding doc comment for the symbol
|
||||
val parsed = parseDocFromText(df.text, name)
|
||||
if (parsed != null) return parsed
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private fun parseDocFromText(text: String, name: String): MiniDoc? {
|
||||
if (text.isBlank()) return null
|
||||
val pattern = Regex("/\\*\\*([\\s\\S]*?)\\*/\\s*(?:public|private|protected|static|abstract|extern|open|closed|override\\s+)*\\s*(?:fun|val|var|class|interface|enum|type)\\s+$name\\b")
|
||||
val m = pattern.find(text) ?: return null
|
||||
val raw = m.groupValues.getOrNull(1)?.trim() ?: return null
|
||||
if (raw.isBlank()) return null
|
||||
val src = net.sergeych.lyng.Source("<doc>", raw)
|
||||
return MiniDoc.parse(MiniRange(src.startPos, src.startPos), raw.lines())
|
||||
}
|
||||
|
||||
private fun renderParamDoc(fn: MiniFunDecl, p: MiniParam): String {
|
||||
val title = "parameter ${p.name}${typeOf(p.type)} in ${fn.name}${signatureOf(fn)}"
|
||||
val sb = StringBuilder()
|
||||
@ -705,25 +565,6 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun renderMemberTypeAliasDoc(className: String, m: MiniMemberTypeAliasDecl): String {
|
||||
val tp = if (m.typeParams.isEmpty()) "" else "<" + m.typeParams.joinToString(", ") + ">"
|
||||
val body = typeOf(m.target)
|
||||
val rhs = if (body.isBlank()) "" else " = ${body.removePrefix(": ")}"
|
||||
val staticStr = if (m.isStatic) "static " else ""
|
||||
val title = "${staticStr}type $className.${m.name}$tp$rhs"
|
||||
val sb = StringBuilder()
|
||||
sb.append(renderTitle(title))
|
||||
sb.append(renderDocBody(m.doc))
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
private fun typeAliasSuffix(d: MiniTypeAliasDecl): String {
|
||||
val tp = if (d.typeParams.isEmpty()) "" else "<" + d.typeParams.joinToString(", ") + ">"
|
||||
val body = typeOf(d.target)
|
||||
val rhs = if (body.isBlank()) "" else " = ${body.removePrefix(": ")}"
|
||||
return "$tp$rhs"
|
||||
}
|
||||
|
||||
private fun typeOf(t: MiniTypeRef?): String {
|
||||
val s = DocLookupUtils.typeOf(t)
|
||||
return if (s.isEmpty()) (if (t == null) ": Object?" else "") else ": $s"
|
||||
|
||||
@ -35,8 +35,8 @@ class LyngLexer : LexerBase() {
|
||||
"fun", "val", "var", "class", "interface", "type", "import", "as",
|
||||
"abstract", "closed", "override", "static", "extern", "open", "private", "protected",
|
||||
"if", "else", "for", "while", "return", "true", "false", "null",
|
||||
"when", "in", "is", "break", "continue", "try", "catch", "finally", "void",
|
||||
"get", "set", "object", "enum", "init", "by", "step", "property", "constructor"
|
||||
"when", "in", "is", "break", "continue", "try", "catch", "finally",
|
||||
"get", "set", "object", "enum", "init", "by", "property", "constructor"
|
||||
)
|
||||
|
||||
override fun start(buffer: CharSequence, startOffset: Int, endOffset: Int, initialState: Int) {
|
||||
|
||||
@ -20,18 +20,12 @@ package net.sergeych.lyng.idea.navigation
|
||||
import com.intellij.openapi.project.Project
|
||||
import com.intellij.openapi.util.TextRange
|
||||
import com.intellij.psi.*
|
||||
import com.intellij.psi.search.FileTypeIndex
|
||||
import com.intellij.psi.search.FilenameIndex
|
||||
import com.intellij.psi.search.GlobalSearchScope
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.highlight.offsetOf
|
||||
import net.sergeych.lyng.idea.LyngFileType
|
||||
import net.sergeych.lyng.idea.util.LyngAstManager
|
||||
import net.sergeych.lyng.idea.util.TextCtx
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.tools.IdeLenientImportProvider
|
||||
import net.sergeych.lyng.tools.LyngAnalysisRequest
|
||||
import net.sergeych.lyng.tools.LyngLanguageTools
|
||||
|
||||
class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiElement>(element, TextRange(0, element.textLength)) {
|
||||
|
||||
@ -42,10 +36,9 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
val name = element.text ?: ""
|
||||
val results = mutableListOf<ResolveResult>()
|
||||
|
||||
val analysis = LyngAstManager.getAnalysis(file) ?: return emptyArray()
|
||||
val mini = analysis.mini ?: return emptyArray()
|
||||
val binding = analysis.binding
|
||||
val imported = analysis.importedModules.toSet()
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: return emptyArray()
|
||||
val binding = LyngAstManager.getBinding(file)
|
||||
val imported = DocLookupUtils.canonicalImportedModules(mini, text).toSet()
|
||||
val currentPackage = getPackageName(file)
|
||||
val allowedPackages = if (currentPackage != null) imported + currentPackage else imported
|
||||
|
||||
@ -54,17 +47,16 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
if (dotPos != null) {
|
||||
val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported.toList(), binding)
|
||||
?: DocLookupUtils.guessReceiverClass(text, dotPos, imported.toList(), mini)
|
||||
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, imported.toList(), binding)
|
||||
|
||||
if (receiverClass != null) {
|
||||
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported.toList(), receiverClass, name, mini, staticOnly = staticOnly)
|
||||
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported.toList(), receiverClass, name, mini)
|
||||
if (resolved != null) {
|
||||
val owner = resolved.first
|
||||
val member = resolved.second
|
||||
|
||||
// We need to find the actual PSI element for this member
|
||||
val targetFile = findFileForClass(file.project, owner) ?: file
|
||||
val targetMini = loadMini(targetFile)
|
||||
val targetMini = LyngAstManager.getMiniAst(targetFile)
|
||||
if (targetMini != null) {
|
||||
val targetSrc = targetMini.range.start.source
|
||||
val off = targetSrc.offsetOf(member.nameStart)
|
||||
@ -72,13 +64,11 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
val kind = when(member) {
|
||||
is MiniMemberFunDecl -> "Function"
|
||||
is MiniMemberValDecl -> if (member.mutable) "Variable" else "Value"
|
||||
is MiniMemberTypeAliasDecl -> "TypeAlias"
|
||||
is MiniInitDecl -> "Initializer"
|
||||
is MiniFunDecl -> "Function"
|
||||
is MiniValDecl -> if (member.mutable) "Variable" else "Value"
|
||||
is MiniClassDecl -> "Class"
|
||||
is MiniEnumDecl -> "Enum"
|
||||
is MiniTypeAliasDecl -> "TypeAlias"
|
||||
}
|
||||
results.add(PsiElementResolveResult(LyngDeclarationElement(it, member.name, kind)))
|
||||
}
|
||||
@ -129,37 +119,24 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
}
|
||||
|
||||
private fun findFileForClass(project: Project, className: String): PsiFile? {
|
||||
// 1. Try file with matching name first (optimization)
|
||||
val scope = GlobalSearchScope.projectScope(project)
|
||||
val psiManager = PsiManager.getInstance(project)
|
||||
val matchingFiles = FileTypeIndex.getFiles(LyngFileType, scope)
|
||||
.asSequence()
|
||||
.filter { it.name == "$className.lyng" }
|
||||
.mapNotNull { psiManager.findFile(it) }
|
||||
.toList()
|
||||
val matchingDeclFiles = FileTypeIndex.getFiles(LyngFileType, scope)
|
||||
.asSequence()
|
||||
.filter { it.name == "$className.lyng.d" }
|
||||
.mapNotNull { psiManager.findFile(it) }
|
||||
.toList()
|
||||
|
||||
// 1. Try file with matching name first (optimization)
|
||||
val matchingFiles = FilenameIndex.getFilesByName(project, "$className.lyng", GlobalSearchScope.projectScope(project))
|
||||
for (file in matchingFiles) {
|
||||
val mini = loadMini(file) ?: continue
|
||||
if (mini.declarations.any { isLocalDecl(mini, it) && ((it is MiniClassDecl && it.name == className) || (it is MiniEnumDecl && it.name == className)) }) {
|
||||
return file
|
||||
}
|
||||
}
|
||||
for (file in matchingDeclFiles) {
|
||||
val mini = loadMini(file) ?: continue
|
||||
if (mini.declarations.any { isLocalDecl(mini, it) && ((it is MiniClassDecl && it.name == className) || (it is MiniEnumDecl && it.name == className)) }) {
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: continue
|
||||
if (mini.declarations.any { (it is MiniClassDecl && it.name == className) || (it is MiniEnumDecl && it.name == className) }) {
|
||||
return file
|
||||
}
|
||||
}
|
||||
|
||||
// 2. Fallback to full project scan
|
||||
for (file in collectLyngFiles(project)) {
|
||||
if (matchingFiles.contains(file) || matchingDeclFiles.contains(file)) continue // already checked
|
||||
val mini = loadMini(file) ?: continue
|
||||
if (mini.declarations.any { isLocalDecl(mini, it) && ((it is MiniClassDecl && it.name == className) || (it is MiniEnumDecl && it.name == className)) }) {
|
||||
val allFiles = FilenameIndex.getAllFilesByExt(project, "lyng", GlobalSearchScope.projectScope(project))
|
||||
for (vFile in allFiles) {
|
||||
val file = psiManager.findFile(vFile) ?: continue
|
||||
if (matchingFiles.contains(file)) continue // already checked
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: continue
|
||||
if (mini.declarations.any { (it is MiniClassDecl && it.name == className) || (it is MiniEnumDecl && it.name == className) }) {
|
||||
return file
|
||||
}
|
||||
}
|
||||
@ -167,7 +144,7 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
}
|
||||
|
||||
private fun getPackageName(file: PsiFile): String? {
|
||||
val mini = loadMini(file) ?: return null
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: return null
|
||||
return try {
|
||||
val pkg = mini.range.start.source.extractPackageName()
|
||||
if (pkg.startsWith("lyng.")) pkg else "lyng.$pkg"
|
||||
@ -191,19 +168,19 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
|
||||
private fun resolveGlobally(project: Project, name: String, membersOnly: Boolean = false, allowedPackages: Set<String>? = null): List<ResolveResult> {
|
||||
val results = mutableListOf<ResolveResult>()
|
||||
val files = FilenameIndex.getAllFilesByExt(project, "lyng", GlobalSearchScope.projectScope(project))
|
||||
val psiManager = PsiManager.getInstance(project)
|
||||
|
||||
for (file in collectLyngFiles(project)) {
|
||||
for (vFile in files) {
|
||||
val file = psiManager.findFile(vFile) ?: continue
|
||||
|
||||
// Filter by package if requested
|
||||
if (allowedPackages != null) {
|
||||
val pkg = getPackageName(file)
|
||||
if (pkg == null) {
|
||||
if (!file.name.endsWith(".lyng.d")) continue
|
||||
} else if (pkg !in allowedPackages) continue
|
||||
if (pkg == null || pkg !in allowedPackages) continue
|
||||
}
|
||||
|
||||
val mini = loadMini(file) ?: continue
|
||||
val mini = LyngAstManager.getMiniAst(file) ?: continue
|
||||
val src = mini.range.start.source
|
||||
|
||||
fun addIfMatch(dName: String, nameStart: net.sergeych.lyng.Pos, dKind: String) {
|
||||
@ -216,14 +193,12 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
}
|
||||
|
||||
for (d in mini.declarations) {
|
||||
if (!isLocalDecl(mini, d)) continue
|
||||
if (!membersOnly) {
|
||||
val dKind = when(d) {
|
||||
is net.sergeych.lyng.miniast.MiniFunDecl -> "Function"
|
||||
is net.sergeych.lyng.miniast.MiniClassDecl -> "Class"
|
||||
is net.sergeych.lyng.miniast.MiniEnumDecl -> "Enum"
|
||||
is net.sergeych.lyng.miniast.MiniValDecl -> if (d.mutable) "Variable" else "Value"
|
||||
is net.sergeych.lyng.miniast.MiniTypeAliasDecl -> "TypeAlias"
|
||||
}
|
||||
addIfMatch(d.name, d.nameStart, dKind)
|
||||
}
|
||||
@ -236,11 +211,9 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
}
|
||||
|
||||
for (m in members) {
|
||||
if (m.range.start.source != src) continue
|
||||
val mKind = when(m) {
|
||||
is net.sergeych.lyng.miniast.MiniMemberFunDecl -> "Function"
|
||||
is net.sergeych.lyng.miniast.MiniMemberValDecl -> if (m.mutable) "Variable" else "Value"
|
||||
is net.sergeych.lyng.miniast.MiniMemberTypeAliasDecl -> "TypeAlias"
|
||||
is net.sergeych.lyng.miniast.MiniInitDecl -> "Initializer"
|
||||
}
|
||||
addIfMatch(m.name, m.nameStart, mKind)
|
||||
@ -250,42 +223,5 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
|
||||
return results
|
||||
}
|
||||
|
||||
private fun collectLyngFiles(project: Project): List<PsiFile> {
|
||||
val scope = GlobalSearchScope.projectScope(project)
|
||||
val psiManager = PsiManager.getInstance(project)
|
||||
val out = LinkedHashSet<PsiFile>()
|
||||
|
||||
val lyngFiles = FilenameIndex.getAllFilesByExt(project, "lyng", scope)
|
||||
for (vFile in lyngFiles) {
|
||||
psiManager.findFile(vFile)?.let { out.add(it) }
|
||||
}
|
||||
|
||||
// Include declaration files (*.lyng.d) which are indexed as extension "d".
|
||||
val dFiles = FilenameIndex.getAllFilesByExt(project, "d", scope)
|
||||
for (vFile in dFiles) {
|
||||
if (!vFile.name.endsWith(".lyng.d")) continue
|
||||
psiManager.findFile(vFile)?.let { out.add(it) }
|
||||
}
|
||||
|
||||
return out.toList()
|
||||
}
|
||||
|
||||
private fun loadMini(file: PsiFile): MiniScript? {
|
||||
LyngAstManager.getMiniAst(file)?.let { return it }
|
||||
return try {
|
||||
val provider = IdeLenientImportProvider.create()
|
||||
runBlocking {
|
||||
LyngLanguageTools.analyze(
|
||||
LyngAnalysisRequest(text = file.text, fileName = file.name, importProvider = provider)
|
||||
)
|
||||
}.mini
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
private fun isLocalDecl(mini: MiniScript, decl: MiniDecl): Boolean =
|
||||
decl.range.start.source == mini.range.start.source
|
||||
|
||||
override fun getVariants(): Array<Any> = emptyArray()
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2025 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.
|
||||
@ -14,7 +14,7 @@
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
package net.sergeych.lyng.tools
|
||||
package net.sergeych.lyng.idea.util
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Pos
|
||||
@ -28,13 +28,7 @@ import net.sergeych.lyng.pacman.ImportProvider
|
||||
* the compiler can still build MiniAst for Quick Docs / highlighting.
|
||||
*/
|
||||
class IdeLenientImportProvider private constructor(root: Scope) : ImportProvider(root) {
|
||||
override suspend fun createModuleScope(pos: Pos, packageName: String): ModuleScope {
|
||||
return try {
|
||||
Script.defaultImportManager.createModuleScope(pos, packageName)
|
||||
} catch (_: Throwable) {
|
||||
ModuleScope(this, pos, packageName)
|
||||
}
|
||||
}
|
||||
override suspend fun createModuleScope(pos: Pos, packageName: String): ModuleScope = ModuleScope(this, pos, packageName)
|
||||
|
||||
companion object {
|
||||
/** Create a provider based on the default manager's root scope. */
|
||||
@ -21,32 +21,63 @@ import com.intellij.openapi.application.runReadAction
|
||||
import com.intellij.openapi.util.Key
|
||||
import com.intellij.psi.PsiFile
|
||||
import com.intellij.psi.PsiManager
|
||||
import com.intellij.psi.search.FileTypeIndex
|
||||
import com.intellij.psi.search.FilenameIndex
|
||||
import com.intellij.psi.search.GlobalSearchScope
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Compiler
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.binding.Binder
|
||||
import net.sergeych.lyng.binding.BindingSnapshot
|
||||
import net.sergeych.lyng.idea.LyngFileType
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.tools.*
|
||||
import net.sergeych.lyng.miniast.MiniAstBuilder
|
||||
import net.sergeych.lyng.miniast.MiniScript
|
||||
|
||||
object LyngAstManager {
|
||||
private val MINI_KEY = Key.create<MiniScript>("lyng.mini.cache")
|
||||
private val BINDING_KEY = Key.create<BindingSnapshot>("lyng.binding.cache")
|
||||
private val STAMP_KEY = Key.create<Long>("lyng.mini.cache.stamp")
|
||||
private val ANALYSIS_KEY = Key.create<LyngAnalysisResult>("lyng.analysis.cache")
|
||||
private val implicitBuiltinNames = setOf("void")
|
||||
private val includeSymbolsDirective = Regex("""(?im)^\s*//\s*include\s+symbols\s*:\s*(.+?)\s*$""")
|
||||
|
||||
fun getMiniAst(file: PsiFile): MiniScript? = runReadAction {
|
||||
getAnalysis(file)?.mini
|
||||
val vFile = file.virtualFile ?: return@runReadAction null
|
||||
val combinedStamp = getCombinedStamp(file)
|
||||
|
||||
val prevStamp = file.getUserData(STAMP_KEY)
|
||||
val cached = file.getUserData(MINI_KEY)
|
||||
if (cached != null && prevStamp != null && prevStamp == combinedStamp) return@runReadAction cached
|
||||
|
||||
val text = file.viewProvider.contents.toString()
|
||||
val sink = MiniAstBuilder()
|
||||
val built = try {
|
||||
val provider = IdeLenientImportProvider.create()
|
||||
val src = Source(file.name, text)
|
||||
runBlocking { Compiler.compileWithMini(src, provider, sink) }
|
||||
val script = sink.build()
|
||||
if (script != null && !file.name.endsWith(".lyng.d")) {
|
||||
val dFiles = collectDeclarationFiles(file)
|
||||
for (df in dFiles) {
|
||||
val scriptD = getMiniAst(df)
|
||||
if (scriptD != null) {
|
||||
script.declarations.addAll(scriptD.declarations)
|
||||
script.imports.addAll(scriptD.imports)
|
||||
}
|
||||
}
|
||||
}
|
||||
script
|
||||
} catch (_: Throwable) {
|
||||
sink.build()
|
||||
}
|
||||
|
||||
if (built != null) {
|
||||
file.putUserData(MINI_KEY, built)
|
||||
file.putUserData(STAMP_KEY, combinedStamp)
|
||||
// Invalidate binding too
|
||||
file.putUserData(BINDING_KEY, null)
|
||||
}
|
||||
built
|
||||
}
|
||||
|
||||
fun getCombinedStamp(file: PsiFile): Long = runReadAction {
|
||||
var combinedStamp = file.viewProvider.modificationStamp
|
||||
if (!file.name.endsWith(".lyng.d")) {
|
||||
collectDeclarationFiles(file).forEach { symbolsFile ->
|
||||
combinedStamp += symbolsFile.viewProvider.modificationStamp
|
||||
collectDeclarationFiles(file).forEach { df ->
|
||||
combinedStamp += df.viewProvider.modificationStamp
|
||||
}
|
||||
}
|
||||
combinedStamp
|
||||
@ -54,188 +85,49 @@ object LyngAstManager {
|
||||
|
||||
private fun collectDeclarationFiles(file: PsiFile): List<PsiFile> = runReadAction {
|
||||
val psiManager = PsiManager.getInstance(file.project)
|
||||
var current = file.virtualFile?.parent
|
||||
val seen = mutableSetOf<String>()
|
||||
val result = mutableListOf<PsiFile>()
|
||||
|
||||
var currentDir = file.containingDirectory
|
||||
while (currentDir != null) {
|
||||
for (child in currentDir.files) {
|
||||
if (child.name.endsWith(".lyng.d") && child != file && seen.add(child.virtualFile.path)) {
|
||||
result.add(child)
|
||||
while (current != null) {
|
||||
for (child in current.children) {
|
||||
if (child.name.endsWith(".lyng.d") && child != file.virtualFile && seen.add(child.path)) {
|
||||
val psiD = psiManager.findFile(child) ?: continue
|
||||
result.add(psiD)
|
||||
}
|
||||
}
|
||||
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)
|
||||
val basePath = file.virtualFile?.path ?: return@runReadAction result
|
||||
val scope = GlobalSearchScope.projectScope(file.project)
|
||||
val dFiles = FilenameIndex.getAllFilesByExt(file.project, "d", scope)
|
||||
for (vFile in dFiles) {
|
||||
if (!vFile.name.endsWith(".lyng.d")) continue
|
||||
if (vFile.path == basePath) continue
|
||||
val parentPath = vFile.parent?.path ?: continue
|
||||
if (basePath == parentPath || basePath.startsWith(parentPath.trimEnd('/') + "/")) {
|
||||
if (seen.add(vFile.path)) {
|
||||
psiManager.findFile(vFile)?.let { result.add(it) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (result.isNotEmpty()) return@runReadAction result
|
||||
|
||||
// Fallback: scan all Lyng files in project index and filter by .lyng.d
|
||||
val lyngFiles = FileTypeIndex.getFiles(LyngFileType, scope)
|
||||
for (vFile in lyngFiles) {
|
||||
if (!vFile.name.endsWith(".lyng.d")) continue
|
||||
if (vFile.path == basePath) continue
|
||||
if (seen.add(vFile.path)) {
|
||||
psiManager.findFile(vFile)?.let { result.add(it) }
|
||||
}
|
||||
}
|
||||
|
||||
if (result.isNotEmpty()) return@runReadAction result
|
||||
|
||||
// Final fallback: include all .lyng.d files in project scope
|
||||
for (vFile in dFiles) {
|
||||
if (!vFile.name.endsWith(".lyng.d")) continue
|
||||
if (vFile.path == basePath) continue
|
||||
if (seen.add(vFile.path)) {
|
||||
psiManager.findFile(vFile)?.let { result.add(it) }
|
||||
}
|
||||
current = current.parent
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fun getDeclarationFiles(file: PsiFile): List<PsiFile> = runReadAction {
|
||||
collectDeclarationFiles(file)
|
||||
}
|
||||
|
||||
fun getBinding(file: PsiFile): BindingSnapshot? = runReadAction {
|
||||
getAnalysis(file)?.binding
|
||||
}
|
||||
|
||||
fun getAnalysis(file: PsiFile): LyngAnalysisResult? = runReadAction {
|
||||
val vFile = file.virtualFile ?: return@runReadAction null
|
||||
val combinedStamp = getCombinedStamp(file)
|
||||
var combinedStamp = file.viewProvider.modificationStamp
|
||||
|
||||
val dFiles = if (!file.name.endsWith(".lyng.d")) collectDeclarationFiles(file) else emptyList()
|
||||
for (df in dFiles) {
|
||||
combinedStamp += df.viewProvider.modificationStamp
|
||||
}
|
||||
|
||||
val prevStamp = file.getUserData(STAMP_KEY)
|
||||
val cached = file.getUserData(ANALYSIS_KEY)
|
||||
val cached = file.getUserData(BINDING_KEY)
|
||||
|
||||
if (cached != null && prevStamp != null && prevStamp == combinedStamp) return@runReadAction cached
|
||||
|
||||
val mini = getMiniAst(file) ?: return@runReadAction null
|
||||
val text = file.viewProvider.contents.toString()
|
||||
val built = try {
|
||||
val provider = IdeLenientImportProvider.create()
|
||||
runBlocking {
|
||||
LyngLanguageTools.analyze(
|
||||
LyngAnalysisRequest(text = text, fileName = file.name, importProvider = provider)
|
||||
)
|
||||
}
|
||||
val binding = try {
|
||||
Binder.bind(text, mini)
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
|
||||
if (built != null) {
|
||||
val isDecl = file.name.endsWith(".lyng.d")
|
||||
val merged = if (!isDecl && built.mini == null) {
|
||||
MiniScript(MiniRange(built.source.startPos, built.source.startPos))
|
||||
} else {
|
||||
built.mini
|
||||
}
|
||||
if (merged != null && !isDecl) {
|
||||
val dFiles = collectDeclarationFiles(file)
|
||||
for (df in dFiles) {
|
||||
val dMini = getAnalysis(df)?.mini ?: run {
|
||||
val dText = df.viewProvider.contents.toString()
|
||||
try {
|
||||
val provider = IdeLenientImportProvider.create()
|
||||
runBlocking {
|
||||
LyngLanguageTools.analyze(
|
||||
LyngAnalysisRequest(text = dText, fileName = df.name, importProvider = provider)
|
||||
)
|
||||
}.mini
|
||||
} catch (_: Throwable) {
|
||||
null
|
||||
}
|
||||
} ?: continue
|
||||
merged.declarations.addAll(dMini.declarations)
|
||||
merged.imports.addAll(dMini.imports)
|
||||
}
|
||||
}
|
||||
val finalAnalysis = if (merged != null) {
|
||||
val mergedImports = DocLookupUtils.canonicalImportedModules(merged, text)
|
||||
built.copy(
|
||||
mini = merged,
|
||||
importedModules = mergedImports,
|
||||
diagnostics = filterDiagnostics(built.diagnostics, merged, text, mergedImports)
|
||||
)
|
||||
} else {
|
||||
built
|
||||
}
|
||||
file.putUserData(ANALYSIS_KEY, finalAnalysis)
|
||||
file.putUserData(MINI_KEY, finalAnalysis.mini)
|
||||
file.putUserData(BINDING_KEY, finalAnalysis.binding)
|
||||
if (binding != null) {
|
||||
file.putUserData(BINDING_KEY, binding)
|
||||
// stamp is already set by getMiniAst or we set it here if getMiniAst was cached
|
||||
file.putUserData(STAMP_KEY, combinedStamp)
|
||||
return@runReadAction finalAnalysis
|
||||
}
|
||||
null
|
||||
}
|
||||
|
||||
private fun filterDiagnostics(
|
||||
diagnostics: List<LyngDiagnostic>,
|
||||
merged: MiniScript,
|
||||
text: String,
|
||||
importedModules: List<String>
|
||||
): List<LyngDiagnostic> {
|
||||
if (diagnostics.isEmpty()) return diagnostics
|
||||
val declaredTopLevel = merged.declarations.map { it.name }.toSet()
|
||||
|
||||
val declaredMembers = linkedSetOf<String>()
|
||||
val aggregatedClasses = DocLookupUtils.aggregateClasses(importedModules, merged)
|
||||
for (cls in aggregatedClasses.values) {
|
||||
cls.members.forEach { declaredMembers.add(it.name) }
|
||||
cls.ctorFields.forEach { declaredMembers.add(it.name) }
|
||||
cls.classFields.forEach { declaredMembers.add(it.name) }
|
||||
}
|
||||
merged.declarations.filterIsInstance<MiniEnumDecl>().forEach { en ->
|
||||
DocLookupUtils.enumToSyntheticClass(en).members.forEach { declaredMembers.add(it.name) }
|
||||
}
|
||||
|
||||
val builtinTopLevel = linkedSetOf<String>()
|
||||
for (mod in importedModules) {
|
||||
BuiltinDocRegistry.docsForModule(mod).forEach { builtinTopLevel.add(it.name) }
|
||||
}
|
||||
|
||||
return diagnostics.filterNot { diag ->
|
||||
val msg = diag.message
|
||||
if (msg.startsWith("unresolved name: ")) {
|
||||
val name = msg.removePrefix("unresolved name: ").trim()
|
||||
name in declaredTopLevel || name in builtinTopLevel || name in implicitBuiltinNames
|
||||
} else if (msg.startsWith("unresolved member: ")) {
|
||||
val name = msg.removePrefix("unresolved member: ").trim()
|
||||
val range = diag.range
|
||||
val dotLeft = if (range != null) DocLookupUtils.findDotLeft(text, range.start) else null
|
||||
dotLeft != null && name in declaredMembers
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
binding
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,182 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.idea.definitions
|
||||
|
||||
import com.intellij.testFramework.fixtures.BasePlatformTestCase
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.idea.docs.LyngDocumentationProvider
|
||||
import net.sergeych.lyng.idea.navigation.LyngPsiReference
|
||||
import net.sergeych.lyng.idea.settings.LyngFormatterSettings
|
||||
import net.sergeych.lyng.idea.util.LyngAstManager
|
||||
import net.sergeych.lyng.miniast.CompletionEngineLight
|
||||
|
||||
class LyngDefinitionFilesTest : BasePlatformTestCase() {
|
||||
|
||||
override fun getTestDataPath(): String = ""
|
||||
|
||||
private fun enableCompletion() {
|
||||
LyngFormatterSettings.getInstance(project).enableLyngCompletionExperimental = true
|
||||
}
|
||||
|
||||
private fun addDefinitionsFile() {
|
||||
val defs = """
|
||||
/** Utilities exposed via .lyng.d */
|
||||
class Declared(val name: String) {
|
||||
/** Size property */
|
||||
val size: Int = 0
|
||||
|
||||
/** Returns greeting. */
|
||||
fun greet(who: String): String = "hi " + who
|
||||
}
|
||||
|
||||
/** Top-level function. */
|
||||
fun topFun(x: Int): Int = x + 1
|
||||
""".trimIndent()
|
||||
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()
|
||||
run {
|
||||
val code = """
|
||||
val v = top<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 topFun from .lyng.d; got=$engine", engine.contains("topFun"))
|
||||
}
|
||||
run {
|
||||
val code = """
|
||||
<caret>
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("other.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 Declared from .lyng.d; got=$engine", engine.contains("Declared"))
|
||||
}
|
||||
}
|
||||
|
||||
fun test_GotoDefinitionResolvesToDefinitionFile() {
|
||||
addDefinitionsFile()
|
||||
val code = """
|
||||
val x = topFun(1)
|
||||
val y = Declared("x")
|
||||
y.gre<caret>et("me")
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("main.lyng", code)
|
||||
val offset = myFixture.caretOffset
|
||||
val element = myFixture.file.findElementAt(offset) ?: myFixture.file.findElementAt((offset - 1).coerceAtLeast(0))
|
||||
assertNotNull("Expected element at caret for resolve", element)
|
||||
val ref = LyngPsiReference(element!!)
|
||||
val resolved = ref.resolve()
|
||||
assertNotNull("Expected reference to resolve", resolved)
|
||||
assertTrue("Expected .lyng.d target; got=${resolved!!.containingFile.name}", resolved.containingFile.name.endsWith(".lyng.d"))
|
||||
}
|
||||
|
||||
fun test_QuickDocUsesDefinitionDocs() {
|
||||
addDefinitionsFile()
|
||||
val code = """
|
||||
val y = Declared("x")
|
||||
y.gre<caret>et("me")
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("main.lyng", code)
|
||||
val provider = LyngDocumentationProvider()
|
||||
val offset = myFixture.caretOffset
|
||||
val element = myFixture.file.findElementAt(offset) ?: myFixture.file.findElementAt((offset - 1).coerceAtLeast(0))
|
||||
assertNotNull("Expected element at caret for doc", element)
|
||||
val doc = provider.generateDoc(element, element)
|
||||
assertNotNull("Expected Quick Doc", doc)
|
||||
assertTrue("Doc should include summary; got=$doc", doc!!.contains("Returns greeting"))
|
||||
}
|
||||
|
||||
fun test_DiagnosticsIgnoreDefinitionSymbols() {
|
||||
addDefinitionsFile()
|
||||
val code = """
|
||||
val x = topFun(1)
|
||||
val y = Declared("x")
|
||||
y.greet("me")
|
||||
""".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 topFun", messages.none { it.contains("unresolved name: topFun") })
|
||||
assertTrue("Should not report unresolved name for Declared", messages.none { it.contains("unresolved name: Declared") })
|
||||
assertTrue("Should not report unresolved member for greet", messages.none { it.contains("unresolved member: greet") })
|
||||
}
|
||||
|
||||
fun test_DiagnosticsDoNotReportVoidAsUnresolvedName() {
|
||||
val code = """
|
||||
fun f(): void {
|
||||
return void
|
||||
}
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("main.lyng", code)
|
||||
val analysis = LyngAstManager.getAnalysis(myFixture.file)
|
||||
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
|
||||
assertTrue("Should not report unresolved name for void, got=$messages", messages.none { it.contains("unresolved name: void") })
|
||||
}
|
||||
|
||||
fun test_CompletionsIncludePlainLyngViaDirective() {
|
||||
addPlainSymbolsFile()
|
||||
enableCompletion()
|
||||
val code = """
|
||||
// include symbols: plain_symbols.lyng
|
||||
val v = plainTop<caret>
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("main.lyng", code)
|
||||
val text = myFixture.editor.document.text
|
||||
val caret = myFixture.caretOffset
|
||||
val analysis = LyngAstManager.getAnalysis(myFixture.file)
|
||||
val engine = runBlocking { CompletionEngineLight.completeSuspend(text, caret, analysis?.mini, analysis?.binding).map { it.name } }
|
||||
assertTrue("Expected plainTopFun from included .lyng; got=$engine", engine.contains("plainTopFun"))
|
||||
}
|
||||
|
||||
fun test_DiagnosticsIgnorePlainLyngSymbolsViaDirective() {
|
||||
addPlainSymbolsFile()
|
||||
val code = """
|
||||
// include symbols: plain_symbols.lyng
|
||||
val x = plainTopFun(1)
|
||||
val y = PlainDeclared("x")
|
||||
y.hello()
|
||||
""".trimIndent()
|
||||
myFixture.configureByText("main.lyng", code)
|
||||
val analysis = LyngAstManager.getAnalysis(myFixture.file)
|
||||
val messages = analysis?.diagnostics?.map { it.message } ?: emptyList()
|
||||
assertTrue("Should not report unresolved name for plainTopFun", messages.none { it.contains("unresolved name: plainTopFun") })
|
||||
assertTrue("Should not report unresolved name for PlainDeclared", messages.none { it.contains("unresolved name: PlainDeclared") })
|
||||
assertTrue("Should not report unresolved member for hello", messages.none { it.contains("unresolved member: hello") })
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2025 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.
|
||||
@ -27,15 +27,12 @@ import com.github.ajalt.clikt.parameters.arguments.optional
|
||||
import com.github.ajalt.clikt.parameters.options.flag
|
||||
import com.github.ajalt.clikt.parameters.options.option
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.Compiler
|
||||
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
|
||||
@ -71,9 +68,6 @@ 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)
|
||||
}
|
||||
}
|
||||
|
||||
@ -173,7 +167,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
|
||||
|
||||
override fun help(context: Context): String =
|
||||
"""
|
||||
The Lyng script language runtime, language version is $LyngVersion.
|
||||
The Lyng script language interpreter, language version is $LyngVersion.
|
||||
|
||||
Please refer form more information to the project site:
|
||||
https://gitea.sergeych.net/SergeychWorks/lyng
|
||||
@ -204,12 +198,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
|
||||
launcher {
|
||||
// there is no script name, it is a first argument instead:
|
||||
processErrors {
|
||||
val script = Compiler.compileWithResolution(
|
||||
Source("<eval>", execute!!),
|
||||
baseScope.currentImportProvider,
|
||||
seedScope = baseScope
|
||||
)
|
||||
script.execute(baseScope)
|
||||
baseScope.eval(execute!!)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -247,13 +236,7 @@ suspend fun executeFile(fileName: String) {
|
||||
text = text.substring(pos + 1)
|
||||
}
|
||||
processErrors {
|
||||
val scope = baseScopeDefer.await()
|
||||
val script = Compiler.compileWithResolution(
|
||||
Source(fileName, text),
|
||||
scope.currentImportProvider,
|
||||
seedScope = scope
|
||||
)
|
||||
script.execute(scope)
|
||||
baseScopeDefer.await().eval(Source(fileName, text))
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
* Copyright 2025 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.
|
||||
@ -56,7 +56,7 @@ class FsIntegrationJvmTest {
|
||||
"""
|
||||
import lyng.io.fs
|
||||
// list current folder files
|
||||
println( Path(".").list() )
|
||||
println( Path(".").list().toList() )
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@ -78,7 +78,6 @@ kotlin {
|
||||
api(project(":lynglib"))
|
||||
api(libs.okio)
|
||||
api(libs.kotlinx.coroutines.core)
|
||||
api(libs.mordant.core)
|
||||
}
|
||||
}
|
||||
val commonTest by getting {
|
||||
@ -95,13 +94,6 @@ 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 {
|
||||
@ -112,64 +104,6 @@ kotlin {
|
||||
}
|
||||
}
|
||||
|
||||
abstract class GenerateLyngioConsoleDecls : DefaultTask() {
|
||||
@get:InputFile
|
||||
@get:PathSensitive(PathSensitivity.RELATIVE)
|
||||
abstract val sourceFile: RegularFileProperty
|
||||
|
||||
@get:OutputDirectory
|
||||
abstract val outputDir: DirectoryProperty
|
||||
|
||||
@TaskAction
|
||||
fun generate() {
|
||||
val targetPkg = "net.sergeych.lyngio.stdlib_included"
|
||||
val pkgPath = targetPkg.replace('.', '/')
|
||||
val targetDir = outputDir.get().asFile.resolve(pkgPath)
|
||||
targetDir.mkdirs()
|
||||
|
||||
val text = sourceFile.get().asFile.readText()
|
||||
fun escapeForQuoted(s: String): String = buildString {
|
||||
for (ch in s) when (ch) {
|
||||
'\\' -> append("\\\\")
|
||||
'"' -> append("\\\"")
|
||||
'\n' -> append("\\n")
|
||||
'\r' -> {}
|
||||
'\t' -> append("\\t")
|
||||
else -> append(ch)
|
||||
}
|
||||
}
|
||||
|
||||
val out = buildString {
|
||||
append("package ").append(targetPkg).append("\n\n")
|
||||
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
|
||||
append("internal val consoleLyng = \"")
|
||||
append(escapeForQuoted(text))
|
||||
append("\"\n")
|
||||
}
|
||||
targetDir.resolve("console_types_lyng.generated.kt").writeText(out)
|
||||
}
|
||||
}
|
||||
|
||||
val lyngioConsoleDeclsFile = layout.projectDirectory.file("stdlib/lyng/io/console.lyng")
|
||||
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
|
||||
|
||||
val generateLyngioConsoleDecls by tasks.registering(GenerateLyngioConsoleDecls::class) {
|
||||
sourceFile.set(lyngioConsoleDeclsFile)
|
||||
outputDir.set(generatedLyngioDeclsDir)
|
||||
}
|
||||
|
||||
kotlin.sourceSets.named("commonMain") {
|
||||
kotlin.srcDir(generateLyngioConsoleDecls)
|
||||
}
|
||||
|
||||
kotlin.targets.configureEach {
|
||||
compilations.configureEach {
|
||||
compileTaskProvider.configure {
|
||||
dependsOn(generateLyngioConsoleDecls)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
android {
|
||||
namespace = "net.sergeych.lyngio"
|
||||
compileSdk = libs.versions.android.compileSdk.get().toInt()
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||
// no-op on Android
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
actual fun getSystemConsole(): LyngConsole = MordantLyngConsole
|
||||
@ -1,494 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.console
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.Source
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjEnumClass
|
||||
import net.sergeych.lyng.obj.ObjEnumEntry
|
||||
import net.sergeych.lyng.obj.ObjIterable
|
||||
import net.sergeych.lyng.obj.ObjIterationFinishedException
|
||||
import net.sergeych.lyng.obj.ObjIterator
|
||||
import net.sergeych.lyng.obj.ObjNull
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
import net.sergeych.lyng.obj.ObjVoid
|
||||
import net.sergeych.lyng.obj.requiredArg
|
||||
import net.sergeych.lyng.obj.thisAs
|
||||
import net.sergeych.lyng.obj.toObj
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.raiseIllegalOperation
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyngio.console.*
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessDeniedException
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.console.security.LyngConsoleSecured
|
||||
import net.sergeych.lyngio.stdlib_included.consoleLyng
|
||||
|
||||
private const val CONSOLE_MODULE_NAME = "lyng.io.console"
|
||||
|
||||
/**
|
||||
* Install Lyng module `lyng.io.console` into the given scope's ImportManager.
|
||||
*/
|
||||
fun createConsoleModule(policy: ConsoleAccessPolicy, scope: Scope): Boolean =
|
||||
createConsoleModule(policy, scope.importManager)
|
||||
|
||||
fun createConsole(policy: ConsoleAccessPolicy, scope: Scope): Boolean = createConsoleModule(policy, scope)
|
||||
|
||||
/** Same as [createConsoleModule] but with explicit [ImportManager]. */
|
||||
fun createConsoleModule(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean {
|
||||
if (manager.packageNames.contains(CONSOLE_MODULE_NAME)) return false
|
||||
|
||||
manager.addPackage(CONSOLE_MODULE_NAME) { module ->
|
||||
buildConsoleModule(module, policy)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
fun createConsole(policy: ConsoleAccessPolicy, manager: ImportManager): Boolean = createConsoleModule(policy, manager)
|
||||
|
||||
private suspend fun buildConsoleModule(module: ModuleScope, policy: ConsoleAccessPolicy) {
|
||||
// Load Lyng declarations for console enums/types first (module-local source of truth).
|
||||
module.eval(Source(CONSOLE_MODULE_NAME, consoleLyng))
|
||||
ConsoleEnums.initialize(module)
|
||||
val console: LyngConsole = LyngConsoleSecured(getSystemConsole(), policy)
|
||||
|
||||
val consoleType = object : net.sergeych.lyng.obj.ObjClass("Console") {}
|
||||
|
||||
consoleType.apply {
|
||||
addClassFn("isSupported") {
|
||||
ObjBool(console.isSupported)
|
||||
}
|
||||
|
||||
addClassFn("isTty") {
|
||||
consoleGuard {
|
||||
ObjBool(console.isTty())
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("ansiLevel") {
|
||||
consoleGuard {
|
||||
ConsoleEnums.ansiLevel(console.ansiLevel().name)
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("geometry") {
|
||||
consoleGuard {
|
||||
console.geometry()?.let { ObjConsoleGeometry(it.columns, it.rows) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("details") {
|
||||
consoleGuard {
|
||||
val tty = console.isTty()
|
||||
val ansi = console.ansiLevel()
|
||||
val geometry = console.geometry()
|
||||
ObjConsoleDetails(
|
||||
supported = console.isSupported,
|
||||
isTty = tty,
|
||||
ansiLevel = ConsoleEnums.ansiLevel(ansi.name),
|
||||
geometry = geometry?.let { ObjConsoleGeometry(it.columns, it.rows) },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("write") {
|
||||
consoleGuard {
|
||||
val text = requiredArg<ObjString>(0).value
|
||||
console.write(text)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("flush") {
|
||||
consoleGuard {
|
||||
console.flush()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("home") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[H")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("clear") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[2J")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("moveTo") {
|
||||
consoleGuard {
|
||||
val row = requiredArg<net.sergeych.lyng.obj.ObjInt>(0).value
|
||||
val col = requiredArg<net.sergeych.lyng.obj.ObjInt>(1).value
|
||||
console.write("\u001B[${row};${col}H")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("clearLine") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[2K")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("enterAltScreen") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[?1049h")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("leaveAltScreen") {
|
||||
consoleGuard {
|
||||
console.write("\u001B[?1049l")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("setCursorVisible") {
|
||||
consoleGuard {
|
||||
val visible = requiredArg<ObjBool>(0).value
|
||||
console.write(if (visible) "\u001B[?25h" else "\u001B[?25l")
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("events") {
|
||||
consoleGuard {
|
||||
console.events().toConsoleEventStream()
|
||||
}
|
||||
}
|
||||
|
||||
addClassFn("setRawMode") {
|
||||
consoleGuard {
|
||||
val enabled = requiredArg<ObjBool>(0).value
|
||||
ObjBool(console.setRawMode(enabled))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.addConst("Console", consoleType)
|
||||
module.addConst("ConsoleGeometry", ObjConsoleGeometry.type)
|
||||
module.addConst("ConsoleDetails", ObjConsoleDetails.type)
|
||||
module.addConst("ConsoleEvent", ObjConsoleEvent.type)
|
||||
module.addConst("ConsoleResizeEvent", ObjConsoleResizeEvent.type)
|
||||
module.addConst("ConsoleKeyEvent", ObjConsoleKeyEvent.typeObj)
|
||||
module.addConst("ConsoleEventStream", ObjConsoleEventStream.type)
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.consoleGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: ConsoleAccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "console access denied")
|
||||
} catch (e: Exception) {
|
||||
raiseIllegalOperation(e.message ?: "console error")
|
||||
}
|
||||
}
|
||||
|
||||
private fun ConsoleEventSource.toConsoleEventStream(): ObjConsoleEventStream {
|
||||
return ObjConsoleEventStream(this)
|
||||
}
|
||||
|
||||
private class ObjConsoleEventStream(
|
||||
private val source: ConsoleEventSource,
|
||||
) : Obj() {
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||
get() = type
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventStream", ObjIterable).apply {
|
||||
addFn("iterator") {
|
||||
val stream = thisAs<ObjConsoleEventStream>()
|
||||
ObjConsoleEventIterator(stream.source)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleEventIterator(
|
||||
private val source: ConsoleEventSource,
|
||||
) : Obj() {
|
||||
private var cached: Obj? = null
|
||||
private var closed = false
|
||||
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass
|
||||
get() = type
|
||||
|
||||
private suspend fun ensureCached(): Boolean {
|
||||
if (closed) return false
|
||||
if (cached != null) return true
|
||||
while (!closed && cached == null) {
|
||||
val event = try {
|
||||
source.nextEvent()
|
||||
} catch (e: Throwable) {
|
||||
// Consumer loops must survive source/read failures: report and keep polling.
|
||||
consoleFlowDebug("console-bridge: nextEvent failed; dropping failure and continuing", e)
|
||||
continue
|
||||
}
|
||||
if (event == null) {
|
||||
closeSource()
|
||||
return false
|
||||
}
|
||||
cached = try {
|
||||
event.toObjEvent()
|
||||
} catch (e: Throwable) {
|
||||
// Malformed/native event payload must not terminate consumer iteration.
|
||||
consoleFlowDebug("console-bridge: malformed event dropped: $event", e)
|
||||
null
|
||||
}
|
||||
}
|
||||
return cached != null
|
||||
}
|
||||
|
||||
private suspend fun closeSource() {
|
||||
if (closed) return
|
||||
closed = true
|
||||
// Do not close the underlying console source from VM iterator cancellation.
|
||||
// CmdFrame.cancelIterators() may call cancelIteration() while user code is still
|
||||
// expected to keep processing input (e.g. recover from app-level exceptions).
|
||||
// The source lifecycle is managed by the console runtime.
|
||||
}
|
||||
|
||||
suspend fun hasNext(): Boolean = ensureCached()
|
||||
|
||||
suspend fun next(scope: Scope): Obj {
|
||||
if (!ensureCached()) {
|
||||
scope.raiseError(ObjIterationFinishedException(scope))
|
||||
}
|
||||
val out = cached ?: scope.raiseError("console iterator internal error: missing cached event")
|
||||
cached = null
|
||||
return out
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEventIterator", ObjIterator).apply {
|
||||
addFn("hasNext") {
|
||||
thisAs<ObjConsoleEventIterator>().hasNext().toObj()
|
||||
}
|
||||
addFn("next") {
|
||||
thisAs<ObjConsoleEventIterator>().next(requireScope())
|
||||
}
|
||||
addFn("cancelIteration") {
|
||||
thisAs<ObjConsoleEventIterator>().closeSource()
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun ConsoleEvent.toObjEvent(): Obj = when (this) {
|
||||
is ConsoleEvent.Resize -> ObjConsoleResizeEvent(columns, rows)
|
||||
is ConsoleEvent.KeyDown -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_DOWN, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
is ConsoleEvent.KeyUp -> ObjConsoleKeyEvent(type = ConsoleEnums.KEY_UP, key = sanitizedKeyOrFallback(key), codeName = code, ctrl = ctrl, alt = alt, shift = shift, meta = meta)
|
||||
}
|
||||
|
||||
private fun sanitizedKeyOrFallback(key: String): String {
|
||||
if (key.isNotEmpty()) return key
|
||||
consoleFlowDebug("console-bridge: empty key value received; using fallback key name")
|
||||
return "Unknown"
|
||||
}
|
||||
|
||||
private object ConsoleEnums {
|
||||
lateinit var eventTypeClass: ObjEnumClass
|
||||
private set
|
||||
lateinit var keyCodeClass: ObjEnumClass
|
||||
private set
|
||||
lateinit var ansiLevelClass: ObjEnumClass
|
||||
private set
|
||||
|
||||
private lateinit var eventEntries: Map<String, ObjEnumEntry>
|
||||
private lateinit var keyCodeEntries: Map<String, ObjEnumEntry>
|
||||
private lateinit var ansiLevelEntries: Map<String, ObjEnumEntry>
|
||||
|
||||
val UNKNOWN: ObjEnumEntry get() = event("UNKNOWN")
|
||||
val RESIZE: ObjEnumEntry get() = event("RESIZE")
|
||||
val KEY_DOWN: ObjEnumEntry get() = event("KEY_DOWN")
|
||||
val KEY_UP: ObjEnumEntry get() = event("KEY_UP")
|
||||
val CODE_UNKNOWN: ObjEnumEntry get() = code("UNKNOWN")
|
||||
val CHARACTER: ObjEnumEntry get() = code("CHARACTER")
|
||||
|
||||
fun initialize(module: ModuleScope) {
|
||||
eventTypeClass = resolveEnum(module, "ConsoleEventType")
|
||||
keyCodeClass = resolveEnum(module, "ConsoleKeyCode")
|
||||
ansiLevelClass = resolveEnum(module, "ConsoleAnsiLevel")
|
||||
eventEntries = resolveEntries(
|
||||
eventTypeClass,
|
||||
listOf("UNKNOWN", "RESIZE", "KEY_DOWN", "KEY_UP")
|
||||
)
|
||||
keyCodeEntries = resolveEntries(
|
||||
keyCodeClass,
|
||||
listOf(
|
||||
"UNKNOWN", "CHARACTER", "ARROW_UP", "ARROW_DOWN", "ARROW_LEFT", "ARROW_RIGHT",
|
||||
"HOME", "END", "INSERT", "DELETE", "PAGE_UP", "PAGE_DOWN",
|
||||
"ESCAPE", "ENTER", "TAB", "BACKSPACE", "SPACE"
|
||||
)
|
||||
)
|
||||
ansiLevelEntries = resolveEntries(
|
||||
ansiLevelClass,
|
||||
listOf("NONE", "BASIC16", "ANSI256", "TRUECOLOR")
|
||||
)
|
||||
}
|
||||
|
||||
private fun resolveEnum(module: ModuleScope, enumName: String): ObjEnumClass {
|
||||
val local = module.get(enumName)?.value as? ObjEnumClass
|
||||
if (local != null) return local
|
||||
val root = module.importProvider.rootScope.get(enumName)?.value as? ObjEnumClass
|
||||
return root ?: error("lyng.io.console declaration enum is missing: $enumName")
|
||||
}
|
||||
|
||||
private fun resolveEntries(enumClass: ObjEnumClass, names: List<String>): Map<String, ObjEnumEntry> {
|
||||
return names.associateWith { name ->
|
||||
(enumClass.byName[ObjString(name)] as? ObjEnumEntry)
|
||||
?: error("lyng.io.console enum entry is missing: ${enumClass.className}.$name")
|
||||
}
|
||||
}
|
||||
|
||||
fun event(name: String): ObjEnumEntry = eventEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${eventTypeClass.className}.$name")
|
||||
|
||||
fun code(name: String): ObjEnumEntry = keyCodeEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${keyCodeClass.className}.$name")
|
||||
|
||||
fun ansiLevel(name: String): ObjEnumEntry = ansiLevelEntries[name]
|
||||
?: error("lyng.io.console enum entry is missing: ${ansiLevelClass.className}.$name")
|
||||
}
|
||||
|
||||
private val KEY_CODE_BY_KEY_NAME = mapOf(
|
||||
"ArrowUp" to "ARROW_UP",
|
||||
"ArrowDown" to "ARROW_DOWN",
|
||||
"ArrowLeft" to "ARROW_LEFT",
|
||||
"ArrowRight" to "ARROW_RIGHT",
|
||||
"Home" to "HOME",
|
||||
"End" to "END",
|
||||
"Insert" to "INSERT",
|
||||
"Delete" to "DELETE",
|
||||
"PageUp" to "PAGE_UP",
|
||||
"PageDown" to "PAGE_DOWN",
|
||||
"Escape" to "ESCAPE",
|
||||
"Enter" to "ENTER",
|
||||
"Tab" to "TAB",
|
||||
"Backspace" to "BACKSPACE",
|
||||
" " to "SPACE",
|
||||
)
|
||||
|
||||
private fun codeFrom(key: String, codeName: String?): ObjEnumEntry {
|
||||
val resolved = KEY_CODE_BY_KEY_NAME[codeName ?: key]
|
||||
return when {
|
||||
resolved != null -> ConsoleEnums.code(resolved)
|
||||
key.length == 1 -> ConsoleEnums.CHARACTER
|
||||
else -> ConsoleEnums.CODE_UNKNOWN
|
||||
}
|
||||
}
|
||||
|
||||
private abstract class ObjConsoleEventBase(
|
||||
private val type: ObjEnumEntry,
|
||||
final override val objClass: net.sergeych.lyng.obj.ObjClass,
|
||||
) : Obj() {
|
||||
fun type(): ObjEnumEntry = type
|
||||
}
|
||||
|
||||
private class ObjConsoleEvent : ObjConsoleEventBase(ConsoleEnums.UNKNOWN, type) {
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleEvent").apply {
|
||||
addProperty(name = "type", getter = { (this.thisObj as ObjConsoleEventBase).type() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleResizeEvent(
|
||||
val columns: Int,
|
||||
val rows: Int,
|
||||
) : ObjConsoleEventBase(ConsoleEnums.RESIZE, type) {
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleResizeEvent", ObjConsoleEvent.type).apply {
|
||||
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleResizeEvent).columns.toObj() })
|
||||
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleResizeEvent).rows.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleKeyEvent(
|
||||
type: ObjEnumEntry,
|
||||
val key: String,
|
||||
val codeName: String?,
|
||||
val ctrl: Boolean,
|
||||
val alt: Boolean,
|
||||
val shift: Boolean,
|
||||
val meta: Boolean,
|
||||
) : ObjConsoleEventBase(type, typeObj) {
|
||||
init {
|
||||
require(key.isNotEmpty()) { "ConsoleKeyEvent.key must never be empty" }
|
||||
}
|
||||
|
||||
companion object {
|
||||
val typeObj = net.sergeych.lyng.obj.ObjClass("ConsoleKeyEvent", ObjConsoleEvent.type).apply {
|
||||
addProperty(name = "key", getter = { ObjString((this.thisObj as ObjConsoleKeyEvent).key) })
|
||||
addProperty(name = "code", getter = { codeFrom((this.thisObj as ObjConsoleKeyEvent).key, (this.thisObj as ObjConsoleKeyEvent).codeName) })
|
||||
addProperty(name = "codeName", getter = {
|
||||
val code = (this.thisObj as ObjConsoleKeyEvent).codeName
|
||||
code?.let(::ObjString) ?: ObjNull
|
||||
})
|
||||
addProperty(name = "ctrl", getter = { (this.thisObj as ObjConsoleKeyEvent).ctrl.toObj() })
|
||||
addProperty(name = "alt", getter = { (this.thisObj as ObjConsoleKeyEvent).alt.toObj() })
|
||||
addProperty(name = "shift", getter = { (this.thisObj as ObjConsoleKeyEvent).shift.toObj() })
|
||||
addProperty(name = "meta", getter = { (this.thisObj as ObjConsoleKeyEvent).meta.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleGeometry(
|
||||
val columns: Int,
|
||||
val rows: Int,
|
||||
) : Obj() {
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleGeometry").apply {
|
||||
addProperty(name = "columns", getter = { (this.thisObj as ObjConsoleGeometry).columns.toObj() })
|
||||
addProperty(name = "rows", getter = { (this.thisObj as ObjConsoleGeometry).rows.toObj() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private class ObjConsoleDetails(
|
||||
val supported: Boolean,
|
||||
val isTty: Boolean,
|
||||
val ansiLevel: ObjEnumEntry,
|
||||
val geometry: ObjConsoleGeometry?,
|
||||
) : Obj() {
|
||||
override val objClass: net.sergeych.lyng.obj.ObjClass get() = type
|
||||
|
||||
companion object {
|
||||
val type = net.sergeych.lyng.obj.ObjClass("ConsoleDetails").apply {
|
||||
addProperty(name = "supported", getter = { (this.thisObj as ObjConsoleDetails).supported.toObj() })
|
||||
addProperty(name = "isTty", getter = { (this.thisObj as ObjConsoleDetails).isTty.toObj() })
|
||||
addProperty(name = "ansiLevel", getter = { (this.thisObj as ObjConsoleDetails).ansiLevel })
|
||||
addProperty(name = "geometry", getter = { (this.thisObj as ObjConsoleDetails).geometry ?: ObjNull })
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -23,11 +23,11 @@ package net.sergeych.lyng.io.fs
|
||||
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.ScopeCallable
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.obj.*
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyng.pacman.ModuleBuilder
|
||||
import net.sergeych.lyngio.fs.LyngFS
|
||||
import net.sergeych.lyngio.fs.LyngFs
|
||||
import net.sergeych.lyngio.fs.LyngPath
|
||||
@ -52,9 +52,11 @@ fun createFsModule(policy: FsAccessPolicy, manager: ImportManager): Boolean {
|
||||
// Avoid re-registering in this ImportManager
|
||||
if (manager.packageNames.contains(name)) return false
|
||||
|
||||
manager.addPackage(name) { module ->
|
||||
buildFsModule(module, policy)
|
||||
}
|
||||
manager.addPackage(name, object : ModuleBuilder {
|
||||
override suspend fun build(module: ModuleScope) {
|
||||
buildFsModule(module, policy)
|
||||
}
|
||||
})
|
||||
return true
|
||||
}
|
||||
|
||||
@ -80,322 +82,394 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
|
||||
name = "name",
|
||||
doc = "Base name of the path (last segment).",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val self = thisAs<ObjPath>()
|
||||
self.path.name.toObj()
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjPath>()
|
||||
return self.path.name.toObj()
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "parent",
|
||||
doc = "Parent directory as a Path or null if none.",
|
||||
returns = type("Path", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val self = thisAs<ObjPath>()
|
||||
self.path.parent?.let {
|
||||
ObjPath( this@apply, self.secured, it)
|
||||
} ?: ObjNull
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjPath>()
|
||||
return self.path.parent?.let {
|
||||
ObjPath(this@apply, self.secured, it)
|
||||
} ?: ObjNull
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "segments",
|
||||
doc = "List of path segments.",
|
||||
// returns: List<String>
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val self = thisAs<ObjPath>()
|
||||
ObjList(self.path.segments.map { ObjString(it) }.toMutableList())
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjPath>()
|
||||
return ObjList(self.path.segments.map { ObjString(it) }.toMutableList())
|
||||
}
|
||||
}
|
||||
)
|
||||
// exists(): Bool
|
||||
addFnDoc(
|
||||
name = "exists",
|
||||
doc = "Check whether this path exists.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
(self.secured.exists(self.path)).toObj()
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
(self.secured.exists(self.path)).toObj()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// isFile(): Bool — cached metadata
|
||||
addFnDoc(
|
||||
name = "isFile",
|
||||
doc = "True if this path is a regular file (based on cached metadata).",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
self.ensureMetadata().let { ObjBool(it.isRegularFile) }
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
self.ensureMetadata().let { ObjBool(it.isRegularFile) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// isDirectory(): Bool — cached metadata
|
||||
addFnDoc(
|
||||
name = "isDirectory",
|
||||
doc = "True if this path is a directory (based on cached metadata).",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
self.ensureMetadata().let { ObjBool(it.isDirectory) }
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
self.ensureMetadata().let { ObjBool(it.isDirectory) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// size(): Int? — null when unavailable
|
||||
addFnDoc(
|
||||
name = "size",
|
||||
doc = "File size in bytes, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.size?.let { ObjInt(it) } ?: ObjNull
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.size?.let { ObjInt(it) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// createdAt(): Instant? — Lyng Instant, null when unavailable
|
||||
addFnDoc(
|
||||
name = "createdAt",
|
||||
doc = "Creation time as `Instant`, or null when unavailable.",
|
||||
returns = type("lyng.Instant", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.createdAtMillis?.let { ObjInstant(kotlin.time.Instant.fromEpochMilliseconds(it)) } ?: ObjNull
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.createdAtMillis?.let { ObjInstant(kotlin.time.Instant.fromEpochMilliseconds(it)) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// createdAtMillis(): Int? — milliseconds since epoch or null
|
||||
addFnDoc(
|
||||
name = "createdAtMillis",
|
||||
doc = "Creation time in milliseconds since epoch, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.createdAtMillis?.let { ObjInt(it) } ?: ObjNull
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.createdAtMillis?.let { ObjInt(it) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// modifiedAt(): Instant? — Lyng Instant, null when unavailable
|
||||
addFnDoc(
|
||||
name = "modifiedAt",
|
||||
doc = "Last modification time as `Instant`, or null when unavailable.",
|
||||
returns = type("lyng.Instant", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.modifiedAtMillis?.let { ObjInstant(kotlin.time.Instant.fromEpochMilliseconds(it)) } ?: ObjNull
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.modifiedAtMillis?.let { ObjInstant(kotlinx.datetime.Instant.fromEpochMilliseconds(it)) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// modifiedAtMillis(): Int? — milliseconds since epoch or null
|
||||
addFnDoc(
|
||||
name = "modifiedAtMillis",
|
||||
doc = "Last modification time in milliseconds since epoch, or null when unavailable.",
|
||||
returns = type("lyng.Int", nullable = true),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.modifiedAtMillis?.let { ObjInt(it) } ?: ObjNull
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.ensureMetadata()
|
||||
m.modifiedAtMillis?.let { ObjInt(it) } ?: ObjNull
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// list(): List<Path>
|
||||
addFnDoc(
|
||||
name = "list",
|
||||
doc = "List directory entries as `Path` objects.",
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("Path"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val items = self.secured.list(self.path).map { ObjPath(self.objClass, self.secured, it) }
|
||||
ObjList(items.toMutableList())
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val items = self.secured.list(self.path).map { ObjPath(self.objClass, self.secured, it) }
|
||||
ObjList(items.toMutableList())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// readBytes(): Buffer
|
||||
addFnDoc(
|
||||
name = "readBytes",
|
||||
doc = "Read the file into a binary buffer.",
|
||||
returns = type("lyng.Buffer"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val bytes = self.secured.readBytes(self.path)
|
||||
ObjBuffer(bytes.asUByteArray())
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val bytes = self.secured.readBytes(self.path)
|
||||
ObjBuffer(bytes.asUByteArray())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// writeBytes(bytes: Buffer)
|
||||
addFnDoc(
|
||||
name = "writeBytes",
|
||||
doc = "Write a binary buffer to the file, replacing content.",
|
||||
params = listOf(ParamDoc("bytes", type("lyng.Buffer"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val buf = requiredArg<ObjBuffer>(0)
|
||||
self.secured.writeBytes(self.path, buf.byteArray.asByteArray(), append = false)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val buf = scp.requiredArg<ObjBuffer>(0)
|
||||
self.secured.writeBytes(self.path, buf.byteArray.asByteArray(), append = false)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// appendBytes(bytes: Buffer)
|
||||
addFnDoc(
|
||||
name = "appendBytes",
|
||||
doc = "Append a binary buffer to the end of the file.",
|
||||
params = listOf(ParamDoc("bytes", type("lyng.Buffer"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val buf = requiredArg<ObjBuffer>(0)
|
||||
self.secured.writeBytes(self.path, buf.byteArray.asByteArray(), append = true)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val buf = scp.requiredArg<ObjBuffer>(0)
|
||||
self.secured.writeBytes(self.path, buf.byteArray.asByteArray(), append = true)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// readUtf8(): String
|
||||
addFnDoc(
|
||||
name = "readUtf8",
|
||||
doc = "Read the file as a UTF-8 string.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
self.secured.readUtf8(self.path).toObj()
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
self.secured.readUtf8(self.path).toObj()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// writeUtf8(text: String)
|
||||
addFnDoc(
|
||||
name = "writeUtf8",
|
||||
doc = "Write a UTF-8 string to the file, replacing content.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val text = requireOnlyArg<ObjString>().value
|
||||
self.secured.writeUtf8(self.path, text, append = false)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val text = scp.requireOnlyArg<ObjString>().value
|
||||
self.secured.writeUtf8(self.path, text, append = false)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// appendUtf8(text: String)
|
||||
addFnDoc(
|
||||
name = "appendUtf8",
|
||||
doc = "Append UTF-8 text to the end of the file.",
|
||||
params = listOf(ParamDoc("text", type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val text = requireOnlyArg<ObjString>().value
|
||||
self.secured.writeUtf8(self.path, text, append = true)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val text = scp.requireOnlyArg<ObjString>().value
|
||||
self.secured.writeUtf8(self.path, text, append = true)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// metadata(): Map
|
||||
addFnDoc(
|
||||
name = "metadata",
|
||||
doc = "Fetch cached metadata as a map of fields: `isFile`, `isDirectory`, `size`, `createdAtMillis`, `modifiedAtMillis`, `isSymlink`.",
|
||||
returns = TypeGenericDoc(type("lyng.Map"), listOf(type("lyng.String"), type("lyng.Any"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val m = self.secured.metadata(self.path)
|
||||
ObjMap(mutableMapOf(
|
||||
ObjString("isFile") to ObjBool(m.isRegularFile),
|
||||
ObjString("isDirectory") to ObjBool(m.isDirectory),
|
||||
ObjString("size") to (m.size ?: 0L).toObj(),
|
||||
ObjString("createdAtMillis") to (m.createdAtMillis ?: 0L).toObj(),
|
||||
ObjString("modifiedAtMillis") to (m.modifiedAtMillis ?: 0L).toObj(),
|
||||
ObjString("isSymlink") to ObjBool(m.isSymlink),
|
||||
))
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val m = self.secured.metadata(self.path)
|
||||
ObjMap(mutableMapOf(
|
||||
ObjString("isFile") to ObjBool(m.isRegularFile),
|
||||
ObjString("isDirectory") to ObjBool(m.isDirectory),
|
||||
ObjString("size") to (m.size?.toLong() ?: 0L).toObj(),
|
||||
ObjString("createdAtMillis") to ((m.createdAtMillis ?: 0L)).toObj(),
|
||||
ObjString("modifiedAtMillis") to ((m.modifiedAtMillis ?: 0L)).toObj(),
|
||||
ObjString("isSymlink") to ObjBool(m.isSymlink),
|
||||
))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// mkdirs(mustCreate: Bool=false)
|
||||
addFnDoc(
|
||||
name = "mkdirs",
|
||||
doc = "Create directories (like `mkdir -p`). If `mustCreate` is true and the path already exists, the call fails. Otherwise it is a no‑op when the directory exists.",
|
||||
params = listOf(ParamDoc("mustCreate", type("lyng.Bool"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val mustCreate = args.list.getOrNull(0)?.toBool() ?: false
|
||||
self.secured.createDirectories(self.path, mustCreate)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val mustCreate = scp.args.list.getOrNull(0)?.toBool() ?: false
|
||||
self.secured.createDirectories(self.path, mustCreate)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// move(to: Path|String, overwrite: Bool=false)
|
||||
addFnDoc(
|
||||
name = "move",
|
||||
doc = "Move this path to a new location. `to` may be a `Path` or `String`. When `overwrite` is false and the target exists, the operation fails (provider may throw `AccessDeniedException`).",
|
||||
// types vary; keep generic description in doc
|
||||
params = listOf(ParamDoc("to"), ParamDoc("overwrite", type("lyng.Bool"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val toPath = parsePathArg(this, self, requiredArg<Obj>(0))
|
||||
val overwrite = args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.move(self.path, toPath, overwrite)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val toPath = parsePathArg(scp, self, scp.requiredArg<Obj>(0))
|
||||
val overwrite = scp.args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.move(self.path, toPath, overwrite)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// delete(mustExist: Bool=false, recursively: Bool=false)
|
||||
addFnDoc(
|
||||
name = "delete",
|
||||
doc = "Delete this path. `mustExist=true` causes failure if the path does not exist. `recursively=true` removes directories with their contents. Providers can throw `AccessDeniedException` on policy violations.",
|
||||
params = listOf(ParamDoc("mustExist", type("lyng.Bool")), ParamDoc("recursively", type("lyng.Bool"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val mustExist = args.list.getOrNull(0)?.toBool() ?: false
|
||||
val recursively = args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.delete(self.path, mustExist, recursively)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val mustExist = scp.args.list.getOrNull(0)?.toBool() ?: false
|
||||
val recursively = scp.args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.delete(self.path, mustExist, recursively)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// copy(to: Path|String, overwrite: Bool=false)
|
||||
addFnDoc(
|
||||
name = "copy",
|
||||
doc = "Copy this path to a new location. `to` may be a `Path` or `String`. When `overwrite` is false and the target exists, the operation fails (provider may throw `AccessDeniedException`).",
|
||||
params = listOf(ParamDoc("to"), ParamDoc("overwrite", type("lyng.Bool"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val toPath = parsePathArg(this, self, requiredArg<Obj>(0))
|
||||
val overwrite = args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.copy(self.path, toPath, overwrite)
|
||||
ObjVoid
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val toPath = parsePathArg(scp, self, scp.requiredArg<Obj>(0))
|
||||
val overwrite = scp.args.list.getOrNull(1)?.toBool() ?: false
|
||||
self.secured.copy(self.path, toPath, overwrite)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
// glob(pattern: String): List<Path>
|
||||
addFnDoc(
|
||||
name = "glob",
|
||||
doc = "List entries matching a glob pattern (no recursion).",
|
||||
params = listOf(ParamDoc("pattern", type("lyng.String"))),
|
||||
returns = TypeGenericDoc(type("lyng.List"), listOf(type("Path"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val pattern = requireOnlyArg<ObjString>().value
|
||||
val matches = self.secured.glob(self.path, pattern)
|
||||
ObjList(matches.map { ObjPath(self.objClass, self.secured, it) }.toMutableList())
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val pattern = scp.requireOnlyArg<ObjString>().value
|
||||
val matches = self.secured.glob(self.path, pattern)
|
||||
ObjList(matches.map { ObjPath(self.objClass, self.secured, it) }.toMutableList())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
// --- streaming readers (initial version: chunk from whole content, API stable) ---
|
||||
|
||||
@ -405,15 +479,18 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
|
||||
doc = "Read file in fixed-size chunks as an iterator of `Buffer`.",
|
||||
params = listOf(ParamDoc("size", type("lyng.Int"))),
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.Buffer"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val size = args.list.getOrNull(0)?.toInt() ?: 65536
|
||||
val bytes = self.secured.readBytes(self.path)
|
||||
ObjFsBytesIterator(bytes, size)
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val size = scp.args.list.getOrNull(0)?.toInt() ?: 65536
|
||||
val bytes = self.secured.readBytes(self.path)
|
||||
ObjFsBytesIterator(bytes, size)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
// readUtf8Chunks(size: Int = 65536) -> Iterator<String>
|
||||
addFnDoc(
|
||||
@ -421,28 +498,34 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
|
||||
doc = "Read UTF-8 text in fixed-size chunks as an iterator of `String`.",
|
||||
params = listOf(ParamDoc("size", type("lyng.Int"))),
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val self = this.thisObj as ObjPath
|
||||
val size = args.list.getOrNull(0)?.toInt() ?: 65536
|
||||
val text = self.secured.readUtf8(self.path)
|
||||
ObjFsStringChunksIterator(text, size)
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val self = scp.thisObj as ObjPath
|
||||
val size = scp.args.list.getOrNull(0)?.toInt() ?: 65536
|
||||
val text = self.secured.readUtf8(self.path)
|
||||
ObjFsStringChunksIterator(text, size)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
// lines() -> Iterator<String>, implemented via readUtf8Chunks
|
||||
addFnDoc(
|
||||
name = "lines",
|
||||
doc = "Iterate lines of the file as `String` values.",
|
||||
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
fsGuard {
|
||||
val chunkIt = thisObj.invokeInstanceMethod(requireScope(), "readUtf8Chunks")
|
||||
ObjFsLinesIterator(chunkIt)
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.fsGuard {
|
||||
val chunkIt = scp.thisObj.invokeInstanceMethod(scp, "readUtf8Chunks")
|
||||
ObjFsLinesIterator(chunkIt)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
// Export into the module scope with docs
|
||||
@ -465,7 +548,7 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
|
||||
|
||||
// --- Helper classes and utilities ---
|
||||
|
||||
private fun parsePathArg(scope: ScopeFacade, self: ObjPath, arg: Obj): LyngPath {
|
||||
private fun parsePathArg(scope: Scope, self: ObjPath, arg: Obj): LyngPath {
|
||||
return when (arg) {
|
||||
is ObjString -> arg.value.toPath()
|
||||
is ObjPath -> arg.path
|
||||
@ -474,11 +557,11 @@ private fun parsePathArg(scope: ScopeFacade, self: ObjPath, arg: Obj): LyngPath
|
||||
}
|
||||
|
||||
// Map Fs access denials to Lyng runtime exceptions for script-friendly errors
|
||||
private suspend inline fun ScopeFacade.fsGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
private suspend inline fun Scope.fsGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: AccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "access denied")
|
||||
raiseError(ObjIllegalOperationException(this, e.reasonDetail ?: "access denied"))
|
||||
}
|
||||
}
|
||||
|
||||
@ -520,39 +603,51 @@ class ObjFsBytesIterator(
|
||||
name = "iterator",
|
||||
doc = "Return this iterator instance (enables `for` loops).",
|
||||
returns = type("BytesIterator"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) { thisObj }
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = scp.thisObj
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "hasNext",
|
||||
doc = "Whether there is another chunk available.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsBytesIterator>()
|
||||
(self.pos < self.data.size).toObj()
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsBytesIterator>()
|
||||
return (self.pos < self.data.size).toObj()
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "next",
|
||||
doc = "Return the next chunk as a `Buffer`.",
|
||||
returns = type("lyng.Buffer"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsBytesIterator>()
|
||||
if (self.pos >= self.data.size) raiseIllegalState("iterator exhausted")
|
||||
val end = minOf(self.pos + self.chunkSize, self.data.size)
|
||||
val chunk = self.data.copyOfRange(self.pos, end)
|
||||
self.pos = end
|
||||
ObjBuffer(chunk.asUByteArray())
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsBytesIterator>()
|
||||
if (self.pos >= self.data.size) scp.raiseIllegalState("iterator exhausted")
|
||||
val end = minOf(self.pos + self.chunkSize, self.data.size)
|
||||
val chunk = self.data.copyOfRange(self.pos, end)
|
||||
self.pos = end
|
||||
return ObjBuffer(chunk.asUByteArray())
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "cancelIteration",
|
||||
doc = "Stop the iteration early; subsequent `hasNext` returns false.",
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsBytesIterator>()
|
||||
self.pos = self.data.size
|
||||
ObjVoid
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsBytesIterator>()
|
||||
self.pos = self.data.size
|
||||
return ObjVoid
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -575,35 +670,47 @@ class ObjFsStringChunksIterator(
|
||||
name = "iterator",
|
||||
doc = "Return this iterator instance (enables `for` loops).",
|
||||
returns = type("StringChunksIterator"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) { thisObj }
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = scp.thisObj
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "hasNext",
|
||||
doc = "Whether there is another chunk available.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsStringChunksIterator>()
|
||||
(self.pos < self.text.length).toObj()
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsStringChunksIterator>()
|
||||
return (self.pos < self.text.length).toObj()
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "next",
|
||||
doc = "Return the next UTF-8 chunk as a `String`.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsStringChunksIterator>()
|
||||
if (self.pos >= self.text.length) raiseIllegalState("iterator exhausted")
|
||||
val end = minOf(self.pos + self.chunkChars, self.text.length)
|
||||
val chunk = self.text.substring(self.pos, end)
|
||||
self.pos = end
|
||||
ObjString(chunk)
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsStringChunksIterator>()
|
||||
if (self.pos >= self.text.length) scp.raiseIllegalState("iterator exhausted")
|
||||
val end = minOf(self.pos + self.chunkChars, self.text.length)
|
||||
val chunk = self.text.substring(self.pos, end)
|
||||
self.pos = end
|
||||
return ObjString(chunk)
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "cancelIteration",
|
||||
doc = "Stop the iteration early; subsequent `hasNext` returns false.",
|
||||
moduleName = "lyng.io.fs"
|
||||
) { ObjVoid }
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = ObjVoid
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -626,61 +733,72 @@ class ObjFsLinesIterator(
|
||||
name = "iterator",
|
||||
doc = "Return this iterator instance (enables `for` loops).",
|
||||
returns = type("LinesIterator"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) { thisObj }
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = scp.thisObj
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "hasNext",
|
||||
doc = "Whether another line is available.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsLinesIterator>()
|
||||
self.ensureBufferFilled(this)
|
||||
(self.buffer.isNotEmpty() || !self.exhausted).toObj()
|
||||
}
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsLinesIterator>()
|
||||
self.ensureBufferFilled(scp)
|
||||
return (self.buffer.isNotEmpty() || !self.exhausted).toObj()
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "next",
|
||||
doc = "Return the next line as `String`.",
|
||||
returns = type("lyng.String"),
|
||||
moduleName = "lyng.io.fs"
|
||||
) {
|
||||
val self = thisAs<ObjFsLinesIterator>()
|
||||
self.ensureBufferFilled(this)
|
||||
if (self.buffer.isEmpty() && self.exhausted) raiseIllegalState("iterator exhausted")
|
||||
val idx = self.buffer.indexOf('\n')
|
||||
val line = if (idx >= 0) {
|
||||
val l = self.buffer.substring(0, idx)
|
||||
self.buffer = self.buffer.substring(idx + 1)
|
||||
l
|
||||
} else {
|
||||
// last line without trailing newline
|
||||
val l = self.buffer
|
||||
self.buffer = ""
|
||||
self.exhausted = true
|
||||
l
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjFsLinesIterator>()
|
||||
self.ensureBufferFilled(scp)
|
||||
if (self.buffer.isEmpty() && self.exhausted) scp.raiseIllegalState("iterator exhausted")
|
||||
val idx = self.buffer.indexOf('\n')
|
||||
val line = if (idx >= 0) {
|
||||
val l = self.buffer.substring(0, idx)
|
||||
self.buffer = self.buffer.substring(idx + 1)
|
||||
l
|
||||
} else {
|
||||
// last line without trailing newline
|
||||
val l = self.buffer
|
||||
self.buffer = ""
|
||||
self.exhausted = true
|
||||
l
|
||||
}
|
||||
return ObjString(line)
|
||||
}
|
||||
}
|
||||
ObjString(line)
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "cancelIteration",
|
||||
doc = "Stop the iteration early; subsequent `hasNext` returns false.",
|
||||
moduleName = "lyng.io.fs"
|
||||
) { ObjVoid }
|
||||
moduleName = "lyng.io.fs",
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = ObjVoid
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun ensureBufferFilled(scope: ScopeFacade) {
|
||||
private suspend fun ensureBufferFilled(scope: Scope) {
|
||||
if (buffer.contains('\n') || exhausted) return
|
||||
val actualScope = scope.requireScope()
|
||||
// Pull next chunk from the underlying iterator
|
||||
val it = chunksIterator.invokeInstanceMethod(actualScope, "iterator")
|
||||
val hasNext = it.invokeInstanceMethod(actualScope, "hasNext").toBool()
|
||||
val it = chunksIterator.invokeInstanceMethod(scope, "iterator")
|
||||
val hasNext = it.invokeInstanceMethod(scope, "hasNext").toBool()
|
||||
if (!hasNext) {
|
||||
exhausted = true
|
||||
return
|
||||
}
|
||||
val next = it.invokeInstanceMethod(actualScope, "next")
|
||||
val next = it.invokeInstanceMethod(scope, "next")
|
||||
buffer += next.toString()
|
||||
}
|
||||
}
|
||||
|
||||
@ -20,11 +20,12 @@ package net.sergeych.lyng.io.process
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import net.sergeych.lyng.ModuleScope
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.ScopeFacade
|
||||
import net.sergeych.lyng.ScopeCallable
|
||||
import net.sergeych.lyng.miniast.*
|
||||
import net.sergeych.lyng.obj.*
|
||||
import net.sergeych.lyng.pacman.ImportManager
|
||||
import net.sergeych.lyng.requireScope
|
||||
import net.sergeych.lyng.pacman.ModuleBuilder
|
||||
import net.sergeych.lyng.statement
|
||||
import net.sergeych.lyngio.process.*
|
||||
import net.sergeych.lyngio.process.security.ProcessAccessDeniedException
|
||||
import net.sergeych.lyngio.process.security.ProcessAccessPolicy
|
||||
@ -40,9 +41,11 @@ fun createProcessModule(policy: ProcessAccessPolicy, manager: ImportManager): Bo
|
||||
val name = "lyng.io.process"
|
||||
if (manager.packageNames.contains(name)) return false
|
||||
|
||||
manager.addPackage(name) { module ->
|
||||
buildProcessModule(module, policy)
|
||||
}
|
||||
manager.addPackage(name, object : ModuleBuilder {
|
||||
override suspend fun build(module: ModuleScope) {
|
||||
buildProcessModule(module, policy)
|
||||
}
|
||||
})
|
||||
return true
|
||||
}
|
||||
|
||||
@ -60,59 +63,74 @@ private suspend fun buildProcessModule(module: ModuleScope, policy: ProcessAcces
|
||||
name = "stdout",
|
||||
doc = "Get standard output stream as a Flow of lines.",
|
||||
returns = type("lyng.Flow"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val self = thisAs<ObjRunningProcess>()
|
||||
self.process.stdout.toLyngFlow(this)
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjRunningProcess>()
|
||||
return self.process.stdout.toLyngFlow(scp)
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "stderr",
|
||||
doc = "Get standard error stream as a Flow of lines.",
|
||||
returns = type("lyng.Flow"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val self = thisAs<ObjRunningProcess>()
|
||||
self.process.stderr.toLyngFlow(this)
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val self = scp.thisAs<ObjRunningProcess>()
|
||||
return self.process.stderr.toLyngFlow(scp)
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "signal",
|
||||
doc = "Send a signal to the process (e.g. 'SIGINT', 'SIGTERM', 'SIGKILL').",
|
||||
params = listOf(ParamDoc("signal", type("lyng.String"))),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
processGuard {
|
||||
val sigStr = requireOnlyArg<ObjString>().value.uppercase()
|
||||
val sig = try {
|
||||
ProcessSignal.valueOf(sigStr)
|
||||
} catch (e: Exception) {
|
||||
try {
|
||||
ProcessSignal.valueOf("SIG$sigStr")
|
||||
} catch (e2: Exception) {
|
||||
raiseIllegalArgument("Unknown signal: $sigStr")
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.processGuard {
|
||||
val sigStr = scp.requireOnlyArg<ObjString>().value.uppercase()
|
||||
val sig = try {
|
||||
ProcessSignal.valueOf(sigStr)
|
||||
} catch (e: Exception) {
|
||||
try {
|
||||
ProcessSignal.valueOf("SIG$sigStr")
|
||||
} catch (e2: Exception) {
|
||||
scp.raiseIllegalArgument("Unknown signal: $sigStr")
|
||||
}
|
||||
}
|
||||
scp.thisAs<ObjRunningProcess>().process.sendSignal(sig)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
thisAs<ObjRunningProcess>().process.sendSignal(sig)
|
||||
ObjVoid
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "waitFor",
|
||||
doc = "Wait for the process to exit and return its exit code.",
|
||||
returns = type("lyng.Int"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
processGuard {
|
||||
thisAs<ObjRunningProcess>().process.waitFor().toObj()
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
return scp.processGuard {
|
||||
scp.thisAs<ObjRunningProcess>().process.waitFor().toObj()
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
addFnDoc(
|
||||
name = "destroy",
|
||||
doc = "Forcefully terminate the process.",
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
thisAs<ObjRunningProcess>().process.destroy()
|
||||
ObjVoid
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
scp.thisAs<ObjRunningProcess>().process.destroy()
|
||||
return ObjVoid
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
val processType = object : ObjClass("Process") {}
|
||||
@ -123,30 +141,36 @@ private suspend fun buildProcessModule(module: ModuleScope, policy: ProcessAcces
|
||||
doc = "Execute a process with arguments.",
|
||||
params = listOf(ParamDoc("executable", type("lyng.String")), ParamDoc("args", type("lyng.List"))),
|
||||
returns = type("RunningProcess"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
if (runner == null) raiseError("Processes are not supported on this platform")
|
||||
processGuard {
|
||||
val executable = requiredArg<ObjString>(0).value
|
||||
val args = requiredArg<ObjList>(1).list.map { it.toString() }
|
||||
val lp = runner.execute(executable, args)
|
||||
ObjRunningProcess(runningProcessType, lp)
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
if (runner == null) scp.raiseError("Processes are not supported on this platform")
|
||||
return scp.processGuard {
|
||||
val executable = scp.requiredArg<ObjString>(0).value
|
||||
val args = scp.requiredArg<ObjList>(1).list.map { it.toString() }
|
||||
val lp = runner.execute(executable, args)
|
||||
ObjRunningProcess(runningProcessType, lp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
addClassFnDoc(
|
||||
name = "shell",
|
||||
doc = "Execute a command via system shell.",
|
||||
params = listOf(ParamDoc("command", type("lyng.String"))),
|
||||
returns = type("RunningProcess"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
if (runner == null) raiseError("Processes are not supported on this platform")
|
||||
processGuard {
|
||||
val command = requireOnlyArg<ObjString>().value
|
||||
val lp = runner.shell(command)
|
||||
ObjRunningProcess(runningProcessType, lp)
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
if (runner == null) scp.raiseError("Processes are not supported on this platform")
|
||||
return scp.processGuard {
|
||||
val command = scp.requireOnlyArg<ObjString>().value
|
||||
val lp = runner.shell(command)
|
||||
ObjRunningProcess(runningProcessType, lp)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
val platformType = object : ObjClass("Platform") {}
|
||||
@ -156,24 +180,28 @@ private suspend fun buildProcessModule(module: ModuleScope, policy: ProcessAcces
|
||||
name = "details",
|
||||
doc = "Get platform core details.",
|
||||
returns = type("lyng.Map"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
val d = getPlatformDetails()
|
||||
ObjMap(mutableMapOf(
|
||||
ObjString("name") to ObjString(d.name),
|
||||
ObjString("version") to ObjString(d.version),
|
||||
ObjString("arch") to ObjString(d.arch),
|
||||
ObjString("kernelVersion") to (d.kernelVersion?.toObj() ?: ObjNull)
|
||||
))
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val d = getPlatformDetails()
|
||||
return ObjMap(mutableMapOf(
|
||||
ObjString("name") to ObjString(d.name),
|
||||
ObjString("version") to ObjString(d.version),
|
||||
ObjString("arch") to ObjString(d.arch),
|
||||
ObjString("kernelVersion") to (d.kernelVersion?.toObj() ?: ObjNull)
|
||||
))
|
||||
}
|
||||
}
|
||||
)
|
||||
addClassFnDoc(
|
||||
name = "isSupported",
|
||||
doc = "Check if processes are supported on this platform.",
|
||||
returns = type("lyng.Bool"),
|
||||
moduleName = module.packageName
|
||||
) {
|
||||
isProcessSupported().toObj()
|
||||
}
|
||||
moduleName = module.packageName,
|
||||
code = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj = isProcessSupported().toObj()
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
module.addConstDoc(
|
||||
@ -206,31 +234,32 @@ class ObjRunningProcess(
|
||||
override fun toString(): String = "RunningProcess($process)"
|
||||
}
|
||||
|
||||
private suspend inline fun ScopeFacade.processGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
private suspend inline fun Scope.processGuard(crossinline block: suspend () -> Obj): Obj {
|
||||
return try {
|
||||
block()
|
||||
} catch (e: ProcessAccessDeniedException) {
|
||||
raiseIllegalOperation(e.reasonDetail ?: "process access denied")
|
||||
raiseError(ObjIllegalOperationException(this, e.reasonDetail ?: "process access denied"))
|
||||
} catch (e: Exception) {
|
||||
raiseIllegalOperation(e.message ?: "process error")
|
||||
raiseError(ObjIllegalOperationException(this, e.message ?: "process error"))
|
||||
}
|
||||
}
|
||||
|
||||
private fun Flow<String>.toLyngFlow(flowScope: ScopeFacade): ObjFlow {
|
||||
val producer = net.sergeych.lyng.obj.ObjExternCallable.fromBridge {
|
||||
val scope = requireScope()
|
||||
val builder = (scope as? net.sergeych.lyng.BytecodeClosureScope)?.callScope?.thisObj as? ObjFlowBuilder
|
||||
?: scope.thisObj as? ObjFlowBuilder
|
||||
private fun Flow<String>.toLyngFlow(flowScope: Scope): ObjFlow {
|
||||
val producer = statement(f = object : ScopeCallable {
|
||||
override suspend fun call(scp: Scope): Obj {
|
||||
val builder = (scp as? net.sergeych.lyng.ClosureScope)?.callScope?.thisObj as? ObjFlowBuilder
|
||||
?: scp.thisObj as? ObjFlowBuilder
|
||||
|
||||
this@toLyngFlow.collect {
|
||||
try {
|
||||
builder?.output?.send(ObjString(it))
|
||||
} catch (e: Exception) {
|
||||
// Channel closed or other error, stop collecting
|
||||
return@collect
|
||||
this@toLyngFlow.collect {
|
||||
try {
|
||||
builder?.output?.send(ObjString(it))
|
||||
} catch (e: Exception) {
|
||||
// Channel closed or other error, stop collecting
|
||||
return@collect
|
||||
}
|
||||
}
|
||||
return ObjVoid
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
return ObjFlow(producer, flowScope.requireScope())
|
||||
})
|
||||
return ObjFlow(producer, flowScope)
|
||||
}
|
||||
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal expect fun consoleFlowDebug(message: String, error: Throwable? = null)
|
||||
@ -1,132 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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
|
||||
}
|
||||
@ -1,292 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
import com.github.ajalt.mordant.input.KeyboardEvent
|
||||
import com.github.ajalt.mordant.input.RawModeScope
|
||||
import com.github.ajalt.mordant.input.enterRawModeOrNull
|
||||
import com.github.ajalt.mordant.rendering.AnsiLevel
|
||||
import com.github.ajalt.mordant.terminal.Terminal
|
||||
import kotlinx.coroutines.*
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import net.sergeych.lyng.ScriptFlowIsNoMoreCollected
|
||||
import net.sergeych.mp_tools.globalLaunch
|
||||
import kotlin.time.Duration.Companion.milliseconds
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
import kotlin.time.TimeSource
|
||||
|
||||
/**
|
||||
* Mordant-backed console runtime implementation.
|
||||
*/
|
||||
object MordantLyngConsole : LyngConsole {
|
||||
private val terminal: Terminal? by lazy {
|
||||
runCatching { Terminal() }.getOrNull()
|
||||
}
|
||||
|
||||
private val stateMutex = Mutex()
|
||||
private var rawModeRequested: Boolean = false
|
||||
private var rawModeScope: RawModeScope? = null
|
||||
|
||||
private suspend fun forceRawModeReset(t: Terminal): Boolean = stateMutex.withLock {
|
||||
if (!rawModeRequested) return@withLock false
|
||||
runCatching { rawModeScope?.close() }
|
||||
.onFailure { consoleFlowDebug("forceRawModeReset: close failed", it) }
|
||||
rawModeScope = null
|
||||
rawModeRequested = false
|
||||
if (!t.terminalInfo.inputInteractive) return@withLock false
|
||||
val reopened = t.enterRawModeOrNull()
|
||||
rawModeScope = reopened
|
||||
rawModeRequested = reopened != null
|
||||
reopened != null
|
||||
}
|
||||
|
||||
override val isSupported: Boolean
|
||||
get() = terminal != null
|
||||
|
||||
override suspend fun isTty(): Boolean {
|
||||
val t = terminal ?: return false
|
||||
return t.terminalInfo.outputInteractive
|
||||
}
|
||||
|
||||
override suspend fun geometry(): ConsoleGeometry? {
|
||||
val t = terminal ?: return null
|
||||
val size = t.updateSize()
|
||||
return ConsoleGeometry(size.width, size.height)
|
||||
}
|
||||
|
||||
override suspend fun ansiLevel(): ConsoleAnsiLevel {
|
||||
val t = terminal ?: return ConsoleAnsiLevel.NONE
|
||||
return when (t.terminalInfo.ansiLevel) {
|
||||
AnsiLevel.NONE -> ConsoleAnsiLevel.NONE
|
||||
AnsiLevel.ANSI16 -> ConsoleAnsiLevel.BASIC16
|
||||
AnsiLevel.ANSI256 -> ConsoleAnsiLevel.ANSI256
|
||||
AnsiLevel.TRUECOLOR -> ConsoleAnsiLevel.TRUECOLOR
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun write(text: String) {
|
||||
terminal?.rawPrint(text)
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
// Mordant prints via platform streams immediately.
|
||||
}
|
||||
|
||||
override fun events(): ConsoleEventSource {
|
||||
val t = terminal ?: return object : ConsoleEventSource {
|
||||
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
|
||||
|
||||
override suspend fun close() {}
|
||||
}
|
||||
val out = Channel<ConsoleEvent>(Channel.UNLIMITED)
|
||||
val sourceState = Mutex()
|
||||
var running = true
|
||||
|
||||
globalLaunch {
|
||||
val initialSize = runCatching { t.updateSize() }.getOrNull()
|
||||
var lastWidth = initialSize?.width ?: 0
|
||||
var lastHeight = initialSize?.height ?: 0
|
||||
val startMark = TimeSource.Monotonic.markNow()
|
||||
var lastHeartbeatMark = startMark
|
||||
var loops = 0L
|
||||
var readAttempts = 0L
|
||||
var readFailures = 0L
|
||||
var keyEvents = 0L
|
||||
var resizeEvents = 0L
|
||||
var rawNullLoops = 0L
|
||||
var lastKeyMark = startMark
|
||||
var lastRawRecoveryMark = startMark
|
||||
|
||||
fun tryEmitResize(width: Int, height: Int) {
|
||||
if (width < 1 || height < 1) {
|
||||
consoleFlowDebug("events: ignored invalid resize width=$width height=$height")
|
||||
return
|
||||
}
|
||||
if (width == lastWidth && height == lastHeight) return
|
||||
out.trySend(ConsoleEvent.Resize(width, height))
|
||||
lastWidth = width
|
||||
lastHeight = height
|
||||
resizeEvents += 1
|
||||
}
|
||||
|
||||
consoleFlowDebug("events: collector started")
|
||||
try {
|
||||
while (currentCoroutineContext().isActive && sourceState.withLock { running }) {
|
||||
loops += 1
|
||||
val currentSize = runCatching { t.updateSize() }.getOrNull()
|
||||
if (currentSize == null) {
|
||||
delay(150)
|
||||
continue
|
||||
}
|
||||
tryEmitResize(currentSize.width, currentSize.height)
|
||||
|
||||
val raw = stateMutex.withLock {
|
||||
if (!rawModeRequested) {
|
||||
null
|
||||
} else {
|
||||
// Recover raw scope lazily if it was dropped due to an earlier read failure.
|
||||
if (rawModeScope == null) {
|
||||
rawModeScope = t.enterRawModeOrNull()
|
||||
if (rawModeScope == null) {
|
||||
consoleFlowDebug("events: failed to reopen raw mode scope")
|
||||
} else {
|
||||
consoleFlowDebug("events: raw mode scope reopened")
|
||||
}
|
||||
}
|
||||
rawModeScope
|
||||
}
|
||||
}
|
||||
if (raw == null || !t.terminalInfo.inputInteractive) {
|
||||
rawNullLoops += 1
|
||||
delay(150)
|
||||
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
|
||||
consoleFlowDebug(
|
||||
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
|
||||
)
|
||||
lastHeartbeatMark = TimeSource.Monotonic.markNow()
|
||||
}
|
||||
continue
|
||||
}
|
||||
|
||||
readAttempts += 1
|
||||
val readResult = runCatching { raw.readEventOrNull(150.milliseconds) }
|
||||
if (readResult.isFailure) {
|
||||
readFailures += 1
|
||||
consoleFlowDebug("events: readEventOrNull failed; resetting raw scope", readResult.exceptionOrNull())
|
||||
// Raw scope became invalid; close and force reopen on next iteration.
|
||||
stateMutex.withLock {
|
||||
runCatching { rawModeScope?.close() }
|
||||
rawModeScope = null
|
||||
}
|
||||
delay(50)
|
||||
continue
|
||||
}
|
||||
val ev = readResult.getOrNull()
|
||||
|
||||
val resized = runCatching { t.updateSize() }.getOrNull()
|
||||
if (resized != null) {
|
||||
tryEmitResize(resized.width, resized.height)
|
||||
}
|
||||
|
||||
when (ev) {
|
||||
is KeyboardEvent -> {
|
||||
keyEvents += 1
|
||||
lastKeyMark = TimeSource.Monotonic.markNow()
|
||||
out.trySend(
|
||||
ConsoleEvent.KeyDown(
|
||||
key = ev.key,
|
||||
code = null,
|
||||
ctrl = ev.ctrl,
|
||||
alt = ev.alt,
|
||||
shift = ev.shift,
|
||||
meta = false,
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
else -> {
|
||||
// Mouse/other events are ignored in Lyng console v1.
|
||||
}
|
||||
}
|
||||
|
||||
// Some terminals silently stop delivering keyboard events while raw reads keep succeeding.
|
||||
// If we had keys before and then prolonged key inactivity, proactively recycle raw scope.
|
||||
if (keyEvents > 0L &&
|
||||
lastKeyMark.elapsedNow() >= 4.seconds &&
|
||||
lastRawRecoveryMark.elapsedNow() >= 4.seconds
|
||||
) {
|
||||
if (rawModeRequested) {
|
||||
consoleFlowDebug("events: key inactivity detected; forcing raw reset")
|
||||
val resetOk = forceRawModeReset(t)
|
||||
if (resetOk) {
|
||||
consoleFlowDebug("events: raw reset succeeded during inactivity recovery")
|
||||
lastKeyMark = TimeSource.Monotonic.markNow()
|
||||
} else {
|
||||
consoleFlowDebug("events: raw reset failed during inactivity recovery")
|
||||
}
|
||||
lastRawRecoveryMark = TimeSource.Monotonic.markNow()
|
||||
}
|
||||
}
|
||||
|
||||
if (lastHeartbeatMark.elapsedNow() >= 2.seconds) {
|
||||
consoleFlowDebug(
|
||||
"events: heartbeat loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested inputInteractive=${t.terminalInfo.inputInteractive}"
|
||||
)
|
||||
lastHeartbeatMark = TimeSource.Monotonic.markNow()
|
||||
}
|
||||
}
|
||||
} catch (e: CancellationException) {
|
||||
consoleFlowDebug("events: collector cancelled (normal)")
|
||||
// normal
|
||||
} catch (e: ScriptFlowIsNoMoreCollected) {
|
||||
consoleFlowDebug("events: collector stopped by flow consumer (normal)")
|
||||
// normal
|
||||
} catch (e: Exception) {
|
||||
consoleFlowDebug("events: collector loop failed", e)
|
||||
// terminate event source loop
|
||||
} finally {
|
||||
consoleFlowDebug(
|
||||
"events: collector ended uptime=${startMark.elapsedNow().inWholeMilliseconds}ms loops=$loops reads=$readAttempts readFailures=$readFailures keys=$keyEvents resize=$resizeEvents rawNullLoops=$rawNullLoops rawRequested=$rawModeRequested"
|
||||
)
|
||||
out.close()
|
||||
}
|
||||
}
|
||||
|
||||
return object : ConsoleEventSource {
|
||||
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
|
||||
if (timeoutMs <= 0L) {
|
||||
return out.receiveCatching().getOrNull()
|
||||
}
|
||||
return withTimeoutOrNull(timeoutMs.milliseconds) {
|
||||
out.receiveCatching().getOrNull()
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun close() {
|
||||
sourceState.withLock { running = false }
|
||||
out.close()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun setRawMode(enabled: Boolean): Boolean {
|
||||
val t = terminal ?: return false
|
||||
return stateMutex.withLock {
|
||||
if (enabled) {
|
||||
if (!t.terminalInfo.inputInteractive) return@withLock false
|
||||
if (rawModeRequested) return@withLock false
|
||||
val scope = t.enterRawModeOrNull() ?: return@withLock false
|
||||
rawModeScope = scope
|
||||
rawModeRequested = true
|
||||
consoleFlowDebug("setRawMode(true): enabled")
|
||||
true
|
||||
} else {
|
||||
val hadRaw = rawModeRequested || rawModeScope != null
|
||||
rawModeRequested = false
|
||||
val scope = rawModeScope
|
||||
rawModeScope = null
|
||||
runCatching { scope?.close() }
|
||||
.onFailure { consoleFlowDebug("setRawMode(false): close failed", it) }
|
||||
consoleFlowDebug("setRawMode(false): disabled hadRaw=$hadRaw")
|
||||
hadRaw
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
/**
|
||||
* Get the system default console implementation.
|
||||
*/
|
||||
expect fun getSystemConsole(): LyngConsole
|
||||
@ -1,55 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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)
|
||||
}
|
||||
@ -1,68 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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)
|
||||
}
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.docs
|
||||
|
||||
/**
|
||||
* Console docs are declared in `lyngio/stdlib/lyng/io/console.lyng`.
|
||||
* Keep this shim for compatibility with reflective loaders.
|
||||
*/
|
||||
object ConsoleBuiltinDocs {
|
||||
fun ensure() {
|
||||
// No Kotlin-side doc registration: console.lyng is the source of truth.
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||
// no-op on JS
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
actual fun getSystemConsole(): LyngConsole = MordantLyngConsole
|
||||
@ -1,46 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,602 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
import kotlinx.coroutines.channels.Channel
|
||||
import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.coroutines.withTimeoutOrNull
|
||||
import org.jline.terminal.Attributes
|
||||
import org.jline.terminal.Terminal
|
||||
import org.jline.terminal.TerminalBuilder
|
||||
import org.jline.utils.NonBlockingReader
|
||||
import java.io.EOFException
|
||||
import java.io.InterruptedIOException
|
||||
import java.util.*
|
||||
import java.util.concurrent.atomic.AtomicBoolean
|
||||
import java.util.concurrent.atomic.AtomicLong
|
||||
import java.util.concurrent.atomic.AtomicReference
|
||||
import kotlin.concurrent.thread
|
||||
import kotlin.time.Duration.Companion.milliseconds
|
||||
import kotlin.time.Duration.Companion.seconds
|
||||
import kotlin.time.TimeSource
|
||||
|
||||
/**
|
||||
* JVM console implementation:
|
||||
* - output/capabilities/input use a single JLine terminal instance
|
||||
* to avoid dual-terminal contention.
|
||||
*/
|
||||
object JvmLyngConsole : LyngConsole {
|
||||
private const val DEBUG_REVISION = "jline-r27-no-close-on-vm-iterator-cancel-2026-03-19"
|
||||
private val codeSourceLocation: String by lazy {
|
||||
runCatching {
|
||||
JvmLyngConsole::class.java.protectionDomain?.codeSource?.location?.toString()
|
||||
}.getOrNull() ?: "<unknown>"
|
||||
}
|
||||
|
||||
private val terminalRef = AtomicReference<Terminal?>(null)
|
||||
private val terminalInitLock = Any()
|
||||
private val shutdownHook = Thread(
|
||||
{
|
||||
restoreTerminalStateOnShutdown()
|
||||
},
|
||||
"lyng-console-shutdown"
|
||||
).apply { isDaemon = true }
|
||||
|
||||
init {
|
||||
runCatching { Runtime.getRuntime().addShutdownHook(shutdownHook) }
|
||||
.onFailure { consoleFlowDebug("jline-events: shutdown hook install failed", it) }
|
||||
}
|
||||
|
||||
private fun restoreTerminalStateOnShutdown() {
|
||||
val term = terminalRef.get() ?: return
|
||||
runCatching {
|
||||
term.writer().print("\u001B[?25h")
|
||||
term.writer().print("\u001B[?1049l")
|
||||
term.writer().flush()
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: shutdown visual restore failed", it)
|
||||
}
|
||||
val saved = if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
|
||||
try {
|
||||
rawModeRequested = false
|
||||
val s = rawSavedAttributes
|
||||
rawSavedAttributes = null
|
||||
s
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
} else {
|
||||
null
|
||||
}
|
||||
if (saved != null) {
|
||||
runCatching { term.setAttributes(saved) }
|
||||
.onFailure { consoleFlowDebug("jline-events: shutdown raw attrs restore failed", it) }
|
||||
}
|
||||
}
|
||||
|
||||
private fun currentTerminal(): Terminal? {
|
||||
val existing = terminalRef.get()
|
||||
if (existing != null) return existing
|
||||
synchronized(terminalInitLock) {
|
||||
val already = terminalRef.get()
|
||||
if (already != null) return already
|
||||
val created = buildTerminal()
|
||||
if (created != null) terminalRef.set(created)
|
||||
return created
|
||||
}
|
||||
}
|
||||
|
||||
private fun buildTerminal(): Terminal? {
|
||||
System.setProperty(TerminalBuilder.PROP_DISABLE_DEPRECATED_PROVIDER_WARNING, "true")
|
||||
|
||||
val providerOrders = listOf(
|
||||
"exec",
|
||||
"exec,ffm",
|
||||
null,
|
||||
)
|
||||
for (providers in providerOrders) {
|
||||
val terminal = runCatching {
|
||||
val builder = TerminalBuilder.builder().system(true)
|
||||
if (providers != null) builder.providers(providers)
|
||||
builder.build()
|
||||
}.onFailure {
|
||||
if (providers != null) {
|
||||
consoleFlowDebug("jline-events: terminal build failed providers=$providers", it)
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: terminal build failed default providers", it)
|
||||
}
|
||||
}.getOrNull()
|
||||
if (terminal != null) {
|
||||
val termType = terminal.type.lowercase(Locale.getDefault())
|
||||
if (termType.contains("dumb")) {
|
||||
consoleFlowDebug("jline-events: terminal rejected providers=${providers ?: "<default>"} type=${terminal.type}")
|
||||
runCatching { terminal.close() }
|
||||
continue
|
||||
}
|
||||
consoleFlowDebug("jline-events: terminal built providers=${providers ?: "<default>"} type=${terminal.type}")
|
||||
consoleFlowDebug("jline-events: runtime-marker rev=$DEBUG_REVISION codeSource=$codeSourceLocation")
|
||||
return terminal
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
private val stateMutex = Mutex()
|
||||
private var rawModeRequested: Boolean = false
|
||||
private var rawSavedAttributes: Attributes? = null
|
||||
|
||||
private fun enforceRawReadAttrs(term: Terminal) {
|
||||
runCatching {
|
||||
val attrs = term.attributes
|
||||
attrs.setLocalFlag(Attributes.LocalFlag.ICANON, false)
|
||||
attrs.setLocalFlag(Attributes.LocalFlag.ECHO, false)
|
||||
attrs.setControlChar(Attributes.ControlChar.VMIN, 0)
|
||||
attrs.setControlChar(Attributes.ControlChar.VTIME, 1)
|
||||
term.setAttributes(attrs)
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: enforceRawReadAttrs failed", it)
|
||||
}
|
||||
}
|
||||
|
||||
override val isSupported: Boolean
|
||||
get() = currentTerminal() != null
|
||||
|
||||
override suspend fun isTty(): Boolean {
|
||||
val term = currentTerminal() ?: return false
|
||||
return !term.type.lowercase(Locale.getDefault()).contains("dumb")
|
||||
}
|
||||
|
||||
override suspend fun geometry(): ConsoleGeometry? {
|
||||
val term = currentTerminal() ?: return null
|
||||
val size = runCatching { term.size }.getOrNull() ?: return null
|
||||
if (size.columns <= 0 || size.rows <= 0) return null
|
||||
return ConsoleGeometry(size.columns, size.rows)
|
||||
}
|
||||
|
||||
override suspend fun ansiLevel(): ConsoleAnsiLevel {
|
||||
val colorTerm = (System.getenv("COLORTERM") ?: "").lowercase(Locale.getDefault())
|
||||
val term = (System.getenv("TERM") ?: "").lowercase(Locale.getDefault())
|
||||
return when {
|
||||
colorTerm.contains("truecolor") || colorTerm.contains("24bit") -> ConsoleAnsiLevel.TRUECOLOR
|
||||
term.contains("256color") -> ConsoleAnsiLevel.ANSI256
|
||||
term.isNotBlank() && term != "dumb" -> ConsoleAnsiLevel.BASIC16
|
||||
else -> ConsoleAnsiLevel.NONE
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun write(text: String) {
|
||||
val term = currentTerminal() ?: return
|
||||
term.writer().print(text)
|
||||
}
|
||||
|
||||
override suspend fun flush() {
|
||||
val term = currentTerminal() ?: return
|
||||
term.writer().flush()
|
||||
}
|
||||
|
||||
override fun events(): ConsoleEventSource {
|
||||
var activeTerm = currentTerminal() ?: return object : ConsoleEventSource {
|
||||
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? = null
|
||||
|
||||
override suspend fun close() {}
|
||||
}
|
||||
val out = Channel<ConsoleEvent>(Channel.UNLIMITED)
|
||||
val keyEvents = AtomicLong(0L)
|
||||
val keyCodesRead = AtomicLong(0L)
|
||||
val keySendFailures = AtomicLong(0L)
|
||||
val readFailures = AtomicLong(0L)
|
||||
val readerRecoveries = AtomicLong(0L)
|
||||
var lastHeartbeat = TimeSource.Monotonic.markNow()
|
||||
val keyLoopRunning = AtomicBoolean(true)
|
||||
val keyLoopCount = AtomicLong(0L)
|
||||
val keyReadStartNs = AtomicLong(0L)
|
||||
val keyReadEndNs = AtomicLong(0L)
|
||||
val lastKeyReadNs = AtomicLong(System.nanoTime())
|
||||
val lastRecoveryNs = AtomicLong(0L)
|
||||
val recoveryRequested = AtomicBoolean(false)
|
||||
val running = AtomicBoolean(true)
|
||||
var winchHandler: Terminal.SignalHandler? = null
|
||||
var reader = activeTerm.reader()
|
||||
var keyThread: Thread? = null
|
||||
var heartbeatThread: Thread? = null
|
||||
val resizeEmitMutex = Any()
|
||||
var lastResizeCols = Int.MIN_VALUE
|
||||
var lastResizeRows = Int.MIN_VALUE
|
||||
|
||||
fun emitResize() {
|
||||
val size = runCatching { activeTerm.size }.getOrNull() ?: return
|
||||
val cols = size.columns
|
||||
val rows = size.rows
|
||||
if (cols < 1 || rows < 1) {
|
||||
consoleFlowDebug("jline-events: ignored invalid resize columns=$cols rows=$rows")
|
||||
return
|
||||
}
|
||||
val shouldEmit = synchronized(resizeEmitMutex) {
|
||||
if (cols == lastResizeCols && rows == lastResizeRows) {
|
||||
false
|
||||
} else {
|
||||
lastResizeCols = cols
|
||||
lastResizeRows = rows
|
||||
true
|
||||
}
|
||||
}
|
||||
if (!shouldEmit) return
|
||||
out.trySend(ConsoleEvent.Resize(cols, rows))
|
||||
}
|
||||
|
||||
fun cleanup() {
|
||||
running.set(false)
|
||||
keyLoopRunning.set(false)
|
||||
runCatching { reader.shutdown() }
|
||||
runCatching {
|
||||
if (winchHandler != null) {
|
||||
activeTerm.handle(Terminal.Signal.WINCH, winchHandler)
|
||||
}
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: WINCH handler restore failed", it)
|
||||
}
|
||||
runCatching { keyThread?.interrupt() }
|
||||
runCatching { heartbeatThread?.interrupt() }
|
||||
out.close()
|
||||
}
|
||||
|
||||
fun installWinchHandler() {
|
||||
winchHandler = runCatching {
|
||||
activeTerm.handle(Terminal.Signal.WINCH) {
|
||||
emitResize()
|
||||
}
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: WINCH handler install failed", it)
|
||||
}.getOrNull()
|
||||
}
|
||||
|
||||
fun tryRebuildTerminal(): Boolean {
|
||||
val oldTerm = activeTerm
|
||||
val rebuilt = runCatching {
|
||||
synchronized(terminalInitLock) {
|
||||
if (terminalRef.get() === oldTerm) {
|
||||
terminalRef.set(null)
|
||||
}
|
||||
}
|
||||
runCatching { oldTerm.close() }
|
||||
.onFailure { consoleFlowDebug("jline-events: old terminal close failed during rebuild", it) }
|
||||
currentTerminal()
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: terminal rebuild failed", it)
|
||||
}.getOrNull() ?: return false
|
||||
if (rebuilt === oldTerm) {
|
||||
consoleFlowDebug("jline-events: terminal rebuild returned same terminal instance")
|
||||
return false
|
||||
}
|
||||
activeTerm = rebuilt
|
||||
reader = activeTerm.reader()
|
||||
val rawRequestedNow = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
|
||||
rawModeRequested
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
if (rawRequestedNow) {
|
||||
val saved = runCatching { activeTerm.enterRawMode() }.getOrNull()
|
||||
if (saved != null) {
|
||||
enforceRawReadAttrs(activeTerm)
|
||||
if (runCatching { stateMutex.tryLock() }.getOrNull() == true) {
|
||||
try {
|
||||
rawSavedAttributes = saved
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: terminal rebuild succeeded but enterRawMode failed")
|
||||
}
|
||||
}
|
||||
installWinchHandler()
|
||||
emitResize()
|
||||
consoleFlowDebug("jline-events: terminal rebuilt and rebound")
|
||||
return true
|
||||
}
|
||||
|
||||
consoleFlowDebug("jline-events: collector started rev=$DEBUG_REVISION")
|
||||
emitResize()
|
||||
installWinchHandler()
|
||||
|
||||
keyThread = thread(start = true, isDaemon = true, name = "lyng-jline-key-reader") {
|
||||
consoleFlowDebug("jline-events: key-reader thread started")
|
||||
consoleFlowDebug("jline-events: using NonBlockingReader key path")
|
||||
while (running.get() && keyLoopRunning.get()) {
|
||||
keyLoopCount.incrementAndGet()
|
||||
try {
|
||||
if (recoveryRequested.compareAndSet(true, false)) {
|
||||
val prevReader = reader
|
||||
runCatching { prevReader.shutdown() }
|
||||
.onFailure { consoleFlowDebug("jline-events: reader shutdown failed during recovery", it) }
|
||||
|
||||
reader = activeTerm.reader()
|
||||
if (reader === prevReader) {
|
||||
consoleFlowDebug("jline-events: reader recovery no-op oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)} -> forcing terminal rebuild")
|
||||
if (!tryRebuildTerminal()) {
|
||||
consoleFlowDebug("jline-events: forced terminal rebuild did not produce a new reader")
|
||||
}
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: reader recovered oldReader=${System.identityHashCode(prevReader)} newReader=${System.identityHashCode(reader)}")
|
||||
}
|
||||
|
||||
readerRecoveries.incrementAndGet()
|
||||
lastRecoveryNs.set(System.nanoTime())
|
||||
}
|
||||
|
||||
val isRaw = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
|
||||
rawModeRequested
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
if (!isRaw) {
|
||||
Thread.sleep(20)
|
||||
continue
|
||||
}
|
||||
keyReadStartNs.set(System.nanoTime())
|
||||
val event = readKeyEvent(reader)
|
||||
keyReadEndNs.set(System.nanoTime())
|
||||
if (event == null) {
|
||||
continue
|
||||
}
|
||||
keyCodesRead.incrementAndGet()
|
||||
lastKeyReadNs.set(System.nanoTime())
|
||||
if (out.trySend(event).isSuccess) {
|
||||
keyEvents.incrementAndGet()
|
||||
} else {
|
||||
keySendFailures.incrementAndGet()
|
||||
}
|
||||
} catch (e: InterruptedException) {
|
||||
// Keep input alive if this is a transient interrupt while still running.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: key-reader interrupted; scheduling reader recovery", e)
|
||||
Thread.interrupted()
|
||||
continue
|
||||
} catch (e: InterruptedIOException) {
|
||||
// Common during reader shutdown/rebind. Recover silently and keep input flowing.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: read interrupted; scheduling reader recovery", e)
|
||||
try {
|
||||
Thread.sleep(10)
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during recovery backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
} catch (e: EOFException) {
|
||||
// EOF from reader should trigger rebind/rebuild rather than ending input stream.
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: reader EOF; scheduling reader recovery", e)
|
||||
try {
|
||||
Thread.sleep(20)
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during EOF backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
readFailures.incrementAndGet()
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: blocking read failed", e)
|
||||
try {
|
||||
Thread.sleep(50)
|
||||
} catch (ie: InterruptedException) {
|
||||
if (!running.get() || !keyLoopRunning.get()) break
|
||||
recoveryRequested.set(true)
|
||||
consoleFlowDebug("jline-events: interrupted during error backoff; continuing", ie)
|
||||
Thread.interrupted()
|
||||
}
|
||||
}
|
||||
}
|
||||
consoleFlowDebug(
|
||||
"jline-events: key-reader thread stopped running=${running.get()} keyLoopRunning=${keyLoopRunning.get()} loops=${keyLoopCount.get()} keys=${keyEvents.get()} readFailures=${readFailures.get()}"
|
||||
)
|
||||
}
|
||||
|
||||
heartbeatThread = thread(start = true, isDaemon = true, name = "lyng-jline-heartbeat") {
|
||||
while (running.get()) {
|
||||
if (lastHeartbeat.elapsedNow() >= 2.seconds) {
|
||||
val requested = runCatching { stateMutex.tryLock() }.getOrNull() == true && try {
|
||||
rawModeRequested
|
||||
} finally {
|
||||
stateMutex.unlock()
|
||||
}
|
||||
val readStartNs = keyReadStartNs.get()
|
||||
val readEndNs = keyReadEndNs.get()
|
||||
val lastKeyNs = lastKeyReadNs.get()
|
||||
val idleMs = if (lastKeyNs > 0L) (System.nanoTime() - lastKeyNs) / 1_000_000L else 0L
|
||||
val readBlockedMs = if (readStartNs > 0L && readEndNs < readStartNs) {
|
||||
(System.nanoTime() - readStartNs) / 1_000_000L
|
||||
} else 0L
|
||||
val streamIdle = requested && keyCodesRead.get() > 0L && idleMs >= 1400L
|
||||
val readStalled = requested && readBlockedMs >= 1600L
|
||||
if (streamIdle || readStalled) {
|
||||
val sinceRecoveryMs = (System.nanoTime() - lastRecoveryNs.get()) / 1_000_000L
|
||||
if (sinceRecoveryMs >= 1200L) {
|
||||
recoveryRequested.set(true)
|
||||
if (readStalled) {
|
||||
consoleFlowDebug("jline-events: key read blocked ${readBlockedMs}ms; scheduling reader recovery")
|
||||
} else {
|
||||
consoleFlowDebug("jline-events: key stream idle ${idleMs}ms; scheduling reader recovery")
|
||||
}
|
||||
}
|
||||
}
|
||||
consoleFlowDebug(
|
||||
"jline-events: heartbeat keyCodes=${keyCodesRead.get()} keysSent=${keyEvents.get()} sendFailures=${keySendFailures.get()} readFailures=${readFailures.get()} recoveries=${readerRecoveries.get()} rawRequested=$requested keyLoop=${keyLoopCount.get()} readBlockedMs=$readBlockedMs keyIdleMs=$idleMs keyPath=reader"
|
||||
)
|
||||
lastHeartbeat = TimeSource.Monotonic.markNow()
|
||||
}
|
||||
try {
|
||||
Thread.sleep(200)
|
||||
} catch (_: InterruptedException) {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return object : ConsoleEventSource {
|
||||
override suspend fun nextEvent(timeoutMs: Long): ConsoleEvent? {
|
||||
if (!running.get()) return null
|
||||
if (timeoutMs <= 0L) {
|
||||
return out.receiveCatching().getOrNull()
|
||||
}
|
||||
return withTimeoutOrNull(timeoutMs.milliseconds) {
|
||||
out.receiveCatching().getOrNull()
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun close() {
|
||||
consoleFlowDebug("jline-events: collector close requested", Throwable("collector close caller"))
|
||||
cleanup()
|
||||
consoleFlowDebug(
|
||||
"jline-events: collector ended keys=${keyEvents.get()} readFailures=${readFailures.get()}"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun setRawMode(enabled: Boolean): Boolean {
|
||||
val term = currentTerminal() ?: return false
|
||||
return stateMutex.withLock {
|
||||
if (enabled) {
|
||||
if (rawModeRequested) return@withLock false
|
||||
val saved = runCatching { term.enterRawMode() }.getOrNull() ?: return@withLock false
|
||||
enforceRawReadAttrs(term)
|
||||
rawSavedAttributes = saved
|
||||
rawModeRequested = true
|
||||
consoleFlowDebug("jline-events: setRawMode(true): enabled")
|
||||
true
|
||||
} else {
|
||||
val hadRaw = rawModeRequested
|
||||
rawModeRequested = false
|
||||
val saved = rawSavedAttributes
|
||||
rawSavedAttributes = null
|
||||
runCatching {
|
||||
if (saved != null) term.setAttributes(saved)
|
||||
}.onFailure {
|
||||
consoleFlowDebug("jline-events: setRawMode(false): restore failed", it)
|
||||
}
|
||||
consoleFlowDebug("jline-events: setRawMode(false): disabled hadRaw=$hadRaw")
|
||||
hadRaw
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun readKeyEvent(reader: NonBlockingReader): ConsoleEvent.KeyDown? {
|
||||
val code = reader.read(120L)
|
||||
if (code == NonBlockingReader.READ_EXPIRED) return null
|
||||
if (code < 0) throw EOFException("non-blocking reader returned EOF")
|
||||
return decodeKey(code) { timeout -> readNextCode(reader, timeout) }
|
||||
}
|
||||
|
||||
private fun decodeKey(code: Int, nextCode: (Long) -> Int?): ConsoleEvent.KeyDown {
|
||||
if (code == 27) {
|
||||
val next = nextCode(25L)
|
||||
if (next == null || next < 0) {
|
||||
return key("Escape")
|
||||
}
|
||||
if (next == '['.code || next == 'O'.code) {
|
||||
val sb = StringBuilder()
|
||||
sb.append(next.toChar())
|
||||
var i = 0
|
||||
while (i < 6) {
|
||||
val c = nextCode(25L) ?: break
|
||||
if (c < 0) break
|
||||
sb.append(c.toChar())
|
||||
if (c.toChar().isLetter() || c == '~'.code) break
|
||||
i += 1
|
||||
}
|
||||
return keyFromAnsiSequence(sb.toString()) ?: key("Escape")
|
||||
}
|
||||
// Alt+key
|
||||
val base = decodePlainKey(next)
|
||||
return ConsoleEvent.KeyDown(
|
||||
key = base.key,
|
||||
code = base.code,
|
||||
ctrl = base.ctrl,
|
||||
alt = true,
|
||||
shift = base.shift,
|
||||
meta = false
|
||||
)
|
||||
}
|
||||
return decodePlainKey(code)
|
||||
}
|
||||
|
||||
private fun readNextCode(reader: NonBlockingReader, timeoutMs: Long): Int? {
|
||||
val c = reader.read(timeoutMs)
|
||||
if (c == NonBlockingReader.READ_EXPIRED) return null
|
||||
if (c < 0) throw EOFException("non-blocking reader returned EOF while decoding key sequence")
|
||||
return c
|
||||
}
|
||||
|
||||
|
||||
private fun decodePlainKey(code: Int): ConsoleEvent.KeyDown = when (code) {
|
||||
3 -> key("c", ctrl = true)
|
||||
9 -> key("Tab")
|
||||
10, 13 -> key("Enter")
|
||||
127, 8 -> key("Backspace")
|
||||
32 -> key(" ")
|
||||
else -> {
|
||||
if (code in 1..26) {
|
||||
val ch = ('a'.code + code - 1).toChar().toString()
|
||||
key(ch, ctrl = true)
|
||||
} else {
|
||||
val ch = code.toChar().toString()
|
||||
key(ch, shift = ch.length == 1 && ch[0].isLetter() && ch[0].isUpperCase())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun keyFromAnsiSequence(seq: String): ConsoleEvent.KeyDown? = when (seq) {
|
||||
"[A", "OA" -> key("ArrowUp")
|
||||
"[B", "OB" -> key("ArrowDown")
|
||||
"[C", "OC" -> key("ArrowRight")
|
||||
"[D", "OD" -> key("ArrowLeft")
|
||||
"[H", "OH" -> key("Home")
|
||||
"[F", "OF" -> key("End")
|
||||
"[2~" -> key("Insert")
|
||||
"[3~" -> key("Delete")
|
||||
"[5~" -> key("PageUp")
|
||||
"[6~" -> key("PageDown")
|
||||
else -> null
|
||||
}
|
||||
|
||||
private fun key(
|
||||
value: String,
|
||||
ctrl: Boolean = false,
|
||||
alt: Boolean = false,
|
||||
shift: Boolean = false,
|
||||
): ConsoleEvent.KeyDown {
|
||||
require(value.isNotEmpty()) { "ConsoleEvent.KeyDown.key must never be empty" }
|
||||
return ConsoleEvent.KeyDown(
|
||||
key = value,
|
||||
code = null,
|
||||
ctrl = ctrl,
|
||||
alt = alt,
|
||||
shift = shift,
|
||||
meta = false
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
actual fun getSystemConsole(): LyngConsole = JvmLyngConsole
|
||||
@ -1,115 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.io.console
|
||||
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import net.sergeych.lyng.ExecutionError
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.obj.ObjBool
|
||||
import net.sergeych.lyng.obj.ObjIllegalOperationException
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessOp
|
||||
import net.sergeych.lyngio.console.security.ConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
|
||||
import net.sergeych.lyngio.fs.security.AccessContext
|
||||
import net.sergeych.lyngio.fs.security.AccessDecision
|
||||
import net.sergeych.lyngio.fs.security.Decision
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertIs
|
||||
import kotlin.test.assertTrue
|
||||
|
||||
class LyngConsoleModuleTest {
|
||||
|
||||
private fun newScope(): Scope = Scope.new()
|
||||
|
||||
@Test
|
||||
fun installIsIdempotent() = runBlocking {
|
||||
val scope = newScope()
|
||||
assertTrue(createConsoleModule(PermitAllConsoleAccessPolicy, scope))
|
||||
assertFalse(createConsoleModule(PermitAllConsoleAccessPolicy, scope))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun moduleSmokeScript() = runBlocking {
|
||||
val scope = newScope()
|
||||
createConsoleModule(PermitAllConsoleAccessPolicy, scope)
|
||||
|
||||
val code = """
|
||||
import lyng.io.console
|
||||
import lyng.stdlib
|
||||
|
||||
val d = Console.details()
|
||||
assert(d.supported is Bool)
|
||||
assert(d.isTty is Bool)
|
||||
assert(d.ansiLevel is ConsoleAnsiLevel)
|
||||
|
||||
val g = Console.geometry()
|
||||
if (g != null) {
|
||||
assert(g.columns is Int)
|
||||
assert(g.rows is Int)
|
||||
assert(g.columns > 0)
|
||||
assert(g.rows > 0)
|
||||
}
|
||||
|
||||
assert(Console.events() is Iterable)
|
||||
Console.write("")
|
||||
Console.flush()
|
||||
Console.home()
|
||||
Console.clear()
|
||||
Console.moveTo(1, 1)
|
||||
Console.clearLine()
|
||||
Console.enterAltScreen()
|
||||
Console.leaveAltScreen()
|
||||
Console.setCursorVisible(true)
|
||||
|
||||
val changed = Console.setRawMode(false)
|
||||
assert(changed is Bool)
|
||||
true
|
||||
""".trimIndent()
|
||||
|
||||
val result = scope.eval(code)
|
||||
assertIs<ObjBool>(result)
|
||||
assertTrue(result.value)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun denyWritePolicyMapsToIllegalOperation() {
|
||||
runBlocking {
|
||||
val denyWritePolicy = object : ConsoleAccessPolicy {
|
||||
override suspend fun check(op: ConsoleAccessOp, ctx: AccessContext): AccessDecision = when (op) {
|
||||
is ConsoleAccessOp.WriteText -> AccessDecision(Decision.Deny, "denied by test policy")
|
||||
else -> AccessDecision(Decision.Allow)
|
||||
}
|
||||
}
|
||||
|
||||
val scope = newScope()
|
||||
createConsoleModule(denyWritePolicy, scope)
|
||||
|
||||
val error = kotlin.test.assertFailsWith<ExecutionError> {
|
||||
scope.eval(
|
||||
"""
|
||||
import lyng.io.console
|
||||
Console.write("x")
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
assertIs<ObjIllegalOperationException>(error.errorObject)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,77 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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}"
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,243 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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)
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,67 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.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)
|
||||
}
|
||||
}
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
|
||||
@ -1,20 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun getNativeSystemConsole(): LyngConsole = MordantLyngConsole
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||
// no-op on Native
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
actual fun getSystemConsole(): LyngConsole = getNativeSystemConsole()
|
||||
|
||||
internal expect fun getNativeSystemConsole(): LyngConsole
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyngio.console
|
||||
|
||||
internal actual fun consoleFlowDebug(message: String, error: Throwable?) {
|
||||
// no-op on wasmJs
|
||||
}
|
||||
@ -1,157 +0,0 @@
|
||||
package lyng.io.console
|
||||
|
||||
/* Console event kinds used by `ConsoleEvent.type`. */
|
||||
enum ConsoleEventType {
|
||||
UNKNOWN,
|
||||
RESIZE,
|
||||
KEY_DOWN,
|
||||
KEY_UP
|
||||
}
|
||||
|
||||
/* Normalized key codes used by `ConsoleKeyEvent.code`. */
|
||||
enum ConsoleKeyCode {
|
||||
UNKNOWN,
|
||||
CHARACTER,
|
||||
ARROW_UP,
|
||||
ARROW_DOWN,
|
||||
ARROW_LEFT,
|
||||
ARROW_RIGHT,
|
||||
HOME,
|
||||
END,
|
||||
INSERT,
|
||||
DELETE,
|
||||
PAGE_UP,
|
||||
PAGE_DOWN,
|
||||
ESCAPE,
|
||||
ENTER,
|
||||
TAB,
|
||||
BACKSPACE,
|
||||
SPACE
|
||||
}
|
||||
|
||||
/* Detected ANSI terminal capability level. */
|
||||
enum ConsoleAnsiLevel {
|
||||
NONE,
|
||||
BASIC16,
|
||||
ANSI256,
|
||||
TRUECOLOR
|
||||
}
|
||||
|
||||
/* Base class for console events. */
|
||||
extern class ConsoleEvent {
|
||||
/* Event kind for stable matching/switching. */
|
||||
val type: ConsoleEventType
|
||||
}
|
||||
|
||||
/* Terminal resize event. */
|
||||
extern class ConsoleResizeEvent : ConsoleEvent {
|
||||
/* Current terminal width in character cells. */
|
||||
val columns: Int
|
||||
/* Current terminal height in character cells. */
|
||||
val rows: Int
|
||||
}
|
||||
|
||||
/* Keyboard event. */
|
||||
extern class ConsoleKeyEvent : ConsoleEvent {
|
||||
/*
|
||||
Logical key name normalized for app-level handling, for example:
|
||||
"a", "A", "ArrowLeft", "Escape", "Enter".
|
||||
*/
|
||||
val key: String
|
||||
/* Normalized key code enum for robust matching independent of backend specifics. */
|
||||
val code: ConsoleKeyCode
|
||||
/*
|
||||
Optional backend-specific raw identifier (if available).
|
||||
Not guaranteed to be present or stable across platforms.
|
||||
*/
|
||||
val codeName: String?
|
||||
/* True when Ctrl was pressed during the key event. */
|
||||
val ctrl: Bool
|
||||
/* True when Alt/Option was pressed during the key event. */
|
||||
val alt: Bool
|
||||
/* True when Shift was pressed during the key event. */
|
||||
val shift: Bool
|
||||
/* True when Meta/Super/Command was pressed during the key event. */
|
||||
val meta: Bool
|
||||
}
|
||||
|
||||
/* Pull iterator over console events. */
|
||||
extern class ConsoleEventIterator : Iterator<ConsoleEvent> {
|
||||
/* Whether another event is currently available from the stream. */
|
||||
override fun hasNext(): Bool
|
||||
/* Returns next event or throws iteration-finished when exhausted/cancelled. */
|
||||
override fun next(): ConsoleEvent
|
||||
/* Stops this iterator. The underlying console service remains managed by runtime. */
|
||||
override fun cancelIteration(): void
|
||||
}
|
||||
|
||||
/* Endless iterable console event stream. */
|
||||
extern class ConsoleEventStream : Iterable<ConsoleEvent> {
|
||||
/* Creates a fresh event iterator bound to the current console input stream. */
|
||||
override fun iterator(): ConsoleEventIterator
|
||||
}
|
||||
|
||||
/* Terminal geometry in character cells. */
|
||||
extern class ConsoleGeometry {
|
||||
val columns: Int
|
||||
val rows: Int
|
||||
}
|
||||
|
||||
/* Snapshot of console support/capabilities. */
|
||||
extern class ConsoleDetails {
|
||||
/* True when current runtime has console control implementation. */
|
||||
val supported: Bool
|
||||
/* True when output/input are attached to an interactive terminal. */
|
||||
val isTty: Bool
|
||||
/* Detected terminal color capability level. */
|
||||
val ansiLevel: ConsoleAnsiLevel
|
||||
/* Current terminal size if available, otherwise null. */
|
||||
val geometry: ConsoleGeometry?
|
||||
}
|
||||
|
||||
/* Console API singleton object. */
|
||||
extern object Console {
|
||||
/* Returns true when console control API is implemented in this runtime. */
|
||||
fun isSupported(): Bool
|
||||
/* Returns true when process is attached to interactive TTY. */
|
||||
fun isTty(): Bool
|
||||
/* Returns detected color capability level. */
|
||||
fun ansiLevel(): ConsoleAnsiLevel
|
||||
/* Returns current terminal geometry, or null when unavailable. */
|
||||
fun geometry(): ConsoleGeometry?
|
||||
/* Returns combined capability snapshot in one call. */
|
||||
fun details(): ConsoleDetails
|
||||
|
||||
/* Writes raw text to console output buffer (no implicit newline). */
|
||||
fun write(text: String): void
|
||||
/* Flushes pending console output. Call after batched writes. */
|
||||
fun flush(): void
|
||||
|
||||
/* Moves cursor to home position (row 1, column 1). */
|
||||
fun home(): void
|
||||
/* Clears visible screen buffer. Cursor position is backend-dependent after clear. */
|
||||
fun clear(): void
|
||||
/* Moves cursor to 1-based row/column. Values outside viewport are backend-defined. */
|
||||
fun moveTo(row: Int, column: Int): void
|
||||
/* Clears current line content. Cursor stays on the same line. */
|
||||
fun clearLine(): void
|
||||
|
||||
/* Switches terminal into alternate screen buffer (useful for TUIs). */
|
||||
fun enterAltScreen(): void
|
||||
/* Returns from alternate screen buffer to the normal terminal screen. */
|
||||
fun leaveAltScreen(): void
|
||||
/* Shows or hides the cursor. Prefer restoring visibility in finally blocks. */
|
||||
fun setCursorVisible(visible: Bool): void
|
||||
|
||||
/*
|
||||
Returns endless event stream (resize + key events).
|
||||
Typical usage is consuming in a launched loop.
|
||||
*/
|
||||
fun events(): ConsoleEventStream
|
||||
|
||||
/*
|
||||
Enables/disables raw keyboard mode.
|
||||
Returns true when state was actually changed.
|
||||
*/
|
||||
fun setRawMode(enabled: Bool): Bool
|
||||
}
|
||||
@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "1.5.0"
|
||||
version = "1.2.1-SNAPSHOT"
|
||||
|
||||
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
|
||||
|
||||
|
||||
@ -1,28 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
actual object Benchmarks {
|
||||
actual val enabled: Boolean = run {
|
||||
val p = System.getProperty("LYNG_BENCHMARKS")?.lowercase()
|
||||
val e = System.getenv("BENCHMARKS")?.lowercase()
|
||||
fun parse(v: String?): Boolean =
|
||||
v == "true" || v == "1" || v == "yes"
|
||||
parse(p) || parse(e)
|
||||
}
|
||||
}
|
||||
@ -42,4 +42,4 @@ actual object PerfDefaults {
|
||||
actual val ARG_SMALL_ARITY_12: Boolean = false
|
||||
actual val INDEX_PIC_SIZE_4: Boolean = false
|
||||
actual val RANGE_FAST_ITER: Boolean = false
|
||||
}
|
||||
}
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng.bytecode
|
||||
|
||||
internal actual fun vmIterDebug(message: String, error: Throwable?) {
|
||||
// no-op on Android
|
||||
}
|
||||
@ -20,7 +20,6 @@ package net.sergeych.lyng
|
||||
import net.sergeych.lyng.miniast.MiniTypeRef
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
import net.sergeych.lyng.obj.ObjList
|
||||
import net.sergeych.lyng.obj.ObjNull
|
||||
import net.sergeych.lyng.obj.ObjRecord
|
||||
|
||||
/**
|
||||
@ -62,59 +61,30 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
}
|
||||
}
|
||||
if (!hasComplex) {
|
||||
if (arguments.list.size > params.size)
|
||||
if (arguments.list.size != params.size)
|
||||
scope.raiseIllegalArgument("expected ${params.size} arguments, got ${arguments.list.size}")
|
||||
if (arguments.list.size < params.size) {
|
||||
for (i in arguments.list.size until params.size) {
|
||||
val a = params[i]
|
||||
if (!a.type.isNullable) {
|
||||
scope.raiseIllegalArgument("expected ${params.size} arguments, got ${arguments.list.size}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i in params.indices) {
|
||||
val a = params[i]
|
||||
val value = if (i < arguments.list.size) arguments.list[i] else ObjNull
|
||||
val recordType = if (declaringClass != null && a.accessType != null) {
|
||||
ObjRecord.Type.ConstructorField
|
||||
} else {
|
||||
ObjRecord.Type.Argument
|
||||
}
|
||||
scope.addItem(
|
||||
a.name,
|
||||
(a.accessType ?: defaultAccessType).isMutable,
|
||||
val value = arguments.list[i]
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
a.visibility ?: defaultVisibility,
|
||||
recordType = recordType,
|
||||
recordType = ObjRecord.Type.Argument,
|
||||
declaringClass = declaringClass,
|
||||
isTransient = a.isTransient
|
||||
)
|
||||
isTransient = a.isTransient)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
fun assign(a: Item, value: Obj) {
|
||||
val recordType = if (declaringClass != null && a.accessType != null) {
|
||||
ObjRecord.Type.ConstructorField
|
||||
} else {
|
||||
ObjRecord.Type.Argument
|
||||
}
|
||||
scope.addItem(
|
||||
a.name,
|
||||
(a.accessType ?: defaultAccessType).isMutable,
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
a.visibility ?: defaultVisibility,
|
||||
recordType = recordType,
|
||||
recordType = ObjRecord.Type.Argument,
|
||||
declaringClass = declaringClass,
|
||||
isTransient = a.isTransient
|
||||
)
|
||||
}
|
||||
|
||||
suspend fun missingValue(a: Item, error: String): Obj {
|
||||
return a.defaultValue?.callOn(scope)
|
||||
?: if (a.type.isNullable) ObjNull else scope.raiseIllegalArgument(error)
|
||||
isTransient = a.isTransient)
|
||||
}
|
||||
|
||||
// Prepare positional args and parameter count, handle tail-block binding
|
||||
@ -184,251 +154,73 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
}
|
||||
}
|
||||
|
||||
// Helper: assign head part, consuming from headPos; stop at ellipsis
|
||||
suspend fun processHead(index: Int, headPos: Int): Pair<Int, Int> {
|
||||
var i = index
|
||||
var hp = headPos
|
||||
while (i < paramsSize) {
|
||||
val a = params[i]
|
||||
if (a.isEllipsis) break
|
||||
if (assignedByName[i]) {
|
||||
assign(a, namedValues[i]!!)
|
||||
} else {
|
||||
val value = if (hp < callArgs.size) callArgs[hp++]
|
||||
else missingValue(a, "too few arguments for the call (missing ${a.name})")
|
||||
assign(a, value)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return i to hp
|
||||
}
|
||||
|
||||
// Helper: assign tail part from the end, consuming from tailPos; stop before ellipsis index
|
||||
// Do not consume elements below headPosBound to avoid overlap with head consumption
|
||||
suspend fun processTail(startExclusive: Int, tailStart: Int, headPosBound: Int): Int {
|
||||
var i = paramsSize - 1
|
||||
var tp = tailStart
|
||||
while (i > startExclusive) {
|
||||
val a = params[i]
|
||||
if (a.isEllipsis) break
|
||||
if (i < assignedByName.size && assignedByName[i]) {
|
||||
assign(a, namedValues[i]!!)
|
||||
} else {
|
||||
val value = if (tp >= headPosBound) callArgs[tp--]
|
||||
else missingValue(a, "too few arguments for the call")
|
||||
assign(a, value)
|
||||
}
|
||||
i--
|
||||
}
|
||||
return tp
|
||||
}
|
||||
|
||||
fun processEllipsis(index: Int, headPos: Int, tailPos: Int) {
|
||||
val a = params[index]
|
||||
val from = headPos
|
||||
val to = tailPos
|
||||
val l = if (from > to) ObjList()
|
||||
else ObjList(callArgs.subList(from, to + 1).toMutableList())
|
||||
assign(a, l)
|
||||
}
|
||||
|
||||
// Locate ellipsis index within considered parameters
|
||||
val ellipsisIndex = params.subList(0, paramsSize).indexOfFirst { it.isEllipsis }
|
||||
|
||||
var headPos = 0
|
||||
var tailPos = callArgs.size - 1
|
||||
|
||||
if (ellipsisIndex >= 0) {
|
||||
// Assign head first to know how many positionals are consumed from the start
|
||||
val (afterHead, headConsumedTo) = processHead(0, 0)
|
||||
// Then assign tail consuming from the end down to headConsumedTo boundary
|
||||
val tailConsumedFrom = processTail(ellipsisIndex, callArgs.size - 1, headConsumedTo)
|
||||
// Assign ellipsis list from remaining positionals between headConsumedTo..tailConsumedFrom
|
||||
processEllipsis(ellipsisIndex, headConsumedTo, tailConsumedFrom)
|
||||
} else {
|
||||
// No ellipsis: assign head only; any leftover positionals → error
|
||||
val (_, headConsumedTo) = processHead(0, 0)
|
||||
if (headConsumedTo != callArgs.size)
|
||||
scope.raiseIllegalArgument("too many arguments for the call")
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Assign arguments directly into frame slots using [paramSlotPlan] without creating scope locals.
|
||||
* Default expressions must resolve through frame slots (no scope mirroring).
|
||||
*/
|
||||
suspend fun assignToFrame(
|
||||
scope: Scope,
|
||||
arguments: Arguments = scope.args,
|
||||
paramSlotPlan: Map<String, Int>,
|
||||
frame: FrameAccess,
|
||||
slotOffset: Int = 0
|
||||
) {
|
||||
fun slotFor(name: String): Int {
|
||||
val full = paramSlotPlan[name] ?: scope.raiseIllegalState("parameter slot for '$name' is missing")
|
||||
val slot = full - slotOffset
|
||||
if (slot < 0) scope.raiseIllegalState("parameter slot for '$name' is out of range")
|
||||
return slot
|
||||
}
|
||||
|
||||
fun setFrameValue(slot: Int, value: Obj) {
|
||||
when (value) {
|
||||
is net.sergeych.lyng.obj.ObjInt -> frame.setInt(slot, value.value)
|
||||
is net.sergeych.lyng.obj.ObjReal -> frame.setReal(slot, value.value)
|
||||
is net.sergeych.lyng.obj.ObjBool -> frame.setBool(slot, value.value)
|
||||
else -> frame.setObj(slot, value)
|
||||
}
|
||||
}
|
||||
|
||||
fun assign(a: Item, value: Obj) {
|
||||
val slot = slotFor(a.name)
|
||||
setFrameValue(slot, value.byValueCopy())
|
||||
}
|
||||
|
||||
suspend fun missingValue(a: Item, error: String): Obj {
|
||||
return a.defaultValue?.callOn(scope)
|
||||
?: if (a.type.isNullable) ObjNull else scope.raiseIllegalArgument(error)
|
||||
}
|
||||
|
||||
// Fast path for simple positional-only calls with no ellipsis and no defaults
|
||||
if (arguments.named.isEmpty() && !arguments.tailBlockMode) {
|
||||
var hasComplex = false
|
||||
for (p in params) {
|
||||
if (p.isEllipsis || p.defaultValue != null) {
|
||||
hasComplex = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if (!hasComplex) {
|
||||
if (arguments.list.size > params.size)
|
||||
scope.raiseIllegalArgument("expected ${params.size} arguments, got ${arguments.list.size}")
|
||||
if (arguments.list.size < params.size) {
|
||||
for (i in arguments.list.size until params.size) {
|
||||
val a = params[i]
|
||||
if (!a.type.isNullable) {
|
||||
scope.raiseIllegalArgument("expected ${params.size} arguments, got ${arguments.list.size}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (i in params.indices) {
|
||||
val a = params[i]
|
||||
val value = if (i < arguments.list.size) arguments.list[i] else ObjNull
|
||||
assign(a, value)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
// Prepare positional args and parameter count, handle tail-block binding
|
||||
val callArgs: List<Obj>
|
||||
val paramsSize: Int
|
||||
if (arguments.tailBlockMode) {
|
||||
val lastParam = params.last()
|
||||
if (arguments.named.containsKey(lastParam.name))
|
||||
scope.raiseIllegalArgument("trailing block cannot be used when the last parameter is already assigned by a named argument")
|
||||
paramsSize = params.size - 1
|
||||
assign(lastParam, arguments.list.last())
|
||||
callArgs = arguments.list.dropLast(1)
|
||||
} else {
|
||||
paramsSize = params.size
|
||||
callArgs = arguments.list
|
||||
}
|
||||
|
||||
val coveredByPositional = BooleanArray(paramsSize)
|
||||
run {
|
||||
var headRequired = 0
|
||||
var tailRequired = 0
|
||||
val ellipsisIdx = params.subList(0, paramsSize).indexOfFirst { it.isEllipsis }
|
||||
if (ellipsisIdx >= 0) {
|
||||
for (i in 0 until ellipsisIdx) if (!params[i].isEllipsis && params[i].defaultValue == null) headRequired++
|
||||
for (i in paramsSize - 1 downTo ellipsisIdx + 1) if (params[i].defaultValue == null) tailRequired++
|
||||
} else {
|
||||
for (i in 0 until paramsSize) if (params[i].defaultValue == null) headRequired++
|
||||
}
|
||||
val P = callArgs.size
|
||||
if (ellipsisIdx < 0) {
|
||||
val k = minOf(P, paramsSize)
|
||||
for (i in 0 until k) coveredByPositional[i] = true
|
||||
} else {
|
||||
val headTake = minOf(P, headRequired)
|
||||
for (i in 0 until headTake) coveredByPositional[i] = true
|
||||
val remaining = P - headTake
|
||||
val tailTake = minOf(remaining, tailRequired)
|
||||
var j = paramsSize - 1
|
||||
var taken = 0
|
||||
while (j > ellipsisIdx && taken < tailTake) {
|
||||
coveredByPositional[j] = true
|
||||
j--
|
||||
taken++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val assignedByName = BooleanArray(paramsSize)
|
||||
val namedValues = arrayOfNulls<Obj>(paramsSize)
|
||||
if (arguments.named.isNotEmpty()) {
|
||||
for ((k, v) in arguments.named) {
|
||||
val idx = params.subList(0, paramsSize).indexOfFirst { it.name == k }
|
||||
if (idx < 0) scope.raiseIllegalArgument("unknown parameter '$k'")
|
||||
if (params[idx].isEllipsis) scope.raiseIllegalArgument("ellipsis (variadic) parameter cannot be assigned by name: '$k'")
|
||||
if (coveredByPositional[idx]) scope.raiseIllegalArgument("argument '$k' is already set by positional argument")
|
||||
if (assignedByName[idx]) scope.raiseIllegalArgument("argument '$k' is already set")
|
||||
assignedByName[idx] = true
|
||||
namedValues[idx] = v
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun processHead(index: Int, headPos: Int): Pair<Int, Int> {
|
||||
var i = index
|
||||
var hp = headPos
|
||||
var i = 0
|
||||
while (i < paramsSize) {
|
||||
val a = params[i]
|
||||
if (a.isEllipsis) break
|
||||
if (assignedByName[i]) {
|
||||
assign(a, namedValues[i]!!)
|
||||
} else {
|
||||
val value = if (hp < callArgs.size) callArgs[hp++]
|
||||
else missingValue(a, "too few arguments for the call (missing ${a.name})")
|
||||
val value = if (headPos < callArgs.size) callArgs[headPos++]
|
||||
else a.defaultValue?.execute(scope)
|
||||
?: scope.raiseIllegalArgument("too few arguments for the call (missing ${a.name})")
|
||||
assign(a, value)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return i to hp
|
||||
}
|
||||
val afterHead = i
|
||||
val headConsumedTo = headPos
|
||||
|
||||
suspend fun processTail(startExclusive: Int, tailStart: Int, headPosBound: Int): Int {
|
||||
var i = paramsSize - 1
|
||||
var tp = tailStart
|
||||
while (i > startExclusive) {
|
||||
// Then assign tail consuming from the end down to headConsumedTo boundary
|
||||
i = paramsSize - 1
|
||||
var tp = tailPos
|
||||
while (i > ellipsisIndex) {
|
||||
val a = params[i]
|
||||
if (a.isEllipsis) break
|
||||
if (i < assignedByName.size && assignedByName[i]) {
|
||||
assign(a, namedValues[i]!!)
|
||||
} else {
|
||||
val value = if (tp >= headPosBound) callArgs[tp--]
|
||||
else missingValue(a, "too few arguments for the call")
|
||||
val value = if (tp >= headConsumedTo) callArgs[tp--]
|
||||
else a.defaultValue?.execute(scope)
|
||||
?: scope.raiseIllegalArgument("too few arguments for the call")
|
||||
assign(a, value)
|
||||
}
|
||||
i--
|
||||
}
|
||||
return tp
|
||||
}
|
||||
val tailConsumedFrom = tp
|
||||
|
||||
fun processEllipsis(index: Int, headPos: Int, tailPos: Int) {
|
||||
val a = params[index]
|
||||
val from = headPos
|
||||
val to = tailPos
|
||||
// Assign ellipsis list from remaining positionals between headConsumedTo..tailConsumedFrom
|
||||
val a = params[ellipsisIndex]
|
||||
val from = headConsumedTo
|
||||
val to = tailConsumedFrom
|
||||
val l = if (from > to) ObjList()
|
||||
else ObjList(callArgs.subList(from, to + 1).toMutableList())
|
||||
assign(a, l)
|
||||
}
|
||||
|
||||
val ellipsisIndex = params.subList(0, paramsSize).indexOfFirst { it.isEllipsis }
|
||||
|
||||
if (ellipsisIndex >= 0) {
|
||||
val (_, headConsumedTo) = processHead(0, 0)
|
||||
val tailConsumedFrom = processTail(ellipsisIndex, callArgs.size - 1, headConsumedTo)
|
||||
processEllipsis(ellipsisIndex, headConsumedTo, tailConsumedFrom)
|
||||
} else {
|
||||
val (_, headConsumedTo) = processHead(0, 0)
|
||||
// No ellipsis: assign head only; any leftover positionals → error
|
||||
var i = 0
|
||||
while (i < paramsSize) {
|
||||
val a = params[i]
|
||||
if (a.isEllipsis) break
|
||||
if (assignedByName[i]) {
|
||||
assign(a, namedValues[i]!!)
|
||||
} else {
|
||||
val value = if (headPos < callArgs.size) callArgs[headPos++]
|
||||
else a.defaultValue?.execute(scope)
|
||||
?: scope.raiseIllegalArgument("too few arguments for the call (missing ${a.name})")
|
||||
assign(a, value)
|
||||
}
|
||||
i++
|
||||
}
|
||||
val headConsumedTo = headPos
|
||||
if (headConsumedTo != callArgs.size)
|
||||
scope.raiseIllegalArgument("too many arguments for the call")
|
||||
}
|
||||
@ -437,7 +229,7 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
/**
|
||||
* Single argument declaration descriptor.
|
||||
*
|
||||
* @param defaultValue default value, callable evaluated at call site.
|
||||
* @param defaultValue default value, if set, can't be an [Obj] as it can depend on the call site, call args, etc.
|
||||
* If not null, could be executed on __caller context__ only.
|
||||
*/
|
||||
data class Item(
|
||||
@ -450,9 +242,9 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
* Default value, if set, can't be an [Obj] as it can depend on the call site, call args, etc.
|
||||
* So it is a [Statement] that must be executed on __caller context__.
|
||||
*/
|
||||
val defaultValue: Obj? = null,
|
||||
val defaultValue: Statement? = null,
|
||||
val accessType: AccessType? = null,
|
||||
val visibility: Visibility? = null,
|
||||
val isTransient: Boolean = false,
|
||||
)
|
||||
}
|
||||
}
|
||||
@ -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.
|
||||
@ -20,7 +20,7 @@ package net.sergeych.lyng
|
||||
import net.sergeych.lyng.obj.*
|
||||
|
||||
data class ParsedArgument(
|
||||
val value: Obj,
|
||||
val value: Statement,
|
||||
val pos: Pos,
|
||||
val isSplat: Boolean = false,
|
||||
val name: String? = null,
|
||||
@ -37,128 +37,128 @@ data class ParsedArgument(
|
||||
count++
|
||||
if (count > limit) break
|
||||
}
|
||||
if (!hasSplatOrNamed && count == this.size) {
|
||||
if (!hasSplatOrNamed && count == this.size) {
|
||||
val quick = when (count) {
|
||||
0 -> Arguments.EMPTY
|
||||
1 -> Arguments(listOf(this.elementAt(0).value.callOn(scope)), tailBlockMode)
|
||||
1 -> Arguments(listOf(this.elementAt(0).value.execute(scope)), tailBlockMode)
|
||||
2 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
Arguments(listOf(a0, a1), tailBlockMode)
|
||||
}
|
||||
3 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2), tailBlockMode)
|
||||
}
|
||||
4 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3), tailBlockMode)
|
||||
}
|
||||
5 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4), tailBlockMode)
|
||||
}
|
||||
6 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5), tailBlockMode)
|
||||
}
|
||||
7 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6), tailBlockMode)
|
||||
}
|
||||
8 -> {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a7 = this.elementAt(7).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
val a7 = this.elementAt(7).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7), tailBlockMode)
|
||||
}
|
||||
9 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a7 = this.elementAt(7).value.callOn(scope)
|
||||
val a8 = this.elementAt(8).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
val a7 = this.elementAt(7).value.execute(scope)
|
||||
val a8 = this.elementAt(8).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8), tailBlockMode)
|
||||
} else null
|
||||
10 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a7 = this.elementAt(7).value.callOn(scope)
|
||||
val a8 = this.elementAt(8).value.callOn(scope)
|
||||
val a9 = this.elementAt(9).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
val a7 = this.elementAt(7).value.execute(scope)
|
||||
val a8 = this.elementAt(8).value.execute(scope)
|
||||
val a9 = this.elementAt(9).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9), tailBlockMode)
|
||||
} else null
|
||||
11 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a7 = this.elementAt(7).value.callOn(scope)
|
||||
val a8 = this.elementAt(8).value.callOn(scope)
|
||||
val a9 = this.elementAt(9).value.callOn(scope)
|
||||
val a10 = this.elementAt(10).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
val a7 = this.elementAt(7).value.execute(scope)
|
||||
val a8 = this.elementAt(8).value.execute(scope)
|
||||
val a9 = this.elementAt(9).value.execute(scope)
|
||||
val a10 = this.elementAt(10).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), tailBlockMode)
|
||||
} else null
|
||||
12 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
|
||||
val a0 = this.elementAt(0).value.callOn(scope)
|
||||
val a1 = this.elementAt(1).value.callOn(scope)
|
||||
val a2 = this.elementAt(2).value.callOn(scope)
|
||||
val a3 = this.elementAt(3).value.callOn(scope)
|
||||
val a4 = this.elementAt(4).value.callOn(scope)
|
||||
val a5 = this.elementAt(5).value.callOn(scope)
|
||||
val a6 = this.elementAt(6).value.callOn(scope)
|
||||
val a7 = this.elementAt(7).value.callOn(scope)
|
||||
val a8 = this.elementAt(8).value.callOn(scope)
|
||||
val a9 = this.elementAt(9).value.callOn(scope)
|
||||
val a10 = this.elementAt(10).value.callOn(scope)
|
||||
val a11 = this.elementAt(11).value.callOn(scope)
|
||||
val a0 = this.elementAt(0).value.execute(scope)
|
||||
val a1 = this.elementAt(1).value.execute(scope)
|
||||
val a2 = this.elementAt(2).value.execute(scope)
|
||||
val a3 = this.elementAt(3).value.execute(scope)
|
||||
val a4 = this.elementAt(4).value.execute(scope)
|
||||
val a5 = this.elementAt(5).value.execute(scope)
|
||||
val a6 = this.elementAt(6).value.execute(scope)
|
||||
val a7 = this.elementAt(7).value.execute(scope)
|
||||
val a8 = this.elementAt(8).value.execute(scope)
|
||||
val a9 = this.elementAt(9).value.execute(scope)
|
||||
val a10 = this.elementAt(10).value.execute(scope)
|
||||
val a11 = this.elementAt(11).value.execute(scope)
|
||||
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), tailBlockMode)
|
||||
} else null
|
||||
else -> null
|
||||
}
|
||||
if (quick != null) return quick
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// General path: build positional list and named map, enforcing ordering rules
|
||||
val positional: MutableList<Obj> = mutableListOf()
|
||||
val positional: MutableList<Obj> = mutableListOf()
|
||||
var named: MutableMap<String, Obj>? = null
|
||||
var namedSeen = false
|
||||
for ((idx, x) in this.withIndex()) {
|
||||
@ -166,12 +166,12 @@ data class ParsedArgument(
|
||||
// Named argument
|
||||
if (named == null) named = linkedMapOf()
|
||||
if (named.containsKey(x.name)) scope.raiseIllegalArgument("argument '${x.name}' is already set")
|
||||
val v = x.value.callOn(scope)
|
||||
val v = x.value.execute(scope)
|
||||
named[x.name] = v
|
||||
namedSeen = true
|
||||
continue
|
||||
}
|
||||
val value = x.value.callOn(scope)
|
||||
val value = x.value.execute(scope)
|
||||
if (x.isSplat) {
|
||||
when {
|
||||
// IMPORTANT: handle ObjMap BEFORE generic Iterable to ensure map splats
|
||||
@ -220,7 +220,6 @@ data class ParsedArgument(
|
||||
val list: List<Obj>,
|
||||
val tailBlockMode: Boolean = false,
|
||||
val named: Map<String, Obj> = emptyMap(),
|
||||
val explicitTypeArgs: List<TypeDecl> = emptyList(),
|
||||
) : List<Obj> by list {
|
||||
|
||||
constructor(vararg values: Obj) : this(values.toList())
|
||||
@ -245,13 +244,20 @@ data class ParsedArgument(
|
||||
* Convert to list of kotlin objects, see [Obj.toKotlin].
|
||||
*/
|
||||
suspend fun toKotlinList(scope: Scope): List<Any?> {
|
||||
return list.map { it.toKotlin(scope) }
|
||||
val res = ArrayList<Any?>(list.size)
|
||||
for (i in list) res.add(i.toKotlin(scope))
|
||||
return res
|
||||
}
|
||||
|
||||
suspend fun inspect(scope: Scope): String {
|
||||
val res = ArrayList<String>(list.size)
|
||||
for (i in list) res.add(i.inspect(scope))
|
||||
return res.joinToString(",")
|
||||
}
|
||||
|
||||
suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
|
||||
|
||||
companion object {
|
||||
val EMPTY = Arguments(emptyList())
|
||||
fun from(values: Collection<Obj>) = Arguments(values.toList())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,22 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
expect object Benchmarks {
|
||||
val enabled: Boolean
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.Obj
|
||||
|
||||
class BlockStatement(
|
||||
val block: Script,
|
||||
val slotPlan: Map<String, Int>,
|
||||
val scopeId: Int,
|
||||
val captureSlots: List<CaptureSlot> = emptyList(),
|
||||
private val startPos: Pos,
|
||||
) : Statement() {
|
||||
override val pos: Pos = startPos
|
||||
|
||||
override suspend fun execute(scope: Scope): Obj {
|
||||
return bytecodeOnly(scope, "block statement")
|
||||
}
|
||||
|
||||
fun statements(): List<Statement> = block.debugStatements()
|
||||
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.bytecode.BytecodeStatement
|
||||
|
||||
interface BytecodeBodyProvider {
|
||||
fun bytecodeBody(): BytecodeStatement?
|
||||
}
|
||||
@ -1,19 +0,0 @@
|
||||
/*
|
||||
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
interface BytecodeCallable
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user