Compare commits

..
92 Commits
Author SHA1 Message Date
sergeych 2d4ae0d98b fixed site sample to be more expressive 2026-02-17 22:34:56 +03:00
sergeych 74d911e837 Migrate IdeLenientImportProvider to lynglib, add detailed time-related documentation, and improve analysis support for unresolved references. 2026-02-17 22:20:31 +03:00
sergeych 2e7c28f735 corrected home page samples 2026-02-17 12:47:55 +03:00
sergeych 69156893d4 Improve receiver class handling and enhance resolution logic 2026-02-17 12:35:31 +03:00
sergeych df19524177 Refine variable resolution logic, update type alias syntax 2026-02-17 08:17:57 +03:00
sergeych b6851b7098 Improve variable resolution and expand test coverage; improved wahtsnew 2026-02-17 08:06:06 +03:00
sergeych afa4b20070 update version, site and docs 2026-02-16 19:29:14 +03:00
sergeych c5b8871c3a Add support for closed classes and enhancements to the Kotlin reflection bridge 2026-02-16 19:08:32 +03:00
sergeych 7f2f99524f Expand fast ops optimization plan 2026-02-16 18:09:58 +03:00
sergeych bfa8a59df3 Unbox assign-op operands for fast int/real ops 2026-02-16 18:04:55 +03:00
sergeych 09b1eb68ae Enable fast string compares for indexed list 2026-02-16 17:58:05 +03:00
sergeych fdb23b3a76 Reuse void slot for if statements 2026-02-16 17:50:39 +03:00
sergeych 7c28296f92 Elide redundant bool conversions in logical ops 2026-02-16 17:42:04 +03:00
sergeych 3e654ddd60 Use primitive ops for mixed int/real 2026-02-16 17:37:49 +03:00
sergeych e8f5c9eaf4 Use fast compare for stable obj temps 2026-02-16 17:35:08 +03:00
sergeych 44f9573eec Add mixed compare benchmark baseline 2026-02-16 17:33:05 +03:00
sergeych a8f6aa31f1 Fix for-loop real widening coercions 2026-02-16 16:53:53 +03:00
sergeych fd2da1efd3 VM optimizations 2026-02-16 06:16:29 +03:00
sergeych 637258581d Optimize int loop jumps and document loop var immutability 2026-02-15 15:12:52 +03:00
sergeych db9dc73da8 Fix portability issues and move JVM-only test 2026-02-15 11:09:55 +03:00
sergeych b233d4c15f Improve plugin symbol accuracy in completion and docs 2026-02-15 11:05:57 +03:00
sergeych 3f2c38c471 Add Scope.requireClass helper for stdlib binding 2026-02-15 01:45:21 +03:00
sergeych d8d2eff436 Bind KotlinIterator via stdlib extern class 2026-02-15 01:37:40 +03:00
sergeych 6295cea6ad Test module-frame lookup in bridge resolver 2026-02-15 01:29:13 +03:00
sergeych cc681c76a0 Test extension callable handles 2026-02-15 01:26:31 +03:00
sergeych 9cf87d1075 Add Kotlin bridge reflection handles and tests 2026-02-15 01:23:13 +03:00
sergeych cd145f6a96 Migrate runtime locals to frame slots 2026-02-14 23:25:19 +03:00
sergeych 34678068ac Remove interpreter paths and enforce bytecode-only execution 2026-02-14 01:20:13 +03:00
sergeych e73fe0d3c5 Remove interpreter fallbacks and enforce bytecode execution 2026-02-14 00:41:33 +03:00
sergeych 26564438e2 Enforce bytecode-only statements and wrap defaults 2026-02-13 06:44:00 +03:00
sergeych 489dae6604 Enforce bytecode-only wrappers and add extern bridge opcode 2026-02-13 04:46:07 +03:00
sergeych 05cba5b653 Enforce bytecode-only class and instance init bodies 2026-02-13 01:37:16 +03:00
sergeych 70ba424ef9 Require bytecode for StatementRef evaluation 2026-02-13 01:36:10 +03:00
sergeych 90826b519d Remove interpreter paths and enforce bytecode-only execution 2026-02-13 00:19:47 +03:00
sergeych 4cd8e5ded2 Block non-bytecode Statements in bytecode calls 2026-02-12 17:55:30 +03:00
sergeych db4f7d0973 Finalize bytecode-only lambdas and frame binding 2026-02-12 17:47:05 +03:00
sergeych a481371349 Step 27E: add CLI bytecode fallback reporting 2026-02-12 00:15:35 +03:00
sergeych 51319fa8b7 Step 27D: expose lambda fallback reporter 2026-02-12 00:03:48 +03:00
sergeych 86ac7eee54 Step 27C: report lambda bytecode fallbacks 2026-02-12 00:02:09 +03:00
sergeych 18278794d6 Step 27B: bytecode ::class 2026-02-11 23:10:32 +03:00
sergeych ac680ceb6c Step 27A: remove EVAL_STMT 2026-02-11 21:15:43 +03:00
sergeych 6efdfc1964 Step 26C: remove forceScopeSlots 2026-02-11 21:02:48 +03:00
sergeych b9af80a1b2 Step 26B: drop containsValueFnRef 2026-02-11 20:53:15 +03:00
sergeych bde32ca7b5 Step 26A: bytecode lambda callables 2026-02-11 20:50:56 +03:00
sergeych 99ca15d20f Step 24E: frame capture refs 2026-02-11 20:33:58 +03:00
sergeych c14c7d43d9 Step 24D: bytecode closure scope 2026-02-11 11:36:19 +03:00
sergeych 1271f347bd Step 25D: module decl disasm coverage 2026-02-10 09:31:21 +03:00
sergeych 4e08339756 Step 25C: bytecode class declarations 2026-02-10 08:30:10 +03:00
sergeych b32a937636 Step 25B: bytecode function declarations 2026-02-10 08:13:58 +03:00
sergeych 4db0a7fbab Step 25A: bytecode enum declarations 2026-02-10 08:04:28 +03:00
sergeych 8b196c7b0c Step 24E: isolate interpreter-only capture logic 2026-02-10 07:58:29 +03:00
sergeych 54ca886753 Step 24D: update plan 2026-02-10 07:56:24 +03:00
sergeych abbebec153 Step 24D: bytecode-only closure path for lambdas 2026-02-10 07:56:08 +03:00
sergeych c066dc7150 Step 24C: remove scope mirroring in bytecode runtime 2026-02-10 04:46:42 +03:00
sergeych 6c0b86f6e6 Step 24B: frame-slot captures for bytecode lambdas 2026-02-10 04:33:04 +03:00
sergeych 8f1c660f4e Step 24A: bytecode capture tables for lambdas 2026-02-10 04:19:52 +03:00
sergeych 3ce9029162 Mark step 25 complete 2026-02-09 22:01:02 +03:00
sergeych 0caa9849cf Step 25: emit DECL_EXEC for declarations 2026-02-09 22:00:46 +03:00
sergeych 8314127fdb Update bytecode migration plan for interpreter removal 2026-02-09 20:44:45 +03:00
sergeych dab0b9f165 Step 24: remove assign scope slot 2026-02-09 20:42:02 +03:00
sergeych 6aa23e8ef3 Step 23: frame-based delegated locals 2026-02-09 19:57:59 +03:00
sergeych c035b4c34c Step 22: delegated locals in bytecode 2026-02-09 12:34:23 +03:00
sergeych 9d508e219f Step 21: union mismatch bytecode throw 2026-02-09 12:13:33 +03:00
sergeych b49f291bff Step 20: bytecode NopStatement 2026-02-09 12:04:51 +03:00
sergeych ae88898f58 Step 16: remove ToBoolStatement 2026-02-09 11:42:51 +03:00
sergeych 565dbf98ed Step 19: union member access 2026-02-09 11:38:04 +03:00
sergeych 5305ced89f Step 18: delegated member access in bytecode 2026-02-09 11:00:29 +03:00
sergeych b2d5897aa8 Step 17: callable property calls 2026-02-09 10:50:53 +03:00
sergeych 0b94b46d40 Step 15: class-scope ?= in bytecode 2026-02-09 10:34:36 +03:00
sergeych 541738646f Enable fast local refs behind compiler flag 2026-02-09 10:28:32 +03:00
sergeych f0dc0d2396 Support qualified this refs in bytecode 2026-02-09 10:16:04 +03:00
sergeych 7850d5fbde Cover optional index pre-inc short-circuit 2026-02-09 10:07:32 +03:00
sergeych cde7cf2caf Add optional inc/dec bytecode tests 2026-02-09 10:06:39 +03:00
sergeych 473a5dd6ed Handle optional assign-ops and inc/dec in bytecode 2026-02-09 10:04:37 +03:00
sergeych 694d15c69d Add bytecode destructuring assignment 2026-02-09 09:58:34 +03:00
sergeych 780227a229 Complete bytecode module declaration step 2026-02-09 09:49:04 +03:00
sergeych 8a7582891a Fix bytecode object refs and post-inc 2026-02-09 03:20:14 +03:00
sergeych 5b1a8af4e3 Allow delay in bytecode 2026-02-09 02:18:00 +03:00
sergeych 58581d6bf0 Step 9: module-level bytecode execution 2026-02-09 02:09:29 +03:00
sergeych e2f503744d Bytecode: dynamic member assign ops 2026-02-09 02:05:58 +03:00
sergeych d739833c57 Step 8: bytecode ObjDynamic member access 2026-02-09 02:02:10 +03:00
sergeych 5fd322a43e Step 7: bytecode class-scope member refs 2026-02-09 01:53:12 +03:00
sergeych 3a46e59ec8 Step 6: support map spread in bytecode 2026-02-09 01:43:58 +03:00
sergeych 026b023892 Step 5: allow bytecode for delegated var decls 2026-02-09 01:40:31 +03:00
sergeych f9fe3d1186 Step 4: allow bytecode for destructuring/extension decls 2026-02-09 01:39:00 +03:00
sergeych f5ced02505 Step 3: bytecode try/catch/finally 2026-02-09 01:18:20 +03:00
sergeych 7ea67d4816 Step 2: bytecode for implicit this refs 2026-02-09 00:52:44 +03:00
sergeych 7b70a37e90 Step 1: module import slots and extension lookup 2026-02-08 21:47:36 +03:00
sergeych a557d0cc59 Add import binding data for module slot seeding 2026-02-08 21:47:36 +03:00
sergeych 40a55f298e Allow wrapping break/continue/return statements 2026-02-08 21:47:36 +03:00
sergeych b857686d7d Add bytecode support for destructuring decls 2026-02-08 21:47:36 +03:00
sergeych eb58720365 Add bytecode support for delegated var decls 2026-02-08 21:47:36 +03:00
141 changed files with 15851 additions and 5199 deletions

No files matched your search

+27 -12
View File
@@ -1,6 +1,31 @@
## Changelog ## 1.5.0-SNAPSHOT
### Unreleased ### 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:
- Language: Refined `protected` visibility rules - 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). - 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).
@@ -109,16 +134,6 @@
- Documentation updated (docs/OOP.md and tutorial quick-start) to reflect MI with active C3 MRO. - 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. - CLI: Added `fmt` as a first-class Clikt subcommand.
- Default behavior: formats files to stdout (no in-place edits by default). - Default behavior: formats files to stdout (no in-place edits by default).
- Options: - Options:
+1 -1
View File
@@ -1,4 +1,4 @@
# Lyng Language AI Specification (V1.3) # Lyng Language AI Specification (V1.5.0-SNAPSHOT)
High-density specification for LLMs. Reference this for all Lyng code generation. High-density specification for LLMs. Reference this for all Lyng code generation.
+4 -4
View File
@@ -48,7 +48,7 @@ assertEquals(A.One, A.E.One)
- [Language home](https://lynglang.com) - [Language home](https://lynglang.com)
- [introduction and tutorial](docs/tutorial.md) - start here please - [introduction and tutorial](docs/tutorial.md) - start here please
- [What's New in 1.3](docs/whats_new_1_3.md) - [What's New in 1.5](docs/whats_new_1_5.md)
- [Testing and Assertions](docs/Testing.md) - [Testing and Assertions](docs/Testing.md)
- [Filesystem and Processes (lyngio)](docs/lyngio.md) - [Filesystem and Processes (lyngio)](docs/lyngio.md)
- [Return Statement](docs/return_statement.md) - [Return Statement](docs/return_statement.md)
@@ -64,7 +64,7 @@ assertEquals(A.One, A.E.One)
```kotlin ```kotlin
// update to current please: // update to current please:
val lyngVersion = "0.6.1-SNAPSHOT" val lyngVersion = "1.5.0-SNAPSHOT"
repositories { repositories {
// ... // ...
@@ -177,7 +177,7 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
# Language Roadmap # Language Roadmap
We are now at **v1.0**: basic optimization performed, battery included: standard library is 90% here, initial We are now at **v1.5.0-SNAPSHOT** (stable development cycle): 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. support in HTML, popular editors, and IDEA; tools to syntax highlight and format code are ready. It was released closed to schedule.
Ready features: Ready features:
@@ -217,7 +217,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. 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 v1.5 Enhancing ## plan: towards v2.0 Next Generation
- [x] site with integrated interpreter to give a try - [x] site with integrated interpreter to give a try
- [x] kotlin part public API good docs, integration focused - [x] kotlin part public API good docs, integration focused
+7
View File
@@ -0,0 +1,7 @@
# Bytecode Migration Plan (Archived)
Status: completed.
Historical reference:
- `notes/archive/bytecode_migration_plan.md` (full plan)
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
+2
View File
@@ -63,6 +63,8 @@ In spite of this you can use ranges in for loops:
>>> 3 >>> 3
>>> void >>> void
The loop variable is read-only inside the loop body (behaves like a `val`).
but but
for( i in 1..<3 ) for( i in 1..<3 )
+1
View File
@@ -105,6 +105,7 @@ arguments list in almost arbitrary ways. For example:
var result = "" var result = ""
for( a in args ) result += a for( a in args ) result += a
} }
// loop variables are read-only inside the loop body
assertEquals( assertEquals(
"4231", "4231",
+71
View File
@@ -182,6 +182,77 @@ instance.value = 42
println(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.
```lyng
// Lyng side (in a module)
class Counter {
extern var value: Int
extern fun inc(by: Int): Int
}
```
Note: members must be marked `extern` so the compiler emits the ABI slots that Kotlin bindings attach to. This applies to functions and properties bound via `addFun` / `addVal` / `addVar`.
```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 = { _, self -> self.readField(this, "value").value },
set = { _, self, v -> self.writeField(this, "value", v) }
)
addFun("inc") { _, self, args ->
val by = args.requiredArg<ObjInt>(0).value
val current = self.readField(this, "value").value as ObjInt
val next = ObjInt(current.value + by)
self.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.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 ### 7) Read variable values back in Kotlin
The simplest approach: evaluate an expression that yields the value and convert it. The simplest approach: evaluate an expression that yields the value and convert it.
+1
View File
@@ -739,6 +739,7 @@ See also: [Testing and Assertions](Testing.md)
var result = [] var result = []
for( x in iterable ) result += transform(x) 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 })) assert( [11, 21, 31] == mapValues( [1,2,3], { it*10+1 }))
>>> void >>> void
+10 -2
View File
@@ -1,7 +1,7 @@
# What's New in Lyng # What's New in Lyng
This document highlights the latest additions and improvements to the Lyng language and its ecosystem. 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_3.md`. For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## Language Features
@@ -102,7 +102,7 @@ Singleton objects are declared using the `object` keyword. They provide a conven
```lyng ```lyng
object Config { object Config {
val version = "1.2.3" val version = "1.5.0-SNAPSHOT"
fun show() = println("Config version: " + version) fun show() = println("Config version: " + version)
} }
@@ -243,3 +243,11 @@ You can enable it in **Settings | Lyng Formatter | Enable Lyng autocompletion**.
### Kotlin API: Exception Handling ### 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. 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 classes/members in Lyng (marked `extern`) and bind the implementations in Kotlin before the first instance is created.
See **Embedding Lyng** for full samples and usage details.
+140
View File
@@ -0,0 +1,140 @@
# 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).
### 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). No type erasure: in a generic function you can, for example, check `A in T`, where T is the generic type.
- **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)
@@ -38,6 +38,7 @@ import kotlinx.coroutines.launch
import net.sergeych.lyng.ExecutionError import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Script import net.sergeych.lyng.Script
import net.sergeych.lyng.Source import net.sergeych.lyng.Source
import net.sergeych.lyng.requireScope
import net.sergeych.lyng.idea.LyngIcons import net.sergeych.lyng.idea.LyngIcons
import net.sergeych.lyng.obj.ObjVoid import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.getLyngExceptionMessageWithStackTrace import net.sergeych.lyng.obj.getLyngExceptionMessageWithStackTrace
@@ -81,7 +82,7 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
val sb = StringBuilder() val sb = StringBuilder()
for ((i, arg) in args.list.withIndex()) { for ((i, arg) in args.list.withIndex()) {
if (i > 0) sb.append(" ") if (i > 0) sb.append(" ")
sb.append(arg.toString(this).value) sb.append(arg.toString(requireScope()).value)
} }
console.print(sb.toString(), ConsoleViewContentType.NORMAL_OUTPUT) console.print(sb.toString(), ConsoleViewContentType.NORMAL_OUTPUT)
ObjVoid ObjVoid
@@ -90,7 +91,7 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
val sb = StringBuilder() val sb = StringBuilder()
for ((i, arg) in args.list.withIndex()) { for ((i, arg) in args.list.withIndex()) {
if (i > 0) sb.append(" ") if (i > 0) sb.append(" ")
sb.append(arg.toString(this).value) sb.append(arg.toString(requireScope()).value)
} }
console.print(sb.toString() + "\n", ConsoleViewContentType.NORMAL_OUTPUT) console.print(sb.toString() + "\n", ConsoleViewContentType.NORMAL_OUTPUT)
ObjVoid ObjVoid
@@ -122,6 +122,7 @@ class LyngCompletionContributor : CompletionContributor() {
fromText.forEach { add(it) } fromText.forEach { add(it) }
add("lyng.stdlib") add("lyng.stdlib")
}.toList() }.toList()
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, memberDotPos, imported, binding)
// Try inferring return/receiver class around the dot // Try inferring return/receiver class around the dot
val inferred = val inferred =
@@ -136,7 +137,7 @@ class LyngCompletionContributor : CompletionContributor() {
if (inferred != null) { if (inferred != null) {
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback inferred receiver/return class='$inferred' — offering its members") if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback inferred receiver/return class='$inferred' — offering its members")
offerMembers(emit, imported, inferred, sourceText = text, mini = mini) offerMembers(emit, imported, inferred, staticOnly = staticOnly, sourceText = text, mini = mini)
return return
} else { } else {
if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback could not infer class; keeping list empty (no globals after dot)") if (DEBUG_COMPLETION) log.info("[LYNG_DEBUG] Fallback could not infer class; keeping list empty (no globals after dot)")
@@ -295,6 +296,9 @@ class LyngCompletionContributor : CompletionContributor() {
} }
is MiniEnumDecl -> LookupElementBuilder.create(name) is MiniEnumDecl -> LookupElementBuilder.create(name)
.withIcon(AllIcons.Nodes.Enum) .withIcon(AllIcons.Nodes.Enum)
is MiniTypeAliasDecl -> LookupElementBuilder.create(name)
.withIcon(AllIcons.Nodes.Class)
.withTypeText(typeOf(d.target), true)
} }
emit(builder) emit(builder)
} }
@@ -372,6 +376,7 @@ class LyngCompletionContributor : CompletionContributor() {
when (m) { when (m) {
is MiniMemberFunDecl -> if (!m.isStatic) continue is MiniMemberFunDecl -> if (!m.isStatic) continue
is MiniMemberValDecl -> if (!m.isStatic) continue is MiniMemberValDecl -> if (!m.isStatic) continue
is MiniMemberTypeAliasDecl -> if (!m.isStatic) continue
is MiniInitDecl -> continue is MiniInitDecl -> continue
} }
} }
@@ -461,6 +466,16 @@ class LyngCompletionContributor : CompletionContributor() {
emit(builder) 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 -> {} is MiniInitDecl -> {}
} }
} }
@@ -317,7 +317,8 @@ 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 (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) { if (className != null) {
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini)?.let { (owner, member) -> val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] QuickDoc: literal/call '$ident' resolved to $owner.${member.name}") if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] QuickDoc: literal/call '$ident' resolved to $owner.${member.name}")
return when (member) { return when (member) {
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member) is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
@@ -380,7 +381,9 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
val lhs = previousWordBefore(text, idRange.startOffset) val lhs = previousWordBefore(text, idRange.startOffset)
if (lhs != null && hasDotBetween(text, lhs.endOffset, idRange.startOffset)) { if (lhs != null && hasDotBetween(text, lhs.endOffset, idRange.startOffset)) {
val className = text.substring(lhs.startOffset, lhs.endOffset) val className = text.substring(lhs.startOffset, lhs.endOffset)
DocLookupUtils.resolveMemberWithInheritance(importedModules, className, ident, mini)?.let { (owner, member) -> 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) ->
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Inheritance resolved $className.$ident to $owner.${member.name}") if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Inheritance resolved $className.$ident to $owner.${member.name}")
return when (member) { return when (member) {
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member) is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
@@ -405,7 +408,8 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
else -> DocLookupUtils.guessClassFromCallBefore(text, dotPos, importedModules, mini) else -> DocLookupUtils.guessClassFromCallBefore(text, dotPos, importedModules, mini)
} }
if (guessed != null) { if (guessed != null) {
DocLookupUtils.resolveMemberWithInheritance(importedModules, guessed, ident, mini)?.let { (owner, member) -> val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
DocLookupUtils.resolveMemberWithInheritance(importedModules, guessed, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Heuristic '$guessed.$ident' resolved via inheritance to $owner.${member.name}") if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Heuristic '$guessed.$ident' resolved via inheritance to $owner.${member.name}")
return when (member) { return when (member) {
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member) is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
@@ -424,7 +428,8 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
run { run {
val candidates = listOf("String", "Iterable", "Iterator", "List", "Collection", "Array", "Dict", "Regex") val candidates = listOf("String", "Iterable", "Iterator", "List", "Collection", "Array", "Dict", "Regex")
for (c in candidates) { for (c in candidates) {
DocLookupUtils.resolveMemberWithInheritance(importedModules, c, ident, mini)?.let { (owner, member) -> val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, importedModules, analysis.binding)
DocLookupUtils.resolveMemberWithInheritance(importedModules, c, ident, mini, staticOnly = staticOnly)?.let { (owner, member) ->
if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Candidate '$c.$ident' resolved via inheritance to $owner.${member.name}") if (DEBUG_INHERITANCE) log.info("[LYNG_DEBUG] Candidate '$c.$ident' resolved via inheritance to $owner.${member.name}")
return when (member) { return when (member) {
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member) is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
@@ -461,11 +466,13 @@ class LyngDocumentationProvider : AbstractDocumentationProvider() {
return when (member) { return when (member) {
is MiniMemberFunDecl -> renderMemberFunDoc(owner, member) is MiniMemberFunDecl -> renderMemberFunDoc(owner, member)
is MiniMemberValDecl -> renderMemberValDoc(owner, member) is MiniMemberValDecl -> renderMemberValDoc(owner, member)
is MiniMemberTypeAliasDecl -> renderMemberTypeAliasDoc(owner, member)
is MiniInitDecl -> null is MiniInitDecl -> null
is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules) is MiniFunDecl -> renderDeclDoc(member, text, mini, importedModules)
is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules) is MiniValDecl -> renderDeclDoc(member, text, mini, importedModules)
is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules) is MiniClassDecl -> renderDeclDoc(member, text, mini, importedModules)
is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules) is MiniEnumDecl -> renderDeclDoc(member, text, mini, importedModules)
is MiniTypeAliasDecl -> renderDeclDoc(member, text, mini, importedModules)
} }
} }
} }
@@ -48,9 +48,10 @@ class LyngPsiReference(element: PsiElement) : PsiPolyVariantReferenceBase<PsiEle
if (dotPos != null) { if (dotPos != null) {
val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported.toList(), binding) val receiverClass = DocLookupUtils.guessReceiverClassViaMini(mini, text, dotPos, imported.toList(), binding)
?: DocLookupUtils.guessReceiverClass(text, dotPos, imported.toList(), mini) ?: DocLookupUtils.guessReceiverClass(text, dotPos, imported.toList(), mini)
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, dotPos, imported.toList(), binding)
if (receiverClass != null) { if (receiverClass != null) {
val resolved = DocLookupUtils.resolveMemberWithInheritance(imported.toList(), receiverClass, name, mini) val resolved = DocLookupUtils.resolveMemberWithInheritance(imported.toList(), receiverClass, name, mini, staticOnly = staticOnly)
if (resolved != null) { if (resolved != null) {
val owner = resolved.first val owner = resolved.first
val member = resolved.second val member = resolved.second
@@ -25,6 +25,7 @@ import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.binding.BindingSnapshot import net.sergeych.lyng.binding.BindingSnapshot
import net.sergeych.lyng.miniast.DocLookupUtils import net.sergeych.lyng.miniast.DocLookupUtils
import net.sergeych.lyng.miniast.MiniScript import net.sergeych.lyng.miniast.MiniScript
import net.sergeych.lyng.tools.IdeLenientImportProvider
import net.sergeych.lyng.tools.LyngAnalysisRequest import net.sergeych.lyng.tools.LyngAnalysisRequest
import net.sergeych.lyng.tools.LyngAnalysisResult import net.sergeych.lyng.tools.LyngAnalysisResult
import net.sergeych.lyng.tools.LyngLanguageTools import net.sergeych.lyng.tools.LyngLanguageTools
+15 -3
View File
@@ -27,6 +27,7 @@ import com.github.ajalt.clikt.parameters.arguments.optional
import com.github.ajalt.clikt.parameters.options.flag import com.github.ajalt.clikt.parameters.options.flag
import com.github.ajalt.clikt.parameters.options.option import com.github.ajalt.clikt.parameters.options.option
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.LyngVersion import net.sergeych.lyng.LyngVersion
import net.sergeych.lyng.Script import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError import net.sergeych.lyng.ScriptError
@@ -167,7 +168,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
override fun help(context: Context): String = override fun help(context: Context): String =
""" """
The Lyng script language interpreter, language version is $LyngVersion. The Lyng script language runtime, language version is $LyngVersion.
Please refer form more information to the project site: Please refer form more information to the project site:
https://gitea.sergeych.net/SergeychWorks/lyng https://gitea.sergeych.net/SergeychWorks/lyng
@@ -198,7 +199,12 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
launcher { launcher {
// there is no script name, it is a first argument instead: // there is no script name, it is a first argument instead:
processErrors { processErrors {
baseScope.eval(execute!!) val script = Compiler.compileWithResolution(
Source("<eval>", execute!!),
baseScope.currentImportProvider,
seedScope = baseScope
)
script.execute(baseScope)
} }
} }
} }
@@ -236,7 +242,13 @@ suspend fun executeFile(fileName: String) {
text = text.substring(pos + 1) text = text.substring(pos + 1)
} }
processErrors { processErrors {
baseScopeDefer.await().eval(Source(fileName, text)) val scope = baseScopeDefer.await()
val script = Compiler.compileWithResolution(
Source(fileName, text),
scope.currentImportProvider,
seedScope = scope
)
script.execute(scope)
} }
} }
@@ -23,6 +23,8 @@ package net.sergeych.lyng.io.fs
import net.sergeych.lyng.ModuleScope import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.requireScope
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
@@ -437,7 +439,7 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
moduleName = module.packageName moduleName = module.packageName
) { ) {
fsGuard { fsGuard {
val chunkIt = thisObj.invokeInstanceMethod(this, "readUtf8Chunks") val chunkIt = thisObj.invokeInstanceMethod(requireScope(), "readUtf8Chunks")
ObjFsLinesIterator(chunkIt) ObjFsLinesIterator(chunkIt)
} }
} }
@@ -463,7 +465,7 @@ private suspend fun buildFsModule(module: ModuleScope, policy: FsAccessPolicy) {
// --- Helper classes and utilities --- // --- Helper classes and utilities ---
private fun parsePathArg(scope: Scope, self: ObjPath, arg: Obj): LyngPath { private fun parsePathArg(scope: ScopeFacade, self: ObjPath, arg: Obj): LyngPath {
return when (arg) { return when (arg) {
is ObjString -> arg.value.toPath() is ObjString -> arg.value.toPath()
is ObjPath -> arg.path is ObjPath -> arg.path
@@ -472,11 +474,11 @@ private fun parsePathArg(scope: Scope, self: ObjPath, arg: Obj): LyngPath {
} }
// Map Fs access denials to Lyng runtime exceptions for script-friendly errors // Map Fs access denials to Lyng runtime exceptions for script-friendly errors
private suspend inline fun Scope.fsGuard(crossinline block: suspend () -> Obj): Obj { private suspend inline fun ScopeFacade.fsGuard(crossinline block: suspend () -> Obj): Obj {
return try { return try {
block() block()
} catch (e: AccessDeniedException) { } catch (e: AccessDeniedException) {
raiseError(ObjIllegalOperationException(this, e.reasonDetail ?: "access denied")) raiseError(ObjIllegalOperationException(requireScope(), e.reasonDetail ?: "access denied"))
} }
} }
@@ -668,16 +670,17 @@ class ObjFsLinesIterator(
} }
} }
private suspend fun ensureBufferFilled(scope: Scope) { private suspend fun ensureBufferFilled(scope: ScopeFacade) {
if (buffer.contains('\n') || exhausted) return if (buffer.contains('\n') || exhausted) return
val actualScope = scope.requireScope()
// Pull next chunk from the underlying iterator // Pull next chunk from the underlying iterator
val it = chunksIterator.invokeInstanceMethod(scope, "iterator") val it = chunksIterator.invokeInstanceMethod(actualScope, "iterator")
val hasNext = it.invokeInstanceMethod(scope, "hasNext").toBool() val hasNext = it.invokeInstanceMethod(actualScope, "hasNext").toBool()
if (!hasNext) { if (!hasNext) {
exhausted = true exhausted = true
return return
} }
val next = it.invokeInstanceMethod(scope, "next") val next = it.invokeInstanceMethod(actualScope, "next")
buffer += next.toString() buffer += next.toString()
} }
} }
@@ -20,10 +20,11 @@ package net.sergeych.lyng.io.process
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import net.sergeych.lyng.ModuleScope import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.requireScope
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.statement
import net.sergeych.lyngio.process.* import net.sergeych.lyngio.process.*
import net.sergeych.lyngio.process.security.ProcessAccessDeniedException import net.sergeych.lyngio.process.security.ProcessAccessDeniedException
import net.sergeych.lyngio.process.security.ProcessAccessPolicy import net.sergeych.lyngio.process.security.ProcessAccessPolicy
@@ -205,20 +206,21 @@ class ObjRunningProcess(
override fun toString(): String = "RunningProcess($process)" override fun toString(): String = "RunningProcess($process)"
} }
private suspend inline fun Scope.processGuard(crossinline block: suspend () -> Obj): Obj { private suspend inline fun ScopeFacade.processGuard(crossinline block: suspend () -> Obj): Obj {
return try { return try {
block() block()
} catch (e: ProcessAccessDeniedException) { } catch (e: ProcessAccessDeniedException) {
raiseError(ObjIllegalOperationException(this, e.reasonDetail ?: "process access denied")) raiseError(ObjIllegalOperationException(requireScope(), e.reasonDetail ?: "process access denied"))
} catch (e: Exception) { } catch (e: Exception) {
raiseError(ObjIllegalOperationException(this, e.message ?: "process error")) raiseError(ObjIllegalOperationException(requireScope(), e.message ?: "process error"))
} }
} }
private fun Flow<String>.toLyngFlow(flowScope: Scope): ObjFlow { private fun Flow<String>.toLyngFlow(flowScope: ScopeFacade): ObjFlow {
val producer = statement { val producer = net.sergeych.lyng.obj.ObjExternCallable.fromBridge {
val builder = (this as? net.sergeych.lyng.ClosureScope)?.callScope?.thisObj as? ObjFlowBuilder val scope = requireScope()
?: this.thisObj as? ObjFlowBuilder val builder = (scope as? net.sergeych.lyng.BytecodeClosureScope)?.callScope?.thisObj as? ObjFlowBuilder
?: scope.thisObj as? ObjFlowBuilder
this@toLyngFlow.collect { this@toLyngFlow.collect {
try { try {
@@ -230,5 +232,5 @@ private fun Flow<String>.toLyngFlow(flowScope: Scope): ObjFlow {
} }
ObjVoid ObjVoid
} }
return ObjFlow(producer, flowScope) return ObjFlow(producer, flowScope.requireScope())
} }
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.3.0-SNAPSHOT" version = "1.5.0-SNAPSHOT"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -113,7 +113,7 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
} }
suspend fun missingValue(a: Item, error: String): Obj { suspend fun missingValue(a: Item, error: String): Obj {
return a.defaultValue?.execute(scope) return a.defaultValue?.callOn(scope)
?: if (a.type.isNullable) ObjNull else scope.raiseIllegalArgument(error) ?: if (a.type.isNullable) ObjNull else scope.raiseIllegalArgument(error)
} }
@@ -250,10 +250,194 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
} }
} }
/**
* 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
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
}
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)
}
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)
if (headConsumedTo != callArgs.size)
scope.raiseIllegalArgument("too many arguments for the call")
}
}
/** /**
* Single argument declaration descriptor. * Single argument declaration descriptor.
* *
* @param defaultValue default value, if set, can't be an [Obj] as it can depend on the call site, call args, etc. * @param defaultValue default value, callable evaluated at call site.
* If not null, could be executed on __caller context__ only. * If not null, could be executed on __caller context__ only.
*/ */
data class Item( data class Item(
@@ -266,7 +450,7 @@ 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. * 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__. * So it is a [Statement] that must be executed on __caller context__.
*/ */
val defaultValue: Statement? = null, val defaultValue: Obj? = null,
val accessType: AccessType? = null, val accessType: AccessType? = null,
val visibility: Visibility? = null, val visibility: Visibility? = null,
val isTransient: Boolean = false, val isTransient: Boolean = false,
@@ -20,7 +20,7 @@ package net.sergeych.lyng
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
data class ParsedArgument( data class ParsedArgument(
val value: Statement, val value: Obj,
val pos: Pos, val pos: Pos,
val isSplat: Boolean = false, val isSplat: Boolean = false,
val name: String? = null, val name: String? = null,
@@ -40,115 +40,115 @@ data class ParsedArgument(
if (!hasSplatOrNamed && count == this.size) { if (!hasSplatOrNamed && count == this.size) {
val quick = when (count) { val quick = when (count) {
0 -> Arguments.EMPTY 0 -> Arguments.EMPTY
1 -> Arguments(listOf(this.elementAt(0).value.execute(scope)), tailBlockMode) 1 -> Arguments(listOf(this.elementAt(0).value.callOn(scope)), tailBlockMode)
2 -> { 2 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
Arguments(listOf(a0, a1), tailBlockMode) Arguments(listOf(a0, a1), tailBlockMode)
} }
3 -> { 3 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
Arguments(listOf(a0, a1, a2), tailBlockMode) Arguments(listOf(a0, a1, a2), tailBlockMode)
} }
4 -> { 4 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3), tailBlockMode) Arguments(listOf(a0, a1, a2, a3), tailBlockMode)
} }
5 -> { 5 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4), tailBlockMode)
} }
6 -> { 6 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5), tailBlockMode)
} }
7 -> { 7 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6), tailBlockMode)
} }
8 -> { 8 -> {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
val a7 = this.elementAt(7).value.execute(scope) val a7 = this.elementAt(7).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7), tailBlockMode)
} }
9 -> if (PerfFlags.ARG_SMALL_ARITY_12) { 9 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
val a7 = this.elementAt(7).value.execute(scope) val a7 = this.elementAt(7).value.callOn(scope)
val a8 = this.elementAt(8).value.execute(scope) val a8 = this.elementAt(8).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8), tailBlockMode)
} else null } else null
10 -> if (PerfFlags.ARG_SMALL_ARITY_12) { 10 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
val a7 = this.elementAt(7).value.execute(scope) val a7 = this.elementAt(7).value.callOn(scope)
val a8 = this.elementAt(8).value.execute(scope) val a8 = this.elementAt(8).value.callOn(scope)
val a9 = this.elementAt(9).value.execute(scope) val a9 = this.elementAt(9).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9), tailBlockMode)
} else null } else null
11 -> if (PerfFlags.ARG_SMALL_ARITY_12) { 11 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
val a7 = this.elementAt(7).value.execute(scope) val a7 = this.elementAt(7).value.callOn(scope)
val a8 = this.elementAt(8).value.execute(scope) val a8 = this.elementAt(8).value.callOn(scope)
val a9 = this.elementAt(9).value.execute(scope) val a9 = this.elementAt(9).value.callOn(scope)
val a10 = this.elementAt(10).value.execute(scope) val a10 = this.elementAt(10).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), tailBlockMode)
} else null } else null
12 -> if (PerfFlags.ARG_SMALL_ARITY_12) { 12 -> if (PerfFlags.ARG_SMALL_ARITY_12) {
val a0 = this.elementAt(0).value.execute(scope) val a0 = this.elementAt(0).value.callOn(scope)
val a1 = this.elementAt(1).value.execute(scope) val a1 = this.elementAt(1).value.callOn(scope)
val a2 = this.elementAt(2).value.execute(scope) val a2 = this.elementAt(2).value.callOn(scope)
val a3 = this.elementAt(3).value.execute(scope) val a3 = this.elementAt(3).value.callOn(scope)
val a4 = this.elementAt(4).value.execute(scope) val a4 = this.elementAt(4).value.callOn(scope)
val a5 = this.elementAt(5).value.execute(scope) val a5 = this.elementAt(5).value.callOn(scope)
val a6 = this.elementAt(6).value.execute(scope) val a6 = this.elementAt(6).value.callOn(scope)
val a7 = this.elementAt(7).value.execute(scope) val a7 = this.elementAt(7).value.callOn(scope)
val a8 = this.elementAt(8).value.execute(scope) val a8 = this.elementAt(8).value.callOn(scope)
val a9 = this.elementAt(9).value.execute(scope) val a9 = this.elementAt(9).value.callOn(scope)
val a10 = this.elementAt(10).value.execute(scope) val a10 = this.elementAt(10).value.callOn(scope)
val a11 = this.elementAt(11).value.execute(scope) val a11 = this.elementAt(11).value.callOn(scope)
Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), tailBlockMode) Arguments(listOf(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), tailBlockMode)
} else null } else null
else -> null else -> null
@@ -166,12 +166,12 @@ data class ParsedArgument(
// Named argument // Named argument
if (named == null) named = linkedMapOf() if (named == null) named = linkedMapOf()
if (named.containsKey(x.name)) scope.raiseIllegalArgument("argument '${x.name}' is already set") if (named.containsKey(x.name)) scope.raiseIllegalArgument("argument '${x.name}' is already set")
val v = x.value.execute(scope) val v = x.value.callOn(scope)
named[x.name] = v named[x.name] = v
namedSeen = true namedSeen = true
continue continue
} }
val value = x.value.execute(scope) val value = x.value.callOn(scope)
if (x.isSplat) { if (x.isSplat) {
when { when {
// IMPORTANT: handle ObjMap BEFORE generic Iterable to ensure map splats // IMPORTANT: handle ObjMap BEFORE generic Iterable to ensure map splats
@@ -21,28 +21,14 @@ import net.sergeych.lyng.obj.Obj
class BlockStatement( class BlockStatement(
val block: Script, val block: Script,
val slotPlan: Map<String, Int>, val slotPlan: Map<String, Int>,
val scopeId: Int,
val captureSlots: List<CaptureSlot> = emptyList(), val captureSlots: List<CaptureSlot> = emptyList(),
private val startPos: Pos, private val startPos: Pos,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = startPos
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
val target = if (scope.skipScopeCreation) scope else scope.createChildScope(startPos) return bytecodeOnly(scope, "block statement")
if (slotPlan.isNotEmpty()) target.applySlotPlan(slotPlan)
if (captureSlots.isNotEmpty()) {
val applyScope = scope as? ApplyScope
for (capture in captureSlots) {
val rec = if (applyScope != null) {
applyScope.resolveCaptureRecord(capture.name)
?: applyScope.callScope.resolveCaptureRecord(capture.name)
} else {
scope.resolveCaptureRecord(capture.name)
} ?: (applyScope?.callScope ?: scope)
.raiseSymbolNotFound("symbol ${capture.name} not found")
target.updateSlotFor(capture.name, rec)
}
}
return block.execute(target)
} }
fun statements(): List<Statement> = block.debugStatements() fun statements(): List<Statement> = block.debugStatements()
@@ -0,0 +1,19 @@
/*
* 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
@@ -0,0 +1,34 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.bytecode.BytecodeStatement
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.bytecode.seedFrameLocalsFromScope
import net.sergeych.lyng.obj.Obj
internal suspend fun executeBytecodeWithSeed(scope: Scope, stmt: Statement, label: String): Obj {
val bytecode = when (stmt) {
is BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
} ?: scope.raiseIllegalState("$label requires bytecode statement")
scope.pos = bytecode.pos
return CmdVm().execute(bytecode.bytecodeFunction(), scope, scope.args) { frame, _ ->
seedFrameLocalsFromScope(frame, scope)
}
}
@@ -19,4 +19,6 @@ package net.sergeych.lyng
data class CaptureSlot( data class CaptureSlot(
val name: String, val name: String,
val ownerScopeId: Int? = null,
val ownerSlot: Int? = null,
) )
@@ -1,5 +1,5 @@
/* /*
* Copyright 2026 Sergey S. Chernov * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -12,20 +12,191 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*
*/ */
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.*
data class ClassDeclBaseSpec(
val name: String,
val args: List<ParsedArgument>?
)
data class ClassDeclSpec(
val declaredName: String?,
val className: String,
val typeName: String,
val startPos: Pos,
val isExtern: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isObject: Boolean,
val isAnonymous: Boolean,
val baseSpecs: List<ClassDeclBaseSpec>,
val constructorArgs: ArgsDeclaration?,
val constructorFieldIds: Map<String, Int>?,
val bodyInit: Statement?,
val initScope: List<Statement>,
)
internal suspend fun executeClassDecl(
scope: Scope,
spec: ClassDeclSpec,
bodyCaptureRecords: List<ObjRecord>? = null,
bodyCaptureNames: List<String>? = null
): Obj {
fun checkClosedParents(parents: List<ObjClass>, pos: Pos) {
val closedParent = parents.firstOrNull { it.isClosed } ?: return
throw ScriptError(pos, "can't inherit from closed class ${closedParent.className}")
}
if (spec.isObject) {
val parentClasses = spec.baseSpecs.map { baseSpec ->
val rec = scope[baseSpec.name] ?: throw ScriptError(spec.startPos, "unknown base class: ${baseSpec.name}")
(rec.value as? ObjClass) ?: throw ScriptError(spec.startPos, "${baseSpec.name} is not a class")
}
checkClosedParents(parentClasses, spec.startPos)
val newClass = ObjInstanceClass(spec.className, *parentClasses.toTypedArray())
newClass.isAnonymous = spec.isAnonymous
newClass.constructorMeta = ArgsDeclaration(emptyList(), Token.Type.RPAREN)
for (i in parentClasses.indices) {
val argsList = spec.baseSpecs[i].args
if (argsList != null) newClass.directParentArgs[parentClasses[i]] = argsList
}
val classScope = scope.createChildScope(newThisObj = newClass)
if (!bodyCaptureRecords.isNullOrEmpty() && !bodyCaptureNames.isNullOrEmpty()) {
classScope.captureRecords = bodyCaptureRecords
classScope.captureNames = bodyCaptureNames
}
classScope.currentClassCtx = newClass
newClass.classScope = classScope
classScope.addConst("object", newClass)
spec.bodyInit?.let { executeBytecodeWithSeed(classScope, it, "object body init") }
val instance = newClass.callOn(scope.createChildScope(Arguments.EMPTY))
if (spec.declaredName != null) {
scope.addItem(spec.declaredName, false, instance)
}
return instance
}
if (spec.isExtern) {
val rec = scope[spec.className]
val existing = rec?.value as? ObjClass
val resolved = if (existing != null) {
existing
} else if (spec.className.contains('.')) {
scope.resolveQualifiedIdentifier(spec.className) as? ObjClass
} else {
null
}
val stub = resolved ?: ObjInstanceClass(spec.className).apply { this.isAbstract = true }
spec.declaredName?.let { scope.addItem(it, false, stub) }
return stub
}
val parentClasses = spec.baseSpecs.map { baseSpec ->
val rec = scope[baseSpec.name]
val cls = rec?.value as? ObjClass
if (cls != null) return@map cls
if (baseSpec.name == "Exception") return@map ObjException.Root
if (rec == null) throw ScriptError(spec.startPos, "unknown base class: ${baseSpec.name}")
throw ScriptError(spec.startPos, "${baseSpec.name} is not a class")
}
checkClosedParents(parentClasses, spec.startPos)
val constructorCode = object : Statement() {
override val pos: Pos = spec.startPos
override suspend fun execute(scope: Scope): Obj {
val instance = scope.thisObj as ObjInstance
return instance
}
}
val newClass = ObjInstanceClass(spec.className, *parentClasses.toTypedArray()).also {
it.isAbstract = spec.isAbstract
it.isClosed = spec.isClosed
it.instanceConstructor = constructorCode
it.constructorMeta = spec.constructorArgs
for (i in parentClasses.indices) {
val argsList = spec.baseSpecs[i].args
if (argsList != null) it.directParentArgs[parentClasses[i]] = argsList
}
spec.constructorArgs?.params?.forEach { p ->
if (p.accessType != null) {
it.createField(
p.name,
ObjNull,
isMutable = p.accessType == AccessType.Var,
visibility = p.visibility ?: Visibility.Public,
declaringClass = it,
pos = Pos.builtIn,
isTransient = p.isTransient,
type = ObjRecord.Type.ConstructorField,
fieldId = spec.constructorFieldIds?.get(p.name)
)
}
}
}
spec.declaredName?.let { name ->
scope.addItem(name, false, newClass)
val module = scope as? ModuleScope
val frame = module?.moduleFrame
if (module != null && frame != null) {
val idx = module.moduleFrameLocalSlotNames.indexOf(name)
if (idx >= 0) {
frame.setObj(idx, newClass)
}
}
}
val classScope = scope.createChildScope(newThisObj = newClass)
if (!bodyCaptureRecords.isNullOrEmpty() && !bodyCaptureNames.isNullOrEmpty()) {
classScope.captureRecords = bodyCaptureRecords
classScope.captureNames = bodyCaptureNames
}
classScope.currentClassCtx = newClass
newClass.classScope = classScope
spec.bodyInit?.let { executeBytecodeWithSeed(classScope, it, "class body init") }
if (spec.initScope.isNotEmpty()) {
for (s in spec.initScope) {
executeBytecodeWithSeed(classScope, s, "class init")
}
}
newClass.checkAbstractSatisfaction(spec.startPos)
return newClass
}
private suspend fun requireBytecodeBody(
scope: Scope,
stmt: Statement,
label: String
): net.sergeych.lyng.bytecode.BytecodeStatement {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
}
return bytecode ?: scope.raiseIllegalState("$label requires bytecode statement")
}
class ClassDeclStatement( class ClassDeclStatement(
private val delegate: Statement, val spec: ClassDeclSpec,
private val startPos: Pos,
val declaredName: String?,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = spec.startPos
val declaredName: String? get() = spec.declaredName
val typeName: String get() = spec.typeName
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
return delegate.execute(scope) return executeClassDecl(scope, spec)
}
override suspend fun callOn(scope: Scope): Obj {
val target = scope.parent ?: scope
return executeClassDecl(target, spec)
} }
} }
@@ -0,0 +1,84 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjProperty
class ClassInstanceInitDeclStatement(
val initStatement: Statement,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
return bytecodeOnly(scope, "class instance init declaration")
}
}
class ClassInstanceFieldDeclStatement(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val fieldId: Int?,
val initStatement: Statement?,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
return bytecodeOnly(scope, "class instance field declaration")
}
}
class ClassInstancePropertyDeclStatement(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val prop: ObjProperty,
val methodId: Int?,
val initStatement: Statement?,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
return bytecodeOnly(scope, "class instance property declaration")
}
}
class ClassInstanceDelegatedDeclStatement(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val methodId: Int?,
val initStatement: Statement?,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
return bytecodeOnly(scope, "class instance delegated declaration")
}
}
@@ -0,0 +1,111 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjUnset
import net.sergeych.lyng.obj.ObjVoid
class ClassStaticFieldInitStatement(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val initializer: Statement?,
val isDelegated: Boolean,
val isTransient: Boolean,
private val startPos: Pos,
) : Statement() {
override val pos: Pos = startPos
override suspend fun execute(scope: Scope): Obj {
val initValue = initializer?.let { execBytecodeOnly(scope, it, "class static field init") }?.byValueCopy()
?: ObjNull
val cls = scope.thisObj as? ObjClass
?: scope.raiseIllegalState("static field init requires class scope")
return if (isDelegated) {
val accessTypeStr = if (isMutable) "Var" else "Val"
val accessType = ObjString(accessTypeStr)
val finalDelegate = try {
initValue.invokeInstanceMethod(
scope,
"bind",
Arguments(ObjString(name), accessType, scope.thisObj)
)
} catch (_: Exception) {
initValue
}
cls.createClassField(
name,
ObjUnset,
isMutable,
visibility,
writeVisibility,
startPos,
isTransient = isTransient,
type = ObjRecord.Type.Delegated
).apply {
delegate = finalDelegate
}
scope.addItem(
name,
isMutable,
ObjUnset,
visibility,
writeVisibility,
recordType = ObjRecord.Type.Delegated,
isTransient = isTransient
).apply {
delegate = finalDelegate
}
finalDelegate
} else {
cls.createClassField(
name,
initValue,
isMutable,
visibility,
writeVisibility,
startPos,
isTransient = isTransient
)
scope.addItem(
name,
isMutable,
initValue,
visibility,
writeVisibility,
recordType = ObjRecord.Type.Field,
isTransient = isTransient
)
initValue
}
}
private suspend fun execBytecodeOnly(scope: Scope, stmt: Statement, label: String): Obj {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
} ?: scope.raiseIllegalState("$label requires bytecode statement")
return bytecode.execute(scope)
}
}
@@ -18,21 +18,18 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjRecord import net.sergeych.lyng.obj.ObjRecord
/** /**
* Scope that adds a "closure" to caller; most often it is used to apply class instance to caller scope. * Bytecode-oriented closure scope that keeps the call scope parent chain for stack traces
* Inherits [Scope.args] and [Scope.thisObj] from [callScope] and adds lookup for symbols * while carrying the lexical closure for `this` variants and module resolution.
* from [closureScope] with proper precedence * Unlike legacy closure scopes, it does not override name lookup.
*/ */
class ClosureScope( class BytecodeClosureScope(
val callScope: Scope, val callScope: Scope,
val closureScope: Scope, val closureScope: Scope,
private val preferredThisType: String? = null private val preferredThisType: String? = null
) : ) :
// Important: use closureScope.thisObj so unqualified members (e.g., fields) resolve to the instance
// we captured, not to the caller's `this` (e.g., FlowBuilder).
Scope(callScope, callScope.args, thisObj = closureScope.thisObj) { Scope(callScope, callScope.args, thisObj = closureScope.thisObj) {
init { init {
@@ -45,43 +42,8 @@ class ClosureScope(
merged.addAll(callScope.thisVariants) merged.addAll(callScope.thisVariants)
merged.addAll(closureScope.thisVariants) merged.addAll(closureScope.thisVariants)
setThisVariants(primaryThis, merged) setThisVariants(primaryThis, merged)
// Preserve the lexical class context of the closure by default. This ensures that lambdas
// created inside a class method keep access to that class's private/protected members even
// when executed from within another object's method (e.g., Mutex.withLock), which may set
// its own currentClassCtx temporarily. If the closure has no class context, inherit caller's.
this.currentClassCtx = closureScope.currentClassCtx ?: callScope.currentClassCtx this.currentClassCtx = closureScope.currentClassCtx ?: callScope.currentClassCtx
} }
override fun get(name: String): ObjRecord? {
if (name == "this") return thisObj.asReadonly
// 1. Current frame locals (parameters, local variables)
tryGetLocalRecord(this, name, currentClassCtx)?.let { return it }
// 2. Lexical environment (captured locals from entire ancestry)
closureScope.chainLookupIgnoreClosure(name, followClosure = true, caller = currentClassCtx)?.let { return it }
// 3. Lexical this members (captured receiver)
val receiver = thisObj
val effectiveClass = receiver as? ObjClass ?: receiver.objClass
for (cls in effectiveClass.mro) {
val rec = cls.members[name] ?: cls.classScope?.objects?.get(name)
if (rec != null && !rec.isAbstract) {
if (canAccessMember(rec.visibility, rec.declaringClass ?: cls, currentClassCtx, name)) {
return rec.copy(receiver = receiver)
}
}
}
// Finally, root object fallback
Obj.rootObjectType.members[name]?.let { rec ->
if (canAccessMember(rec.visibility, rec.declaringClass, currentClassCtx, name)) {
return rec.copy(receiver = receiver)
}
}
// 4. Call environment (caller locals, caller this, and global fallback)
return callScope.get(name)
}
} }
class ApplyScope(val callScope: Scope, val applied: Scope) : class ApplyScope(val callScope: Scope, val applied: Scope) :
@@ -92,7 +54,7 @@ class ApplyScope(val callScope: Scope, val applied: Scope) :
} }
override fun applyClosure(closure: Scope, preferredThisType: String?): Scope { override fun applyClosure(closure: Scope, preferredThisType: String?): Scope {
return ClosureScope(this, closure, preferredThisType) return BytecodeClosureScope(this, closure, preferredThisType)
} }
} }
File diff suppressed because it is too large. Load diff
@@ -18,9 +18,6 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
class DelegatedVarDeclStatement( class DelegatedVarDeclStatement(
val name: String, val name: String,
@@ -28,28 +25,13 @@ class DelegatedVarDeclStatement(
val visibility: Visibility, val visibility: Visibility,
val initializer: Statement, val initializer: Statement,
val isTransient: Boolean, val isTransient: Boolean,
val slotIndex: Int?,
val scopeId: Int?,
private val startPos: Pos, private val startPos: Pos,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = startPos
override suspend fun execute(context: Scope): Obj { override suspend fun execute(context: Scope): Obj {
val initValue = initializer.execute(context) return bytecodeOnly(context, "delegated var declaration")
val accessTypeStr = if (isMutable) "Var" else "Val"
val accessType = ObjString(accessTypeStr)
val finalDelegate = try {
initValue.invokeInstanceMethod(context, "bind", Arguments(ObjString(name), accessType, ObjNull))
} catch (e: Exception) {
initValue
}
val rec = context.addItem(
name,
isMutable,
ObjNull,
visibility,
recordType = ObjRecord.Type.Delegated,
isTransient = isTransient
)
rec.delegate = finalDelegate
return finalDelegate
} }
} }
@@ -18,7 +18,6 @@ package net.sergeych.lyng
import net.sergeych.lyng.obj.ListLiteralRef import net.sergeych.lyng.obj.ListLiteralRef
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjVoid
class DestructuringVarDeclStatement( class DestructuringVarDeclStatement(
val pattern: ListLiteralRef, val pattern: ListLiteralRef,
@@ -30,20 +29,6 @@ class DestructuringVarDeclStatement(
override val pos: Pos, override val pos: Pos,
) : Statement() { ) : Statement() {
override suspend fun execute(context: Scope): Obj { override suspend fun execute(context: Scope): Obj {
val value = initializer.execute(context) return bytecodeOnly(context, "destructuring declaration")
for (name in names) {
context.addItem(name, true, ObjVoid, visibility, isTransient = isTransient)
}
pattern.setAt(pos, context, value)
if (!isMutable) {
for (name in names) {
val rec = context.objects[name]!!
val immutableRec = rec.copy(isMutable = false)
context.objects[name] = immutableRec
context.localBindings[name] = immutableRec
context.updateSlotFor(name, immutableRec)
}
}
return ObjVoid
} }
} }
@@ -19,12 +19,20 @@ package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
class EnumDeclStatement( class EnumDeclStatement(
private val delegate: Statement, val declaredName: String,
val qualifiedName: String,
val entries: List<String>,
val lifted: Boolean,
private val startPos: Pos, private val startPos: Pos,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = startPos
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
return delegate.execute(scope) return bytecodeOnly(scope, "enum declaration")
}
override suspend fun callOn(scope: Scope): Obj {
val target = scope.parent ?: scope
return execute(target)
} }
} }
@@ -17,11 +17,7 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjExtensionPropertyGetterCallable
import net.sergeych.lyng.obj.ObjExtensionPropertySetterCallable
import net.sergeych.lyng.obj.ObjProperty import net.sergeych.lyng.obj.ObjProperty
import net.sergeych.lyng.obj.ObjRecord
class ExtensionPropertyDeclStatement( class ExtensionPropertyDeclStatement(
val extTypeName: String, val extTypeName: String,
@@ -33,28 +29,6 @@ class ExtensionPropertyDeclStatement(
override val pos: Pos = startPos override val pos: Pos = startPos
override suspend fun execute(context: Scope): Obj { override suspend fun execute(context: Scope): Obj {
val type = context[extTypeName]?.value ?: context.raiseSymbolNotFound("class $extTypeName not found") return bytecodeOnly(context, "extension property declaration")
if (type !is ObjClass) context.raiseClassCastError("$extTypeName is not the class instance")
context.addExtension(
type,
property.name,
ObjRecord(
property,
isMutable = false,
visibility = visibility,
writeVisibility = setterVisibility,
declaringClass = null,
type = ObjRecord.Type.Property
)
)
val getterName = extensionPropertyGetterName(extTypeName, property.name)
val getterWrapper = ObjExtensionPropertyGetterCallable(property.name, property)
context.addItem(getterName, false, getterWrapper, visibility, recordType = ObjRecord.Type.Fun)
if (property.setter != null) {
val setterName = extensionPropertySetterName(extTypeName, property.name)
val setterWrapper = ObjExtensionPropertySetterCallable(property.name, property)
context.addItem(setterName, false, setterWrapper, visibility, recordType = ObjRecord.Type.Fun)
}
return property
} }
} }
@@ -36,16 +36,30 @@ class FrameSlotRef(
private val frame: FrameAccess, private val frame: FrameAccess,
private val slot: Int, private val slot: Int,
) : net.sergeych.lyng.obj.Obj() { ) : net.sergeych.lyng.obj.Obj() {
override suspend fun compareTo(scope: Scope, other: Obj): Int {
val resolvedOther = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
return read().compareTo(scope, resolvedOther)
}
fun read(): Obj { fun read(): Obj {
return when (frame.getSlotTypeCode(slot)) { val typeCode = frame.getSlotTypeCode(slot)
return when (typeCode) {
SlotType.INT.code -> ObjInt.of(frame.getInt(slot)) SlotType.INT.code -> ObjInt.of(frame.getInt(slot))
SlotType.REAL.code -> ObjReal.of(frame.getReal(slot)) SlotType.REAL.code -> ObjReal.of(frame.getReal(slot))
SlotType.BOOL.code -> if (frame.getBool(slot)) ObjTrue else ObjFalse SlotType.BOOL.code -> if (frame.getBool(slot)) ObjTrue else ObjFalse
SlotType.OBJ.code -> frame.getObj(slot) SlotType.OBJ.code -> frame.getObj(slot)
else -> ObjNull else -> frame.getObj(slot)
} }
} }
internal fun refersTo(frame: FrameAccess, slot: Int): Boolean {
return this.frame === frame && this.slot == slot
}
fun write(value: Obj) { fun write(value: Obj) {
when (value) { when (value) {
is ObjInt -> frame.setInt(slot, value.value) is ObjInt -> frame.setInt(slot, value.value)
@@ -55,3 +69,25 @@ class FrameSlotRef(
} }
} }
} }
class RecordSlotRef(
private val record: ObjRecord,
) : net.sergeych.lyng.obj.Obj() {
override suspend fun compareTo(scope: Scope, other: Obj): Int {
val resolvedOther = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
return read().compareTo(scope, resolvedOther)
}
fun read(): Obj {
val direct = record.value
return if (direct is FrameSlotRef) direct.read() else direct
}
fun write(value: Obj) {
record.value = value
}
}
@@ -17,14 +17,235 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjExternCallable
import net.sergeych.lyng.obj.ObjExtensionMethodCallable
import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjUnset
import net.sergeych.lyng.obj.ObjVoid
class FunctionClosureBox(
var closure: Scope? = null,
var captureContext: Scope? = null,
var captureRecords: List<ObjRecord>? = null,
)
data class FunctionDeclSpec(
val name: String,
val visibility: Visibility,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isStatic: Boolean,
val isTransient: Boolean,
val isDelegated: Boolean,
val delegateExpression: Statement?,
val delegateInitStatement: Statement?,
val extTypeName: String?,
val extensionWrapperName: String?,
val memberMethodId: Int?,
val actualExtern: Boolean,
val parentIsClassBody: Boolean,
val externCallSignature: CallSignature?,
val annotation: (suspend (Scope, ObjString, Statement) -> Statement)?,
val fnBody: Statement,
val closureBox: FunctionClosureBox,
val captureSlots: List<CaptureSlot>,
val slotIndex: Int?,
val scopeId: Int?,
val startPos: Pos,
)
internal suspend fun executeFunctionDecl(
scope: Scope,
spec: FunctionDeclSpec,
captureRecords: List<ObjRecord>? = null
): Obj {
spec.closureBox.captureRecords = captureRecords
if (spec.actualExtern && spec.extTypeName == null && !spec.parentIsClassBody) {
val existing = scope.get(spec.name)
if (existing != null) {
val value = (existing.value as? ObjExternCallable) ?: ObjExternCallable.wrap(existing.value)
scope.addItem(
spec.name,
false,
value,
spec.visibility,
callSignature = existing.callSignature
)
return value
}
}
if (spec.isDelegated) {
val delegateExpr = spec.delegateExpression ?: scope.raiseError("delegated function missing delegate")
val accessType = ObjString("Callable")
val initValue = executeBytecodeWithSeed(scope, delegateExpr, "delegated function")
val finalDelegate = try {
initValue.invokeInstanceMethod(scope, "bind", Arguments(ObjString(spec.name), accessType, scope.thisObj))
} catch (e: Exception) {
initValue
}
if (spec.extTypeName != null) {
val type = scope[spec.extTypeName]?.value ?: scope.raiseSymbolNotFound("class ${spec.extTypeName} not found")
if (type !is ObjClass) scope.raiseClassCastError("${spec.extTypeName} is not the class instance")
scope.addExtension(
type,
spec.name,
ObjRecord(ObjUnset, isMutable = false, visibility = spec.visibility, declaringClass = null, type = ObjRecord.Type.Delegated).apply {
delegate = finalDelegate
}
)
return finalDelegate
}
val th = scope.thisObj
if (spec.isStatic) {
(th as ObjClass).createClassField(
spec.name,
ObjUnset,
false,
spec.visibility,
null,
spec.startPos,
isTransient = spec.isTransient,
type = ObjRecord.Type.Delegated
).apply {
delegate = finalDelegate
}
scope.addItem(
spec.name,
false,
ObjUnset,
spec.visibility,
recordType = ObjRecord.Type.Delegated,
isTransient = spec.isTransient
).apply {
delegate = finalDelegate
}
} else if (th is ObjClass) {
val cls: ObjClass = th
cls.createField(
spec.name,
ObjUnset,
false,
spec.visibility,
null,
spec.startPos,
declaringClass = cls,
isAbstract = spec.isAbstract,
isClosed = spec.isClosed,
isOverride = spec.isOverride,
isTransient = spec.isTransient,
type = ObjRecord.Type.Delegated,
methodId = spec.memberMethodId
)
val initStmt = spec.delegateInitStatement
?: scope.raiseIllegalState("missing delegated init statement for ${spec.name}")
cls.instanceInitializers += requireBytecodeBody(scope, initStmt, "delegated function init")
} else {
scope.addItem(
spec.name,
false,
ObjUnset,
spec.visibility,
recordType = ObjRecord.Type.Delegated,
isTransient = spec.isTransient
).apply {
delegate = finalDelegate
}
}
return finalDelegate
}
if (spec.isStatic || !spec.parentIsClassBody) {
spec.closureBox.closure = scope
}
if (spec.parentIsClassBody) {
spec.closureBox.captureContext = scope
}
val annotatedFnBody = spec.annotation?.invoke(scope, ObjString(spec.name), spec.fnBody) ?: spec.fnBody
val compiledFnBody = annotatedFnBody
spec.extTypeName?.let { typeName ->
val type = scope[typeName]?.value ?: scope.raiseSymbolNotFound("class $typeName not found")
if (type !is ObjClass) scope.raiseClassCastError("$typeName is not the class instance")
scope.addExtension(
type,
spec.name,
ObjRecord(
compiledFnBody,
isMutable = false,
visibility = spec.visibility,
declaringClass = null,
type = ObjRecord.Type.Fun
)
)
val wrapperName = spec.extensionWrapperName ?: extensionCallableName(typeName, spec.name)
val wrapper = ObjExtensionMethodCallable(spec.name, compiledFnBody)
scope.addItem(wrapperName, false, wrapper, spec.visibility, recordType = ObjRecord.Type.Fun)
} ?: run {
val th = scope.thisObj
if (!spec.isStatic && th is ObjClass) {
val cls: ObjClass = th
cls.createField(
spec.name,
compiledFnBody,
isMutable = true,
visibility = spec.visibility,
pos = spec.startPos,
declaringClass = cls,
isAbstract = spec.isAbstract,
isClosed = spec.isClosed,
isOverride = spec.isOverride,
type = ObjRecord.Type.Fun,
methodId = spec.memberMethodId
)
val memberValue = cls.members[spec.name]?.value ?: compiledFnBody
scope.addItem(spec.name, false, memberValue, spec.visibility, callSignature = spec.externCallSignature)
compiledFnBody
} else {
scope.addItem(
spec.name,
false,
compiledFnBody,
spec.visibility,
recordType = ObjRecord.Type.Fun,
callSignature = spec.externCallSignature
)
}
}
return annotatedFnBody
}
private suspend fun requireBytecodeBody(
scope: Scope,
stmt: Statement,
label: String
): net.sergeych.lyng.bytecode.BytecodeStatement {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
}
return bytecode ?: scope.raiseIllegalState("$label requires bytecode statement")
}
class FunctionDeclStatement( class FunctionDeclStatement(
private val delegate: Statement, val spec: FunctionDeclSpec,
private val startPos: Pos,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = spec.startPos
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
return delegate.execute(scope) return executeFunctionDecl(scope, spec)
}
override suspend fun callOn(scope: Scope): Obj {
val target = scope.parent ?: scope
return executeFunctionDecl(target, spec)
} }
} }
@@ -0,0 +1,28 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
sealed class ImportBindingSource {
data class Module(val name: String, val pos: Pos) : ImportBindingSource()
object Root : ImportBindingSource()
object Seed : ImportBindingSource()
}
data class ImportBinding(
val symbol: String,
val source: ImportBindingSource,
)
@@ -28,10 +28,19 @@ class InlineBlockStatement(
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
var last: Obj = ObjVoid var last: Obj = ObjVoid
for (stmt in statements) { for (stmt in statements) {
last = stmt.execute(scope) last = requireBytecodeBody(scope, stmt, "inline block").execute(scope)
} }
return last return last
} }
fun statements(): List<Statement> = statements fun statements(): List<Statement> = statements
private suspend fun requireBytecodeBody(scope: Scope, stmt: Statement, label: String): net.sergeych.lyng.bytecode.BytecodeStatement {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
}
return bytecode ?: scope.raiseIllegalState("$label requires bytecode statement")
}
} }
@@ -0,0 +1,139 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjProperty
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjUnset
import net.sergeych.lyng.obj.ObjVoid
class InstanceFieldInitStatement(
val storageName: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val isLateInitVal: Boolean,
val initializer: Statement?,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
val initValue = initializer?.let { execBytecodeOnly(scope, it, "instance field init") }?.byValueCopy()
?: if (isLateInitVal) ObjUnset else ObjNull
scope.addItem(
storageName,
isMutable,
initValue,
visibility,
writeVisibility,
recordType = ObjRecord.Type.Field,
isAbstract = isAbstract,
isClosed = isClosed,
isOverride = isOverride,
isTransient = isTransient
)
return ObjVoid
}
private suspend fun execBytecodeOnly(scope: Scope, stmt: Statement, label: String): Obj {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
} ?: scope.raiseIllegalState("$label requires bytecode statement")
return bytecode.execute(scope)
}
}
class InstancePropertyInitStatement(
val storageName: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val prop: ObjProperty,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
scope.addItem(
storageName,
isMutable,
prop,
visibility,
writeVisibility,
recordType = ObjRecord.Type.Property,
isAbstract = isAbstract,
isClosed = isClosed,
isOverride = isOverride,
isTransient = isTransient
)
return ObjVoid
}
}
class InstanceDelegatedInitStatement(
val storageName: String,
val memberName: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val isTransient: Boolean,
val accessTypeLabel: String,
val initializer: Statement,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
val initValue = executeBytecodeWithSeed(scope, initializer, "instance delegated init")
val accessType = ObjString(accessTypeLabel)
val finalDelegate = try {
initValue.invokeInstanceMethod(
scope,
"bind",
Arguments(ObjString(memberName), accessType, scope.thisObj)
)
} catch (_: Exception) {
initValue
}
scope.addItem(
storageName,
isMutable,
ObjUnset,
visibility,
writeVisibility,
recordType = ObjRecord.Type.Delegated,
isAbstract = isAbstract,
isClosed = isClosed,
isOverride = isOverride,
isTransient = isTransient
).apply {
delegate = finalDelegate
}
return ObjVoid
}
}
@@ -17,6 +17,8 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.bytecode.BytecodeFrame
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.obj.ObjRecord import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.pacman.ImportProvider import net.sergeych.lyng.pacman.ImportProvider
@@ -33,6 +35,29 @@ class ModuleScope(
constructor(importProvider: ImportProvider, source: Source) : this(importProvider, source.startPos, source.fileName) constructor(importProvider: ImportProvider, source: Source) : this(importProvider, source.startPos, source.fileName)
internal var importedModules: List<ModuleScope> = emptyList()
internal var moduleFrame: BytecodeFrame? = null
internal var moduleFrameLocalCount: Int = -1
internal var moduleFrameLocalSlotNames: Array<String?> = emptyArray()
internal var moduleFrameLocalSlotMutables: BooleanArray = BooleanArray(0)
internal var moduleFrameLocalSlotDelegated: BooleanArray = BooleanArray(0)
internal fun ensureModuleFrame(fn: CmdFunction): BytecodeFrame {
val current = moduleFrame
val frame = if (current == null || moduleFrameLocalCount != fn.localCount) {
BytecodeFrame(fn.localCount, 0).also {
moduleFrame = it
moduleFrameLocalCount = fn.localCount
}
} else {
current
}
moduleFrameLocalSlotNames = fn.localSlotNames
moduleFrameLocalSlotMutables = fn.localSlotMutables
moduleFrameLocalSlotDelegated = fn.localSlotDelegated
return frame
}
/** /**
* Import symbols into the scope. It _is called_ after the module is imported by [ImportProvider.prepareImport] * Import symbols into the scope. It _is called_ after the module is imported by [ImportProvider.prepareImport]
* which checks symbol availability and accessibility prior to execution. * which checks symbol availability and accessibility prior to execution.
@@ -92,4 +117,3 @@ class ModuleScope(
super.get(name) super.get(name)
} }
} }
@@ -0,0 +1,60 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.bytecode.CmdFrame
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjNull
class PropertyAccessorStatement(
val body: Statement,
val argName: String?,
override val pos: Pos,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
if (argName != null) {
val prev = scope.skipScopeCreation
scope.skipScopeCreation = true
return try {
val bytecodeStmt = requireBytecodeBody(scope, body, "property accessor")
val fn = bytecodeStmt.bytecodeFunction()
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, arguments ->
val slotPlan = fn.localSlotPlanByName()
val slotIndex = slotPlan[argName]
?: scope.raiseIllegalState("property accessor argument $argName missing from slot plan")
val argValue = arguments.list.firstOrNull() ?: ObjNull
frame.frame.setObj(slotIndex, argValue)
}
scope.pos = pos
CmdVm().execute(fn, scope, scope.args, binder)
} finally {
scope.skipScopeCreation = prev
}
}
return requireBytecodeBody(scope, body, "property accessor").execute(scope)
}
private suspend fun requireBytecodeBody(scope: Scope, stmt: Statement, label: String): net.sergeych.lyng.bytecode.BytecodeStatement {
val bytecode = when (stmt) {
is net.sergeych.lyng.bytecode.BytecodeStatement -> stmt
is BytecodeBodyProvider -> stmt.bytecodeBody()
else -> null
}
return bytecode ?: scope.raiseIllegalState("$label requires bytecode statement")
}
}
@@ -20,7 +20,7 @@ package net.sergeych.lyng
/** /**
* Tiny, size-bounded cache for compiled Regex patterns. Activated only when [PerfFlags.REGEX_CACHE] is true. * Tiny, size-bounded cache for compiled Regex patterns. Activated only when [PerfFlags.REGEX_CACHE] is true.
* This is a very simple FIFO-ish cache sufficient for micro-benchmarks and common repeated patterns. * This is a very simple FIFO-ish cache sufficient for micro-benchmarks and common repeated patterns.
* Not thread-safe by design; the interpreter typically runs scripts on confined executors. * Not thread-safe by design; the runtime typically runs scripts on confined executors.
*/ */
object RegexCache { object RegexCache {
private const val MAX = 64 private const val MAX = 64
@@ -39,7 +39,7 @@ fun nextFrameId(): Long = FrameIdGen.nextId()
* *
* There are special types of scopes: * There are special types of scopes:
* *
* - [ClosureScope] - scope used to apply a closure to some thisObj scope * - [BytecodeClosureScope] - scope used to apply a closure to some thisObj scope
*/ */
open class Scope( open class Scope(
var parent: Scope?, var parent: Scope?,
@@ -59,6 +59,8 @@ open class Scope(
// Enabled by default for child scopes; module/class scopes can ignore it. // Enabled by default for child scopes; module/class scopes can ignore it.
private val slots: MutableList<ObjRecord> = mutableListOf() private val slots: MutableList<ObjRecord> = mutableListOf()
private val nameToSlot: MutableMap<String, Int> = mutableMapOf() private val nameToSlot: MutableMap<String, Int> = mutableMapOf()
internal var captureRecords: List<ObjRecord>? = null
internal var captureNames: List<String>? = null
/** /**
* Auxiliary per-frame map of local bindings (locals declared in this frame). * Auxiliary per-frame map of local bindings (locals declared in this frame).
* This helps resolving locals across suspension when slot ownership isn't * This helps resolving locals across suspension when slot ownership isn't
@@ -74,9 +76,19 @@ open class Scope(
internal fun setThisVariants(primary: Obj, extras: List<Obj>) { internal fun setThisVariants(primary: Obj, extras: List<Obj>) {
thisObj = primary thisObj = primary
val extrasSnapshot = when {
extras.isEmpty() -> emptyList()
else -> {
try {
extras.toList()
} catch (_: Exception) {
emptyList()
}
}
}
thisVariants.clear() thisVariants.clear()
thisVariants.add(primary) thisVariants.add(primary)
for (obj in extras) { for (obj in extrasSnapshot) {
if (obj !== primary && !thisVariants.contains(obj)) { if (obj !== primary && !thisVariants.contains(obj)) {
thisVariants.add(obj) thisVariants.add(obj)
} }
@@ -96,7 +108,7 @@ open class Scope(
for (cls in receiverClass.mro) { for (cls in receiverClass.mro) {
s.extensions[cls]?.get(name)?.let { return it } s.extensions[cls]?.get(name)?.let { return it }
} }
if (s is ClosureScope) { if (s is BytecodeClosureScope) {
s.closureScope.findExtension(receiverClass, name)?.let { return it } s.closureScope.findExtension(receiverClass, name)?.let { return it }
} }
s = s.parent s = s.parent
@@ -120,7 +132,7 @@ open class Scope(
/** /**
* Internal lookup helpers that deliberately avoid invoking overridden `get` implementations * Internal lookup helpers that deliberately avoid invoking overridden `get` implementations
* (notably in ClosureScope) to prevent accidental ping-pong and infinite recursion across * (notably in BytecodeClosureScope) to prevent accidental ping-pong and infinite recursion across
* intertwined closure frames. They traverse the plain parent chain and consult only locals * intertwined closure frames. They traverse the plain parent chain and consult only locals
* and bindings of each frame. Instance/class member fallback must be decided by the caller. * and bindings of each frame. Instance/class member fallback must be decided by the caller.
*/ */
@@ -163,20 +175,16 @@ open class Scope(
val effectiveCaller = caller ?: currentClassCtx val effectiveCaller = caller ?: currentClassCtx
while (s != null && hops++ < 1024) { while (s != null && hops++ < 1024) {
tryGetLocalRecord(s, name, effectiveCaller)?.let { return it } tryGetLocalRecord(s, name, effectiveCaller)?.let { return it }
s = if (followClosure && s is ClosureScope) s.closureScope else s.parent s = if (followClosure && s is BytecodeClosureScope) s.closureScope else s.parent
} }
return null return null
} }
internal fun resolveCaptureRecord(name: String): ObjRecord? {
return chainLookupIgnoreClosure(name, followClosure = true, caller = currentClassCtx)
}
/** /**
* Perform base Scope.get semantics for this frame without delegating into parent.get * Perform base Scope.get semantics for this frame without delegating into parent.get
* virtual dispatch. This checks: * virtual dispatch. This checks:
* - locals/bindings in this frame * - locals/bindings in this frame
* - walks raw parent chain for locals/bindings (ignoring ClosureScope-specific overrides) * - walks raw parent chain for locals/bindings (ignoring BytecodeClosureScope-specific overrides)
* - finally falls back to this frame's `thisObj` instance/class members * - finally falls back to this frame's `thisObj` instance/class members
*/ */
internal fun baseGetIgnoreClosure(name: String): ObjRecord? { internal fun baseGetIgnoreClosure(name: String): ObjRecord? {
@@ -206,7 +214,7 @@ open class Scope(
* - locals/bindings of each frame * - locals/bindings of each frame
* - then instance/class members of each frame's `thisObj`. * - then instance/class members of each frame's `thisObj`.
* This completely avoids invoking overridden `get` implementations, preventing * This completely avoids invoking overridden `get` implementations, preventing
* ping-pong recursion between `ClosureScope` frames. * ping-pong recursion between `BytecodeClosureScope` frames.
*/ */
internal fun chainLookupWithMembers(name: String, caller: net.sergeych.lyng.obj.ObjClass? = currentClassCtx, followClosure: Boolean = false): ObjRecord? { internal fun chainLookupWithMembers(name: String, caller: net.sergeych.lyng.obj.ObjClass? = currentClassCtx, followClosure: Boolean = false): ObjRecord? {
var s: Scope? = this var s: Scope? = this
@@ -223,7 +231,7 @@ open class Scope(
} else return rec } else return rec
} }
} }
s = if (followClosure && s is ClosureScope) s.closureScope else s.parent s = if (followClosure && s is BytecodeClosureScope) s.closureScope else s.parent
} }
return null return null
} }
@@ -463,6 +471,24 @@ open class Scope(
} }
} }
internal fun applySlotPlanReset(plan: Map<String, Int>, records: Map<String, ObjRecord>) {
if (plan.isEmpty()) return
slots.clear()
nameToSlot.clear()
val maxIndex = plan.values.maxOrNull() ?: return
val targetSize = maxIndex + 1
repeat(targetSize) {
slots.add(ObjRecord(ObjUnset, isMutable = true))
}
for ((name, idx) in plan) {
nameToSlot[name] = idx
val record = records[name]
if (record != null && record.value !== ObjUnset) {
slots[idx] = record
}
}
}
fun applySlotPlanWithSnapshot(plan: Map<String, Int>): Map<String, Int?> { fun applySlotPlanWithSnapshot(plan: Map<String, Int>): Map<String, Int?> {
if (plan.isEmpty()) return emptyMap() if (plan.isEmpty()) return emptyMap()
val maxIndex = plan.values.maxOrNull() ?: return emptyMap() val maxIndex = plan.values.maxOrNull() ?: return emptyMap()
@@ -612,11 +638,6 @@ open class Scope(
it.value = value it.value = value
// keep local binding index consistent within the frame // keep local binding index consistent within the frame
localBindings[name] = it localBindings[name] = it
// If we are a ClosureScope, mirror binding into the caller frame to keep it discoverable
// across suspension when resumed on the call frame
if (this is ClosureScope) {
callScope.localBindings[name] = it
}
bumpClassLayoutIfNeeded(name, value, recordType) bumpClassLayoutIfNeeded(name, value, recordType)
it it
} ?: addItem(name, true, value, visibility, writeVisibility, recordType, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride) } ?: addItem(name, true, value, visibility, writeVisibility, recordType, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride)
@@ -671,19 +692,6 @@ open class Scope(
} }
// Index this binding within the current frame to help resolve locals across suspension // Index this binding within the current frame to help resolve locals across suspension
localBindings[name] = rec localBindings[name] = rec
// If we are a ClosureScope, mirror binding into the caller frame to keep it discoverable
// across suspension when resumed on the call frame
if (this is ClosureScope) {
callScope.localBindings[name] = rec
// Additionally, expose the binding in caller's objects and slot map so identifier
// resolution after suspension can still find it even if the active scope is a child
// of the callScope (e.g., due to internal withChildFrame usage).
// This keeps visibility within the method body but prevents leaking outside the caller frame.
callScope.objects[name] = rec
if (callScope.getSlotIndexOf(name) == null) {
callScope.allocateSlotFor(name, rec)
}
}
// Map to a slot for fast local access (ensure consistency) // Map to a slot for fast local access (ensure consistency)
if (nameToSlot.isEmpty()) { if (nameToSlot.isEmpty()) {
allocateSlotFor(name, rec) allocateSlotFor(name, rec)
@@ -711,7 +719,7 @@ open class Scope(
return ns.objClass return ns.objClass
} }
inline fun addVoidFn(vararg names: String, crossinline fn: suspend Scope.() -> Unit) { inline fun addVoidFn(vararg names: String, crossinline fn: suspend ScopeFacade.() -> Unit) {
addFn(*names) { addFn(*names) {
fn(this) fn(this)
ObjVoid ObjVoid
@@ -727,13 +735,8 @@ open class Scope(
return CmdDisassembler.disassemble(bytecode) return CmdDisassembler.disassemble(bytecode)
} }
fun addFn(vararg names: String, callSignature: CallSignature? = null, fn: suspend Scope.() -> Obj) { fun addFn(vararg names: String, callSignature: CallSignature? = null, fn: suspend ScopeFacade.() -> Obj) {
val newFn = object : Statement() { val newFn = net.sergeych.lyng.obj.ObjExternCallable.fromBridge { fn() }
override val pos: Pos = Pos.builtIn
override suspend fun execute(scope: Scope): Obj = scope.fn()
}
for (name in names) { for (name in names) {
addItem( addItem(
name, name,
@@ -811,37 +814,34 @@ open class Scope(
} }
open fun applyClosure(closure: Scope, preferredThisType: String? = null): Scope = open fun applyClosure(closure: Scope, preferredThisType: String? = null): Scope =
ClosureScope(this, closure, preferredThisType) BytecodeClosureScope(this, closure, preferredThisType)
internal fun applyClosureForBytecode(closure: Scope, preferredThisType: String? = null): Scope {
return BytecodeClosureScope(this, closure, preferredThisType)
}
/** /**
* Resolve and evaluate a qualified identifier exactly as compiled code would. * Resolve and evaluate a qualified identifier (e.g. `A.B.C`) using the same name/field
* For input like `A.B.C`, it builds the same ObjRef chain the compiler emits: * resolution rules as compiled code, without invoking the compiler or ObjRef evaluation.
* `LocalVarRef("A", Pos.builtIn)` followed by `FieldRef` for each segment, then evaluates it.
* This mirrors `eval("A.B.C")` resolution semantics without invoking the compiler.
*/ */
suspend fun resolveQualifiedIdentifier(qualifiedName: String): Obj { suspend fun resolveQualifiedIdentifier(qualifiedName: String): Obj {
val trimmed = qualifiedName.trim() val trimmed = qualifiedName.trim()
if (trimmed.isEmpty()) raiseSymbolNotFound("empty identifier") if (trimmed.isEmpty()) raiseSymbolNotFound("empty identifier")
val parts = trimmed.split('.') val parts = trimmed.split('.')
val first = parts[0] val first = parts[0]
val ref: ObjRef = if (first == "this") { val base: Obj = if (first == "this") {
ConstRef(thisObj.asReadonly) thisObj
} else { } else {
var s: Scope? = this val rec = get(first) ?: raiseSymbolNotFound(first)
var slot: Int? = null resolve(rec, first)
var guard = 0
while (s != null && guard++ < 1024 && slot == null) {
slot = s.getSlotIndexOf(first)
s = s.parent
}
if (slot == null) raiseSymbolNotFound(first)
LocalSlotRef(first, slot, 0, isMutable = false, isDelegated = false, Pos.builtIn, strict = true)
} }
var ref0: ObjRef = ref var current = base
for (i in 1 until parts.size) { for (i in 1 until parts.size) {
ref0 = FieldRef(ref0, parts[i], false) val name = parts[i]
val rec = current.readField(this, name)
current = resolve(rec, name)
} }
return ref0.evalValue(this) return current
} }
suspend fun resolve(rec: ObjRecord, name: String): Obj { suspend fun resolve(rec: ObjRecord, name: String): Obj {
@@ -892,4 +892,10 @@ open class Scope(
fun new(): Scope = fun new(): Scope =
Script.defaultImportManager.copy().newModuleAt(Pos.builtIn) Script.defaultImportManager.copy().newModuleAt(Pos.builtIn)
} }
fun requireClass(name: String): net.sergeych.lyng.obj.ObjClass {
val rec = get(name) ?: raiseSymbolNotFound(name)
return rec.value as? net.sergeych.lyng.obj.ObjClass
?: raiseClassCastError("Expected class $name, got ${rec.value.objClass.className}")
}
} }
@@ -0,0 +1,110 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
/**
* Limited facade for Kotlin bridge callables.
* Exposes only the minimal API needed to read/write vars and invoke methods.
*/
interface ScopeFacade {
val args: Arguments
var pos: Pos
var thisObj: Obj
operator fun get(name: String): ObjRecord?
suspend fun resolve(rec: ObjRecord, name: String): Obj
suspend fun assign(rec: ObjRecord, name: String, newValue: Obj)
fun raiseError(message: String): Nothing
fun raiseError(obj: net.sergeych.lyng.obj.ObjException): Nothing
fun raiseClassCastError(message: String): Nothing
fun raiseIllegalArgument(message: String): Nothing
fun raiseNoSuchElement(message: String = "No such element"): Nothing
fun raiseSymbolNotFound(name: String): Nothing
fun raiseIllegalState(message: String = "Illegal argument error"): Nothing
fun raiseNotImplemented(what: String = "operation"): Nothing
suspend fun call(callee: Obj, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Obj
suspend fun toStringOf(obj: Obj, forInspect: Boolean = false): ObjString
suspend fun inspect(obj: Obj): String
fun trace(text: String = "")
}
internal class ScopeBridge(internal val scope: Scope) : ScopeFacade {
override val args: Arguments
get() = scope.args
override var pos: Pos
get() = scope.pos
set(value) { scope.pos = value }
override var thisObj: Obj
get() = scope.thisObj
set(value) { scope.thisObj = value }
override fun get(name: String): ObjRecord? = scope[name]
override suspend fun resolve(rec: ObjRecord, name: String): Obj = scope.resolve(rec, name)
override suspend fun assign(rec: ObjRecord, name: String, newValue: Obj) = scope.assign(rec, name, newValue)
override fun raiseError(message: String): Nothing = scope.raiseError(message)
override fun raiseError(obj: net.sergeych.lyng.obj.ObjException): Nothing = scope.raiseError(obj)
override fun raiseClassCastError(message: String): Nothing = scope.raiseClassCastError(message)
override fun raiseIllegalArgument(message: String): Nothing = scope.raiseIllegalArgument(message)
override fun raiseNoSuchElement(message: String): Nothing = scope.raiseNoSuchElement(message)
override fun raiseSymbolNotFound(name: String): Nothing = scope.raiseSymbolNotFound(name)
override fun raiseIllegalState(message: String): Nothing = scope.raiseIllegalState(message)
override fun raiseNotImplemented(what: String): Nothing = scope.raiseNotImplemented(what)
override suspend fun call(callee: Obj, args: Arguments, newThisObj: Obj?): Obj {
return callee.callOn(scope.createChildScope(scope.pos, args = args, newThisObj = newThisObj))
}
override suspend fun toStringOf(obj: Obj, forInspect: Boolean): ObjString = obj.toString(scope, forInspect)
override suspend fun inspect(obj: Obj): String = obj.inspect(scope)
override fun trace(text: String) = scope.trace(text)
}
/** Public factory for bridge facades. */
fun Scope.asFacade(): ScopeFacade = ScopeBridge(this)
inline fun <reified T : Obj> ScopeFacade.requiredArg(index: Int): T {
if (args.list.size <= index) raiseError("Expected at least ${index + 1} argument, got ${args.list.size}")
return (args.list[index].byValueCopy() as? T)
?: raiseClassCastError("Expected type ${T::class.simpleName}, got ${args.list[index]::class.simpleName}")
}
inline fun <reified T : Obj> ScopeFacade.requireOnlyArg(): T {
if (args.list.size != 1) raiseError("Expected exactly 1 argument, got ${args.list.size}")
return requiredArg(0)
}
fun ScopeFacade.requireExactCount(count: Int) {
if (args.list.size != count) {
raiseError("Expected exactly $count arguments, got ${args.list.size}")
}
}
fun ScopeFacade.requireNoArgs() {
if (args.list.isNotEmpty()) {
raiseError("This function does not accept any arguments")
}
}
inline fun <reified T : Obj> ScopeFacade.thisAs(): T {
val obj = thisObj
return (obj as? T) ?: raiseClassCastError(
"Cannot cast ${obj.objClass.className} to ${T::class.simpleName}"
)
}
fun ScopeFacade.requireScope(): Scope =
(this as? ScopeBridge)?.scope ?: raiseIllegalState("ScopeFacade requires ScopeBridge")
@@ -20,10 +20,13 @@ package net.sergeych.lyng
import kotlinx.coroutines.delay import kotlinx.coroutines.delay
import kotlinx.coroutines.yield import kotlinx.coroutines.yield
import net.sergeych.lyng.Script.Companion.defaultImportManager import net.sergeych.lyng.Script.Companion.defaultImportManager
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lyng.bridge.LyngClassBridge
import net.sergeych.lynon.ObjLynonClass import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer import net.sergeych.mp_tools.globalDefer
import kotlin.math.* import kotlin.math.*
@@ -33,39 +36,103 @@ class Script(
override val pos: Pos, override val pos: Pos,
private val statements: List<Statement> = emptyList(), private val statements: List<Statement> = emptyList(),
private val moduleSlotPlan: Map<String, Int> = emptyMap(), private val moduleSlotPlan: Map<String, Int> = emptyMap(),
private val moduleDeclaredNames: Set<String> = emptySet(),
private val importBindings: Map<String, ImportBinding> = emptyMap(),
private val importedModules: List<ImportBindingSource.Module> = emptyList(),
private val moduleBytecode: CmdFunction? = null,
// private val catchReturn: Boolean = false, // private val catchReturn: Boolean = false,
) : Statement() { ) : Statement() {
fun statements(): List<Statement> = statements
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
if (moduleSlotPlan.isNotEmpty()) { scope.pos = pos
scope.applySlotPlan(moduleSlotPlan) val execScope = resolveModuleScope(scope) ?: scope
seedModuleSlots(scope) val isModuleScope = execScope is ModuleScope
val shouldSeedModule = isModuleScope || execScope.thisObj === ObjVoid
val moduleTarget = execScope
if (shouldSeedModule) {
seedModuleSlots(moduleTarget, scope)
} }
var lastResult: Obj = ObjVoid moduleBytecode?.let { fn ->
for (s in statements) { if (execScope is ModuleScope) {
lastResult = s.execute(scope) execScope.ensureModuleFrame(fn)
}
return CmdVm().execute(fn, execScope, scope.args) { frame, _ ->
seedModuleLocals(frame, moduleTarget, scope)
}
} }
return lastResult if (statements.isNotEmpty()) {
scope.raiseIllegalState("bytecode-only execution is required; missing module bytecode")
}
return ObjVoid
} }
private fun seedModuleSlots(scope: Scope) { private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) {
val parent = scope.parent ?: return if (importBindings.isEmpty() && importedModules.isEmpty()) return
for (name in moduleSlotPlan.keys) { seedImportBindings(scope, seedScope)
if (scope.objects.containsKey(name)) { }
scope.updateSlotFor(name, scope.objects[name]!!)
continue private suspend fun seedModuleLocals(
frame: net.sergeych.lyng.bytecode.CmdFrame,
scope: Scope,
seedScope: Scope
) {
val localNames = frame.fn.localSlotNames
if (localNames.isEmpty()) return
val values = HashMap<String, Obj>()
val base = frame.fn.scopeSlotCount
for (i in localNames.indices) {
val name = localNames[i] ?: continue
if (moduleDeclaredNames.contains(name)) continue
val record = seedScope.getLocalRecordDirect(name) ?: findSeedRecord(seedScope, name) ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
scope.resolve(record, name)
} else {
record.value
} }
val seed = findSeedRecord(parent, name) frame.setObjUnchecked(base + i, value)
if (seed != null) { }
if (name == "Exception" && seed.value !is ObjClass) { }
scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false))
} else { private suspend fun seedImportBindings(scope: Scope, seedScope: Scope) {
scope.updateSlotFor(name, seed) val provider = scope.currentImportProvider
val importedModules = LinkedHashSet<ModuleScope>()
for (moduleRef in this.importedModules) {
importedModules.add(provider.prepareImport(moduleRef.pos, moduleRef.name, null))
}
if (scope is ModuleScope) {
scope.importedModules = importedModules.toList()
}
for ((name, binding) in importBindings) {
val record = when (val source = binding.source) {
is ImportBindingSource.Module -> {
val module = provider.prepareImport(source.pos, source.name, null)
importedModules.add(module)
module.objects[binding.symbol]?.takeIf { it.visibility.isPublic }
?: scope.raiseSymbolNotFound("symbol ${source.name}.${binding.symbol} not found")
}
ImportBindingSource.Root -> {
provider.rootScope.objects[binding.symbol]?.takeIf { it.visibility.isPublic }
?: scope.raiseSymbolNotFound("symbol ${binding.symbol} not found")
}
ImportBindingSource.Seed -> {
findSeedRecord(seedScope, binding.symbol)
?: scope.raiseSymbolNotFound("symbol ${binding.symbol} not found")
} }
continue
} }
if (name == "Exception") { if (name == "Exception" && record.value !is ObjClass) {
scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false)) scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false))
} else {
scope.updateSlotFor(name, record)
}
}
for (module in importedModules) {
for ((cls, map) in module.extensions) {
for ((symbol, record) in map) {
if (record.visibility.isPublic) {
scope.addExtension(cls, symbol, record)
}
}
} }
} }
} }
@@ -85,6 +152,10 @@ class Script(
return null return null
} }
private fun resolveModuleScope(scope: Scope): ModuleScope? {
return scope as? ModuleScope
}
internal fun debugStatements(): List<Statement> = statements internal fun debugStatements(): List<Statement> = statements
suspend fun execute() = execute( suspend fun execute() = execute(
@@ -105,15 +176,15 @@ class Script(
addConst("Unset", ObjUnset) addConst("Unset", ObjUnset)
addFn("print") { addFn("print") {
for ((i, a) in args.withIndex()) { for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.toString(this).value) if (i > 0) print(' ' + toStringOf(a).value)
else print(a.toString(this).value) else print(toStringOf(a).value)
} }
ObjVoid ObjVoid
} }
addFn("println") { addFn("println") {
for ((i, a) in args.withIndex()) { for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.toString(this).value) if (i > 0) print(' ' + toStringOf(a).value)
else print(a.toString(this).value) else print(toStringOf(a).value)
} }
println() println()
ObjVoid ObjVoid
@@ -126,7 +197,7 @@ class Script(
} else { } else {
Arguments.EMPTY Arguments.EMPTY
} }
callee.callOn(createChildScope(pos, args = rest)) call(callee, rest)
} }
addFn("floor") { addFn("floor") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
@@ -224,12 +295,12 @@ class Script(
var result = value var result = value
if (range.start != null && !range.start.isNull) { if (range.start != null && !range.start.isNull) {
if (result.compareTo(this, range.start) < 0) { if (result.compareTo(requireScope(), range.start) < 0) {
result = range.start result = range.start
} }
} }
if (range.end != null && !range.end.isNull) { if (range.end != null && !range.end.isNull) {
val cmp = range.end.compareTo(this, result) val cmp = range.end.compareTo(requireScope(), result)
if (range.isEndInclusive) { if (range.isEndInclusive) {
if (cmp < 0) result = range.end if (cmp < 0) result = range.end
} else { } else {
@@ -252,43 +323,53 @@ class Script(
addVoidFn("assert") { addVoidFn("assert") {
val cond = requiredArg<ObjBool>(0) val cond = requiredArg<ObjBool>(0)
val message = if (args.size > 1) val message = if (args.size > 1)
": " + (args[1] as Statement).execute(this).toString(this).value ": " + toStringOf(call(args[1] as Obj)).value
else "" else ""
if (!cond.value == true) if (!cond.value == true)
raiseError(ObjAssertionFailedException(this, "Assertion failed$message")) raiseError(ObjAssertionFailedException(requireScope(), "Assertion failed$message"))
}
fun unwrapCompareArg(value: Obj): Obj {
val resolved = when (value) {
is FrameSlotRef -> value.read()
is RecordSlotRef -> value.read()
else -> value
}
return if (resolved === ObjUnset.objClass) ObjUnset else resolved
} }
addVoidFn("assertEquals") { addVoidFn("assertEquals") {
val a = requiredArg<Obj>(0) val a = unwrapCompareArg(requiredArg(0))
val b = requiredArg<Obj>(1) val b = unwrapCompareArg(requiredArg(1))
if (a.compareTo(this, b) != 0) if (a.compareTo(requireScope(), b) != 0) {
raiseError( raiseError(
ObjAssertionFailedException( ObjAssertionFailedException(
this, requireScope(),
"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}" "Assertion failed: ${inspect(a)} == ${inspect(b)}"
) )
) )
}
} }
// alias used in tests // alias used in tests
addVoidFn("assertEqual") { addVoidFn("assertEqual") {
val a = requiredArg<Obj>(0) val a = unwrapCompareArg(requiredArg(0))
val b = requiredArg<Obj>(1) val b = unwrapCompareArg(requiredArg(1))
if (a.compareTo(this, b) != 0) if (a.compareTo(requireScope(), b) != 0)
raiseError( raiseError(
ObjAssertionFailedException( ObjAssertionFailedException(
this, requireScope(),
"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}" "Assertion failed: ${inspect(a)} == ${inspect(b)}"
) )
) )
} }
addVoidFn("assertNotEquals") { addVoidFn("assertNotEquals") {
val a = requiredArg<Obj>(0) val a = unwrapCompareArg(requiredArg(0))
val b = requiredArg<Obj>(1) val b = unwrapCompareArg(requiredArg(1))
if (a.compareTo(this, b) == 0) if (a.compareTo(requireScope(), b) == 0)
raiseError( raiseError(
ObjAssertionFailedException( ObjAssertionFailedException(
this, requireScope(),
"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}" "Assertion failed: ${inspect(a)} != ${inspect(b)}"
) )
) )
} }
@@ -305,23 +386,23 @@ class Script(
will be accepted. will be accepted.
""".trimIndent() """.trimIndent()
) { ) {
val code: Statement val code: Obj
val expectedClass: ObjClass? val expectedClass: ObjClass?
when (args.size) { when (args.size) {
1 -> { 1 -> {
code = requiredArg<Statement>(0) code = requiredArg<Obj>(0)
expectedClass = null expectedClass = null
} }
2 -> { 2 -> {
code = requiredArg<Statement>(1) code = requiredArg<Obj>(1)
expectedClass = requiredArg<ObjClass>(0) expectedClass = requiredArg<ObjClass>(0)
} }
else -> raiseIllegalArgument("Expected 1 or 2 arguments, got ${args.size}") else -> raiseIllegalArgument("Expected 1 or 2 arguments, got ${args.size}")
} }
val result = try { val result = try {
code.execute(this) call(code)
null null
} catch (e: ExecutionError) { } catch (e: ExecutionError) {
e.errorObject e.errorObject
@@ -330,7 +411,7 @@ class Script(
} }
if (result == null) raiseError( if (result == null) raiseError(
ObjAssertionFailedException( ObjAssertionFailedException(
this, requireScope(),
"Expected exception but nothing was thrown" "Expected exception but nothing was thrown"
) )
) )
@@ -344,7 +425,7 @@ class Script(
} }
addFn("dynamic", callSignature = CallSignature(tailBlockReceiverType = "DelegateContext")) { addFn("dynamic", callSignature = CallSignature(tailBlockReceiverType = "DelegateContext")) {
ObjDynamic.create(this, requireOnlyArg()) ObjDynamic.create(requireScope(), requireOnlyArg())
} }
val root = this val root = this
@@ -361,7 +442,7 @@ class Script(
val condition = requiredArg<ObjBool>(0) val condition = requiredArg<ObjBool>(0)
if (!condition.value) { if (!condition.value) {
var message = args.list.getOrNull(1) var message = args.list.getOrNull(1)
if (message is Statement) message = message.execute(this) if (message is Obj && message.objClass == Statement.type) message = call(message)
raiseIllegalArgument(message?.toString() ?: "requirement not met") raiseIllegalArgument(message?.toString() ?: "requirement not met")
} }
ObjVoid ObjVoid
@@ -370,38 +451,34 @@ class Script(
val condition = requiredArg<ObjBool>(0) val condition = requiredArg<ObjBool>(0)
if (!condition.value) { if (!condition.value) {
var message = args.list.getOrNull(1) var message = args.list.getOrNull(1)
if (message is Statement) message = message.execute(this) if (message is Obj && message.objClass == Statement.type) message = call(message)
raiseIllegalState(message?.toString() ?: "check failed") raiseIllegalState(message?.toString() ?: "check failed")
} }
ObjVoid ObjVoid
} }
addFn("traceScope") { addFn("traceScope") {
this.trace(args.getOrNull(0)?.toString() ?: "") trace(args.getOrNull(0)?.toString() ?: "")
ObjVoid ObjVoid
} }
addFn("run") { addFn("run") {
requireOnlyArg<Statement>().execute(this) call(requireOnlyArg())
} }
addFn("cached") { addFn("cached") {
val builder = requireOnlyArg<Statement>() val builder = requireOnlyArg<Obj>()
val capturedScope = this val capturedScope = this
var calculated = false var calculated = false
var cachedValue: Obj = ObjVoid var cachedValue: Obj = ObjVoid
val thunk = object : Statement() { net.sergeych.lyng.obj.ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn if (!calculated) {
override suspend fun execute(scope: Scope): Obj { cachedValue = capturedScope.call(builder)
if (!calculated) { calculated = true
cachedValue = builder.execute(capturedScope)
calculated = true
}
return cachedValue
} }
cachedValue
} }
thunk
} }
addFn("lazy") { addFn("lazy") {
val builder = requireOnlyArg<Statement>() val builder = requireOnlyArg<Obj>()
ObjLazyDelegate(builder, this) ObjLazyDelegate(builder, requireScope())
} }
addVoidFn("delay") { addVoidFn("delay") {
val a = args.firstAndOnly() val a = args.firstAndOnly()
@@ -409,7 +486,7 @@ class Script(
is ObjInt -> delay(a.value) is ObjInt -> delay(a.value)
is ObjReal -> delay((a.value * 1000).roundToLong()) is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration) is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Int, Real or Duration, got ${a.inspect(this)}") else -> raiseIllegalArgument("Expected Int, Real or Duration, got ${inspect(a)}")
} }
} }
@@ -429,6 +506,7 @@ class Script(
// interfaces // interfaces
addConst("Iterable", ObjIterable) addConst("Iterable", ObjIterable)
addConst("Collection", ObjCollection) addConst("Collection", ObjCollection)
addConst("Iterator", ObjIterator)
addConst("Array", ObjArray) addConst("Array", ObjArray)
addConst("RingBuffer", ObjRingBuffer.type) addConst("RingBuffer", ObjRingBuffer.type)
addConst("Class", ObjClassType) addConst("Class", ObjClassType)
@@ -446,9 +524,10 @@ class Script(
addConst("MapEntry", ObjMapEntry.type) addConst("MapEntry", ObjMapEntry.type)
addFn("launch") { addFn("launch") {
val callable = requireOnlyArg<Statement>() val callable = requireOnlyArg<Obj>()
val captured = this
ObjDeferred(globalDefer { ObjDeferred(globalDefer {
callable.execute(this@addFn) captured.call(callable)
}) })
} }
@@ -460,7 +539,7 @@ class Script(
addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) { addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) {
// important is: current context contains closure often used in call; // important is: current context contains closure often used in call;
// we'll need it for the producer // we'll need it for the producer
ObjFlow(requireOnlyArg<Statement>(), this) ObjFlow(requireOnlyArg<Obj>(), requireScope())
} }
val pi = ObjReal(PI) val pi = ObjReal(PI)
@@ -482,9 +561,10 @@ class Script(
val defaultImportManager: ImportManager by lazy { val defaultImportManager: ImportManager by lazy {
ImportManager(rootScope, SecurityManager.allowAll).apply { ImportManager(rootScope, SecurityManager.allowAll).apply {
addTextPackages( addPackage("lyng.stdlib") { module ->
rootLyng module.eval(Source("lyng.stdlib", rootLyng))
) ObjKotlinIterator.bindTo(module.requireClass("KotlinIterator"))
}
addPackage("lyng.buffer") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
name = "Buffer", name = "Buffer",
@@ -535,7 +615,7 @@ class Script(
is ObjInt -> delay(a.value * 1000) is ObjInt -> delay(a.value * 1000)
is ObjReal -> delay((a.value * 1000).roundToLong()) is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration) is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}") else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${inspect(a)}")
} }
} }
} }
@@ -17,14 +17,33 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjException
class TryStatement( class TryStatement(
private val delegate: Statement, val body: Statement,
val catches: List<CatchBlock>,
val finallyClause: Statement?,
private val startPos: Pos, private val startPos: Pos,
) : Statement() { ) : Statement() {
override val pos: Pos = startPos override val pos: Pos = startPos
data class CatchBlock(
val catchVarName: String,
val catchVarPos: Pos,
val classNames: List<String>,
val block: Statement
)
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
return delegate.execute(scope) return bytecodeOnly(scope, "try statement")
}
private fun resolveExceptionClass(scope: Scope, name: String): ObjClass {
val rec = scope[name]
val cls = rec?.value as? ObjClass
if (cls != null) return cls
if (name == "Exception") return ObjException.Root
scope.raiseSymbolNotFound("error class does not exist or is not a class: $name")
} }
} }
@@ -18,9 +18,6 @@ package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjUnset
class VarDeclStatement( class VarDeclStatement(
val name: String, val name: String,
@@ -36,15 +33,6 @@ class VarDeclStatement(
override val pos: Pos = startPos override val pos: Pos = startPos
override suspend fun execute(context: Scope): Obj { override suspend fun execute(context: Scope): Obj {
val initValue = initializer?.execute(context)?.byValueCopy() ?: ObjUnset return bytecodeOnly(context, "var declaration")
context.addItem(
name,
isMutable,
initValue,
visibility,
recordType = ObjRecord.Type.Other,
isTransient = isTransient
)
return initValue
} }
} }
@@ -17,9 +17,12 @@
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjVoid
sealed class WhenCondition(open val expr: Statement, open val pos: Pos) { sealed class WhenCondition(open val expr: Statement, open val pos: Pos) {
protected fun bytecodeOnly(scope: Scope): Nothing {
return scope.raiseIllegalState("bytecode-only execution is required; when condition needs compiled bytecode")
}
abstract suspend fun matches(scope: Scope, value: Obj): Boolean abstract suspend fun matches(scope: Scope, value: Obj): Boolean
} }
@@ -28,7 +31,7 @@ class WhenEqualsCondition(
override val pos: Pos, override val pos: Pos,
) : WhenCondition(expr, pos) { ) : WhenCondition(expr, pos) {
override suspend fun matches(scope: Scope, value: Obj): Boolean { override suspend fun matches(scope: Scope, value: Obj): Boolean {
return expr.execute(scope).compareTo(scope, value) == 0 return bytecodeOnly(scope)
} }
} }
@@ -38,8 +41,7 @@ class WhenInCondition(
override val pos: Pos, override val pos: Pos,
) : WhenCondition(expr, pos) { ) : WhenCondition(expr, pos) {
override suspend fun matches(scope: Scope, value: Obj): Boolean { override suspend fun matches(scope: Scope, value: Obj): Boolean {
val result = expr.execute(scope).contains(scope, value) return bytecodeOnly(scope)
return if (negated) !result else result
} }
} }
@@ -49,12 +51,7 @@ class WhenIsCondition(
override val pos: Pos, override val pos: Pos,
) : WhenCondition(expr, pos) { ) : WhenCondition(expr, pos) {
override suspend fun matches(scope: Scope, value: Obj): Boolean { override suspend fun matches(scope: Scope, value: Obj): Boolean {
val typeExpr = expr.execute(scope) return bytecodeOnly(scope)
val result = when (typeExpr) {
is net.sergeych.lyng.obj.ObjTypeExpr -> net.sergeych.lyng.obj.matchesTypeDecl(scope, value, typeExpr.typeDecl)
else -> value.isInstanceOf(typeExpr)
}
return if (negated) !result else result
} }
} }
@@ -67,14 +64,6 @@ class WhenStatement(
override val pos: Pos, override val pos: Pos,
) : Statement() { ) : Statement() {
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
val whenValue = value.execute(scope) return bytecodeOnly(scope, "when statement")
for (case in cases) {
for (condition in case.conditions) {
if (condition.matches(scope, whenValue)) {
return case.block.execute(scope)
}
}
}
return elseCase?.execute(scope) ?: ObjVoid
} }
} }
@@ -0,0 +1,614 @@
/*
* 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.
*
*/
/*
* Kotlin bridge reflection facade: handle-based access for fast get/set/call.
*/
package net.sergeych.lyng.bridge
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjIllegalAccessException
import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.obj.ObjProperty
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjUnset
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.requireScope
/**
* Where a bridge resolver should search for names.
*
* Used by [LookupSpec] to control reflection scope for Kotlin-side tooling and bindings.
*/
enum class LookupTarget {
/** Resolve from the current frame only (locals/params declared in the active scope). */
CurrentFrame,
/** Resolve by walking the raw parent chain of frames (locals only, no member fallback). */
ParentChain,
/** Resolve against the module frame (top-level declarations in the module). */
ModuleFrame
}
/**
* Explicit receiver view, similar to `this@Base` in Lyng.
*
* When provided, the resolver will treat `this` as the requested type
* for member resolution and visibility checks.
*/
data class ReceiverView(
val type: ObjClass? = null,
val typeName: String? = null
)
/**
* Lookup rules for bridge resolution.
*
* @property targets where to resolve names from
* @property receiverView optional explicit receiver for member lookup (like `this@Base`)
*/
data class LookupSpec(
val targets: Set<LookupTarget> = setOf(LookupTarget.CurrentFrame, LookupTarget.ModuleFrame),
val receiverView: ReceiverView? = null
)
/**
* Base handle type returned by the Kotlin reflection bridge.
*
* Handles are inexpensive to keep and cache; they resolve lazily and
* may internally cache slots/records once a frame is known.
*/
sealed interface BridgeHandle {
/** Name of the underlying symbol (as written in Lyng). */
val name: String
}
/** Read-only value handle resolved in a [ScopeFacade]. */
interface ValHandle : BridgeHandle {
/** Read the current value. */
suspend fun get(scope: ScopeFacade): Obj
}
/** Read/write value handle resolved in a [ScopeFacade]. */
interface VarHandle : ValHandle {
/** Assign a new value. */
suspend fun set(scope: ScopeFacade, value: Obj)
}
/** Callable handle (function/closure/method). */
interface CallableHandle : BridgeHandle {
/**
* Call the target with optional [args].
*
* @param newThisObj overrides receiver for member calls (defaults to current `this`/record receiver).
*/
suspend fun call(scope: ScopeFacade, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Obj
}
/** Member handle resolved against an instance or receiver view. */
interface MemberHandle : BridgeHandle {
/** Declaring class resolved for the last call/get/set (if known). */
val declaringClass: ObjClass?
/** Explicit receiver view used for resolution (if any). */
val receiverView: ReceiverView?
}
/** Member field/property (read-only). */
interface MemberValHandle : MemberHandle, ValHandle
/** Member var/property with write access. */
interface MemberVarHandle : MemberHandle, VarHandle
/** Member callable (method or extension). */
interface MemberCallableHandle : MemberHandle, CallableHandle
/**
* Direct record handle (debug/inspection).
*
* Exposes raw [ObjRecord] access and should be used only in tooling.
*/
interface RecordHandle : BridgeHandle {
/** Resolve and return the raw [ObjRecord]. */
fun record(): ObjRecord
}
/**
* Bridge resolver API (entry point for Kotlin reflection and bindings).
*
* Obtain via [ScopeFacade.resolver] and reuse for multiple lookups.
* Resolver methods return handles that can be cached and reused across calls.
*/
interface BridgeResolver {
/** Source position used for error reporting. */
val pos: Pos
/** Treat `this` as [type] for member lookup (like `this@Type`). */
fun selfAs(type: ObjClass): BridgeResolver
/** Treat `this` as [typeName] for member lookup (like `this@Type`). */
fun selfAs(typeName: String): BridgeResolver
/** Resolve a read-only value by name using [lookup]. */
fun resolveVal(name: String, lookup: LookupSpec = LookupSpec()): ValHandle
/** Resolve a mutable value by name using [lookup]. */
fun resolveVar(name: String, lookup: LookupSpec = LookupSpec()): VarHandle
/** Resolve a callable by name using [lookup]. */
fun resolveCallable(name: String, lookup: LookupSpec = LookupSpec()): CallableHandle
/** Resolve a member value on [receiver]. */
fun resolveMemberVal(
receiver: Obj,
name: String,
lookup: LookupSpec = LookupSpec()
): MemberValHandle
/** Resolve a mutable member on [receiver]. */
fun resolveMemberVar(
receiver: Obj,
name: String,
lookup: LookupSpec = LookupSpec()
): MemberVarHandle
/** Resolve a member callable on [receiver]. */
fun resolveMemberCallable(
receiver: Obj,
name: String,
lookup: LookupSpec = LookupSpec()
): MemberCallableHandle
/**
* Resolve an extension function treated as a member for reflection.
*
* This uses the extension wrapper name (same rules as Lyng compiler).
*/
fun resolveExtensionCallable(
receiverClass: ObjClass,
name: String,
lookup: LookupSpec = LookupSpec()
): MemberCallableHandle
/** Debug: resolve locals by name (optional, for tooling). */
fun resolveLocalVal(name: String): ValHandle
/** Debug: resolve mutable locals by name (optional, for tooling). */
fun resolveLocalVar(name: String): VarHandle
/** Debug: access raw record handles if needed. */
fun resolveRecord(name: String, lookup: LookupSpec = LookupSpec()): RecordHandle
}
/**
* Convenience: call by name with implicit caching in resolver implementation.
*
* Implemented by the default resolver; useful for lightweight call-by-name flows.
*/
interface BridgeCallByName {
/** Resolve and call [name] with [args] using [lookup]. */
suspend fun callByName(
scope: ScopeFacade,
name: String,
args: Arguments = Arguments.EMPTY,
lookup: LookupSpec = LookupSpec()
): Obj
}
/**
* Optional typed wrapper (sugar) around [ValHandle].
*
* Performs a runtime cast to [T] and raises a class cast error on mismatch.
*/
interface TypedHandle<T : Obj> : ValHandle {
/** Read value and cast it to [T]. */
suspend fun getTyped(scope: ScopeFacade): T
}
/**
* Factory for bridge resolver.
*
* Prefer this over ad-hoc lookups when writing Kotlin extensions or tooling.
*/
fun ScopeFacade.resolver(): BridgeResolver = BridgeResolverImpl(this)
private class BridgeResolverImpl(
private val facade: ScopeFacade,
private val receiverView: ReceiverView? = null
) : BridgeResolver, BridgeCallByName {
private val cachedCallables: MutableMap<String, CallableHandle> = LinkedHashMap()
override val pos: Pos
get() = facade.pos
override fun selfAs(type: ObjClass): BridgeResolver = BridgeResolverImpl(facade, ReceiverView(type = type))
override fun selfAs(typeName: String): BridgeResolver = BridgeResolverImpl(facade, ReceiverView(typeName = typeName))
override fun resolveVal(name: String, lookup: LookupSpec): ValHandle =
LocalValHandle(this, name, lookup)
override fun resolveVar(name: String, lookup: LookupSpec): VarHandle =
LocalVarHandle(this, name, lookup)
override fun resolveCallable(name: String, lookup: LookupSpec): CallableHandle =
LocalCallableHandle(this, name, lookup)
override fun resolveMemberVal(receiver: Obj, name: String, lookup: LookupSpec): MemberValHandle =
MemberValHandleImpl(this, receiver, name, lookup.receiverView ?: receiverView)
override fun resolveMemberVar(receiver: Obj, name: String, lookup: LookupSpec): MemberVarHandle =
MemberVarHandleImpl(this, receiver, name, lookup.receiverView ?: receiverView)
override fun resolveMemberCallable(receiver: Obj, name: String, lookup: LookupSpec): MemberCallableHandle =
MemberCallableHandleImpl(this, receiver, name, lookup.receiverView ?: receiverView)
override fun resolveExtensionCallable(receiverClass: ObjClass, name: String, lookup: LookupSpec): MemberCallableHandle =
ExtensionCallableHandleImpl(this, receiverClass, name, lookup)
override fun resolveLocalVal(name: String): ValHandle =
LocalValHandle(this, name, LookupSpec(targets = setOf(LookupTarget.CurrentFrame)))
override fun resolveLocalVar(name: String): VarHandle =
LocalVarHandle(this, name, LookupSpec(targets = setOf(LookupTarget.CurrentFrame)))
override fun resolveRecord(name: String, lookup: LookupSpec): RecordHandle =
RecordHandleImpl(this, name, lookup)
override suspend fun callByName(scope: ScopeFacade, name: String, args: Arguments, lookup: LookupSpec): Obj {
val handle = cachedCallables.getOrPut(name) { resolveCallable(name, lookup) }
return handle.call(scope, args)
}
fun facade(): ScopeFacade = facade
fun resolveLocalRecord(scope: Scope, name: String, lookup: LookupSpec): ObjRecord {
val caller = scope.currentClassCtx
if (LookupTarget.CurrentFrame in lookup.targets) {
scope.tryGetLocalRecord(scope, name, caller)?.let { return it }
}
if (LookupTarget.ParentChain in lookup.targets) {
scope.chainLookupIgnoreClosure(name, followClosure = false, caller = caller)?.let { return it }
}
if (LookupTarget.ModuleFrame in lookup.targets) {
findModuleScope(scope)?.let { module ->
module.tryGetLocalRecord(module, name, caller)?.let { return it }
}
}
facade.raiseSymbolNotFound(name)
}
fun resolveReceiver(scope: Scope, receiver: Obj, view: ReceiverView?): Obj {
if (view == null) return receiver
if (receiver !== scope.thisObj) return receiver
val target = when {
view.type != null -> scope.thisVariants.firstOrNull { it.isInstanceOf(view.type) }
view.typeName != null -> scope.thisVariants.firstOrNull { it.isInstanceOf(view.typeName) }
else -> null
}
return target ?: facade.raiseSymbolNotFound(view.typeName ?: view.type?.className ?: "<receiver>")
}
fun resolveMemberRecord(scope: Scope, receiver: Obj, name: String): MemberResolution {
if (receiver is ObjClass) {
val rec = receiver.classScope?.objects?.get(name) ?: receiver.members[name]
?: facade.raiseSymbolNotFound("member $name not found on ${receiver.className}")
val decl = rec.declaringClass ?: receiver
if (!canAccessMember(rec.visibility, decl, scope.currentClassCtx, name)) {
facade.raiseError(
ObjIllegalAccessException(
scope,
"can't access ${name}: not visible (declared in ${decl.className}, caller ${scope.currentClassCtx?.className ?: "?"})"
)
)
}
return MemberResolution(rec, decl, receiver, rec.fieldId, rec.methodId)
}
val cls = receiver.objClass
val resolved = cls.resolveInstanceMember(name)
?: facade.raiseSymbolNotFound("member $name not found on ${cls.className}")
val decl = resolved.declaringClass
if (!canAccessMember(resolved.record.visibility, decl, scope.currentClassCtx, name)) {
facade.raiseError(
ObjIllegalAccessException(
scope,
"can't access ${name}: not visible (declared in ${decl.className}, caller ${scope.currentClassCtx?.className ?: "?"})"
)
)
}
val fieldId = if (resolved.record.type == ObjRecord.Type.Field ||
resolved.record.type == ObjRecord.Type.ConstructorField
) {
resolved.record.fieldId ?: cls.instanceFieldIdMap()[name]
} else null
val methodId = if (resolved.record.type == ObjRecord.Type.Fun ||
resolved.record.type == ObjRecord.Type.Property ||
resolved.record.type == ObjRecord.Type.Delegated
) {
resolved.record.methodId ?: cls.instanceMethodIdMap(includeAbstract = true)[name]
} else null
return MemberResolution(resolved.record, decl, receiver.objClass, fieldId, methodId)
}
private fun findModuleScope(scope: Scope): ModuleScope? {
var s: Scope? = scope
var hops = 0
while (s != null && hops++ < 1024) {
if (s is ModuleScope) return s
s = s.parent
}
return null
}
}
private data class LocalResolution(
val record: ObjRecord,
val frameId: Long
)
private data class MemberResolution(
val record: ObjRecord,
val declaringClass: ObjClass,
val receiverClass: ObjClass,
val fieldId: Int?,
val methodId: Int?
)
private abstract class LocalHandleBase(
protected val resolver: BridgeResolverImpl,
override val name: String,
private val lookup: LookupSpec
) : BridgeHandle {
private var cached: LocalResolution? = null
protected fun resolve(scope: Scope): ObjRecord {
val cachedLocal = cached
if (cachedLocal != null && cachedLocal.frameId == scope.frameId) {
return cachedLocal.record
}
val rec = resolver.resolveLocalRecord(scope, name, lookup)
cached = LocalResolution(rec, scope.frameId)
return rec
}
}
private class LocalValHandle(
resolver: BridgeResolverImpl,
name: String,
lookup: LookupSpec
) : LocalHandleBase(resolver, name, lookup), ValHandle {
override suspend fun get(scope: ScopeFacade): Obj {
val real = scope.requireScope()
val rec = resolve(real)
return real.resolve(rec, name)
}
}
private class LocalVarHandle(
resolver: BridgeResolverImpl,
name: String,
lookup: LookupSpec
) : LocalHandleBase(resolver, name, lookup), VarHandle {
override suspend fun get(scope: ScopeFacade): Obj {
val real = scope.requireScope()
val rec = resolve(real)
return real.resolve(rec, name)
}
override suspend fun set(scope: ScopeFacade, value: Obj) {
val real = scope.requireScope()
val rec = resolve(real)
real.assign(rec, name, value)
}
}
private class LocalCallableHandle(
resolver: BridgeResolverImpl,
name: String,
lookup: LookupSpec
) : LocalHandleBase(resolver, name, lookup), CallableHandle {
override suspend fun call(scope: ScopeFacade, args: Arguments, newThisObj: Obj?): Obj {
val real = scope.requireScope()
val rec = resolve(real)
val callee = rec.value
return scope.call(callee, args, newThisObj ?: rec.receiver)
}
}
private abstract class MemberHandleBase(
protected val resolver: BridgeResolverImpl,
receiver: Obj,
override val name: String,
override val receiverView: ReceiverView?
) : MemberHandle {
private val baseReceiver: Obj = receiver
private var cachedResolution: MemberResolution? = null
private var cachedDeclaringClass: ObjClass? = null
protected fun resolve(scope: Scope): Pair<Obj, MemberResolution> {
val resolvedReceiver = resolver.resolveReceiver(scope, baseReceiver, receiverView)
val cached = cachedResolution
if (cached != null && resolvedReceiver.objClass === cached.receiverClass) {
cachedDeclaringClass = cached.declaringClass
return Pair(resolvedReceiver, cached)
}
val res = resolver.resolveMemberRecord(scope, resolvedReceiver, name)
cachedResolution = res
cachedDeclaringClass = res.declaringClass
return Pair(resolvedReceiver, res)
}
protected fun declaringClass(): ObjClass? = cachedDeclaringClass
}
private class MemberValHandleImpl(
resolver: BridgeResolverImpl,
receiver: Obj,
name: String,
receiverView: ReceiverView?
) : MemberHandleBase(resolver, receiver, name, receiverView), MemberValHandle {
override val declaringClass: ObjClass?
get() = declaringClass()
override suspend fun get(scope: ScopeFacade): Obj {
val real = scope.requireScope()
val (receiver, res) = resolve(real)
val rec = resolveMemberRecordFast(receiver, res)
return receiver.resolveRecord(real, rec, name, res.declaringClass).value
}
}
private class MemberVarHandleImpl(
resolver: BridgeResolverImpl,
receiver: Obj,
name: String,
receiverView: ReceiverView?
) : MemberHandleBase(resolver, receiver, name, receiverView), MemberVarHandle {
override val declaringClass: ObjClass?
get() = declaringClass()
override suspend fun get(scope: ScopeFacade): Obj {
val real = scope.requireScope()
val (receiver, res) = resolve(real)
val rec = resolveMemberRecordFast(receiver, res)
return receiver.resolveRecord(real, rec, name, res.declaringClass).value
}
override suspend fun set(scope: ScopeFacade, value: Obj) {
val real = scope.requireScope()
val (receiver, res) = resolve(real)
val rec = resolveMemberRecordFast(receiver, res)
assignMemberRecord(real, receiver, res.declaringClass, rec, name, value)
}
}
private class MemberCallableHandleImpl(
resolver: BridgeResolverImpl,
receiver: Obj,
name: String,
receiverView: ReceiverView?
) : MemberHandleBase(resolver, receiver, name, receiverView), MemberCallableHandle {
override val declaringClass: ObjClass?
get() = declaringClass()
override suspend fun call(scope: ScopeFacade, args: Arguments, newThisObj: Obj?): Obj {
val real = scope.requireScope()
val (receiver, res) = resolve(real)
val rec = resolveMemberRecordFast(receiver, res)
if (rec.type != ObjRecord.Type.Fun) {
scope.raiseError("member $name is not callable")
}
return rec.value.invoke(real, receiver, args, res.declaringClass)
}
}
private class ExtensionCallableHandleImpl(
private val resolver: BridgeResolverImpl,
private val receiverClass: ObjClass,
override val name: String,
private val lookup: LookupSpec
) : MemberCallableHandle {
override val receiverView: ReceiverView?
get() = null
override val declaringClass: ObjClass?
get() = receiverClass
override suspend fun call(scope: ScopeFacade, args: Arguments, newThisObj: Obj?): Obj {
val real = scope.requireScope()
val wrapperName = extensionCallableName(receiverClass.className, name)
val rec = resolver.resolveLocalRecord(real, wrapperName, lookup)
val receiver = newThisObj ?: real.thisObj
val callArgs = Arguments(listOf(receiver) + args.list)
return scope.call(rec.value, callArgs)
}
}
private class RecordHandleImpl(
private val resolver: BridgeResolverImpl,
override val name: String,
private val lookup: LookupSpec
) : RecordHandle {
override fun record(): ObjRecord {
val scope = resolver.facade().requireScope()
return resolver.resolveLocalRecord(scope, name, lookup)
}
}
private class TypedHandleImpl<T : Obj>(
private val inner: ValHandle,
private val clazzName: String
) : TypedHandle<T> {
override val name: String
get() = inner.name
override suspend fun get(scope: ScopeFacade): Obj = inner.get(scope)
@Suppress("UNCHECKED_CAST")
override suspend fun getTyped(scope: ScopeFacade): T {
val value = inner.get(scope)
return (value as? T)
?: scope.raiseClassCastError("Expected $clazzName, got ${value.objClass.className}")
}
}
private fun resolveMemberRecordFast(receiver: Obj, res: MemberResolution): ObjRecord {
val inst = receiver as? ObjInstance
if (inst != null) {
res.fieldId?.let { inst.fieldRecordForId(it)?.let { return it } }
res.methodId?.let { inst.methodRecordForId(it)?.let { return it } }
}
return res.record
}
private suspend fun assignMemberRecord(
scope: Scope,
receiver: Obj,
declaringClass: ObjClass,
rec: ObjRecord,
name: String,
value: Obj
) {
val caller = scope.currentClassCtx
if (!canAccessMember(rec.effectiveWriteVisibility, declaringClass, caller, name)) {
scope.raiseError(
ObjIllegalAccessException(
scope,
"can't assign ${name}: not visible (declared in ${declaringClass.className}, caller ${caller?.className ?: "?"})"
)
)
}
when {
rec.type == ObjRecord.Type.Delegated -> {
val del = rec.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate")
val th = if (receiver === ObjVoid) net.sergeych.lyng.obj.ObjNull else receiver
del.invokeInstanceMethod(scope, "setValue", Arguments(th, ObjString(name), value))
}
rec.value is ObjProperty || rec.type == ObjRecord.Type.Property -> {
val prop = rec.value as? ObjProperty
?: scope.raiseError("Expected ObjProperty for property member $name")
prop.callSetter(scope, receiver, value, declaringClass)
}
rec.isMutable -> {
val slotRef = rec.value
if (slotRef is net.sergeych.lyng.FrameSlotRef) {
if (!rec.isMutable && slotRef.read() !== ObjUnset) scope.raiseError("can't reassign val $name")
slotRef.write(value)
} else {
rec.value = value
}
}
else -> scope.raiseError("can't assign to read-only field: $name")
}
}
@@ -0,0 +1,351 @@
/*
* 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.
*
*/
/*
* Kotlin bridge bindings for Lyng classes (Lyng-first workflow).
*/
package net.sergeych.lyng.bridge
import net.sergeych.lyng.*
import net.sergeych.lyng.bytecode.BytecodeStatement
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjExternCallable
import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.obj.ObjProperty
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.requiredArg
/**
* Per-instance bridge context passed to init hooks.
*
* Exposes the underlying [instance] and a mutable [data] slot for Kotlin-side state.
*/
interface BridgeInstanceContext {
/** The Lyng instance being initialized. */
val instance: Obj
/** Arbitrary Kotlin-side data attached to the instance. */
var data: Any?
}
/**
* Binder DSL for attaching Kotlin implementations to a declared Lyng class.
*
* Use [LyngClassBridge.bind] to obtain a binder and register implementations.
* Bindings must happen before the first instance of the class is created.
*
* Important: members you bind here must be declared as `extern` in Lyng so the
* compiler emits the ABI slots that Kotlin bindings attach to.
*/
interface ClassBridgeBinder {
/** Arbitrary Kotlin-side data attached to the class. */
var classData: Any?
/** Register an initialization hook that runs for each instance. */
fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit)
/** Register an initialization hook with direct access to the instance. */
fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit)
/** Bind a Lyng function/member to a Kotlin implementation (requires `extern` in Lyng). */
fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj)
/** Bind a read-only member (val/property getter) declared as `extern`. */
fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj)
/** Bind a mutable member (var/property getter/setter) declared as `extern`. */
fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
)
}
/**
* Entry point for Kotlin bindings to declared Lyng classes.
*
* The workflow is Lyng-first: declare the class and its members in Lyng,
* then bind the implementations from Kotlin. Bound members must be marked
* `extern` so the compiler emits the ABI slots for Kotlin to attach to.
*/
object LyngClassBridge {
/**
* Resolve a Lyng class by [className] and bind Kotlin implementations.
*
* @param module module name used for resolution (required when [module] scope is not provided)
* @param importManager import manager used to resolve the module
*/
suspend fun bind(
className: String,
module: String? = null,
importManager: ImportManager = Script.defaultImportManager,
block: ClassBridgeBinder.() -> Unit
): ObjClass {
val cls = resolveClass(className, module, null, importManager)
return bind(cls, block)
}
/**
* Resolve a Lyng class within an existing [moduleScope] and bind Kotlin implementations.
*/
suspend fun bind(
moduleScope: ModuleScope,
className: String,
block: ClassBridgeBinder.() -> Unit
): ObjClass {
val cls = resolveClass(className, null, moduleScope, Script.defaultImportManager)
return bind(cls, block)
}
/**
* Bind Kotlin implementations to an already resolved [clazz].
*
* This must run before the first instance is created.
*/
fun bind(clazz: ObjClass, block: ClassBridgeBinder.() -> Unit): ObjClass {
val binder = ClassBridgeBinderImpl(clazz)
binder.block()
binder.commit()
return clazz
}
}
/**
* Sugar for [LyngClassBridge.bind] on a module scope.
*
* Bound members must be declared as `extern` in Lyng.
*/
suspend fun ModuleScope.bind(
className: String,
block: ClassBridgeBinder.() -> Unit
): ObjClass = LyngClassBridge.bind(this, className, block)
/** Kotlin-side data slot attached to a Lyng instance. */
var ObjInstance.data: Any?
get() = kotlinInstanceData
set(value) { kotlinInstanceData = value }
/** Kotlin-side data slot attached to a Lyng class. */
var ObjClass.classData: Any?
get() = kotlinClassData
set(value) { kotlinClassData = value }
private enum class MemberKind { Instance, Static }
private data class MemberTarget(
val name: String,
val record: ObjRecord,
val kind: MemberKind,
val mirrorClassScope: Boolean = false
)
private class BridgeInstanceContextImpl(
override val instance: Obj
) : BridgeInstanceContext {
private fun instanceObj(): ObjInstance =
instance as? ObjInstance ?: error("Bridge instance is not an ObjInstance")
override var data: Any?
get() = instanceObj().kotlinInstanceData
set(value) { instanceObj().kotlinInstanceData = value }
}
private class ClassBridgeBinderImpl(
private val cls: ObjClass
) : ClassBridgeBinder {
private val initHooks = mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>()
private var checkedTemplate = false
override var classData: Any?
get() = cls.kotlinClassData
set(value) { cls.kotlinClassData = value }
override fun init(block: suspend BridgeInstanceContext.(ScopeFacade) -> Unit) {
initHooks.add { scope, inst ->
val ctx = BridgeInstanceContextImpl(inst)
ctx.block(scope)
}
}
override fun initWithInstance(block: suspend (ScopeFacade, Obj) -> Unit) {
initHooks.add { scope, inst ->
block(scope, inst)
}
}
override fun addFun(name: String, impl: suspend (ScopeFacade, Obj, Arguments) -> Obj) {
ensureTemplateNotBuilt()
val target = findMember(name)
val callable = ObjExternCallable.fromBridge {
impl(this, thisObj, args)
}
val methodId = cls.ensureMethodIdForBridge(name, target.record)
val newRecord = target.record.copy(
value = callable,
type = ObjRecord.Type.Fun,
methodId = methodId
)
replaceMember(target, newRecord)
}
override fun addVal(name: String, impl: suspend (ScopeFacade, Obj) -> Obj) {
ensureTemplateNotBuilt()
val target = findMember(name)
if (target.record.isMutable) {
throw ScriptError(Pos.builtIn, "extern val $name is mutable in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
impl(this, thisObj)
}
val prop = ObjProperty(name, getter, null)
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
target.record.type == ObjRecord.Type.ConstructorField
val newRecord = if (isFieldLike) {
removeFieldInitializersFor(name)
target.record.copy(
value = prop,
type = target.record.type,
fieldId = target.record.fieldId,
methodId = target.record.methodId
)
} else {
val methodId = cls.ensureMethodIdForBridge(name, target.record)
target.record.copy(
value = prop,
type = ObjRecord.Type.Property,
methodId = methodId,
fieldId = null
)
}
replaceMember(target, newRecord)
}
override fun addVar(
name: String,
get: suspend (ScopeFacade, Obj) -> Obj,
set: suspend (ScopeFacade, Obj, Obj) -> Unit
) {
ensureTemplateNotBuilt()
val target = findMember(name)
if (!target.record.isMutable) {
throw ScriptError(Pos.builtIn, "extern var $name is readonly in class ${cls.className}")
}
val getter = ObjExternCallable.fromBridge {
get(this, thisObj)
}
val setter = ObjExternCallable.fromBridge {
val value = requiredArg<Obj>(0)
set(this, thisObj, value)
ObjVoid
}
val prop = ObjProperty(name, getter, setter)
val isFieldLike = target.record.type == ObjRecord.Type.Field ||
target.record.type == ObjRecord.Type.ConstructorField
val newRecord = if (isFieldLike) {
removeFieldInitializersFor(name)
target.record.copy(
value = prop,
type = target.record.type,
fieldId = target.record.fieldId,
methodId = target.record.methodId
)
} else {
val methodId = cls.ensureMethodIdForBridge(name, target.record)
target.record.copy(
value = prop,
type = ObjRecord.Type.Property,
methodId = methodId,
fieldId = null
)
}
replaceMember(target, newRecord)
}
fun commit() {
if (initHooks.isNotEmpty()) {
val target = cls.bridgeInitHooks ?: mutableListOf<suspend (ScopeFacade, ObjInstance) -> Unit>().also {
cls.bridgeInitHooks = it
}
target.addAll(initHooks)
}
}
private fun ensureTemplateNotBuilt() {
if (!checkedTemplate) {
if (cls.instanceTemplateBuilt) {
throw ScriptError(
Pos.builtIn,
"bridge binding for ${cls.className} must happen before first instance is created"
)
}
checkedTemplate = true
}
}
private fun replaceMember(target: MemberTarget, newRecord: ObjRecord) {
when (target.kind) {
MemberKind.Instance -> {
cls.replaceMemberForBridge(target.name, newRecord)
if (target.mirrorClassScope && cls.classScope?.objects?.containsKey(target.name) == true) {
cls.replaceClassScopeMemberForBridge(target.name, newRecord)
}
}
MemberKind.Static -> cls.replaceClassScopeMemberForBridge(target.name, newRecord)
}
}
private fun findMember(name: String): MemberTarget {
val inst = cls.members[name]
val stat = cls.classScope?.objects?.get(name)
if (inst != null) {
return MemberTarget(name, inst, MemberKind.Instance, mirrorClassScope = stat != null)
}
if (stat != null) return MemberTarget(name, stat, MemberKind.Static)
throw ScriptError(Pos.builtIn, "extern member $name not found in class ${cls.className}")
}
private fun removeFieldInitializersFor(name: String) {
if (cls.instanceInitializers.isEmpty()) return
val storageName = cls.mangledName(name)
cls.instanceInitializers.removeAll { init ->
val stmt = init as? Statement ?: return@removeAll false
val original = (stmt as? BytecodeStatement)?.original ?: stmt
original is InstanceFieldInitStatement && original.storageName == storageName
}
}
}
private suspend fun resolveClass(
className: String,
module: String?,
moduleScope: ModuleScope?,
importManager: ImportManager
): ObjClass {
val scope = moduleScope ?: run {
if (module == null) {
throw ScriptError(Pos.builtIn, "module is required to resolve $className")
}
importManager.createModuleScope(Pos.builtIn, module)
}
val rec = scope.get(className)
val direct = rec?.value as? ObjClass
if (direct != null) return direct
if (className.contains('.')) {
val resolved = scope.resolveQualifiedIdentifier(className)
val cls = resolved as? ObjClass
if (cls != null) return cls
}
throw ScriptError(Pos.builtIn, "class $className not found in module ${scope.packageName}")
}
File diff suppressed because it is too large. Load diff
@@ -16,8 +16,10 @@
package net.sergeych.lyng.bytecode package net.sergeych.lyng.bytecode
import net.sergeych.lyng.ArgsDeclaration
import net.sergeych.lyng.Pos import net.sergeych.lyng.Pos
import net.sergeych.lyng.Visibility import net.sergeych.lyng.Visibility
import net.sergeych.lyng.obj.ListLiteralRef
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjProperty import net.sergeych.lyng.obj.ObjProperty
@@ -29,11 +31,32 @@ sealed class BytecodeConst {
data class StringVal(val value: String) : BytecodeConst() data class StringVal(val value: String) : BytecodeConst()
data class PosVal(val pos: Pos) : BytecodeConst() data class PosVal(val pos: Pos) : BytecodeConst()
data class ObjRef(val value: Obj) : BytecodeConst() data class ObjRef(val value: Obj) : BytecodeConst()
data class Ref(val value: net.sergeych.lyng.obj.ObjRef) : BytecodeConst()
data class StatementVal(val statement: net.sergeych.lyng.Statement) : BytecodeConst()
data class ListLiteralPlan(val spreads: List<Boolean>) : BytecodeConst() data class ListLiteralPlan(val spreads: List<Boolean>) : BytecodeConst()
data class ValueFn(val fn: suspend (net.sergeych.lyng.Scope) -> net.sergeych.lyng.obj.ObjRecord) : BytecodeConst() data class LambdaFn(
val fn: CmdFunction,
val captureTableId: Int?,
val captureNames: List<String>,
val paramSlotPlan: Map<String, Int>,
val argsDeclaration: ArgsDeclaration?,
val preferredThisType: String?,
val wrapAsExtensionCallable: Boolean,
val returnLabels: Set<String>,
val pos: Pos,
) : BytecodeConst()
data class EnumDecl(
val declaredName: String,
val qualifiedName: String,
val entries: List<String>,
val lifted: Boolean,
) : BytecodeConst()
data class FunctionDecl(
val spec: net.sergeych.lyng.FunctionDeclSpec,
) : BytecodeConst()
data class ClassDecl(
val spec: net.sergeych.lyng.ClassDeclSpec,
) : BytecodeConst()
data class SlotPlan(val plan: Map<String, Int>, val captures: List<String> = emptyList()) : BytecodeConst() data class SlotPlan(val plan: Map<String, Int>, val captures: List<String> = emptyList()) : BytecodeConst()
data class CaptureTable(val entries: List<BytecodeCaptureEntry>) : BytecodeConst()
data class ExtensionPropertyDecl( data class ExtensionPropertyDecl(
val extTypeName: String, val extTypeName: String,
val property: ObjProperty, val property: ObjProperty,
@@ -46,6 +69,113 @@ sealed class BytecodeConst {
val visibility: Visibility, val visibility: Visibility,
val isTransient: Boolean, val isTransient: Boolean,
) : BytecodeConst() ) : BytecodeConst()
data class DelegatedDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val isTransient: Boolean,
) : BytecodeConst()
data class ClassFieldDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
) : BytecodeConst()
data class ClassDelegatedDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
) : BytecodeConst()
data class ClassInstanceInitDecl(
val initStatement: Obj,
) : BytecodeConst()
data class ClassInstanceFieldDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val fieldId: Int?,
val initStatement: Obj?,
val pos: Pos,
) : BytecodeConst()
data class ClassInstancePropertyDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val prop: ObjProperty,
val methodId: Int?,
val initStatement: Obj?,
val pos: Pos,
) : BytecodeConst()
data class ClassInstanceDelegatedDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val methodId: Int?,
val initStatement: Obj?,
val pos: Pos,
) : BytecodeConst()
data class InstanceFieldDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
) : BytecodeConst()
data class InstancePropertyDecl(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
) : BytecodeConst()
data class InstanceDelegatedDecl(
val storageName: String,
val memberName: String,
val isMutable: Boolean,
val visibility: Visibility,
val writeVisibility: Visibility?,
val isTransient: Boolean,
val isAbstract: Boolean,
val isClosed: Boolean,
val isOverride: Boolean,
val accessTypeLabel: String,
) : BytecodeConst()
data class DestructureDecl(
val pattern: ListLiteralRef,
val names: List<String>,
val isMutable: Boolean,
val visibility: Visibility,
val isTransient: Boolean,
val pos: Pos,
) : BytecodeConst()
data class DestructureAssign(
val pattern: ListLiteralRef,
val pos: Pos,
) : BytecodeConst()
data class CallArgsPlan(val tailBlock: Boolean, val specs: List<CallArgSpec>) : BytecodeConst() data class CallArgsPlan(val tailBlock: Boolean, val specs: List<CallArgSpec>) : BytecodeConst()
data class CallArgSpec(val name: String?, val isSplat: Boolean) data class CallArgSpec(val name: String?, val isSplat: Boolean)
} }
@@ -40,9 +40,29 @@ class BytecodeFrame(
slotTypes[slot] = type.code slotTypes[slot] = type.code
} }
override fun getObj(slot: Int): Obj = objSlots[slot] ?: ObjNull override fun getObj(slot: Int): Obj {
val value = objSlots[slot] ?: return ObjNull
return when (value) {
is net.sergeych.lyng.FrameSlotRef -> value.read()
is net.sergeych.lyng.RecordSlotRef -> value.read()
else -> value
}
}
internal fun getRawObj(slot: Int): Obj? = objSlots[slot]
override fun setObj(slot: Int, value: Obj) { override fun setObj(slot: Int, value: Obj) {
objSlots[slot] = value when (val current = objSlots[slot]) {
is net.sergeych.lyng.FrameSlotRef -> {
if (current.refersTo(this, slot)) {
objSlots[slot] = value
} else {
current.write(value)
}
}
is net.sergeych.lyng.RecordSlotRef -> current.write(value)
else -> objSlots[slot] = value
}
slotTypes[slot] = SlotType.OBJ.code slotTypes[slot] = SlotType.OBJ.code
} }
@@ -20,6 +20,7 @@ package net.sergeych.lyng.bytecode
import net.sergeych.lyng.* import net.sergeych.lyng.*
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ValueFnRef
class BytecodeStatement private constructor( class BytecodeStatement private constructor(
val original: Statement, val original: Statement,
@@ -29,7 +30,7 @@ class BytecodeStatement private constructor(
override suspend fun execute(scope: Scope): Obj { override suspend fun execute(scope: Scope): Obj {
scope.pos = pos scope.pos = pos
return CmdVm().execute(function, scope, scope.args.list) return CmdVm().execute(function, scope, scope.args)
} }
internal fun bytecodeFunction(): CmdFunction = function internal fun bytecodeFunction(): CmdFunction = function
@@ -42,9 +43,23 @@ class BytecodeStatement private constructor(
returnLabels: Set<String> = emptySet(), returnLabels: Set<String> = emptySet(),
rangeLocalNames: Set<String> = emptySet(), rangeLocalNames: Set<String> = emptySet(),
allowedScopeNames: Set<String>? = null, allowedScopeNames: Set<String>? = null,
scopeSlotNameSet: Set<String>? = null,
moduleScopeId: Int? = null, moduleScopeId: Int? = null,
forcedLocalSlots: Map<String, Int> = emptyMap(),
forcedLocalScopeId: Int? = null,
forcedLocalSlotInfo: Map<String, ForcedLocalSlotInfo> = emptyMap(),
globalSlotInfo: Map<String, ForcedLocalSlotInfo> = emptyMap(),
globalSlotScopeId: Int? = null,
slotTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(), slotTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
knownNameObjClass: Map<String, ObjClass> = emptyMap(), knownNameObjClass: Map<String, ObjClass> = emptyMap(),
knownObjectNames: Set<String> = emptySet(),
classFieldTypesByName: Map<String, Map<String, ObjClass>> = emptyMap(),
enumEntriesByName: Map<String, List<String>> = emptyMap(),
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement { ): Statement {
if (statement is BytecodeStatement) return statement if (statement is BytecodeStatement) return statement
val hasUnsupported = containsUnsupportedStatement(statement) val hasUnsupported = containsUnsupportedStatement(statement)
@@ -61,9 +76,23 @@ class BytecodeStatement private constructor(
returnLabels = returnLabels, returnLabels = returnLabels,
rangeLocalNames = rangeLocalNames, rangeLocalNames = rangeLocalNames,
allowedScopeNames = allowedScopeNames, allowedScopeNames = allowedScopeNames,
scopeSlotNameSet = scopeSlotNameSet,
moduleScopeId = moduleScopeId, moduleScopeId = moduleScopeId,
forcedLocalSlots = forcedLocalSlots,
forcedLocalScopeId = forcedLocalScopeId,
forcedLocalSlotInfo = forcedLocalSlotInfo,
globalSlotInfo = globalSlotInfo,
globalSlotScopeId = globalSlotScopeId,
slotTypeByScopeId = slotTypeByScopeId, slotTypeByScopeId = slotTypeByScopeId,
knownNameObjClass = knownNameObjClass slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownNameObjClass,
knownObjectNames = knownObjectNames,
classFieldTypesByName = classFieldTypesByName,
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
val compiled = compiler.compileStatement(nameHint, statement) val compiled = compiler.compileStatement(nameHint, statement)
val fn = compiled ?: throw BytecodeCompileException( val fn = compiled ?: throw BytecodeCompileException(
@@ -122,11 +151,31 @@ class BytecodeStatement private constructor(
target.resultExpr?.let { containsUnsupportedStatement(it) } ?: false target.resultExpr?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.ThrowStatement -> is net.sergeych.lyng.ThrowStatement ->
containsUnsupportedStatement(target.throwExpr) containsUnsupportedStatement(target.throwExpr)
is net.sergeych.lyng.NopStatement -> false
is net.sergeych.lyng.ExtensionPropertyDeclStatement -> false is net.sergeych.lyng.ExtensionPropertyDeclStatement -> false
is net.sergeych.lyng.ClassDeclStatement -> false is net.sergeych.lyng.ClassDeclStatement -> false
is net.sergeych.lyng.FunctionDeclStatement -> false is net.sergeych.lyng.FunctionDeclStatement -> false
is net.sergeych.lyng.EnumDeclStatement -> false is net.sergeych.lyng.EnumDeclStatement -> false
is net.sergeych.lyng.TryStatement -> true is net.sergeych.lyng.ClassStaticFieldInitStatement ->
target.initializer?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.ClassInstanceInitDeclStatement ->
containsUnsupportedStatement(target.initStatement)
is net.sergeych.lyng.ClassInstanceFieldDeclStatement ->
target.initStatement?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.ClassInstancePropertyDeclStatement ->
target.initStatement?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.ClassInstanceDelegatedDeclStatement ->
target.initStatement?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.InstanceFieldInitStatement ->
target.initializer?.let { containsUnsupportedStatement(it) } ?: false
is net.sergeych.lyng.InstancePropertyInitStatement -> false
is net.sergeych.lyng.InstanceDelegatedInitStatement ->
containsUnsupportedStatement(target.initializer)
is net.sergeych.lyng.TryStatement -> {
containsUnsupportedStatement(target.body) ||
target.catches.any { containsUnsupportedStatement(it.block) } ||
(target.finallyClause?.let { containsUnsupportedStatement(it) } ?: false)
}
is net.sergeych.lyng.WhenStatement -> { is net.sergeych.lyng.WhenStatement -> {
containsUnsupportedStatement(target.value) || containsUnsupportedStatement(target.value) ||
target.cases.any { case -> target.cases.any { case ->
@@ -147,6 +196,7 @@ class BytecodeStatement private constructor(
net.sergeych.lyng.BlockStatement( net.sergeych.lyng.BlockStatement(
net.sergeych.lyng.Script(stmt.pos, unwrapped), net.sergeych.lyng.Script(stmt.pos, unwrapped),
stmt.slotPlan, stmt.slotPlan,
stmt.scopeId,
stmt.captureSlots, stmt.captureSlots,
stmt.pos stmt.pos
) )
@@ -193,6 +243,7 @@ class BytecodeStatement private constructor(
stmt.label, stmt.label,
stmt.canBreak, stmt.canBreak,
stmt.loopSlotPlan, stmt.loopSlotPlan,
stmt.loopScopeId,
stmt.pos stmt.pos
) )
} }
@@ -242,6 +293,115 @@ class BytecodeStatement private constructor(
stmt.pos stmt.pos
) )
} }
is net.sergeych.lyng.ClassStaticFieldInitStatement -> {
net.sergeych.lyng.ClassStaticFieldInitStatement(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.initializer?.let { unwrapDeep(it) },
stmt.isDelegated,
stmt.isTransient,
stmt.pos
)
}
is net.sergeych.lyng.ClassInstanceInitDeclStatement -> {
net.sergeych.lyng.ClassInstanceInitDeclStatement(
unwrapDeep(stmt.initStatement),
stmt.pos
)
}
is net.sergeych.lyng.ClassInstanceFieldDeclStatement -> {
net.sergeych.lyng.ClassInstanceFieldDeclStatement(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.fieldId,
stmt.initStatement?.let { unwrapDeep(it) },
stmt.pos
)
}
is net.sergeych.lyng.ClassInstancePropertyDeclStatement -> {
net.sergeych.lyng.ClassInstancePropertyDeclStatement(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.prop,
stmt.methodId,
stmt.initStatement?.let { unwrapDeep(it) },
stmt.pos
)
}
is net.sergeych.lyng.ClassInstanceDelegatedDeclStatement -> {
net.sergeych.lyng.ClassInstanceDelegatedDeclStatement(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.methodId,
stmt.initStatement?.let { unwrapDeep(it) },
stmt.pos
)
}
is net.sergeych.lyng.InstanceFieldInitStatement -> {
net.sergeych.lyng.InstanceFieldInitStatement(
stmt.storageName,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.isLateInitVal,
stmt.initializer?.let { unwrapDeep(it) },
stmt.pos
)
}
is net.sergeych.lyng.InstancePropertyInitStatement -> {
net.sergeych.lyng.InstancePropertyInitStatement(
stmt.storageName,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.prop,
stmt.pos
)
}
is net.sergeych.lyng.InstanceDelegatedInitStatement -> {
net.sergeych.lyng.InstanceDelegatedInitStatement(
stmt.storageName,
stmt.memberName,
stmt.isMutable,
stmt.visibility,
stmt.writeVisibility,
stmt.isAbstract,
stmt.isClosed,
stmt.isOverride,
stmt.isTransient,
stmt.accessTypeLabel,
unwrapDeep(stmt.initializer),
stmt.pos
)
}
else -> stmt else -> stmt
} }
} }
@@ -68,7 +68,9 @@ class CmdBuilder {
scopeSlotNames: Array<String?> = emptyArray(), scopeSlotNames: Array<String?> = emptyArray(),
scopeSlotIsModule: BooleanArray = BooleanArray(0), scopeSlotIsModule: BooleanArray = BooleanArray(0),
localSlotNames: Array<String?> = emptyArray(), localSlotNames: Array<String?> = emptyArray(),
localSlotMutables: BooleanArray = BooleanArray(0) localSlotMutables: BooleanArray = BooleanArray(0),
localSlotDelegated: BooleanArray = BooleanArray(0),
localSlotCaptures: BooleanArray = BooleanArray(0)
): CmdFunction { ): CmdFunction {
val scopeSlotCount = scopeSlotIndices.size val scopeSlotCount = scopeSlotIndices.size
require(scopeSlotNames.isEmpty() || scopeSlotNames.size == scopeSlotCount) { require(scopeSlotNames.isEmpty() || scopeSlotNames.size == scopeSlotCount) {
@@ -78,6 +80,8 @@ class CmdBuilder {
"scope slot module mapping size mismatch" "scope slot module mapping size mismatch"
} }
require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" }
val labelIps = mutableMapOf<Label, Int>() val labelIps = mutableMapOf<Label, Int>()
for ((label, idx) in labelPositions) { for ((label, idx) in labelPositions) {
labelIps[label] = idx labelIps[label] = idx
@@ -98,7 +102,7 @@ class CmdBuilder {
} }
operands[i] = v operands[i] = v
} }
cmds.add(createCmd(ins.op, operands, scopeSlotCount)) cmds.add(createCmd(ins.op, operands, scopeSlotCount, localSlotCaptures))
} }
return CmdFunction( return CmdFunction(
name = name, name = name,
@@ -111,6 +115,8 @@ class CmdBuilder {
scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule, scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule,
localSlotNames = localSlotNames, localSlotNames = localSlotNames,
localSlotMutables = localSlotMutables, localSlotMutables = localSlotMutables,
localSlotDelegated = localSlotDelegated,
localSlotCaptures = localSlotCaptures,
constants = constPool.toList(), constants = constPool.toList(),
cmds = cmds.toTypedArray(), cmds = cmds.toTypedArray(),
posByIp = posByInstr.toTypedArray() posByIp = posByInstr.toTypedArray()
@@ -119,10 +125,12 @@ class CmdBuilder {
private fun operandKinds(op: Opcode): List<OperandKind> { private fun operandKinds(op: Opcode): List<OperandKind> {
return when (op) { return when (op) {
Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN -> emptyList() Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN, Opcode.POP_TRY,
Opcode.CLEAR_PENDING_THROWABLE, Opcode.RETHROW_PENDING -> emptyList()
Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ, Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ,
Opcode.UNBOX_INT_OBJ, Opcode.UNBOX_REAL_OBJ,
Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL, Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL,
Opcode.OBJ_TO_BOOL, Opcode.OBJ_TO_BOOL, Opcode.GET_OBJ_CLASS,
Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT, Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT,
Opcode.ASSERT_IS -> Opcode.ASSERT_IS ->
listOf(OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT)
@@ -134,17 +142,31 @@ class CmdBuilder {
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.RESOLVE_SCOPE_SLOT -> Opcode.RESOLVE_SCOPE_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ADDR) listOf(OperandKind.SLOT, OperandKind.ADDR)
Opcode.DELEGATED_GET_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.DELEGATED_SET_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.BIND_DELEGATE_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.CONST, OperandKind.SLOT)
Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR -> Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR ->
listOf(OperandKind.ADDR, OperandKind.SLOT) listOf(OperandKind.ADDR, OperandKind.SLOT)
Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR -> Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR ->
listOf(OperandKind.SLOT, OperandKind.ADDR) listOf(OperandKind.SLOT, OperandKind.ADDR)
Opcode.CONST_NULL -> Opcode.CONST_NULL ->
listOf(OperandKind.SLOT) listOf(OperandKind.SLOT)
Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL, Opcode.MAKE_VALUE_FN -> Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL,
Opcode.MAKE_LAMBDA_FN ->
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN -> Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN ->
listOf(OperandKind.CONST) listOf(OperandKind.CONST)
Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY -> Opcode.PUSH_TRY ->
listOf(OperandKind.SLOT, OperandKind.IP, OperandKind.IP)
Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY, Opcode.DECL_DELEGATED, Opcode.DECL_DESTRUCTURE,
Opcode.DECL_ENUM, Opcode.DECL_FUNCTION, Opcode.DECL_CLASS, Opcode.DECL_CLASS_FIELD,
Opcode.DECL_CLASS_DELEGATED, Opcode.DECL_CLASS_INSTANCE_INIT, Opcode.DECL_CLASS_INSTANCE_FIELD,
Opcode.DECL_CLASS_INSTANCE_PROPERTY, Opcode.DECL_CLASS_INSTANCE_DELEGATED, Opcode.DECL_INSTANCE_FIELD,
Opcode.DECL_INSTANCE_PROPERTY, Opcode.DECL_INSTANCE_DELEGATED,
Opcode.ASSIGN_DESTRUCTURE ->
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT, Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT,
Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL, Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL,
@@ -158,7 +180,14 @@ class CmdBuilder {
Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT, Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT,
Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT, Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT,
Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ, Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ,
Opcode.CMP_EQ_STR, Opcode.CMP_NEQ_STR, Opcode.CMP_LT_STR, Opcode.CMP_LTE_STR,
Opcode.CMP_GT_STR, Opcode.CMP_GTE_STR,
Opcode.CMP_EQ_INT_OBJ, Opcode.CMP_NEQ_INT_OBJ, Opcode.CMP_LT_INT_OBJ, Opcode.CMP_LTE_INT_OBJ,
Opcode.CMP_GT_INT_OBJ, Opcode.CMP_GTE_INT_OBJ, Opcode.CMP_EQ_REAL_OBJ, Opcode.CMP_NEQ_REAL_OBJ,
Opcode.CMP_LT_REAL_OBJ, Opcode.CMP_LTE_REAL_OBJ, Opcode.CMP_GT_REAL_OBJ, Opcode.CMP_GTE_REAL_OBJ,
Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ, Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ,
Opcode.ADD_INT_OBJ, Opcode.SUB_INT_OBJ, Opcode.MUL_INT_OBJ, Opcode.DIV_INT_OBJ, Opcode.MOD_INT_OBJ,
Opcode.ADD_REAL_OBJ, Opcode.SUB_REAL_OBJ, Opcode.MUL_REAL_OBJ, Opcode.DIV_REAL_OBJ, Opcode.MOD_REAL_OBJ,
Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ, Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ,
Opcode.AND_BOOL, Opcode.OR_BOOL -> Opcode.AND_BOOL, Opcode.OR_BOOL ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
@@ -172,12 +201,18 @@ class CmdBuilder {
listOf(OperandKind.IP) listOf(OperandKind.IP)
Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE -> Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE ->
listOf(OperandKind.SLOT, OperandKind.IP) listOf(OperandKind.SLOT, OperandKind.IP)
Opcode.JMP_IF_EQ_INT, Opcode.JMP_IF_NEQ_INT,
Opcode.JMP_IF_LT_INT, Opcode.JMP_IF_LTE_INT,
Opcode.JMP_IF_GT_INT, Opcode.JMP_IF_GTE_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.IP)
Opcode.CALL_DIRECT -> Opcode.CALL_DIRECT ->
listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_MEMBER_SLOT -> Opcode.CALL_MEMBER_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_SLOT -> Opcode.CALL_SLOT, Opcode.CALL_BRIDGE_SLOT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.GET_INDEX -> Opcode.GET_INDEX ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.SET_INDEX -> Opcode.SET_INDEX ->
@@ -190,6 +225,14 @@ class CmdBuilder {
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
Opcode.SET_MEMBER_SLOT -> Opcode.SET_MEMBER_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
Opcode.GET_CLASS_SCOPE ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.SET_CLASS_SCOPE ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.GET_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.SET_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.ITER_PUSH -> Opcode.ITER_PUSH ->
listOf(OperandKind.SLOT) listOf(OperandKind.SLOT)
Opcode.ITER_POP, Opcode.ITER_CANCEL -> Opcode.ITER_POP, Opcode.ITER_CANCEL ->
@@ -206,19 +249,37 @@ class CmdBuilder {
ID, ID,
} }
private fun createCmd(op: Opcode, operands: IntArray, scopeSlotCount: Int): Cmd { private fun createCmd(
op: Opcode,
operands: IntArray,
scopeSlotCount: Int,
localSlotCaptures: BooleanArray
): Cmd {
fun isFastLocal(slot: Int): Boolean {
if (slot < scopeSlotCount) return false
val localIndex = slot - scopeSlotCount
return localSlotCaptures.getOrNull(localIndex) != true
}
return when (op) { return when (op) {
Opcode.NOP -> CmdNop() Opcode.NOP -> CmdNop()
Opcode.MOVE_OBJ -> CmdMoveObj(operands[0], operands[1]) Opcode.MOVE_OBJ -> CmdMoveObj(operands[0], operands[1])
Opcode.MOVE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) { Opcode.MOVE_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdMoveIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount) CmdMoveIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else { } else {
CmdMoveInt(operands[0], operands[1]) CmdMoveInt(operands[0], operands[1])
} }
Opcode.MOVE_REAL -> CmdMoveReal(operands[0], operands[1]) Opcode.MOVE_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
Opcode.MOVE_BOOL -> CmdMoveBool(operands[0], operands[1]) CmdMoveRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdMoveReal(operands[0], operands[1])
}
Opcode.MOVE_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdMoveBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdMoveBool(operands[0], operands[1])
}
Opcode.CONST_OBJ -> CmdConstObj(operands[0], operands[1]) Opcode.CONST_OBJ -> CmdConstObj(operands[0], operands[1])
Opcode.CONST_INT -> if (operands[1] >= scopeSlotCount) { Opcode.CONST_INT -> if (isFastLocal(operands[1])) {
CmdConstIntLocal(operands[0], operands[1] - scopeSlotCount) CmdConstIntLocal(operands[0], operands[1] - scopeSlotCount)
} else { } else {
CmdConstInt(operands[0], operands[1]) CmdConstInt(operands[0], operands[1])
@@ -226,9 +287,20 @@ class CmdBuilder {
Opcode.CONST_REAL -> CmdConstReal(operands[0], operands[1]) Opcode.CONST_REAL -> CmdConstReal(operands[0], operands[1])
Opcode.CONST_BOOL -> CmdConstBool(operands[0], operands[1]) Opcode.CONST_BOOL -> CmdConstBool(operands[0], operands[1])
Opcode.CONST_NULL -> CmdConstNull(operands[0]) Opcode.CONST_NULL -> CmdConstNull(operands[0])
Opcode.MAKE_VALUE_FN -> CmdMakeValueFn(operands[0], operands[1]) Opcode.MAKE_LAMBDA_FN -> CmdMakeLambda(operands[0], operands[1])
Opcode.BOX_OBJ -> CmdBoxObj(operands[0], operands[1]) Opcode.BOX_OBJ -> CmdBoxObj(operands[0], operands[1])
Opcode.UNBOX_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdUnboxIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdUnboxIntObj(operands[0], operands[1])
}
Opcode.UNBOX_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdUnboxRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdUnboxRealObj(operands[0], operands[1])
}
Opcode.OBJ_TO_BOOL -> CmdObjToBool(operands[0], operands[1]) Opcode.OBJ_TO_BOOL -> CmdObjToBool(operands[0], operands[1])
Opcode.GET_OBJ_CLASS -> CmdGetObjClass(operands[0], operands[1])
Opcode.RANGE_INT_BOUNDS -> CmdRangeIntBounds(operands[0], operands[1], operands[2], operands[3]) Opcode.RANGE_INT_BOUNDS -> CmdRangeIntBounds(operands[0], operands[1], operands[2], operands[3])
Opcode.LOAD_THIS -> CmdLoadThis(operands[0]) Opcode.LOAD_THIS -> CmdLoadThis(operands[0])
Opcode.LOAD_THIS_VARIANT -> CmdLoadThisVariant(operands[0], operands[1]) Opcode.LOAD_THIS_VARIANT -> CmdLoadThisVariant(operands[0], operands[1])
@@ -238,7 +310,11 @@ class CmdBuilder {
Opcode.MAKE_QUALIFIED_VIEW -> CmdMakeQualifiedView(operands[0], operands[1], operands[2]) Opcode.MAKE_QUALIFIED_VIEW -> CmdMakeQualifiedView(operands[0], operands[1], operands[2])
Opcode.RET_LABEL -> CmdRetLabel(operands[0], operands[1]) Opcode.RET_LABEL -> CmdRetLabel(operands[0], operands[1])
Opcode.THROW -> CmdThrow(operands[0], operands[1]) Opcode.THROW -> CmdThrow(operands[0], operands[1])
Opcode.RETHROW_PENDING -> CmdRethrowPending()
Opcode.RESOLVE_SCOPE_SLOT -> CmdResolveScopeSlot(operands[0], operands[1]) Opcode.RESOLVE_SCOPE_SLOT -> CmdResolveScopeSlot(operands[0], operands[1])
Opcode.DELEGATED_GET_LOCAL -> CmdDelegatedGetLocal(operands[0], operands[1], operands[2])
Opcode.DELEGATED_SET_LOCAL -> CmdDelegatedSetLocal(operands[0], operands[1], operands[2])
Opcode.BIND_DELEGATE_LOCAL -> CmdBindDelegateLocal(operands[0], operands[1], operands[2], operands[3])
Opcode.LOAD_OBJ_ADDR -> CmdLoadObjAddr(operands[0], operands[1]) Opcode.LOAD_OBJ_ADDR -> CmdLoadObjAddr(operands[0], operands[1])
Opcode.STORE_OBJ_ADDR -> CmdStoreObjAddr(operands[0], operands[1]) Opcode.STORE_OBJ_ADDR -> CmdStoreObjAddr(operands[0], operands[1])
Opcode.LOAD_INT_ADDR -> CmdLoadIntAddr(operands[0], operands[1]) Opcode.LOAD_INT_ADDR -> CmdLoadIntAddr(operands[0], operands[1])
@@ -247,119 +323,419 @@ class CmdBuilder {
Opcode.STORE_REAL_ADDR -> CmdStoreRealAddr(operands[0], operands[1]) Opcode.STORE_REAL_ADDR -> CmdStoreRealAddr(operands[0], operands[1])
Opcode.LOAD_BOOL_ADDR -> CmdLoadBoolAddr(operands[0], operands[1]) Opcode.LOAD_BOOL_ADDR -> CmdLoadBoolAddr(operands[0], operands[1])
Opcode.STORE_BOOL_ADDR -> CmdStoreBoolAddr(operands[0], operands[1]) Opcode.STORE_BOOL_ADDR -> CmdStoreBoolAddr(operands[0], operands[1])
Opcode.INT_TO_REAL -> CmdIntToReal(operands[0], operands[1]) Opcode.INT_TO_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
Opcode.REAL_TO_INT -> CmdRealToInt(operands[0], operands[1]) CmdIntToRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
Opcode.BOOL_TO_INT -> CmdBoolToInt(operands[0], operands[1]) } else {
Opcode.INT_TO_BOOL -> CmdIntToBool(operands[0], operands[1]) CmdIntToReal(operands[0], operands[1])
Opcode.ADD_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { }
Opcode.REAL_TO_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdRealToIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdRealToInt(operands[0], operands[1])
}
Opcode.BOOL_TO_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdBoolToIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdBoolToInt(operands[0], operands[1])
}
Opcode.INT_TO_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdIntToBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdIntToBool(operands[0], operands[1])
}
Opcode.ADD_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdAddIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdAddIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdAddInt(operands[0], operands[1], operands[2]) CmdAddInt(operands[0], operands[1], operands[2])
} }
Opcode.SUB_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.SUB_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdSubIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdSubIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdSubInt(operands[0], operands[1], operands[2]) CmdSubInt(operands[0], operands[1], operands[2])
} }
Opcode.MUL_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.MUL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdMulIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdMulIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdMulInt(operands[0], operands[1], operands[2]) CmdMulInt(operands[0], operands[1], operands[2])
} }
Opcode.DIV_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.DIV_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdDivIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdDivIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdDivInt(operands[0], operands[1], operands[2]) CmdDivInt(operands[0], operands[1], operands[2])
} }
Opcode.MOD_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.MOD_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdModIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdModIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdModInt(operands[0], operands[1], operands[2]) CmdModInt(operands[0], operands[1], operands[2])
} }
Opcode.NEG_INT -> CmdNegInt(operands[0], operands[1]) Opcode.NEG_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
Opcode.INC_INT -> if (operands[0] >= scopeSlotCount) { CmdNegIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdNegInt(operands[0], operands[1])
}
Opcode.INC_INT -> if (isFastLocal(operands[0])) {
CmdIncIntLocal(operands[0] - scopeSlotCount) CmdIncIntLocal(operands[0] - scopeSlotCount)
} else { } else {
CmdIncInt(operands[0]) CmdIncInt(operands[0])
} }
Opcode.DEC_INT -> if (operands[0] >= scopeSlotCount) { Opcode.DEC_INT -> if (isFastLocal(operands[0])) {
CmdDecIntLocal(operands[0] - scopeSlotCount) CmdDecIntLocal(operands[0] - scopeSlotCount)
} else { } else {
CmdDecInt(operands[0]) CmdDecInt(operands[0])
} }
Opcode.ADD_REAL -> CmdAddReal(operands[0], operands[1], operands[2]) Opcode.ADD_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.SUB_REAL -> CmdSubReal(operands[0], operands[1], operands[2]) CmdAddRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.MUL_REAL -> CmdMulReal(operands[0], operands[1], operands[2]) } else {
Opcode.DIV_REAL -> CmdDivReal(operands[0], operands[1], operands[2]) CmdAddReal(operands[0], operands[1], operands[2])
Opcode.NEG_REAL -> CmdNegReal(operands[0], operands[1]) }
Opcode.AND_INT -> CmdAndInt(operands[0], operands[1], operands[2]) Opcode.SUB_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.OR_INT -> CmdOrInt(operands[0], operands[1], operands[2]) CmdSubRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.XOR_INT -> CmdXorInt(operands[0], operands[1], operands[2]) } else {
Opcode.SHL_INT -> CmdShlInt(operands[0], operands[1], operands[2]) CmdSubReal(operands[0], operands[1], operands[2])
Opcode.SHR_INT -> CmdShrInt(operands[0], operands[1], operands[2]) }
Opcode.USHR_INT -> CmdUshrInt(operands[0], operands[1], operands[2]) Opcode.MUL_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.INV_INT -> CmdInvInt(operands[0], operands[1]) CmdMulRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.CMP_EQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { } else {
CmdMulReal(operands[0], operands[1], operands[2])
}
Opcode.DIV_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdDivRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdDivReal(operands[0], operands[1], operands[2])
}
Opcode.NEG_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdNegRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdNegReal(operands[0], operands[1])
}
Opcode.AND_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdAndIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdAndInt(operands[0], operands[1], operands[2])
}
Opcode.OR_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdOrIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdOrInt(operands[0], operands[1], operands[2])
}
Opcode.XOR_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdXorIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdXorInt(operands[0], operands[1], operands[2])
}
Opcode.SHL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdShlIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdShlInt(operands[0], operands[1], operands[2])
}
Opcode.SHR_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdShrIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdShrInt(operands[0], operands[1], operands[2])
}
Opcode.USHR_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdUshrIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdUshrInt(operands[0], operands[1], operands[2])
}
Opcode.INV_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdInvIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdInvInt(operands[0], operands[1])
}
Opcode.CMP_EQ_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpEqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpEqInt(operands[0], operands[1], operands[2]) CmdCmpEqInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_NEQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.CMP_NEQ_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpNeqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpNeqInt(operands[0], operands[1], operands[2]) CmdCmpNeqInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_LT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.CMP_LT_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpLtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpLtInt(operands[0], operands[1], operands[2]) CmdCmpLtInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_LTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.CMP_LTE_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpLteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpLteInt(operands[0], operands[1], operands[2]) CmdCmpLteInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_GT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.CMP_GT_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpGtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpGtInt(operands[0], operands[1], operands[2]) CmdCmpGtInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_GTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount && operands[2] >= scopeSlotCount) { Opcode.CMP_GTE_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount) CmdCmpGteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else { } else {
CmdCmpGteInt(operands[0], operands[1], operands[2]) CmdCmpGteInt(operands[0], operands[1], operands[2])
} }
Opcode.CMP_EQ_REAL -> CmdCmpEqReal(operands[0], operands[1], operands[2]) Opcode.CMP_EQ_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.CMP_NEQ_REAL -> CmdCmpNeqReal(operands[0], operands[1], operands[2]) CmdCmpEqRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.CMP_LT_REAL -> CmdCmpLtReal(operands[0], operands[1], operands[2]) } else {
Opcode.CMP_LTE_REAL -> CmdCmpLteReal(operands[0], operands[1], operands[2]) CmdCmpEqReal(operands[0], operands[1], operands[2])
Opcode.CMP_GT_REAL -> CmdCmpGtReal(operands[0], operands[1], operands[2]) }
Opcode.CMP_GTE_REAL -> CmdCmpGteReal(operands[0], operands[1], operands[2]) Opcode.CMP_NEQ_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.CMP_EQ_BOOL -> CmdCmpEqBool(operands[0], operands[1], operands[2]) CmdCmpNeqRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.CMP_NEQ_BOOL -> CmdCmpNeqBool(operands[0], operands[1], operands[2]) } else {
Opcode.CMP_EQ_INT_REAL -> CmdCmpEqIntReal(operands[0], operands[1], operands[2]) CmdCmpNeqReal(operands[0], operands[1], operands[2])
Opcode.CMP_EQ_REAL_INT -> CmdCmpEqRealInt(operands[0], operands[1], operands[2]) }
Opcode.CMP_LT_INT_REAL -> CmdCmpLtIntReal(operands[0], operands[1], operands[2]) Opcode.CMP_LT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.CMP_LT_REAL_INT -> CmdCmpLtRealInt(operands[0], operands[1], operands[2]) CmdCmpLtRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.CMP_LTE_INT_REAL -> CmdCmpLteIntReal(operands[0], operands[1], operands[2]) } else {
Opcode.CMP_LTE_REAL_INT -> CmdCmpLteRealInt(operands[0], operands[1], operands[2]) CmdCmpLtReal(operands[0], operands[1], operands[2])
Opcode.CMP_GT_INT_REAL -> CmdCmpGtIntReal(operands[0], operands[1], operands[2]) }
Opcode.CMP_GT_REAL_INT -> CmdCmpGtRealInt(operands[0], operands[1], operands[2]) Opcode.CMP_LTE_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.CMP_GTE_INT_REAL -> CmdCmpGteIntReal(operands[0], operands[1], operands[2]) CmdCmpLteRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.CMP_GTE_REAL_INT -> CmdCmpGteRealInt(operands[0], operands[1], operands[2]) } else {
Opcode.CMP_NEQ_INT_REAL -> CmdCmpNeqIntReal(operands[0], operands[1], operands[2]) CmdCmpLteReal(operands[0], operands[1], operands[2])
Opcode.CMP_NEQ_REAL_INT -> CmdCmpNeqRealInt(operands[0], operands[1], operands[2]) }
Opcode.CMP_GT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpEqBool(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqBool(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpEqIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpEqRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLtIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLtRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_LTE_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLteIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_LTE_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLteRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_GT_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_GT_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_INT_REAL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqIntRealLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqIntReal(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_REAL_INT -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqRealIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqRealInt(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_OBJ -> CmdCmpEqObj(operands[0], operands[1], operands[2]) Opcode.CMP_EQ_OBJ -> CmdCmpEqObj(operands[0], operands[1], operands[2])
Opcode.CMP_NEQ_OBJ -> CmdCmpNeqObj(operands[0], operands[1], operands[2]) Opcode.CMP_NEQ_OBJ -> CmdCmpNeqObj(operands[0], operands[1], operands[2])
Opcode.CMP_REF_EQ_OBJ -> CmdCmpRefEqObj(operands[0], operands[1], operands[2]) Opcode.CMP_REF_EQ_OBJ -> CmdCmpRefEqObj(operands[0], operands[1], operands[2])
Opcode.CMP_REF_NEQ_OBJ -> CmdCmpRefNeqObj(operands[0], operands[1], operands[2]) Opcode.CMP_REF_NEQ_OBJ -> CmdCmpRefNeqObj(operands[0], operands[1], operands[2])
Opcode.NOT_BOOL -> CmdNotBool(operands[0], operands[1]) Opcode.CMP_EQ_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
Opcode.AND_BOOL -> CmdAndBool(operands[0], operands[1], operands[2]) CmdCmpEqStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
Opcode.OR_BOOL -> CmdOrBool(operands[0], operands[1], operands[2]) } else {
CmdCmpEqStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLtStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_LTE_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLteStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_GT_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_STR -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteStrLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteStr(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpEqIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLtIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_LTE_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLteIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_GT_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteIntObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_EQ_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpEqRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpEqRealObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_NEQ_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpNeqRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpNeqRealObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLtRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLtRealObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_LTE_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpLteRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpLteRealObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_GT_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGtRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGtRealObj(operands[0], operands[1], operands[2])
}
Opcode.CMP_GTE_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdCmpGteRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdCmpGteRealObj(operands[0], operands[1], operands[2])
}
Opcode.NOT_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1])) {
CmdNotBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount)
} else {
CmdNotBool(operands[0], operands[1])
}
Opcode.AND_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdAndBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdAndBool(operands[0], operands[1], operands[2])
}
Opcode.OR_BOOL -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdOrBoolLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdOrBool(operands[0], operands[1], operands[2])
}
Opcode.CMP_LT_OBJ -> CmdCmpLtObj(operands[0], operands[1], operands[2]) Opcode.CMP_LT_OBJ -> CmdCmpLtObj(operands[0], operands[1], operands[2])
Opcode.CMP_LTE_OBJ -> CmdCmpLteObj(operands[0], operands[1], operands[2]) Opcode.CMP_LTE_OBJ -> CmdCmpLteObj(operands[0], operands[1], operands[2])
Opcode.CMP_GT_OBJ -> CmdCmpGtObj(operands[0], operands[1], operands[2]) Opcode.CMP_GT_OBJ -> CmdCmpGtObj(operands[0], operands[1], operands[2])
Opcode.CMP_GTE_OBJ -> CmdCmpGteObj(operands[0], operands[1], operands[2]) Opcode.CMP_GTE_OBJ -> CmdCmpGteObj(operands[0], operands[1], operands[2])
Opcode.ADD_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdAddIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdAddIntObj(operands[0], operands[1], operands[2])
}
Opcode.SUB_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdSubIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdSubIntObj(operands[0], operands[1], operands[2])
}
Opcode.MUL_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdMulIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdMulIntObj(operands[0], operands[1], operands[2])
}
Opcode.DIV_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdDivIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdDivIntObj(operands[0], operands[1], operands[2])
}
Opcode.MOD_INT_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdModIntObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdModIntObj(operands[0], operands[1], operands[2])
}
Opcode.ADD_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdAddRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdAddRealObj(operands[0], operands[1], operands[2])
}
Opcode.SUB_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdSubRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdSubRealObj(operands[0], operands[1], operands[2])
}
Opcode.MUL_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdMulRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdMulRealObj(operands[0], operands[1], operands[2])
}
Opcode.DIV_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdDivRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdDivRealObj(operands[0], operands[1], operands[2])
}
Opcode.MOD_REAL_OBJ -> if (isFastLocal(operands[0]) && isFastLocal(operands[1]) && isFastLocal(operands[2])) {
CmdModRealObjLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2] - scopeSlotCount)
} else {
CmdModRealObj(operands[0], operands[1], operands[2])
}
Opcode.ADD_OBJ -> CmdAddObj(operands[0], operands[1], operands[2]) Opcode.ADD_OBJ -> CmdAddObj(operands[0], operands[1], operands[2])
Opcode.SUB_OBJ -> CmdSubObj(operands[0], operands[1], operands[2]) Opcode.SUB_OBJ -> CmdSubObj(operands[0], operands[1], operands[2])
Opcode.MUL_OBJ -> CmdMulObj(operands[0], operands[1], operands[2]) Opcode.MUL_OBJ -> CmdMulObj(operands[0], operands[1], operands[2])
@@ -368,24 +744,86 @@ class CmdBuilder {
Opcode.CONTAINS_OBJ -> CmdContainsObj(operands[0], operands[1], operands[2]) Opcode.CONTAINS_OBJ -> CmdContainsObj(operands[0], operands[1], operands[2])
Opcode.ASSIGN_OP_OBJ -> CmdAssignOpObj(operands[0], operands[1], operands[2], operands[3], operands[4]) Opcode.ASSIGN_OP_OBJ -> CmdAssignOpObj(operands[0], operands[1], operands[2], operands[3], operands[4])
Opcode.JMP -> CmdJmp(operands[0]) Opcode.JMP -> CmdJmp(operands[0])
Opcode.JMP_IF_TRUE -> CmdJmpIfTrue(operands[0], operands[1]) Opcode.JMP_IF_TRUE -> if (operands[0] >= scopeSlotCount) {
Opcode.JMP_IF_FALSE -> CmdJmpIfFalse(operands[0], operands[1]) CmdJmpIfTrueLocal(operands[0] - scopeSlotCount, operands[1])
} else {
CmdJmpIfTrue(operands[0], operands[1])
}
Opcode.JMP_IF_FALSE -> if (operands[0] >= scopeSlotCount) {
CmdJmpIfFalseLocal(operands[0] - scopeSlotCount, operands[1])
} else {
CmdJmpIfFalse(operands[0], operands[1])
}
Opcode.JMP_IF_EQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfEqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfEqInt(operands[0], operands[1], operands[2])
}
Opcode.JMP_IF_NEQ_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfNeqIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfNeqInt(operands[0], operands[1], operands[2])
}
Opcode.JMP_IF_LT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfLtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfLtInt(operands[0], operands[1], operands[2])
}
Opcode.JMP_IF_LTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfLteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfLteInt(operands[0], operands[1], operands[2])
}
Opcode.JMP_IF_GT_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfGtIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfGtInt(operands[0], operands[1], operands[2])
}
Opcode.JMP_IF_GTE_INT -> if (operands[0] >= scopeSlotCount && operands[1] >= scopeSlotCount) {
CmdJmpIfGteIntLocal(operands[0] - scopeSlotCount, operands[1] - scopeSlotCount, operands[2])
} else {
CmdJmpIfGteInt(operands[0], operands[1], operands[2])
}
Opcode.RET -> CmdRet(operands[0]) Opcode.RET -> CmdRet(operands[0])
Opcode.RET_VOID -> CmdRetVoid() Opcode.RET_VOID -> CmdRetVoid()
Opcode.PUSH_SCOPE -> CmdPushScope(operands[0]) Opcode.PUSH_SCOPE -> CmdPushScope(operands[0])
Opcode.POP_SCOPE -> CmdPopScope() Opcode.POP_SCOPE -> CmdPopScope()
Opcode.PUSH_SLOT_PLAN -> CmdPushSlotPlan(operands[0]) Opcode.PUSH_SLOT_PLAN -> CmdPushSlotPlan(operands[0])
Opcode.POP_SLOT_PLAN -> CmdPopSlotPlan() Opcode.POP_SLOT_PLAN -> CmdPopSlotPlan()
Opcode.PUSH_TRY -> CmdPushTry(operands[0], operands[1], operands[2])
Opcode.POP_TRY -> CmdPopTry()
Opcode.CLEAR_PENDING_THROWABLE -> CmdClearPendingThrowable()
Opcode.DECL_LOCAL -> CmdDeclLocal(operands[0], operands[1]) Opcode.DECL_LOCAL -> CmdDeclLocal(operands[0], operands[1])
Opcode.DECL_DELEGATED -> CmdDeclDelegated(operands[0], operands[1])
Opcode.DECL_DESTRUCTURE -> CmdDeclDestructure(operands[0], operands[1])
Opcode.DECL_ENUM -> CmdDeclEnum(operands[0], operands[1])
Opcode.DECL_FUNCTION -> CmdDeclFunction(operands[0], operands[1])
Opcode.DECL_CLASS -> CmdDeclClass(operands[0], operands[1])
Opcode.DECL_CLASS_FIELD -> CmdDeclClassField(operands[0], operands[1])
Opcode.DECL_CLASS_DELEGATED -> CmdDeclClassDelegated(operands[0], operands[1])
Opcode.DECL_CLASS_INSTANCE_INIT -> CmdDeclClassInstanceInit(operands[0], operands[1])
Opcode.DECL_CLASS_INSTANCE_FIELD -> CmdDeclClassInstanceField(operands[0], operands[1])
Opcode.DECL_CLASS_INSTANCE_PROPERTY -> CmdDeclClassInstanceProperty(operands[0], operands[1])
Opcode.DECL_CLASS_INSTANCE_DELEGATED -> CmdDeclClassInstanceDelegated(operands[0], operands[1])
Opcode.DECL_INSTANCE_FIELD -> CmdDeclInstanceField(operands[0], operands[1])
Opcode.DECL_INSTANCE_PROPERTY -> CmdDeclInstanceProperty(operands[0], operands[1])
Opcode.DECL_INSTANCE_DELEGATED -> CmdDeclInstanceDelegated(operands[0], operands[1])
Opcode.DECL_EXT_PROPERTY -> CmdDeclExtProperty(operands[0], operands[1]) Opcode.DECL_EXT_PROPERTY -> CmdDeclExtProperty(operands[0], operands[1])
Opcode.CALL_DIRECT -> CmdCallDirect(operands[0], operands[1], operands[2], operands[3]) Opcode.CALL_DIRECT -> CmdCallDirect(operands[0], operands[1], operands[2], operands[3])
Opcode.ASSIGN_DESTRUCTURE -> CmdAssignDestructure(operands[0], operands[1])
Opcode.CALL_MEMBER_SLOT -> CmdCallMemberSlot(operands[0], operands[1], operands[2], operands[3], operands[4]) Opcode.CALL_MEMBER_SLOT -> CmdCallMemberSlot(operands[0], operands[1], operands[2], operands[3], operands[4])
Opcode.CALL_SLOT -> CmdCallSlot(operands[0], operands[1], operands[2], operands[3]) Opcode.CALL_SLOT -> CmdCallSlot(operands[0], operands[1], operands[2], operands[3])
Opcode.CALL_BRIDGE_SLOT -> CmdCallBridgeSlot(operands[0], operands[1], operands[2], operands[3])
Opcode.CALL_DYNAMIC_MEMBER -> CmdCallDynamicMember(operands[0], operands[1], operands[2], operands[3], operands[4])
Opcode.GET_INDEX -> CmdGetIndex(operands[0], operands[1], operands[2]) Opcode.GET_INDEX -> CmdGetIndex(operands[0], operands[1], operands[2])
Opcode.SET_INDEX -> CmdSetIndex(operands[0], operands[1], operands[2]) Opcode.SET_INDEX -> CmdSetIndex(operands[0], operands[1], operands[2])
Opcode.LIST_LITERAL -> CmdListLiteral(operands[0], operands[1], operands[2], operands[3]) Opcode.LIST_LITERAL -> CmdListLiteral(operands[0], operands[1], operands[2], operands[3])
Opcode.GET_MEMBER_SLOT -> CmdGetMemberSlot(operands[0], operands[1], operands[2], operands[3]) Opcode.GET_MEMBER_SLOT -> CmdGetMemberSlot(operands[0], operands[1], operands[2], operands[3])
Opcode.SET_MEMBER_SLOT -> CmdSetMemberSlot(operands[0], operands[1], operands[2], operands[3]) Opcode.SET_MEMBER_SLOT -> CmdSetMemberSlot(operands[0], operands[1], operands[2], operands[3])
Opcode.GET_CLASS_SCOPE -> CmdGetClassScope(operands[0], operands[1], operands[2])
Opcode.SET_CLASS_SCOPE -> CmdSetClassScope(operands[0], operands[1], operands[2])
Opcode.GET_DYNAMIC_MEMBER -> CmdGetDynamicMember(operands[0], operands[1], operands[2])
Opcode.SET_DYNAMIC_MEMBER -> CmdSetDynamicMember(operands[0], operands[1], operands[2])
Opcode.ITER_PUSH -> CmdIterPush(operands[0]) Opcode.ITER_PUSH -> CmdIterPush(operands[0])
Opcode.ITER_POP -> CmdIterPop() Opcode.ITER_POP -> CmdIterPop()
Opcode.ITER_CANCEL -> CmdIterCancel() Opcode.ITER_CANCEL -> CmdIterCancel()
@@ -1,5 +1,5 @@
/* /*
* Copyright 2026 Sergey S. Chernov * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -12,6 +12,7 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*
*/ */
package net.sergeych.lyng.bytecode package net.sergeych.lyng.bytecode
@@ -50,6 +51,23 @@ object CmdDisassembler {
} }
out.append('\n') out.append('\n')
} }
val captureConsts = fn.constants.withIndex().mapNotNull { (idx, constVal) ->
val table = constVal as? BytecodeConst.CaptureTable ?: return@mapNotNull null
idx to table
}
if (captureConsts.isNotEmpty()) {
out.append("consts:\n")
for ((idx, table) in captureConsts) {
val entries = if (table.entries.isEmpty()) {
"[]"
} else {
table.entries.joinToString(prefix = "[", postfix = "]") { entry ->
"${entry.ownerKind}#${entry.ownerScopeId}:${entry.ownerSlotId}@s${entry.slotIndex}"
}
}
out.append("k").append(idx).append(" CAPTURE_TABLE ").append(entries).append('\n')
}
}
return out.toString() return out.toString()
} }
@@ -59,6 +77,8 @@ object CmdDisassembler {
is CmdMoveObj -> Opcode.MOVE_OBJ to intArrayOf(cmd.src, cmd.dst) is CmdMoveObj -> Opcode.MOVE_OBJ to intArrayOf(cmd.src, cmd.dst)
is CmdMoveInt -> Opcode.MOVE_INT to intArrayOf(cmd.src, cmd.dst) is CmdMoveInt -> Opcode.MOVE_INT to intArrayOf(cmd.src, cmd.dst)
is CmdMoveIntLocal -> Opcode.MOVE_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount) is CmdMoveIntLocal -> Opcode.MOVE_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdMoveRealLocal -> Opcode.MOVE_REAL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdMoveBoolLocal -> Opcode.MOVE_BOOL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdMoveReal -> Opcode.MOVE_REAL to intArrayOf(cmd.src, cmd.dst) is CmdMoveReal -> Opcode.MOVE_REAL to intArrayOf(cmd.src, cmd.dst)
is CmdMoveBool -> Opcode.MOVE_BOOL to intArrayOf(cmd.src, cmd.dst) is CmdMoveBool -> Opcode.MOVE_BOOL to intArrayOf(cmd.src, cmd.dst)
is CmdConstObj -> Opcode.CONST_OBJ to intArrayOf(cmd.constId, cmd.dst) is CmdConstObj -> Opcode.CONST_OBJ to intArrayOf(cmd.constId, cmd.dst)
@@ -69,9 +89,10 @@ object CmdDisassembler {
is CmdLoadThis -> Opcode.LOAD_THIS to intArrayOf(cmd.dst) is CmdLoadThis -> Opcode.LOAD_THIS to intArrayOf(cmd.dst)
is CmdLoadThisVariant -> Opcode.LOAD_THIS_VARIANT to intArrayOf(cmd.typeId, cmd.dst) is CmdLoadThisVariant -> Opcode.LOAD_THIS_VARIANT to intArrayOf(cmd.typeId, cmd.dst)
is CmdConstNull -> Opcode.CONST_NULL to intArrayOf(cmd.dst) is CmdConstNull -> Opcode.CONST_NULL to intArrayOf(cmd.dst)
is CmdMakeValueFn -> Opcode.MAKE_VALUE_FN to intArrayOf(cmd.id, cmd.dst) is CmdMakeLambda -> Opcode.MAKE_LAMBDA_FN to intArrayOf(cmd.id, cmd.dst)
is CmdBoxObj -> Opcode.BOX_OBJ to intArrayOf(cmd.src, cmd.dst) is CmdBoxObj -> Opcode.BOX_OBJ to intArrayOf(cmd.src, cmd.dst)
is CmdObjToBool -> Opcode.OBJ_TO_BOOL to intArrayOf(cmd.src, cmd.dst) is CmdObjToBool -> Opcode.OBJ_TO_BOOL to intArrayOf(cmd.src, cmd.dst)
is CmdGetObjClass -> Opcode.GET_OBJ_CLASS to intArrayOf(cmd.src, cmd.dst)
is CmdCheckIs -> Opcode.CHECK_IS to intArrayOf(cmd.objSlot, cmd.typeSlot, cmd.dst) is CmdCheckIs -> Opcode.CHECK_IS to intArrayOf(cmd.objSlot, cmd.typeSlot, cmd.dst)
is CmdAssertIs -> Opcode.ASSERT_IS to intArrayOf(cmd.objSlot, cmd.typeSlot) is CmdAssertIs -> Opcode.ASSERT_IS to intArrayOf(cmd.objSlot, cmd.typeSlot)
is CmdMakeQualifiedView -> Opcode.MAKE_QUALIFIED_VIEW to intArrayOf(cmd.objSlot, cmd.typeSlot, cmd.dst) is CmdMakeQualifiedView -> Opcode.MAKE_QUALIFIED_VIEW to intArrayOf(cmd.objSlot, cmd.typeSlot, cmd.dst)
@@ -84,6 +105,9 @@ object CmdDisassembler {
cmd.dst cmd.dst
) )
is CmdResolveScopeSlot -> Opcode.RESOLVE_SCOPE_SLOT to intArrayOf(cmd.scopeSlot, cmd.addrSlot) is CmdResolveScopeSlot -> Opcode.RESOLVE_SCOPE_SLOT to intArrayOf(cmd.scopeSlot, cmd.addrSlot)
is CmdDelegatedGetLocal -> Opcode.DELEGATED_GET_LOCAL to intArrayOf(cmd.delegateSlot, cmd.nameId, cmd.dst)
is CmdDelegatedSetLocal -> Opcode.DELEGATED_SET_LOCAL to intArrayOf(cmd.delegateSlot, cmd.nameId, cmd.valueSlot)
is CmdBindDelegateLocal -> Opcode.BIND_DELEGATE_LOCAL to intArrayOf(cmd.delegateSlot, cmd.nameId, cmd.accessId, cmd.dst)
is CmdLoadObjAddr -> Opcode.LOAD_OBJ_ADDR to intArrayOf(cmd.addrSlot, cmd.dst) is CmdLoadObjAddr -> Opcode.LOAD_OBJ_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
is CmdStoreObjAddr -> Opcode.STORE_OBJ_ADDR to intArrayOf(cmd.src, cmd.addrSlot) is CmdStoreObjAddr -> Opcode.STORE_OBJ_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
is CmdLoadIntAddr -> Opcode.LOAD_INT_ADDR to intArrayOf(cmd.addrSlot, cmd.dst) is CmdLoadIntAddr -> Opcode.LOAD_INT_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
@@ -93,9 +117,13 @@ object CmdDisassembler {
is CmdLoadBoolAddr -> Opcode.LOAD_BOOL_ADDR to intArrayOf(cmd.addrSlot, cmd.dst) is CmdLoadBoolAddr -> Opcode.LOAD_BOOL_ADDR to intArrayOf(cmd.addrSlot, cmd.dst)
is CmdStoreBoolAddr -> Opcode.STORE_BOOL_ADDR to intArrayOf(cmd.src, cmd.addrSlot) is CmdStoreBoolAddr -> Opcode.STORE_BOOL_ADDR to intArrayOf(cmd.src, cmd.addrSlot)
is CmdIntToReal -> Opcode.INT_TO_REAL to intArrayOf(cmd.src, cmd.dst) is CmdIntToReal -> Opcode.INT_TO_REAL to intArrayOf(cmd.src, cmd.dst)
is CmdIntToRealLocal -> Opcode.INT_TO_REAL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdRealToInt -> Opcode.REAL_TO_INT to intArrayOf(cmd.src, cmd.dst) is CmdRealToInt -> Opcode.REAL_TO_INT to intArrayOf(cmd.src, cmd.dst)
is CmdRealToIntLocal -> Opcode.REAL_TO_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdBoolToInt -> Opcode.BOOL_TO_INT to intArrayOf(cmd.src, cmd.dst) is CmdBoolToInt -> Opcode.BOOL_TO_INT to intArrayOf(cmd.src, cmd.dst)
is CmdBoolToIntLocal -> Opcode.BOOL_TO_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdIntToBool -> Opcode.INT_TO_BOOL to intArrayOf(cmd.src, cmd.dst) is CmdIntToBool -> Opcode.INT_TO_BOOL to intArrayOf(cmd.src, cmd.dst)
is CmdIntToBoolLocal -> Opcode.INT_TO_BOOL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdAddInt -> Opcode.ADD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdAddInt -> Opcode.ADD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAddIntLocal -> Opcode.ADD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount) is CmdAddIntLocal -> Opcode.ADD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdSubInt -> Opcode.SUB_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdSubInt -> Opcode.SUB_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
@@ -107,22 +135,35 @@ object CmdDisassembler {
is CmdModInt -> Opcode.MOD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdModInt -> Opcode.MOD_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdModIntLocal -> Opcode.MOD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount) is CmdModIntLocal -> Opcode.MOD_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdNegInt -> Opcode.NEG_INT to intArrayOf(cmd.src, cmd.dst) is CmdNegInt -> Opcode.NEG_INT to intArrayOf(cmd.src, cmd.dst)
is CmdNegIntLocal -> Opcode.NEG_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdIncInt -> Opcode.INC_INT to intArrayOf(cmd.slot) is CmdIncInt -> Opcode.INC_INT to intArrayOf(cmd.slot)
is CmdIncIntLocal -> Opcode.INC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount) is CmdIncIntLocal -> Opcode.INC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount)
is CmdDecInt -> Opcode.DEC_INT to intArrayOf(cmd.slot) is CmdDecInt -> Opcode.DEC_INT to intArrayOf(cmd.slot)
is CmdDecIntLocal -> Opcode.DEC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount) is CmdDecIntLocal -> Opcode.DEC_INT to intArrayOf(cmd.slot + fn.scopeSlotCount)
is CmdAddReal -> Opcode.ADD_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdAddReal -> Opcode.ADD_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAddRealLocal -> Opcode.ADD_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdSubReal -> Opcode.SUB_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdSubReal -> Opcode.SUB_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdSubRealLocal -> Opcode.SUB_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdMulReal -> Opcode.MUL_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdMulReal -> Opcode.MUL_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdMulRealLocal -> Opcode.MUL_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdDivReal -> Opcode.DIV_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdDivReal -> Opcode.DIV_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdDivRealLocal -> Opcode.DIV_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdNegReal -> Opcode.NEG_REAL to intArrayOf(cmd.src, cmd.dst) is CmdNegReal -> Opcode.NEG_REAL to intArrayOf(cmd.src, cmd.dst)
is CmdNegRealLocal -> Opcode.NEG_REAL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdAndInt -> Opcode.AND_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdAndInt -> Opcode.AND_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAndIntLocal -> Opcode.AND_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdOrInt -> Opcode.OR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdOrInt -> Opcode.OR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdOrIntLocal -> Opcode.OR_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdXorInt -> Opcode.XOR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdXorInt -> Opcode.XOR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdXorIntLocal -> Opcode.XOR_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdShlInt -> Opcode.SHL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdShlInt -> Opcode.SHL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdShlIntLocal -> Opcode.SHL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdShrInt -> Opcode.SHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdShrInt -> Opcode.SHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdShrIntLocal -> Opcode.SHR_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdUshrInt -> Opcode.USHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdUshrInt -> Opcode.USHR_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdUshrIntLocal -> Opcode.USHR_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdInvInt -> Opcode.INV_INT to intArrayOf(cmd.src, cmd.dst) is CmdInvInt -> Opcode.INV_INT to intArrayOf(cmd.src, cmd.dst)
is CmdInvIntLocal -> Opcode.INV_INT to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpEqInt -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqInt -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqIntLocal -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount) is CmdCmpEqIntLocal -> Opcode.CMP_EQ_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpNeqInt -> Opcode.CMP_NEQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqInt -> Opcode.CMP_NEQ_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
@@ -136,36 +177,273 @@ object CmdDisassembler {
is CmdCmpGteInt -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGteInt -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteIntLocal -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount) is CmdCmpGteIntLocal -> Opcode.CMP_GTE_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpEqReal -> Opcode.CMP_EQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqReal -> Opcode.CMP_EQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqRealLocal -> Opcode.CMP_EQ_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpNeqReal -> Opcode.CMP_NEQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqReal -> Opcode.CMP_NEQ_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqRealLocal -> Opcode.CMP_NEQ_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLtReal -> Opcode.CMP_LT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLtReal -> Opcode.CMP_LT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtRealLocal -> Opcode.CMP_LT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLteReal -> Opcode.CMP_LTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLteReal -> Opcode.CMP_LTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteRealLocal -> Opcode.CMP_LTE_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGtReal -> Opcode.CMP_GT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGtReal -> Opcode.CMP_GT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtRealLocal -> Opcode.CMP_GT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGteReal -> Opcode.CMP_GTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGteReal -> Opcode.CMP_GTE_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteRealLocal -> Opcode.CMP_GTE_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpEqBool -> Opcode.CMP_EQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqBool -> Opcode.CMP_EQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqBoolLocal -> Opcode.CMP_EQ_BOOL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpNeqBool -> Opcode.CMP_NEQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqBool -> Opcode.CMP_NEQ_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqBoolLocal -> Opcode.CMP_NEQ_BOOL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpEqIntReal -> Opcode.CMP_EQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqIntReal -> Opcode.CMP_EQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqIntRealLocal -> Opcode.CMP_EQ_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpEqRealInt -> Opcode.CMP_EQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqRealInt -> Opcode.CMP_EQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqRealIntLocal -> Opcode.CMP_EQ_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLtIntReal -> Opcode.CMP_LT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLtIntReal -> Opcode.CMP_LT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtIntRealLocal -> Opcode.CMP_LT_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLtRealInt -> Opcode.CMP_LT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLtRealInt -> Opcode.CMP_LT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtRealIntLocal -> Opcode.CMP_LT_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLteIntReal -> Opcode.CMP_LTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLteIntReal -> Opcode.CMP_LTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteIntRealLocal -> Opcode.CMP_LTE_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpLteRealInt -> Opcode.CMP_LTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLteRealInt -> Opcode.CMP_LTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteRealIntLocal -> Opcode.CMP_LTE_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGtIntReal -> Opcode.CMP_GT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGtIntReal -> Opcode.CMP_GT_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtIntRealLocal -> Opcode.CMP_GT_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGtRealInt -> Opcode.CMP_GT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGtRealInt -> Opcode.CMP_GT_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtRealIntLocal -> Opcode.CMP_GT_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGteIntReal -> Opcode.CMP_GTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGteIntReal -> Opcode.CMP_GTE_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteIntRealLocal -> Opcode.CMP_GTE_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpGteRealInt -> Opcode.CMP_GTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGteRealInt -> Opcode.CMP_GTE_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteRealIntLocal -> Opcode.CMP_GTE_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpNeqIntReal -> Opcode.CMP_NEQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqIntReal -> Opcode.CMP_NEQ_INT_REAL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqIntRealLocal -> Opcode.CMP_NEQ_INT_REAL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdCmpNeqRealInt -> Opcode.CMP_NEQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqRealInt -> Opcode.CMP_NEQ_REAL_INT to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqRealIntLocal -> Opcode.CMP_NEQ_REAL_INT to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdJmpIfEqInt -> Opcode.JMP_IF_EQ_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfEqIntLocal -> Opcode.JMP_IF_EQ_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdJmpIfNeqInt -> Opcode.JMP_IF_NEQ_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfNeqIntLocal -> Opcode.JMP_IF_NEQ_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdJmpIfLtInt -> Opcode.JMP_IF_LT_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfLtIntLocal -> Opcode.JMP_IF_LT_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdJmpIfLteInt -> Opcode.JMP_IF_LTE_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfLteIntLocal -> Opcode.JMP_IF_LTE_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdJmpIfGtInt -> Opcode.JMP_IF_GT_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfGtIntLocal -> Opcode.JMP_IF_GT_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdJmpIfGteInt -> Opcode.JMP_IF_GTE_INT to intArrayOf(cmd.a, cmd.b, cmd.target)
is CmdJmpIfGteIntLocal -> Opcode.JMP_IF_GTE_INT to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.target
)
is CmdCmpEqObj -> Opcode.CMP_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpEqObj -> Opcode.CMP_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqObj -> Opcode.CMP_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpNeqObj -> Opcode.CMP_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpRefEqObj -> Opcode.CMP_REF_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpRefEqObj -> Opcode.CMP_REF_EQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpRefNeqObj -> Opcode.CMP_REF_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpRefNeqObj -> Opcode.CMP_REF_NEQ_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqStr -> Opcode.CMP_EQ_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqStrLocal -> Opcode.CMP_EQ_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpNeqStr -> Opcode.CMP_NEQ_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqStrLocal -> Opcode.CMP_NEQ_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLtStr -> Opcode.CMP_LT_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtStrLocal -> Opcode.CMP_LT_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLteStr -> Opcode.CMP_LTE_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteStrLocal -> Opcode.CMP_LTE_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGtStr -> Opcode.CMP_GT_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtStrLocal -> Opcode.CMP_GT_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGteStr -> Opcode.CMP_GTE_STR to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteStrLocal -> Opcode.CMP_GTE_STR to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpEqIntObj -> Opcode.CMP_EQ_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqIntObjLocal -> Opcode.CMP_EQ_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpNeqIntObj -> Opcode.CMP_NEQ_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqIntObjLocal -> Opcode.CMP_NEQ_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLtIntObj -> Opcode.CMP_LT_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtIntObjLocal -> Opcode.CMP_LT_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLteIntObj -> Opcode.CMP_LTE_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteIntObjLocal -> Opcode.CMP_LTE_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGtIntObj -> Opcode.CMP_GT_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtIntObjLocal -> Opcode.CMP_GT_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGteIntObj -> Opcode.CMP_GTE_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteIntObjLocal -> Opcode.CMP_GTE_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpEqRealObj -> Opcode.CMP_EQ_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpEqRealObjLocal -> Opcode.CMP_EQ_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpNeqRealObj -> Opcode.CMP_NEQ_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpNeqRealObjLocal -> Opcode.CMP_NEQ_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLtRealObj -> Opcode.CMP_LT_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLtRealObjLocal -> Opcode.CMP_LT_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLteRealObj -> Opcode.CMP_LTE_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteRealObjLocal -> Opcode.CMP_LTE_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGtRealObj -> Opcode.CMP_GT_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtRealObjLocal -> Opcode.CMP_GT_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpGteRealObj -> Opcode.CMP_GTE_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteRealObjLocal -> Opcode.CMP_GTE_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdNotBool -> Opcode.NOT_BOOL to intArrayOf(cmd.src, cmd.dst) is CmdNotBool -> Opcode.NOT_BOOL to intArrayOf(cmd.src, cmd.dst)
is CmdNotBoolLocal -> Opcode.NOT_BOOL to intArrayOf(cmd.src + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdAndBool -> Opcode.AND_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdAndBool -> Opcode.AND_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAndBoolLocal -> Opcode.AND_BOOL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdOrBool -> Opcode.OR_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdOrBool -> Opcode.OR_BOOL to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdOrBoolLocal -> Opcode.OR_BOOL to intArrayOf(cmd.a + fn.scopeSlotCount, cmd.b + fn.scopeSlotCount, cmd.dst + fn.scopeSlotCount)
is CmdUnboxIntObj -> Opcode.UNBOX_INT_OBJ to intArrayOf(cmd.src, cmd.dst)
is CmdUnboxIntObjLocal -> Opcode.UNBOX_INT_OBJ to intArrayOf(
cmd.src + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdUnboxRealObj -> Opcode.UNBOX_REAL_OBJ to intArrayOf(cmd.src, cmd.dst)
is CmdUnboxRealObjLocal -> Opcode.UNBOX_REAL_OBJ to intArrayOf(
cmd.src + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdCmpLtObj -> Opcode.CMP_LT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLtObj -> Opcode.CMP_LT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpLteObj -> Opcode.CMP_LTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpLteObj -> Opcode.CMP_LTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGtObj -> Opcode.CMP_GT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGtObj -> Opcode.CMP_GT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdCmpGteObj -> Opcode.CMP_GTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdCmpGteObj -> Opcode.CMP_GTE_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAddIntObj -> Opcode.ADD_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAddIntObjLocal -> Opcode.ADD_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdSubIntObj -> Opcode.SUB_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdSubIntObjLocal -> Opcode.SUB_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdMulIntObj -> Opcode.MUL_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdMulIntObjLocal -> Opcode.MUL_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdDivIntObj -> Opcode.DIV_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdDivIntObjLocal -> Opcode.DIV_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdModIntObj -> Opcode.MOD_INT_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdModIntObjLocal -> Opcode.MOD_INT_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdAddRealObj -> Opcode.ADD_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdAddRealObjLocal -> Opcode.ADD_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdSubRealObj -> Opcode.SUB_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdSubRealObjLocal -> Opcode.SUB_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdMulRealObj -> Opcode.MUL_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdMulRealObjLocal -> Opcode.MUL_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdDivRealObj -> Opcode.DIV_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdDivRealObjLocal -> Opcode.DIV_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdModRealObj -> Opcode.MOD_REAL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdModRealObjLocal -> Opcode.MOD_REAL_OBJ to intArrayOf(
cmd.a + fn.scopeSlotCount,
cmd.b + fn.scopeSlotCount,
cmd.dst + fn.scopeSlotCount
)
is CmdAddObj -> Opcode.ADD_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdAddObj -> Opcode.ADD_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdSubObj -> Opcode.SUB_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdSubObj -> Opcode.SUB_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
is CmdMulObj -> Opcode.MUL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst) is CmdMulObj -> Opcode.MUL_OBJ to intArrayOf(cmd.a, cmd.b, cmd.dst)
@@ -175,25 +453,52 @@ object CmdDisassembler {
is CmdAssignOpObj -> Opcode.ASSIGN_OP_OBJ to intArrayOf(cmd.opId, cmd.targetSlot, cmd.valueSlot, cmd.dst, cmd.nameId) is CmdAssignOpObj -> Opcode.ASSIGN_OP_OBJ to intArrayOf(cmd.opId, cmd.targetSlot, cmd.valueSlot, cmd.dst, cmd.nameId)
is CmdJmp -> Opcode.JMP to intArrayOf(cmd.target) is CmdJmp -> Opcode.JMP to intArrayOf(cmd.target)
is CmdJmpIfTrue -> Opcode.JMP_IF_TRUE to intArrayOf(cmd.cond, cmd.target) is CmdJmpIfTrue -> Opcode.JMP_IF_TRUE to intArrayOf(cmd.cond, cmd.target)
is CmdJmpIfTrueLocal -> Opcode.JMP_IF_TRUE to intArrayOf(cmd.cond + fn.scopeSlotCount, cmd.target)
is CmdJmpIfFalse -> Opcode.JMP_IF_FALSE to intArrayOf(cmd.cond, cmd.target) is CmdJmpIfFalse -> Opcode.JMP_IF_FALSE to intArrayOf(cmd.cond, cmd.target)
is CmdJmpIfFalseLocal -> Opcode.JMP_IF_FALSE to intArrayOf(cmd.cond + fn.scopeSlotCount, cmd.target)
is CmdRet -> Opcode.RET to intArrayOf(cmd.slot) is CmdRet -> Opcode.RET to intArrayOf(cmd.slot)
is CmdRetLabel -> Opcode.RET_LABEL to intArrayOf(cmd.labelId, cmd.slot) is CmdRetLabel -> Opcode.RET_LABEL to intArrayOf(cmd.labelId, cmd.slot)
is CmdRetVoid -> Opcode.RET_VOID to intArrayOf() is CmdRetVoid -> Opcode.RET_VOID to intArrayOf()
is CmdThrow -> Opcode.THROW to intArrayOf(cmd.posId, cmd.slot) is CmdThrow -> Opcode.THROW to intArrayOf(cmd.posId, cmd.slot)
is CmdRethrowPending -> Opcode.RETHROW_PENDING to intArrayOf()
is CmdPushScope -> Opcode.PUSH_SCOPE to intArrayOf(cmd.planId) is CmdPushScope -> Opcode.PUSH_SCOPE to intArrayOf(cmd.planId)
is CmdPopScope -> Opcode.POP_SCOPE to intArrayOf() is CmdPopScope -> Opcode.POP_SCOPE to intArrayOf()
is CmdPushSlotPlan -> Opcode.PUSH_SLOT_PLAN to intArrayOf(cmd.planId) is CmdPushSlotPlan -> Opcode.PUSH_SLOT_PLAN to intArrayOf(cmd.planId)
is CmdPopSlotPlan -> Opcode.POP_SLOT_PLAN to intArrayOf() is CmdPopSlotPlan -> Opcode.POP_SLOT_PLAN to intArrayOf()
is CmdPushTry -> Opcode.PUSH_TRY to intArrayOf(cmd.exceptionSlot, cmd.catchIp, cmd.finallyIp)
is CmdPopTry -> Opcode.POP_TRY to intArrayOf()
is CmdClearPendingThrowable -> Opcode.CLEAR_PENDING_THROWABLE to intArrayOf()
is CmdDeclLocal -> Opcode.DECL_LOCAL to intArrayOf(cmd.constId, cmd.slot) is CmdDeclLocal -> Opcode.DECL_LOCAL to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclDelegated -> Opcode.DECL_DELEGATED to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclDestructure -> Opcode.DECL_DESTRUCTURE to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclEnum -> Opcode.DECL_ENUM to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclFunction -> Opcode.DECL_FUNCTION to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClass -> Opcode.DECL_CLASS to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassField -> Opcode.DECL_CLASS_FIELD to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassDelegated -> Opcode.DECL_CLASS_DELEGATED to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassInstanceInit -> Opcode.DECL_CLASS_INSTANCE_INIT to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassInstanceField -> Opcode.DECL_CLASS_INSTANCE_FIELD to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassInstanceProperty -> Opcode.DECL_CLASS_INSTANCE_PROPERTY to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclClassInstanceDelegated -> Opcode.DECL_CLASS_INSTANCE_DELEGATED to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclInstanceField -> Opcode.DECL_INSTANCE_FIELD to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclInstanceProperty -> Opcode.DECL_INSTANCE_PROPERTY to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclInstanceDelegated -> Opcode.DECL_INSTANCE_DELEGATED to intArrayOf(cmd.constId, cmd.slot)
is CmdDeclExtProperty -> Opcode.DECL_EXT_PROPERTY to intArrayOf(cmd.constId, cmd.slot) is CmdDeclExtProperty -> Opcode.DECL_EXT_PROPERTY to intArrayOf(cmd.constId, cmd.slot)
is CmdCallDirect -> Opcode.CALL_DIRECT to intArrayOf(cmd.id, cmd.argBase, cmd.argCount, cmd.dst) is CmdCallDirect -> Opcode.CALL_DIRECT to intArrayOf(cmd.id, cmd.argBase, cmd.argCount, cmd.dst)
is CmdAssignDestructure -> Opcode.ASSIGN_DESTRUCTURE to intArrayOf(cmd.constId, cmd.slot)
is CmdCallMemberSlot -> Opcode.CALL_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.methodId, cmd.argBase, cmd.argCount, cmd.dst) is CmdCallMemberSlot -> Opcode.CALL_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.methodId, cmd.argBase, cmd.argCount, cmd.dst)
is CmdCallSlot -> Opcode.CALL_SLOT to intArrayOf(cmd.calleeSlot, cmd.argBase, cmd.argCount, cmd.dst) is CmdCallSlot -> Opcode.CALL_SLOT to intArrayOf(cmd.calleeSlot, cmd.argBase, cmd.argCount, cmd.dst)
is CmdCallBridgeSlot -> Opcode.CALL_BRIDGE_SLOT to intArrayOf(cmd.calleeSlot, cmd.argBase, cmd.argCount, cmd.dst)
is CmdCallDynamicMember -> Opcode.CALL_DYNAMIC_MEMBER to intArrayOf(cmd.recvSlot, cmd.nameId, cmd.argBase, cmd.argCount, cmd.dst)
is CmdGetIndex -> Opcode.GET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.dst) is CmdGetIndex -> Opcode.GET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.dst)
is CmdSetIndex -> Opcode.SET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.valueSlot) is CmdSetIndex -> Opcode.SET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.valueSlot)
is CmdListLiteral -> Opcode.LIST_LITERAL to intArrayOf(cmd.planId, cmd.baseSlot, cmd.count, cmd.dst) is CmdListLiteral -> Opcode.LIST_LITERAL to intArrayOf(cmd.planId, cmd.baseSlot, cmd.count, cmd.dst)
is CmdGetMemberSlot -> Opcode.GET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.dst) is CmdGetMemberSlot -> Opcode.GET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.dst)
is CmdSetMemberSlot -> Opcode.SET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.valueSlot) is CmdSetMemberSlot -> Opcode.SET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.valueSlot)
is CmdGetClassScope -> Opcode.GET_CLASS_SCOPE to intArrayOf(cmd.classSlot, cmd.nameId, cmd.dst)
is CmdSetClassScope -> Opcode.SET_CLASS_SCOPE to intArrayOf(cmd.classSlot, cmd.nameId, cmd.valueSlot)
is CmdGetDynamicMember -> Opcode.GET_DYNAMIC_MEMBER to intArrayOf(cmd.recvSlot, cmd.nameId, cmd.dst)
is CmdSetDynamicMember -> Opcode.SET_DYNAMIC_MEMBER to intArrayOf(cmd.recvSlot, cmd.nameId, cmd.valueSlot)
is CmdIterPush -> Opcode.ITER_PUSH to intArrayOf(cmd.iterSlot) is CmdIterPush -> Opcode.ITER_PUSH to intArrayOf(cmd.iterSlot)
is CmdIterPop -> Opcode.ITER_POP to intArrayOf() is CmdIterPop -> Opcode.ITER_POP to intArrayOf()
is CmdIterCancel -> Opcode.ITER_CANCEL to intArrayOf() is CmdIterCancel -> Opcode.ITER_CANCEL to intArrayOf()
@@ -212,13 +517,15 @@ object CmdDisassembler {
private fun operandKinds(op: Opcode): List<OperandKind> { private fun operandKinds(op: Opcode): List<OperandKind> {
return when (op) { return when (op) {
Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN, Opcode.NOP, Opcode.RET_VOID, Opcode.POP_SCOPE, Opcode.POP_SLOT_PLAN, Opcode.POP_TRY,
Opcode.CLEAR_PENDING_THROWABLE, Opcode.RETHROW_PENDING,
Opcode.ITER_POP, Opcode.ITER_CANCEL -> emptyList() Opcode.ITER_POP, Opcode.ITER_CANCEL -> emptyList()
Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ, Opcode.MOVE_OBJ, Opcode.MOVE_INT, Opcode.MOVE_REAL, Opcode.MOVE_BOOL, Opcode.BOX_OBJ,
Opcode.UNBOX_INT_OBJ, Opcode.UNBOX_REAL_OBJ,
Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL, Opcode.INT_TO_REAL, Opcode.REAL_TO_INT, Opcode.BOOL_TO_INT, Opcode.INT_TO_BOOL,
Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT -> Opcode.NEG_INT, Opcode.NEG_REAL, Opcode.NOT_BOOL, Opcode.INV_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.OBJ_TO_BOOL, Opcode.ASSERT_IS -> Opcode.OBJ_TO_BOOL, Opcode.GET_OBJ_CLASS, Opcode.ASSERT_IS ->
listOf(OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.CHECK_IS, Opcode.MAKE_QUALIFIED_VIEW -> Opcode.CHECK_IS, Opcode.MAKE_QUALIFIED_VIEW ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
@@ -230,17 +537,31 @@ object CmdDisassembler {
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.RESOLVE_SCOPE_SLOT -> Opcode.RESOLVE_SCOPE_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ADDR) listOf(OperandKind.SLOT, OperandKind.ADDR)
Opcode.DELEGATED_GET_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.DELEGATED_SET_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.BIND_DELEGATE_LOCAL ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.CONST, OperandKind.SLOT)
Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR -> Opcode.LOAD_OBJ_ADDR, Opcode.LOAD_INT_ADDR, Opcode.LOAD_REAL_ADDR, Opcode.LOAD_BOOL_ADDR ->
listOf(OperandKind.ADDR, OperandKind.SLOT) listOf(OperandKind.ADDR, OperandKind.SLOT)
Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR -> Opcode.STORE_OBJ_ADDR, Opcode.STORE_INT_ADDR, Opcode.STORE_REAL_ADDR, Opcode.STORE_BOOL_ADDR ->
listOf(OperandKind.SLOT, OperandKind.ADDR) listOf(OperandKind.SLOT, OperandKind.ADDR)
Opcode.CONST_NULL -> Opcode.CONST_NULL ->
listOf(OperandKind.SLOT) listOf(OperandKind.SLOT)
Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL, Opcode.MAKE_VALUE_FN -> Opcode.CONST_OBJ, Opcode.CONST_INT, Opcode.CONST_REAL, Opcode.CONST_BOOL,
Opcode.MAKE_LAMBDA_FN ->
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN -> Opcode.PUSH_SCOPE, Opcode.PUSH_SLOT_PLAN ->
listOf(OperandKind.CONST) listOf(OperandKind.CONST)
Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY -> Opcode.PUSH_TRY ->
listOf(OperandKind.SLOT, OperandKind.IP, OperandKind.IP)
Opcode.DECL_LOCAL, Opcode.DECL_EXT_PROPERTY, Opcode.DECL_DELEGATED, Opcode.DECL_DESTRUCTURE,
Opcode.DECL_ENUM, Opcode.DECL_FUNCTION, Opcode.DECL_CLASS, Opcode.DECL_CLASS_FIELD,
Opcode.DECL_CLASS_DELEGATED, Opcode.DECL_CLASS_INSTANCE_INIT, Opcode.DECL_CLASS_INSTANCE_FIELD,
Opcode.DECL_CLASS_INSTANCE_PROPERTY, Opcode.DECL_CLASS_INSTANCE_DELEGATED, Opcode.DECL_INSTANCE_FIELD,
Opcode.DECL_INSTANCE_PROPERTY, Opcode.DECL_INSTANCE_DELEGATED,
Opcode.ASSIGN_DESTRUCTURE ->
listOf(OperandKind.CONST, OperandKind.SLOT) listOf(OperandKind.CONST, OperandKind.SLOT)
Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT, Opcode.ADD_INT, Opcode.SUB_INT, Opcode.MUL_INT, Opcode.DIV_INT, Opcode.MOD_INT,
Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL, Opcode.ADD_REAL, Opcode.SUB_REAL, Opcode.MUL_REAL, Opcode.DIV_REAL,
@@ -254,7 +575,14 @@ object CmdDisassembler {
Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT, Opcode.CMP_LTE_INT_REAL, Opcode.CMP_LTE_REAL_INT, Opcode.CMP_GT_INT_REAL, Opcode.CMP_GT_REAL_INT,
Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT, Opcode.CMP_GTE_INT_REAL, Opcode.CMP_GTE_REAL_INT, Opcode.CMP_NEQ_INT_REAL, Opcode.CMP_NEQ_REAL_INT,
Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ, Opcode.CMP_EQ_OBJ, Opcode.CMP_NEQ_OBJ, Opcode.CMP_REF_EQ_OBJ, Opcode.CMP_REF_NEQ_OBJ,
Opcode.CMP_EQ_STR, Opcode.CMP_NEQ_STR, Opcode.CMP_LT_STR, Opcode.CMP_LTE_STR,
Opcode.CMP_GT_STR, Opcode.CMP_GTE_STR,
Opcode.CMP_EQ_INT_OBJ, Opcode.CMP_NEQ_INT_OBJ, Opcode.CMP_LT_INT_OBJ, Opcode.CMP_LTE_INT_OBJ,
Opcode.CMP_GT_INT_OBJ, Opcode.CMP_GTE_INT_OBJ, Opcode.CMP_EQ_REAL_OBJ, Opcode.CMP_NEQ_REAL_OBJ,
Opcode.CMP_LT_REAL_OBJ, Opcode.CMP_LTE_REAL_OBJ, Opcode.CMP_GT_REAL_OBJ, Opcode.CMP_GTE_REAL_OBJ,
Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ, Opcode.CMP_LT_OBJ, Opcode.CMP_LTE_OBJ, Opcode.CMP_GT_OBJ, Opcode.CMP_GTE_OBJ,
Opcode.ADD_INT_OBJ, Opcode.SUB_INT_OBJ, Opcode.MUL_INT_OBJ, Opcode.DIV_INT_OBJ, Opcode.MOD_INT_OBJ,
Opcode.ADD_REAL_OBJ, Opcode.SUB_REAL_OBJ, Opcode.MUL_REAL_OBJ, Opcode.DIV_REAL_OBJ, Opcode.MOD_REAL_OBJ,
Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ, Opcode.ADD_OBJ, Opcode.SUB_OBJ, Opcode.MUL_OBJ, Opcode.DIV_OBJ, Opcode.MOD_OBJ, Opcode.CONTAINS_OBJ,
Opcode.AND_BOOL, Opcode.OR_BOOL -> Opcode.AND_BOOL, Opcode.OR_BOOL ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
@@ -268,12 +596,18 @@ object CmdDisassembler {
listOf(OperandKind.IP) listOf(OperandKind.IP)
Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE -> Opcode.JMP_IF_TRUE, Opcode.JMP_IF_FALSE ->
listOf(OperandKind.SLOT, OperandKind.IP) listOf(OperandKind.SLOT, OperandKind.IP)
Opcode.JMP_IF_EQ_INT, Opcode.JMP_IF_NEQ_INT,
Opcode.JMP_IF_LT_INT, Opcode.JMP_IF_LTE_INT,
Opcode.JMP_IF_GT_INT, Opcode.JMP_IF_GTE_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.IP)
Opcode.CALL_DIRECT -> Opcode.CALL_DIRECT ->
listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_SLOT -> Opcode.CALL_SLOT, Opcode.CALL_BRIDGE_SLOT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_MEMBER_SLOT -> Opcode.CALL_MEMBER_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.CALL_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.GET_INDEX -> Opcode.GET_INDEX ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.SET_INDEX -> Opcode.SET_INDEX ->
@@ -284,6 +618,14 @@ object CmdDisassembler {
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
Opcode.SET_MEMBER_SLOT -> Opcode.SET_MEMBER_SLOT ->
listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT) listOf(OperandKind.SLOT, OperandKind.ID, OperandKind.ID, OperandKind.SLOT)
Opcode.GET_CLASS_SCOPE ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.SET_CLASS_SCOPE ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.GET_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
Opcode.SET_DYNAMIC_MEMBER ->
listOf(OperandKind.SLOT, OperandKind.CONST, OperandKind.SLOT)
} }
} }
} }
@@ -28,6 +28,8 @@ data class CmdFunction(
val scopeSlotIsModule: BooleanArray, val scopeSlotIsModule: BooleanArray,
val localSlotNames: Array<String?>, val localSlotNames: Array<String?>,
val localSlotMutables: BooleanArray, val localSlotMutables: BooleanArray,
val localSlotDelegated: BooleanArray,
val localSlotCaptures: BooleanArray,
val constants: List<BytecodeConst>, val constants: List<BytecodeConst>,
val cmds: Array<Cmd>, val cmds: Array<Cmd>,
val posByIp: Array<net.sergeych.lyng.Pos?>, val posByIp: Array<net.sergeych.lyng.Pos?>,
@@ -37,10 +39,31 @@ data class CmdFunction(
require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" } require(scopeSlotNames.size == scopeSlotCount) { "scopeSlotNames size mismatch" }
require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" } require(scopeSlotIsModule.size == scopeSlotCount) { "scopeSlotIsModule size mismatch" }
require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "localSlot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "localSlot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "localSlot capture size mismatch" }
require(localSlotNames.size <= localCount) { "localSlotNames exceed localCount" } require(localSlotNames.size <= localCount) { "localSlotNames exceed localCount" }
require(addrCount >= 0) { "addrCount must be non-negative" } require(addrCount >= 0) { "addrCount must be non-negative" }
if (posByIp.isNotEmpty()) { if (posByIp.isNotEmpty()) {
require(posByIp.size == cmds.size) { "posByIp size mismatch" } require(posByIp.size == cmds.size) { "posByIp size mismatch" }
} }
} }
fun localSlotPlanByName(): Map<String, Int> {
val result = LinkedHashMap<String, Int>()
for (i in localSlotNames.indices) {
val name = localSlotNames[i] ?: continue
val existing = result[name]
if (existing == null) {
result[name] = i
continue
}
val existingIsCapture = localSlotCaptures.getOrNull(existing) == true
val currentIsCapture = localSlotCaptures.getOrNull(i) == true
if (existingIsCapture && !currentIsCapture) {
result[name] = i
}
}
return result
}
} }
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,23 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.bytecode
data class ForcedLocalSlotInfo(
val index: Int,
val isMutable: Boolean,
val isDelegated: Boolean,
)
@@ -0,0 +1,35 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.bytecode
enum class CaptureOwnerFrameKind { MODULE, LOCAL }
data class LambdaCaptureEntry(
val ownerKind: CaptureOwnerFrameKind,
val ownerScopeId: Int,
val ownerSlotId: Int,
val ownerName: String,
val ownerIsMutable: Boolean,
val ownerIsDelegated: Boolean,
)
data class BytecodeCaptureEntry(
val ownerKind: CaptureOwnerFrameKind,
val ownerScopeId: Int,
val ownerSlotId: Int,
val slotIndex: Int,
)
@@ -1,5 +1,5 @@
/* /*
* Copyright 2026 Sergey S. Chernov * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -12,6 +12,7 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*
*/ */
package net.sergeych.lyng.bytecode package net.sergeych.lyng.bytecode
@@ -31,7 +32,6 @@ enum class Opcode(val code: Int) {
RANGE_INT_BOUNDS(0x0B), RANGE_INT_BOUNDS(0x0B),
MAKE_RANGE(0x0C), MAKE_RANGE(0x0C),
LOAD_THIS(0x0D), LOAD_THIS(0x0D),
MAKE_VALUE_FN(0x0E),
LOAD_THIS_VARIANT(0x0F), LOAD_THIS_VARIANT(0x0F),
INT_TO_REAL(0x10), INT_TO_REAL(0x10),
@@ -42,6 +42,8 @@ enum class Opcode(val code: Int) {
CHECK_IS(0x15), CHECK_IS(0x15),
ASSERT_IS(0x16), ASSERT_IS(0x16),
MAKE_QUALIFIED_VIEW(0x17), MAKE_QUALIFIED_VIEW(0x17),
MAKE_LAMBDA_FN(0x18),
GET_OBJ_CLASS(0x19),
ADD_INT(0x20), ADD_INT(0x20),
SUB_INT(0x21), SUB_INT(0x21),
@@ -97,6 +99,36 @@ enum class Opcode(val code: Int) {
CMP_NEQ_OBJ(0x6D), CMP_NEQ_OBJ(0x6D),
CMP_REF_EQ_OBJ(0x6E), CMP_REF_EQ_OBJ(0x6E),
CMP_REF_NEQ_OBJ(0x6F), CMP_REF_NEQ_OBJ(0x6F),
CMP_EQ_STR(0xD6),
CMP_NEQ_STR(0xD7),
CMP_LT_STR(0xD8),
CMP_LTE_STR(0xD9),
CMP_GT_STR(0xDA),
CMP_GTE_STR(0xDB),
CMP_EQ_INT_OBJ(0xDC),
CMP_NEQ_INT_OBJ(0xDD),
CMP_LT_INT_OBJ(0xDE),
CMP_LTE_INT_OBJ(0xDF),
CMP_GT_INT_OBJ(0xE0),
CMP_GTE_INT_OBJ(0xE1),
CMP_EQ_REAL_OBJ(0xE2),
CMP_NEQ_REAL_OBJ(0xE3),
CMP_LT_REAL_OBJ(0xE4),
CMP_LTE_REAL_OBJ(0xE5),
CMP_GT_REAL_OBJ(0xE6),
CMP_GTE_REAL_OBJ(0xE7),
UNBOX_INT_OBJ(0xF2),
UNBOX_REAL_OBJ(0xF3),
ADD_INT_OBJ(0xE8),
SUB_INT_OBJ(0xE9),
MUL_INT_OBJ(0xEA),
DIV_INT_OBJ(0xEB),
MOD_INT_OBJ(0xEC),
ADD_REAL_OBJ(0xED),
SUB_REAL_OBJ(0xEE),
MUL_REAL_OBJ(0xEF),
DIV_REAL_OBJ(0xF0),
MOD_REAL_OBJ(0xF1),
NOT_BOOL(0x70), NOT_BOOL(0x70),
AND_BOOL(0x71), AND_BOOL(0x71),
@@ -116,6 +148,12 @@ enum class Opcode(val code: Int) {
JMP(0x80), JMP(0x80),
JMP_IF_TRUE(0x81), JMP_IF_TRUE(0x81),
JMP_IF_FALSE(0x82), JMP_IF_FALSE(0x82),
JMP_IF_EQ_INT(0xD0),
JMP_IF_NEQ_INT(0xD1),
JMP_IF_LT_INT(0xD2),
JMP_IF_LTE_INT(0xD3),
JMP_IF_GT_INT(0xD4),
JMP_IF_GTE_INT(0xD5),
RET(0x83), RET(0x83),
RET_VOID(0x84), RET_VOID(0x84),
RET_LABEL(0xBA), RET_LABEL(0xBA),
@@ -125,16 +163,28 @@ enum class Opcode(val code: Int) {
POP_SLOT_PLAN(0x88), POP_SLOT_PLAN(0x88),
DECL_LOCAL(0x89), DECL_LOCAL(0x89),
DECL_EXT_PROPERTY(0x8A), DECL_EXT_PROPERTY(0x8A),
DECL_DELEGATED(0x8B),
DECL_DESTRUCTURE(0x8C),
PUSH_TRY(0x8D),
POP_TRY(0x8E),
CLEAR_PENDING_THROWABLE(0x8F),
CALL_DIRECT(0x90), CALL_DIRECT(0x90),
ASSIGN_DESTRUCTURE(0x91),
CALL_MEMBER_SLOT(0x92), CALL_MEMBER_SLOT(0x92),
CALL_SLOT(0x93), CALL_SLOT(0x93),
CALL_BRIDGE_SLOT(0x94),
GET_INDEX(0xA2), GET_INDEX(0xA2),
SET_INDEX(0xA3), SET_INDEX(0xA3),
LIST_LITERAL(0xA5), LIST_LITERAL(0xA5),
GET_MEMBER_SLOT(0xA8), GET_MEMBER_SLOT(0xA8),
SET_MEMBER_SLOT(0xA9), SET_MEMBER_SLOT(0xA9),
GET_CLASS_SCOPE(0xAA),
SET_CLASS_SCOPE(0xAB),
GET_DYNAMIC_MEMBER(0xAC),
SET_DYNAMIC_MEMBER(0xAD),
CALL_DYNAMIC_MEMBER(0xAE),
RESOLVE_SCOPE_SLOT(0xB1), RESOLVE_SCOPE_SLOT(0xB1),
LOAD_OBJ_ADDR(0xB2), LOAD_OBJ_ADDR(0xB2),
@@ -146,9 +196,25 @@ enum class Opcode(val code: Int) {
LOAD_BOOL_ADDR(0xB8), LOAD_BOOL_ADDR(0xB8),
STORE_BOOL_ADDR(0xB9), STORE_BOOL_ADDR(0xB9),
THROW(0xBB), THROW(0xBB),
RETHROW_PENDING(0xBC),
DECL_ENUM(0xBE),
ITER_PUSH(0xBF), ITER_PUSH(0xBF),
ITER_POP(0xC0), ITER_POP(0xC0),
ITER_CANCEL(0xC1), ITER_CANCEL(0xC1),
DELEGATED_GET_LOCAL(0xC2),
DELEGATED_SET_LOCAL(0xC3),
BIND_DELEGATE_LOCAL(0xC4),
DECL_FUNCTION(0xC5),
DECL_CLASS(0xC6),
DECL_CLASS_FIELD(0xC7),
DECL_CLASS_DELEGATED(0xC8),
DECL_CLASS_INSTANCE_INIT(0xC9),
DECL_CLASS_INSTANCE_FIELD(0xCA),
DECL_CLASS_INSTANCE_PROPERTY(0xCB),
DECL_CLASS_INSTANCE_DELEGATED(0xCC),
DECL_INSTANCE_FIELD(0xCD),
DECL_INSTANCE_PROPERTY(0xCE),
DECL_INSTANCE_DELEGATED(0xCF),
; ;
companion object { companion object {
@@ -0,0 +1,44 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.bytecode
import net.sergeych.lyng.Scope
import net.sergeych.lyng.obj.ObjRecord
internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
val localNames = frame.fn.localSlotNames
if (localNames.isEmpty()) return
val base = frame.fn.scopeSlotCount
for (i in localNames.indices) {
val name = localNames[i] ?: continue
val slotType = frame.getLocalSlotTypeCode(i)
if (slotType != SlotType.UNKNOWN.code && slotType != SlotType.OBJ.code) continue
if (slotType == SlotType.OBJ.code && frame.frame.getRawObj(i) != null) continue
val record = scope.getLocalRecordDirect(name)
?: scope.chainLookupIgnoreClosure(name, followClosure = true)
?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
scope.resolve(record, name)
} else {
record.value
}
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, base + i)) {
continue
}
frame.setObjUnchecked(base + i, value)
}
}
@@ -102,6 +102,7 @@ object BuiltinDocRegistry : BuiltinDocSource {
// Register built-in lazy seeds // Register built-in lazy seeds
init { init {
registerLazy("lyng.stdlib") { buildStdlibDocs() } registerLazy("lyng.stdlib") { buildStdlibDocs() }
registerLazy("lyng.time") { buildTimeDocs() }
} }
/** /**
@@ -658,7 +659,32 @@ private fun buildStdlibDocs(): List<MiniDecl> {
} }
decls += mod.build() decls += mod.build()
return decls return decls
} }
private fun buildTimeDocs(): List<MiniDecl> {
val mod = ModuleDocsBuilder("lyng.time")
mod.classDoc(name = "Instant", doc = "Point in time (epoch-based).", bases = listOf(type("Obj"))) {
field(name = "distantFuture", doc = "An instant in the distant future.", type = type("lyng.Instant"), isStatic = true)
field(name = "distantPast", doc = "An instant in the distant past.", type = type("lyng.Instant"), isStatic = true)
method(name = "now", doc = "Return the current instant.", returns = type("lyng.Instant"), isStatic = true)
field(name = "epochSeconds", doc = "Seconds since Unix epoch.", type = type("lyng.Real"))
field(name = "epochWholeSeconds", doc = "Full seconds since Unix epoch.", type = type("lyng.Int"))
field(name = "nanosecondsOfSecond", doc = "Nanoseconds within the current second.", type = type("lyng.Int"))
method(name = "toRFC3339", doc = "Format as RFC3339 string.", returns = type("lyng.String"))
method(name = "toDateTime", doc = "Convert to localized DateTime.", params = listOf(ParamDoc("timeZone")), returns = type("lyng.DateTime"))
method(name = "truncateToMinute", doc = "Truncate to minute.", returns = type("lyng.Instant"))
method(name = "truncateToSecond", doc = "Truncate to second.", returns = type("lyng.Instant"))
method(name = "truncateToMillisecond", doc = "Truncate to millisecond.", returns = type("lyng.Instant"))
method(name = "truncateToMicrosecond", doc = "Truncate to microsecond.", returns = type("lyng.Instant"))
}
mod.classDoc(name = "DateTime", doc = "Localized date and time.", bases = listOf(type("Obj"))) {
method(name = "toInstant", doc = "Convert back to absolute Instant.", returns = type("lyng.Instant"))
}
mod.classDoc(name = "Duration", doc = "Time duration.", bases = listOf(type("Obj")))
mod.funDoc(name = "delay", doc = "Suspend execution.", params = listOf(ParamDoc("duration")))
return mod.build()
}
// (Registration for external modules is provided by their own libraries) // (Registration for external modules is provided by their own libraries)
@@ -74,29 +74,30 @@ object CompletionEngineLight {
val word = DocLookupUtils.wordRangeAt(text, caret) val word = DocLookupUtils.wordRangeAt(text, caret)
val memberDot = DocLookupUtils.findDotLeft(text, word?.first ?: caret) val memberDot = DocLookupUtils.findDotLeft(text, word?.first ?: caret)
if (memberDot != null) { if (memberDot != null) {
val staticOnly = DocLookupUtils.isStaticReceiver(mini, text, memberDot, imported, binding)
val inferredCls = (DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding) ?: DocLookupUtils.guessReceiverClass(text, memberDot, imported, mini)) val inferredCls = (DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding) ?: DocLookupUtils.guessReceiverClass(text, memberDot, imported, mini))
// 0) Try chained member call return type inference // 0) Try chained member call return type inference
DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding)?.let { cls -> DocLookupUtils.guessReturnClassFromMemberCallBeforeMini(mini, text, memberDot, imported, binding)?.let { cls ->
offerMembersAdd(out, prefix, imported, cls, mini) offerMembersAdd(out, prefix, imported, cls, mini, staticOnly)
return out return out
} }
DocLookupUtils.guessReturnClassFromMemberCallBefore(text, memberDot, imported, mini)?.let { cls -> DocLookupUtils.guessReturnClassFromMemberCallBefore(text, memberDot, imported, mini)?.let { cls ->
offerMembersAdd(out, prefix, imported, cls, mini) offerMembersAdd(out, prefix, imported, cls, mini, staticOnly)
return out return out
} }
// 0a) Top-level call before dot // 0a) Top-level call before dot
DocLookupUtils.guessReturnClassFromTopLevelCallBefore(text, memberDot, imported, mini)?.let { cls -> DocLookupUtils.guessReturnClassFromTopLevelCallBefore(text, memberDot, imported, mini)?.let { cls ->
offerMembersAdd(out, prefix, imported, cls, mini) offerMembersAdd(out, prefix, imported, cls, mini, staticOnly)
return out return out
} }
// 0b) Across-known-callees (Iterable/Iterator/List preference) // 0b) Across-known-callees (Iterable/Iterator/List preference)
DocLookupUtils.guessReturnClassAcrossKnownCallees(text, memberDot, imported, mini)?.let { cls -> DocLookupUtils.guessReturnClassAcrossKnownCallees(text, memberDot, imported, mini)?.let { cls ->
offerMembersAdd(out, prefix, imported, cls, mini) offerMembersAdd(out, prefix, imported, cls, mini, staticOnly)
return out return out
} }
// 1) Receiver inference fallback // 1) Receiver inference fallback
(DocLookupUtils.guessReceiverClassViaMini(mini, text, memberDot, imported, binding) ?: DocLookupUtils.guessReceiverClass(text, memberDot, imported, mini))?.let { cls -> (DocLookupUtils.guessReceiverClassViaMini(mini, text, memberDot, imported, binding) ?: DocLookupUtils.guessReceiverClass(text, memberDot, imported, mini))?.let { cls ->
offerMembersAdd(out, prefix, imported, cls, mini) offerMembersAdd(out, prefix, imported, cls, mini, staticOnly)
return out return out
} }
// In member context and unknown receiver/return type: show nothing (no globals after dot) // In member context and unknown receiver/return type: show nothing (no globals after dot)
@@ -106,10 +107,20 @@ object CompletionEngineLight {
// Global identifiers: params > local decls > imported > stdlib; Functions > Classes > Values; alphabetical // Global identifiers: params > local decls > imported > stdlib; Functions > Classes > Values; alphabetical
offerParamsInScope(out, prefix, mini, text, caret) offerParamsInScope(out, prefix, mini, text, caret)
val locals = DocLookupUtils.extractLocalsAt(text, caret) val localsFromBinding = DocLookupUtils.collectLocalsFromBinding(mini, binding, caret)
for (name in locals) { if (localsFromBinding.isNotEmpty()) {
if (name.startsWith(prefix, true)) { for (sym in localsFromBinding) {
out.add(CompletionItem(name, Kind.Value, priority = 150.0)) if (sym.name.startsWith(prefix, true)) {
val t = sym.type?.let { ": $it" }
out.add(CompletionItem(sym.name, Kind.Value, typeText = t, priority = 150.0))
}
}
} else {
val locals = DocLookupUtils.extractLocalsAt(text, caret)
for (name in locals) {
if (name.startsWith(prefix, true)) {
out.add(CompletionItem(name, Kind.Value, priority = 150.0))
}
} }
} }
@@ -238,7 +249,7 @@ object CompletionEngineLight {
} }
} }
private fun offerMembersAdd(out: MutableList<CompletionItem>, prefix: String, imported: List<String>, className: String, mini: MiniScript? = null) { private fun offerMembersAdd(out: MutableList<CompletionItem>, prefix: String, imported: List<String>, className: String, mini: MiniScript? = null, staticOnly: Boolean = false) {
val classes = DocLookupUtils.aggregateClasses(imported, mini) val classes = DocLookupUtils.aggregateClasses(imported, mini)
val visited = mutableSetOf<String>() val visited = mutableSetOf<String>()
val directMap = LinkedHashMap<String, MutableList<MiniMemberDecl>>() val directMap = LinkedHashMap<String, MutableList<MiniMemberDecl>>()
@@ -247,10 +258,15 @@ object CompletionEngineLight {
fun addMembersOf(name: String, direct: Boolean) { fun addMembersOf(name: String, direct: Boolean) {
val cls = classes[name] ?: return val cls = classes[name] ?: return
val target = if (direct) directMap else inheritedMap val target = if (direct) directMap else inheritedMap
for (cf in cls.ctorFields + cls.classFields) { if (!staticOnly) {
target.getOrPut(cf.name) { mutableListOf() }.add(DocLookupUtils.toMemberVal(cf)) for (cf in cls.ctorFields + cls.classFields) {
target.getOrPut(cf.name) { mutableListOf() }.add(DocLookupUtils.toMemberVal(cf))
}
}
for (m in cls.members) {
if (staticOnly && !m.isStatic) continue
target.getOrPut(m.name) { mutableListOf() }.add(m)
} }
for (m in cls.members) target.getOrPut(m.name) { mutableListOf() }.add(m)
for (b in cls.bases) if (visited.add(b)) addMembersOf(b, false) for (b in cls.bases) if (visited.add(b)) addMembersOf(b, false)
} }
@@ -310,7 +326,7 @@ object CompletionEngineLight {
emitGroup(inheritedMap, 0.0) emitGroup(inheritedMap, 0.0)
// Supplement with extension members (both stdlib and local) // Supplement with extension members (both stdlib and local)
run { if (!staticOnly) run {
val already = (directMap.keys + inheritedMap.keys).toMutableSet() val already = (directMap.keys + inheritedMap.keys).toMutableSet()
val extensions = DocLookupUtils.collectExtensionMemberNames(imported, className, mini) val extensions = DocLookupUtils.collectExtensionMemberNames(imported, className, mini)
for (name in extensions) { for (name in extensions) {
@@ -20,6 +20,7 @@
*/ */
package net.sergeych.lyng.miniast package net.sergeych.lyng.miniast
import net.sergeych.lyng.Pos
import net.sergeych.lyng.binding.BindingSnapshot import net.sergeych.lyng.binding.BindingSnapshot
import net.sergeych.lyng.highlight.offsetOf import net.sergeych.lyng.highlight.offsetOf
@@ -301,32 +302,42 @@ object DocLookupUtils {
isExtern = false isExtern = false
) )
fun resolveMemberWithInheritance(importedModules: List<String>, className: String, member: String, localMini: MiniScript? = null): Pair<String, MiniNamedDecl>? { fun resolveMemberWithInheritance(
importedModules: List<String>,
className: String,
member: String,
localMini: MiniScript? = null,
staticOnly: Boolean = false
): Pair<String, MiniNamedDecl>? {
val classes = aggregateClasses(importedModules, localMini) val classes = aggregateClasses(importedModules, localMini)
fun dfs(name: String, visited: MutableSet<String>): Pair<String, MiniNamedDecl>? { fun dfs(name: String, visited: MutableSet<String>): Pair<String, MiniNamedDecl>? {
if (!visited.add(name)) return null if (!visited.add(name)) return null
val cls = classes[name] val cls = classes[name]
if (cls != null) { if (cls != null) {
cls.members.firstOrNull { it.name == member }?.let { return name to it } cls.members.firstOrNull { it.name == member && (!staticOnly || it.isStatic) }?.let { return name to it }
cls.ctorFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) } if (!staticOnly) {
cls.classFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) } cls.ctorFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) }
cls.classFields.firstOrNull { it.name == member }?.let { return name to toMemberVal(it) }
}
for (baseName in cls.bases) { for (baseName in cls.bases) {
dfs(baseName, visited)?.let { return it } dfs(baseName, visited)?.let { return it }
} }
} }
// 1) local extensions in this class or bases if (!staticOnly) {
localMini?.declarations?.firstOrNull { d -> // 1) local extensions in this class or bases
(d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) || localMini?.declarations?.firstOrNull { d ->
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
}?.let { return name to it as MiniNamedDecl }
// 2) built-in extensions from BuiltinDocRegistry
for (mod in importedModules) {
val decls = BuiltinDocRegistry.docsForModule(mod)
decls.firstOrNull { d ->
(d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) || (d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) ||
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) (d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
}?.let { return name to it as MiniNamedDecl } }?.let { return name to it as MiniNamedDecl }
// 2) built-in extensions from BuiltinDocRegistry
for (mod in importedModules) {
val decls = BuiltinDocRegistry.docsForModule(mod)
decls.firstOrNull { d ->
(d is MiniFunDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member) ||
(d is MiniValDecl && d.receiver != null && simpleClassNameOf(d.receiver) == name && d.name == member)
}?.let { return name to it as MiniNamedDecl }
}
} }
return null return null
@@ -430,6 +441,7 @@ object DocLookupUtils {
if (ref != null) { if (ref != null) {
val sym = binding.symbols.firstOrNull { it.id == ref.symbolId } val sym = binding.symbols.firstOrNull { it.id == ref.symbolId }
if (sym != null) { if (sym != null) {
simpleClassNameOfType(sym.type)?.let { return it }
val type = findTypeByRange(mini, sym.name, sym.declStart, text, imported) val type = findTypeByRange(mini, sym.name, sym.declStart, text, imported)
simpleClassNameOf(type)?.let { return it } simpleClassNameOf(type)?.let { return it }
} }
@@ -437,6 +449,7 @@ object DocLookupUtils {
// Check if it's a declaration (e.g. static access to a class) // Check if it's a declaration (e.g. static access to a class)
val sym = binding.symbols.firstOrNull { it.declStart == wordRange.first && it.name == ident } val sym = binding.symbols.firstOrNull { it.declStart == wordRange.first && it.name == ident }
if (sym != null) { if (sym != null) {
simpleClassNameOfType(sym.type)?.let { return it }
val type = findTypeByRange(mini, sym.name, sym.declStart, text, imported) val type = findTypeByRange(mini, sym.name, sym.declStart, text, imported)
simpleClassNameOf(type)?.let { return it } simpleClassNameOf(type)?.let { return it }
// if it's a class/enum, return its name directly // if it's a class/enum, return its name directly
@@ -1042,6 +1055,16 @@ object DocLookupUtils {
is MiniTypeIntersection -> null is MiniTypeIntersection -> null
} }
fun simpleClassNameOfType(type: String?): String? {
if (type.isNullOrBlank()) return null
var t = type.trim()
if (t.endsWith("?")) t = t.dropLast(1)
val first = t.split('|', '&').firstOrNull()?.trim() ?: return null
val base = first.substringBefore('<').trim()
val short = base.substringAfterLast('.').trim()
return short.ifBlank { null }
}
fun typeOf(t: MiniTypeRef?): String = when (t) { fun typeOf(t: MiniTypeRef?): String = when (t) {
is MiniTypeName -> t.segments.joinToString(".") { it.name } + (if (t.nullable) "?" else "") is MiniTypeName -> t.segments.joinToString(".") { it.name } + (if (t.nullable) "?" else "")
is MiniGenericType -> typeOf(t.base) + "<" + t.args.joinToString(", ") { typeOf(it) } + ">" + (if (t.nullable) "?" else "") is MiniGenericType -> typeOf(t.base) + "<" + t.args.joinToString(", ") { typeOf(it) } + ">" + (if (t.nullable) "?" else "")
@@ -1055,6 +1078,90 @@ object DocLookupUtils {
null -> "" null -> ""
} }
fun collectLocalsFromBinding(mini: MiniScript?, binding: BindingSnapshot?, offset: Int): List<net.sergeych.lyng.binding.Symbol> {
if (mini == null || binding == null) return emptyList()
val src = mini.range.start.source
data class FnCtx(val nameStart: Pos, val body: MiniRange)
fun consider(nameStart: Pos, body: MiniRange?, best: FnCtx?): FnCtx? {
if (body == null) return best
val start = src.offsetOf(body.start)
val end = src.offsetOf(body.end)
if (offset < start || offset > end) return best
val len = end - start
val bestLen = best?.let { src.offsetOf(it.body.end) - src.offsetOf(it.body.start) } ?: Int.MAX_VALUE
return if (len < bestLen) FnCtx(nameStart, body) else best
}
var best: FnCtx? = null
for (d in mini.declarations) {
when (d) {
is MiniFunDecl -> best = consider(d.nameStart, d.body?.range, best)
is MiniClassDecl -> {
for (m in d.members) {
if (m is MiniMemberFunDecl) {
best = consider(m.nameStart, m.body?.range, best)
}
}
}
else -> {}
}
}
val fn = best ?: return emptyList()
val fnDeclStart = src.offsetOf(fn.nameStart)
val fnSym = binding.symbols.firstOrNull {
it.kind == net.sergeych.lyng.binding.SymbolKind.Function && it.declStart == fnDeclStart
} ?: return emptyList()
return binding.symbols.filter {
it.containerId == fnSym.id &&
(it.kind == net.sergeych.lyng.binding.SymbolKind.Parameter ||
it.kind == net.sergeych.lyng.binding.SymbolKind.Value ||
it.kind == net.sergeych.lyng.binding.SymbolKind.Variable) &&
it.declStart < offset
}
}
fun isStaticReceiver(
mini: MiniScript?,
text: String,
dotPos: Int,
importedModules: List<String>,
binding: BindingSnapshot? = null
): Boolean {
val i = prevNonWs(text, dotPos - 1)
if (i < 0 || !isIdentChar(text[i])) return false
val wordRange = wordRangeAt(text, i + 1) ?: return false
val ident = text.substring(wordRange.first, wordRange.second)
if (ident == "this") return false
if (binding != null) {
val ref = binding.references.firstOrNull { wordRange.first >= it.start && wordRange.first < it.end }
val sym = ref?.let { r -> binding.symbols.firstOrNull { it.id == r.symbolId } }
?: binding.symbols.firstOrNull { it.declStart == wordRange.first && it.name == ident }
if (sym != null) {
return sym.kind == net.sergeych.lyng.binding.SymbolKind.Class ||
sym.kind == net.sergeych.lyng.binding.SymbolKind.Enum ||
sym.kind == net.sergeych.lyng.binding.SymbolKind.TypeAlias
}
}
if (mini != null) {
val src = mini.range.start.source
val decl = mini.declarations
.filter { it.name == ident && src.offsetOf(it.nameStart) < dotPos }
.maxByOrNull { src.offsetOf(it.nameStart) }
if (decl is MiniClassDecl || decl is MiniEnumDecl || decl is MiniTypeAliasDecl) return true
if (decl is MiniFunDecl || decl is MiniValDecl) return false
}
val classes = aggregateClasses(importedModules, mini)
if (classes.containsKey(ident)) return true
for (mod in importedModules) {
val aliases = BuiltinDocRegistry.docsForModule(mod).filterIsInstance<MiniTypeAliasDecl>()
if (aliases.any { it.name == ident }) return true
}
return false
}
fun findDotLeft(text: String, offset: Int): Int? { fun findDotLeft(text: String, offset: Int): Int? {
var i = (offset - 1).coerceAtLeast(0) var i = (offset - 1).coerceAtLeast(0)
while (i >= 0 && text[i].isWhitespace()) i-- while (i >= 0 && text[i].isWhitespace()) i--
@@ -19,6 +19,7 @@ package net.sergeych.lyng.miniast
import net.sergeych.lyng.ModuleScope import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Visibility import net.sergeych.lyng.Visibility
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass import net.sergeych.lyng.obj.ObjClass
@@ -40,7 +41,7 @@ inline fun <reified T : Obj> Scope.addFnDoc(
tags: Map<String, List<String>> = emptyMap(), tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null, moduleName: String? = null,
callSignature: net.sergeych.lyng.CallSignature? = null, callSignature: net.sergeych.lyng.CallSignature? = null,
crossinline fn: suspend Scope.() -> T crossinline fn: suspend ScopeFacade.() -> T
) { ) {
// Register runtime function(s) // Register runtime function(s)
addFn(*names, callSignature = callSignature) { fn() } addFn(*names, callSignature = callSignature) { fn() }
@@ -57,7 +58,7 @@ inline fun Scope.addVoidFnDoc(
doc: String, doc: String,
tags: Map<String, List<String>> = emptyMap(), tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null, moduleName: String? = null,
crossinline fn: suspend Scope.() -> Unit crossinline fn: suspend ScopeFacade.() -> Unit
) { ) {
addFnDoc<ObjVoid>( addFnDoc<ObjVoid>(
*names, *names,
@@ -98,7 +99,7 @@ fun ObjClass.addFnDoc(
visibility: Visibility = Visibility.Public, visibility: Visibility = Visibility.Public,
tags: Map<String, List<String>> = emptyMap(), tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null, moduleName: String? = null,
code: suspend Scope.() -> Obj code: suspend ScopeFacade.() -> Obj
) { ) {
// Register runtime method // Register runtime method
addFn(name, isOpen, visibility, code = code) addFn(name, isOpen, visibility, code = code)
@@ -136,7 +137,7 @@ fun ObjClass.addClassFnDoc(
isOpen: Boolean = false, isOpen: Boolean = false,
tags: Map<String, List<String>> = emptyMap(), tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null, moduleName: String? = null,
code: suspend Scope.() -> Obj code: suspend ScopeFacade.() -> Obj
) { ) {
addClassFn(name, isOpen, code) addClassFn(name, isOpen, code)
BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) { BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) {
@@ -152,8 +153,8 @@ fun ObjClass.addPropertyDoc(
type: TypeDoc? = null, type: TypeDoc? = null,
visibility: Visibility = Visibility.Public, visibility: Visibility = Visibility.Public,
moduleName: String? = null, moduleName: String? = null,
getter: (suspend Scope.() -> Obj)? = null, getter: (suspend ScopeFacade.() -> Obj)? = null,
setter: (suspend Scope.(Obj) -> Unit)? = null setter: (suspend ScopeFacade.(Obj) -> Unit)? = null
) { ) {
addProperty(name, getter, setter, visibility) addProperty(name, getter, setter, visibility)
BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) { BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) {
@@ -1,3 +1,20 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
/* /*
* Ensure stdlib Obj*-defined docs (like String methods added via ObjString.addFnDoc) * Ensure stdlib Obj*-defined docs (like String methods added via ObjString.addFnDoc)
* are initialized before registry lookups for completion/quick docs. * are initialized before registry lookups for completion/quick docs.
@@ -33,6 +50,19 @@ object StdlibDocsBootstrap {
val _range = net.sergeych.lyng.obj.ObjRange.type val _range = net.sergeych.lyng.obj.ObjRange.type
@Suppress("UNUSED_VARIABLE") @Suppress("UNUSED_VARIABLE")
val _buffer = net.sergeych.lyng.obj.ObjBuffer.type val _buffer = net.sergeych.lyng.obj.ObjBuffer.type
// Also touch time module types so their docs (moduleName = "lyng.time") are registered
// This enables completion/quick docs for symbols imported via `import lyng.time` (e.g., Instant, DateTime, Duration)
try {
@Suppress("UNUSED_VARIABLE")
val _instant = net.sergeych.lyng.obj.ObjInstant.type
@Suppress("UNUSED_VARIABLE")
val _datetime = net.sergeych.lyng.obj.ObjDateTime.type
@Suppress("UNUSED_VARIABLE")
val _duration = net.sergeych.lyng.obj.ObjDuration.type
} catch (_: Throwable) {
// Optional; absence should not affect stdlib core
}
} catch (_: Throwable) { } catch (_: Throwable) {
// Best-effort; absence should not break consumers // Best-effort; absence should not break consumers
} finally { } finally {
@@ -20,7 +20,6 @@ package net.sergeych.lyng.obj
import net.sergeych.lyng.Compiler import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Pos import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScriptError
// avoid KDOC bug: keep it // avoid KDOC bug: keep it
@Suppress("unused") @Suppress("unused")
@@ -37,10 +36,11 @@ private class LambdaRef(
private val getterFn: suspend (Scope) -> ObjRecord, private val getterFn: suspend (Scope) -> ObjRecord,
private val setterFn: (suspend (Pos, Scope, Obj) -> Unit)? = null private val setterFn: (suspend (Pos, Scope, Obj) -> Unit)? = null
) : ObjRef { ) : ObjRef {
override suspend fun get(scope: Scope): ObjRecord = getterFn(scope) override suspend fun get(scope: Scope): ObjRecord {
return scope.raiseIllegalState("bytecode-only execution is required; Accessor evaluation is disabled")
}
override suspend fun setAt(pos: Pos, scope: Scope, newValue: Obj) { override suspend fun setAt(pos: Pos, scope: Scope, newValue: Obj) {
val s = setterFn ?: throw ScriptError(pos, "can't assign value") scope.raiseIllegalState("bytecode-only execution is required; Accessor assignment is disabled")
s(pos, scope, newValue)
} }
} }
@@ -0,0 +1,35 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.ArgsDeclaration
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.LambdaCaptureEntry
class LambdaFnRef(
valueFn: suspend (Scope) -> ObjRecord,
val bytecodeFn: CmdFunction?,
val paramSlotPlan: Map<String, Int>,
val argsDeclaration: ArgsDeclaration?,
val captureEntries: List<LambdaCaptureEntry>,
val preferredThisType: String?,
val wrapAsExtensionCallable: Boolean,
val returnLabels: Set<String>,
val pos: Pos,
) : ValueFnRef(valueFn)
@@ -65,7 +65,8 @@ open class Obj {
fun isInstanceOf(someClass: Obj) = someClass === objClass || fun isInstanceOf(someClass: Obj) = someClass === objClass ||
objClass.allParentsSet.contains(someClass) || objClass.allParentsSet.contains(someClass) ||
someClass == rootObjectType || someClass == rootObjectType ||
(someClass is ObjClass && objClass.allImplementingNames.contains(someClass.className)) (someClass is ObjClass && (objClass.allImplementingNames.contains(someClass.className) ||
objClass.className == someClass.className))
fun isInstanceOf(className: String) = fun isInstanceOf(className: String) =
objClass.mro.any { it.className == className } || objClass.mro.any { it.className == className } ||
@@ -141,6 +142,15 @@ open class Obj {
} }
} }
} }
scope.findExtension(objClass, name)?.let { ext ->
if (ext.type == ObjRecord.Type.Property) {
if (args.isEmpty()) {
return (ext.value as ObjProperty).callGetter(scope, this, ext.declaringClass)
}
} else if (ext.type != ObjRecord.Type.Delegated) {
return ext.value.invoke(scope, this, args, ext.declaringClass)
}
}
return onNotFoundResult?.invoke() return onNotFoundResult?.invoke()
?: scope.raiseError( ?: scope.raiseError(
@@ -255,13 +265,35 @@ open class Obj {
open val objClass: ObjClass get() = rootObjectType open val objClass: ObjClass get() = rootObjectType
open suspend fun plus(scope: Scope, other: Obj): Obj { open suspend fun plus(scope: Scope, other: Obj): Obj {
return invokeInstanceMethod(scope, "plus", Arguments(other)) { val otherValue = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
val self = when (this) {
is FrameSlotRef -> this.read()
is RecordSlotRef -> this.read()
else -> this
}
if (self !== this) return self.plus(scope, otherValue)
return invokeInstanceMethod(scope, "plus", Arguments(otherValue)) {
scope.raiseNotImplemented("plus for ${objClass.className}") scope.raiseNotImplemented("plus for ${objClass.className}")
} }
} }
open suspend fun minus(scope: Scope, other: Obj): Obj { open suspend fun minus(scope: Scope, other: Obj): Obj {
return invokeInstanceMethod(scope, "minus", Arguments(other)) { val otherValue = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
val self = when (this) {
is FrameSlotRef -> this.read()
is RecordSlotRef -> this.read()
else -> this
}
if (self !== this) return self.minus(scope, otherValue)
return invokeInstanceMethod(scope, "minus", Arguments(otherValue)) {
scope.raiseNotImplemented("minus for ${objClass.className}") scope.raiseNotImplemented("minus for ${objClass.className}")
} }
} }
@@ -273,19 +305,52 @@ open class Obj {
} }
open suspend fun mul(scope: Scope, other: Obj): Obj { open suspend fun mul(scope: Scope, other: Obj): Obj {
return invokeInstanceMethod(scope, "mul", Arguments(other)) { val otherValue = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
val self = when (this) {
is FrameSlotRef -> this.read()
is RecordSlotRef -> this.read()
else -> this
}
if (self !== this) return self.mul(scope, otherValue)
return invokeInstanceMethod(scope, "mul", Arguments(otherValue)) {
scope.raiseNotImplemented("mul for ${objClass.className}") scope.raiseNotImplemented("mul for ${objClass.className}")
} }
} }
open suspend fun div(scope: Scope, other: Obj): Obj { open suspend fun div(scope: Scope, other: Obj): Obj {
return invokeInstanceMethod(scope, "div", Arguments(other)) { val otherValue = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
val self = when (this) {
is FrameSlotRef -> this.read()
is RecordSlotRef -> this.read()
else -> this
}
if (self !== this) return self.div(scope, otherValue)
return invokeInstanceMethod(scope, "div", Arguments(otherValue)) {
scope.raiseNotImplemented("div for ${objClass.className}") scope.raiseNotImplemented("div for ${objClass.className}")
} }
} }
open suspend fun mod(scope: Scope, other: Obj): Obj { open suspend fun mod(scope: Scope, other: Obj): Obj {
return invokeInstanceMethod(scope, "mod", Arguments(other)) { val otherValue = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
val self = when (this) {
is FrameSlotRef -> this.read()
is RecordSlotRef -> this.read()
else -> this
}
if (self !== this) return self.mod(scope, otherValue)
return invokeInstanceMethod(scope, "mod", Arguments(otherValue)) {
scope.raiseNotImplemented("mod for ${objClass.className}") scope.raiseNotImplemented("mod for ${objClass.className}")
} }
} }
@@ -437,7 +502,7 @@ open class Obj {
caller.members[name]?.let { rec -> caller.members[name]?.let { rec ->
if (rec.visibility == Visibility.Private && !rec.isAbstract) { if (rec.visibility == Visibility.Private && !rec.isAbstract) {
val resolved = resolveRecord(scope, rec, name, caller) val resolved = resolveRecord(scope, rec, name, caller)
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement) if (resolved.type == ObjRecord.Type.Fun)
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, caller)) return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, caller))
return resolved return resolved
} }
@@ -451,7 +516,7 @@ open class Obj {
if (rec != null && !rec.isAbstract) { if (rec != null && !rec.isAbstract) {
val decl = rec.declaringClass ?: cls val decl = rec.declaringClass ?: cls
val resolved = resolveRecord(scope, rec, name, decl) val resolved = resolveRecord(scope, rec, name, decl)
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement) if (resolved.type == ObjRecord.Type.Fun)
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl)) return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl))
return resolved return resolved
} }
@@ -466,12 +531,20 @@ open class Obj {
if (!canAccessMember(rec.visibility, decl, caller, name)) if (!canAccessMember(rec.visibility, decl, caller, name))
scope.raiseError(ObjIllegalAccessException(scope, "can't access field ${name}: not visible (declared in ${decl.className}, caller ${caller?.className ?: "?"})")) scope.raiseError(ObjIllegalAccessException(scope, "can't access field ${name}: not visible (declared in ${decl.className}, caller ${caller?.className ?: "?"})"))
val resolved = resolveRecord(scope, rec, name, decl) val resolved = resolveRecord(scope, rec, name, decl)
if (resolved.type == ObjRecord.Type.Fun && resolved.value is Statement) if (resolved.type == ObjRecord.Type.Fun)
return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl)) return resolved.copy(value = resolved.value.invoke(scope, this, Arguments.EMPTY, decl))
return resolved return resolved
} }
} }
} }
scope.findExtension(objClass, name)?.let { ext ->
return if (ext.type == ObjRecord.Type.Property) {
val prop = ext.value as ObjProperty
ObjRecord(prop.callGetter(scope, this, ext.declaringClass), isMutable = false)
} else {
ext.copy(value = ext.value.invoke(scope, this, Arguments.EMPTY, ext.declaringClass))
}
}
scope.raiseError( scope.raiseError(
"no such field: $name on ${objClass.className}. Considered order: ${objClass.renderLinearization(true)}" "no such field: $name on ${objClass.className}. Considered order: ${objClass.renderLinearization(true)}"
@@ -482,15 +555,17 @@ open class Obj {
if (obj.type == ObjRecord.Type.Delegated) { if (obj.type == ObjRecord.Type.Delegated) {
val del = obj.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate") val del = obj.delegate ?: scope.raiseError("Internal error: delegated property $name has no delegate")
val th = if (this === ObjVoid) ObjNull else this val th = if (this === ObjVoid) ObjNull else this
val getValueRec = del.objClass.getInstanceMemberOrNull("getValue") val getValueRec = when (del) {
is ObjInstance -> del.methodRecordForKey("getValue")
?: del.instanceScope.objects["getValue"]
?: del.objClass.getInstanceMemberOrNull("getValue")
else -> del.objClass.getInstanceMemberOrNull("getValue")
}
if (getValueRec == null || getValueRec.declaringClass?.className == "Delegate") { if (getValueRec == null || getValueRec.declaringClass?.className == "Delegate") {
val wrapper = object : Statement() { val wrapper = ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn val th2 = if (thisObj === ObjVoid) ObjNull else thisObj
override suspend fun execute(s: Scope): Obj { val allArgs = (listOf(th2, ObjString(name)) + args.list).toTypedArray()
val th2 = if (s.thisObj === ObjVoid) ObjNull else s.thisObj del.invokeInstanceMethod(requireScope(), "invoke", Arguments(*allArgs))
val allArgs = (listOf(th2, ObjString(name)) + s.args.list).toTypedArray()
return del.invokeInstanceMethod(s, "invoke", Arguments(*allArgs))
}
} }
return obj.copy( return obj.copy(
value = wrapper, value = wrapper,
@@ -498,14 +573,11 @@ open class Obj {
) )
} }
val res = del.invokeInstanceMethod(scope, "getValue", Arguments(th, ObjString(name))) val res = del.invokeInstanceMethod(scope, "getValue", Arguments(th, ObjString(name)))
return obj.copy( return obj.copy(value = res, type = ObjRecord.Type.Other)
value = res,
type = ObjRecord.Type.Other
)
} }
val value = obj.value val value = obj.value
if (value is ObjProperty || obj.type == ObjRecord.Type.Property) { if (value is ObjProperty || obj.type == ObjRecord.Type.Property) {
val prop = if (value is ObjProperty) value else (value as? Statement)?.execute(scope.createChildScope(scope.pos, newThisObj = this)) as? ObjProperty val prop = (value as? ObjProperty)
?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}") ?: scope.raiseError("Expected ObjProperty for property member $name, got ${value::class}")
val res = prop.callGetter(scope, this, decl) val res = prop.callGetter(scope, this, decl)
return ObjRecord(res, obj.isMutable) return ObjRecord(res, obj.isMutable)
@@ -587,16 +659,19 @@ open class Obj {
scope.raiseNotImplemented() scope.raiseNotImplemented()
} }
suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments, declaringClass: ObjClass? = null): Obj = suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments, declaringClass: ObjClass? = null): Obj {
if (PerfFlags.SCOPE_POOL) val usePool = PerfFlags.SCOPE_POOL && this !is Statement
return if (usePool) {
scope.withChildFrame(args, newThisObj = thisObj) { child -> scope.withChildFrame(args, newThisObj = thisObj) { child ->
if (declaringClass != null) child.currentClassCtx = declaringClass if (declaringClass != null) child.currentClassCtx = declaringClass
callOn(child) callOn(child)
} }
else } else {
callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj).also { callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj).also {
if (declaringClass != null) it.currentClassCtx = declaringClass if (declaringClass != null) it.currentClassCtx = declaringClass
}) })
}
}
suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj = suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
callOn( callOn(
@@ -665,7 +740,7 @@ open class Obj {
returns = type("lyng.String"), returns = type("lyng.String"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisObj.toString(this, true) toStringOf(thisObj, true)
} }
addFnDoc( addFnDoc(
name = "inspect", name = "inspect",
@@ -673,7 +748,7 @@ open class Obj {
returns = type("lyng.String"), returns = type("lyng.String"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisObj.inspect(this).toObj() inspect(thisObj).toObj()
} }
addFnDoc( addFnDoc(
name = "contains", name = "contains",
@@ -682,7 +757,7 @@ open class Obj {
returns = type("lyng.Bool"), returns = type("lyng.Bool"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
ObjBool(thisObj.contains(this, args.firstAndOnly())) ObjBool(thisObj.contains(requireScope(), args.firstAndOnly()))
} }
// utilities // utilities
addFnDoc( addFnDoc(
@@ -691,7 +766,7 @@ open class Obj {
params = listOf(ParamDoc("block")), params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
args.firstAndOnly().callOn(createChildScope(Arguments(thisObj))) call(args.firstAndOnly(), Arguments(thisObj))
} }
addFnDoc( addFnDoc(
name = "apply", name = "apply",
@@ -700,11 +775,12 @@ open class Obj {
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val body = args.firstAndOnly() val body = args.firstAndOnly()
val scope = requireScope()
(thisObj as? ObjInstance)?.let { (thisObj as? ObjInstance)?.let {
body.callOn(ApplyScope(this, it.instanceScope)) body.callOn(ApplyScope(scope, it.instanceScope))
} ?: run { } ?: run {
val appliedScope = createChildScope(newThisObj = thisObj) val appliedScope = scope.createChildScope(newThisObj = thisObj)
body.callOn(ApplyScope(this, appliedScope)) body.callOn(ApplyScope(scope, appliedScope))
} }
thisObj thisObj
} }
@@ -714,7 +790,7 @@ open class Obj {
params = listOf(ParamDoc("block")), params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
args.firstAndOnly().callOn(createChildScope(Arguments(thisObj))) call(args.firstAndOnly(), Arguments(thisObj))
thisObj thisObj
} }
addFnDoc( addFnDoc(
@@ -723,25 +799,33 @@ open class Obj {
params = listOf(ParamDoc("block")), params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
args.firstAndOnly().callOn(this) call(args.firstAndOnly())
} }
addFn("getAt") { addFn("getAt") {
requireExactCount(1) requireExactCount(1)
thisObj.getAt(this, requiredArg<Obj>(0)) thisObj.getAt(requireScope(), requiredArg<Obj>(0))
} }
addFn("putAt") { addFn("putAt") {
requireExactCount(2) requireExactCount(2)
val newValue = args[1] val newValue = args[1]
thisObj.putAt(this, requiredArg<Obj>(0), newValue) thisObj.putAt(requireScope(), requiredArg<Obj>(0), newValue)
newValue newValue
} }
addFnDoc(
name = "toJson",
doc = "Encodes this object to JSON.",
returns = type("lyng.String"),
moduleName = "lyng.stdlib"
) {
thisObj.toJson(requireScope()).toString().toObj()
}
addFnDoc( addFnDoc(
name = "toJsonString", name = "toJsonString",
doc = "Encodes this object to a JSON string.", doc = "Encodes this object to a JSON string.",
returns = type("lyng.String"), returns = type("lyng.String"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisObj.toJson(this).toString().toObj() thisObj.toJson(requireScope()).toString().toObj()
} }
addFnDoc( addFnDoc(
name = "clamp", name = "clamp",
@@ -753,12 +837,12 @@ open class Obj {
var result = thisObj var result = thisObj
if (range.start != null && !range.start.isNull) { if (range.start != null && !range.start.isNull) {
if (result.compareTo(this, range.start) < 0) { if (result.compareTo(requireScope(), range.start) < 0) {
result = range.start result = range.start
} }
} }
if (range.end != null && !range.end.isNull) { if (range.end != null && !range.end.isNull) {
val cmp = range.end.compareTo(this, result) val cmp = range.end.compareTo(requireScope(), result)
if (range.isEndInclusive) { if (range.isEndInclusive) {
if (cmp < 0) result = range.end if (cmp < 0) result = range.end
} else { } else {
@@ -893,7 +977,14 @@ object ObjNull : Obj() {
@Serializable @Serializable
@SerialName("unset") @SerialName("unset")
object ObjUnset : Obj() { object ObjUnset : Obj() {
override suspend fun compareTo(scope: Scope, other: Obj): Int = if (other === this) 0 else -1 override suspend fun compareTo(scope: Scope, other: Obj): Int {
val resolved = when (other) {
is FrameSlotRef -> other.read()
is RecordSlotRef -> other.read()
else -> other
}
return if (resolved === this) 0 else -1
}
override fun equals(other: Any?): Boolean = other === this override fun equals(other: Any?): Boolean = other === this
override fun toString(): String = "Unset" override fun toString(): String = "Unset"
@@ -32,7 +32,7 @@ val ObjArray by lazy {
doc = "Iterator over elements of this array using its indexer.", doc = "Iterator over elements of this array using its indexer.",
returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.Any"))), returns = TypeGenericDoc(type("lyng.Iterator"), listOf(type("lyng.Any"))),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ObjArrayIterator(thisObj).also { it.init(this) } } ) { ObjArrayIterator(thisObj).also { it.init(requireScope()) } }
addFnDoc( addFnDoc(
name = "contains", name = "contains",
@@ -42,9 +42,10 @@ val ObjArray by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val scope = requireScope()
val obj = args.firstAndOnly() val obj = args.firstAndOnly()
for (i in 0..<thisObj.invokeInstanceMethod(this, "size").toInt()) { for (i in 0..<thisObj.invokeInstanceMethod(scope, "size").toInt()) {
if (thisObj.getAt(this, ObjInt(i.toLong())).compareTo(this, obj) == 0) return@addFnDoc ObjTrue if (thisObj.getAt(scope, ObjInt(i.toLong())).compareTo(scope, obj) == 0) return@addFnDoc ObjTrue
} }
ObjFalse ObjFalse
} }
@@ -55,10 +56,11 @@ val ObjArray by lazy {
type = type("lyng.Any"), type = type("lyng.Any"),
moduleName = "lyng.stdlib", moduleName = "lyng.stdlib",
getter = { getter = {
val scope = requireScope()
this.thisObj.invokeInstanceMethod( this.thisObj.invokeInstanceMethod(
this, scope,
"getAt", "getAt",
(this.thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() (this.thisObj.invokeInstanceMethod(scope, "size").toInt() - 1).toObj()
) )
} }
) )
@@ -68,7 +70,10 @@ val ObjArray by lazy {
doc = "Index of the last element (size - 1).", doc = "Index of the last element (size - 1).",
type = type("lyng.Int"), type = type("lyng.Int"),
moduleName = "lyng.stdlib", moduleName = "lyng.stdlib",
getter = { (this.thisObj.invokeInstanceMethod(this, "size").toInt() - 1).toObj() } getter = {
val scope = requireScope()
(this.thisObj.invokeInstanceMethod(scope, "size").toInt() - 1).toObj()
}
) )
addPropertyDoc( addPropertyDoc(
@@ -76,7 +81,10 @@ val ObjArray by lazy {
doc = "Range of valid indices for this array.", doc = "Range of valid indices for this array.",
type = type("lyng.Range"), type = type("lyng.Range"),
moduleName = "lyng.stdlib", moduleName = "lyng.stdlib",
getter = { ObjRange(0.toObj(), this.thisObj.invokeInstanceMethod(this, "size"), false) } getter = {
val scope = requireScope()
ObjRange(0.toObj(), this.thisObj.invokeInstanceMethod(scope, "size"), false)
}
) )
addFnDoc( addFnDoc(
@@ -86,15 +94,16 @@ val ObjArray by lazy {
returns = type("lyng.Int"), returns = type("lyng.Int"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val scope = requireScope()
val target = args.firstAndOnly() val target = args.firstAndOnly()
var low = 0 var low = 0
var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1 var high = thisObj.invokeInstanceMethod(scope, "size").toInt() - 1
while (low <= high) { while (low <= high) {
val mid = (low + high) / 2 val mid = (low + high) / 2
val midVal = thisObj.getAt(this, ObjInt(mid.toLong())) val midVal = thisObj.getAt(scope, ObjInt(mid.toLong()))
val cmp = midVal.compareTo(this, target) val cmp = midVal.compareTo(scope, target)
when { when {
cmp == 0 -> return@addFnDoc (mid).toObj() cmp == 0 -> return@addFnDoc (mid).toObj()
cmp > 0 -> high = mid - 1 cmp > 0 -> high = mid - 1
@@ -38,8 +38,8 @@ class ObjArrayIterator(val array: Obj) : Obj() {
addFn("next") { addFn("next") {
val self = thisAs<ObjArrayIterator>() val self = thisAs<ObjArrayIterator>()
if (self.nextIndex < self.lastIndex) { if (self.nextIndex < self.lastIndex) {
self.array.invokeInstanceMethod(this, "getAt", (self.nextIndex++).toObj()) self.array.invokeInstanceMethod(requireScope(), "getAt", (self.nextIndex++).toObj())
} else raiseError(ObjIterationFinishedException(this)) } else raiseError(ObjIterationFinishedException(requireScope()))
} }
addFn("hasNext") { addFn("hasNext") {
val self = thisAs<ObjArrayIterator>() val self = thisAs<ObjArrayIterator>()
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -73,6 +73,8 @@ data class ObjBool(val value: Boolean) : Obj() {
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder,lynonType: LynonType?): Obj { override suspend fun deserialize(scope: Scope, decoder: LynonDecoder,lynonType: LynonType?): Obj {
return ObjBool(decoder.unpackBoolean()) return ObjBool(decoder.unpackBoolean())
} }
}.apply {
isClosed = true
} }
} }
} }
@@ -61,7 +61,7 @@ val ObjClassType by lazy {
val names = mutableListOf<Obj>() val names = mutableListOf<Obj>()
for (c in cls.mro) { for (c in cls.mro) {
for ((n, rec) in c.members) { for ((n, rec) in c.members) {
if (rec.value !is Statement && seen.add(n)) names += ObjString(n) if (rec.type != ObjRecord.Type.Fun && seen.add(n)) names += ObjString(n)
} }
} }
ObjList(names.toMutableList()) ObjList(names.toMutableList())
@@ -79,7 +79,7 @@ val ObjClassType by lazy {
val names = mutableListOf<Obj>() val names = mutableListOf<Obj>()
for (c in cls.mro) { for (c in cls.mro) {
for ((n, rec) in c.members) { for ((n, rec) in c.members) {
if (rec.value is Statement && seen.add(n)) names += ObjString(n) if (rec.type == ObjRecord.Type.Fun && seen.add(n)) names += ObjString(n)
} }
} }
ObjList(names.toMutableList()) ObjList(names.toMutableList())
@@ -109,6 +109,7 @@ open class ObjClass(
var isAnonymous: Boolean = false var isAnonymous: Boolean = false
var isAbstract: Boolean = false var isAbstract: Boolean = false
var isClosed: Boolean = false
// Stable identity and simple structural version for PICs // Stable identity and simple structural version for PICs
val classId: Long = ClassIdGen.nextId() val classId: Long = ClassIdGen.nextId()
@@ -136,7 +137,7 @@ open class ObjClass(
} }
} }
cls.classScope?.objects?.forEach { (name, rec) -> cls.classScope?.objects?.forEach { (name, rec) ->
if (rec.visibility == Visibility.Public && (rec.value is Statement || rec.type == ObjRecord.Type.Delegated)) { if (rec.visibility == Visibility.Public && (rec.type == ObjRecord.Type.Fun || rec.type == ObjRecord.Type.Delegated)) {
val key = if (rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name val key = if (rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
res[name] = key res[name] = key
} }
@@ -150,13 +151,13 @@ open class ObjClass(
val classNameObj by lazy { ObjString(className) } val classNameObj by lazy { ObjString(className) }
var constructorMeta: ArgsDeclaration? = null var constructorMeta: ArgsDeclaration? = null
var instanceConstructor: Statement? = null var instanceConstructor: Obj? = null
/** /**
* Per-instance initializers collected from class body (for instance fields). These are executed * Per-instance initializers collected from class body (for instance fields). These are executed
* during construction in the instance scope of the object, once per class in the hierarchy. * during construction in the instance scope of the object, once per class in the hierarchy.
*/ */
val instanceInitializers: MutableList<Statement> = mutableListOf() val instanceInitializers: MutableList<Obj> = mutableListOf()
/** /**
* the scope for class methods, initialize class vars, etc. * the scope for class methods, initialize class vars, etc.
@@ -289,6 +290,14 @@ open class ObjClass(
private var methodSlotMap: Map<String, MethodSlot> = emptyMap() private var methodSlotMap: Map<String, MethodSlot> = emptyMap()
private var methodSlotCount: Int = 0 private var methodSlotCount: Int = 0
/** Kotlin bridge class-level storage (no name lookup). */
internal var kotlinClassData: Any? = null
/** Kotlin bridge instance init hooks. */
internal var bridgeInitHooks: MutableList<suspend (net.sergeych.lyng.ScopeFacade, ObjInstance) -> Unit>? = null
internal var instanceTemplateBuilt: Boolean = false
private fun ensureFieldSlots(): Map<String, FieldSlot> { private fun ensureFieldSlots(): Map<String, FieldSlot> {
if (fieldSlotLayoutVersion == layoutVersion) return fieldSlotMap if (fieldSlotLayoutVersion == layoutVersion) return fieldSlotMap
val res = mutableMapOf<String, FieldSlot>() val res = mutableMapOf<String, FieldSlot>()
@@ -349,8 +358,7 @@ open class ObjClass(
if (cls.className == "Obj") break if (cls.className == "Obj") break
for ((name, rec) in cls.members) { for ((name, rec) in cls.members) {
if (rec.isAbstract) continue if (rec.isAbstract) continue
if (rec.value !is Statement && if (rec.type != ObjRecord.Type.Delegated &&
rec.type != ObjRecord.Type.Delegated &&
rec.type != ObjRecord.Type.Fun && rec.type != ObjRecord.Type.Fun &&
rec.type != ObjRecord.Type.Property) { rec.type != ObjRecord.Type.Property) {
continue continue
@@ -363,9 +371,9 @@ open class ObjClass(
} }
cls.classScope?.objects?.forEach { (name, rec) -> cls.classScope?.objects?.forEach { (name, rec) ->
if (rec.isAbstract) return@forEach if (rec.isAbstract) return@forEach
if (rec.value !is Statement && if (rec.type != ObjRecord.Type.Delegated &&
rec.type != ObjRecord.Type.Delegated && rec.type != ObjRecord.Type.Property &&
rec.type != ObjRecord.Type.Property) return@forEach rec.type != ObjRecord.Type.Fun) return@forEach
val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(name) else name
if (res.containsKey(key)) return@forEach if (res.containsKey(key)) return@forEach
val methodId = rec.methodId ?: cls.assignMethodId(name, rec) val methodId = rec.methodId ?: cls.assignMethodId(name, rec)
@@ -392,7 +400,16 @@ open class ObjClass(
internal fun fieldSlotMap(): Map<String, FieldSlot> = ensureFieldSlots() internal fun fieldSlotMap(): Map<String, FieldSlot> = ensureFieldSlots()
internal fun fieldRecordForId(fieldId: Int): ObjRecord? { internal fun fieldRecordForId(fieldId: Int): ObjRecord? {
ensureFieldSlots() ensureFieldSlots()
return fieldSlotMap.values.firstOrNull { it.slot == fieldId }?.record fieldSlotMap.values.firstOrNull { it.slot == fieldId }?.record?.let { return it }
// Fallback: resolve by id through name mapping if slot map is stale.
val name = fieldIdMap.entries.firstOrNull { it.value == fieldId }?.key
if (name != null) {
for (cls in mro) {
cls.members[name]?.let { return it }
cls.classScope?.objects?.get(name)?.let { return it }
}
}
return null
} }
internal fun resolveInstanceMember(name: String): ResolvedMember? = ensureInstanceMemberCache()[name] internal fun resolveInstanceMember(name: String): ResolvedMember? = ensureInstanceMemberCache()[name]
internal fun methodSlotCount(): Int { internal fun methodSlotCount(): Int {
@@ -416,9 +433,18 @@ open class ObjClass(
if (rec.methodId == methodId) return rec if (rec.methodId == methodId) return rec
} }
} }
// Final fallback: resolve by id through name mapping if slot map is stale.
val name = methodIdMap.entries.firstOrNull { it.value == methodId }?.key
if (name != null) {
for (cls in mro) {
cls.members[name]?.let { return it }
cls.classScope?.objects?.get(name)?.let { return it }
}
}
return null return null
} }
internal fun instanceFieldIdMap(): Map<String, Int> { internal fun instanceFieldIdMap(): Map<String, Int> {
val result = mutableMapOf<String, Int>() val result = mutableMapOf<String, Int>()
for (cls in mro) { for (cls in mro) {
@@ -472,7 +498,13 @@ open class ObjClass(
fieldIdMap[name] = existingId fieldIdMap[name] = existingId
return existingId return existingId
} }
val id = fieldIdMap.getOrPut(name) { nextFieldId++ } val id = fieldIdMap[name] ?: run {
val next = nextFieldId++
fieldIdMap[name] = next
// Field id map affects slot layout; invalidate caches when a new id is assigned.
layoutVersion += 1
next
}
return id return id
} }
@@ -481,12 +513,26 @@ open class ObjClass(
val existingId = rec.methodId val existingId = rec.methodId
if (existingId != null) { if (existingId != null) {
methodIdMap[name] = existingId methodIdMap[name] = existingId
if (existingId >= nextMethodId) {
nextMethodId = existingId + 1
}
return existingId return existingId
} }
val id = methodIdMap.getOrPut(name) { nextMethodId++ } val id = methodIdMap[name] ?: run {
val next = nextMethodId++
methodIdMap[name] = next
// Method id map affects slot layout; invalidate caches when a new id is assigned.
layoutVersion += 1
next
}
if (id >= nextMethodId) {
nextMethodId = id + 1
}
return id return id
} }
internal fun ensureMethodIdForBridge(name: String, rec: ObjRecord): Int = assignMethodId(name, rec)
private fun ensureMethodIdSeeded() { private fun ensureMethodIdSeeded() {
if (methodIdSeeded) return if (methodIdSeeded) return
var maxId = -1 var maxId = -1
@@ -516,6 +562,17 @@ open class ObjClass(
methodIdSeeded = true methodIdSeeded = true
} }
internal fun replaceMemberForBridge(name: String, newRecord: ObjRecord) {
members[name] = newRecord
layoutVersion += 1
}
internal fun replaceClassScopeMemberForBridge(name: String, newRecord: ObjRecord) {
initClassScope()
classScope!!.objects[name] = newRecord
layoutVersion += 1
}
override fun toString(): String = className override fun toString(): String = className
override suspend fun compareTo(scope: Scope, other: Obj): Int = if (other === this) 0 else -1 override suspend fun compareTo(scope: Scope, other: Obj): Int = if (other === this) 0 else -1
@@ -533,7 +590,7 @@ open class ObjClass(
for (cls in mro) { for (cls in mro) {
// 1) members-defined methods and fields // 1) members-defined methods and fields
for ((k, v) in cls.members) { for ((k, v) in cls.members) {
if (!v.isAbstract && (v.value is Statement || v.type == ObjRecord.Type.Delegated || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.ConstructorField)) { if (!v.isAbstract && (v.type == ObjRecord.Type.Fun || v.type == ObjRecord.Type.Property || v.type == ObjRecord.Type.Delegated || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.ConstructorField)) {
val key = if (v.visibility == Visibility.Private || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.ConstructorField || v.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k val key = if (v.visibility == Visibility.Private || v.type == ObjRecord.Type.Field || v.type == ObjRecord.Type.ConstructorField || v.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k
if (!res.containsKey(key)) { if (!res.containsKey(key)) {
res[key] = v res[key] = v
@@ -544,7 +601,7 @@ open class ObjClass(
cls.classScope?.objects?.forEach { (k, rec) -> cls.classScope?.objects?.forEach { (k, rec) ->
// ONLY copy methods and delegated members from class scope to instance scope. // ONLY copy methods and delegated members from class scope to instance scope.
// Fields in class scope are static fields and must NOT be per-instance. // Fields in class scope are static fields and must NOT be per-instance.
if (!rec.isAbstract && (rec.value is Statement || rec.type == ObjRecord.Type.Delegated)) { if (!rec.isAbstract && (rec.type == ObjRecord.Type.Fun || rec.type == ObjRecord.Type.Property || rec.type == ObjRecord.Type.Delegated)) {
val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k val key = if (rec.visibility == Visibility.Private || rec.type == ObjRecord.Type.Delegated) cls.mangledName(k) else k
// if not already present, copy reference for dispatch // if not already present, copy reference for dispatch
if (!res.containsKey(key)) { if (!res.containsKey(key)) {
@@ -553,6 +610,7 @@ open class ObjClass(
} }
} }
} }
instanceTemplateBuilt = true
res res
} }
@@ -576,6 +634,11 @@ open class ObjClass(
val stableParent = classScope ?: scope.parent val stableParent = classScope ?: scope.parent
instance.instanceScope = Scope(stableParent, scope.args, scope.pos, instance) instance.instanceScope = Scope(stableParent, scope.args, scope.pos, instance)
instance.instanceScope.currentClassCtx = null instance.instanceScope.currentClassCtx = null
val classCaptureRecords = classScope?.captureRecords
if (classCaptureRecords != null) {
instance.instanceScope.captureRecords = classCaptureRecords
instance.instanceScope.captureNames = classScope?.captureNames
}
val fieldSlots = fieldSlotMap() val fieldSlots = fieldSlotMap()
if (fieldSlots.isNotEmpty()) { if (fieldSlots.isNotEmpty()) {
instance.initFieldSlots(fieldSlotCount()) instance.initFieldSlots(fieldSlotCount())
@@ -630,6 +693,14 @@ open class ObjClass(
args: Arguments?, args: Arguments?,
runConstructors: Boolean runConstructors: Boolean
) { ) {
bridgeInitHooks?.let { hooks ->
if (hooks.isNotEmpty()) {
val facade = instance.instanceScope.asFacade()
for (hook in hooks) {
hook(facade, instance)
}
}
}
val visited = hashSetOf<ObjClass>() val visited = hashSetOf<ObjClass>()
initClassInternal(instance, visited, this, args, isRoot = true, runConstructors = runConstructors) initClassInternal(instance, visited, this, args, isRoot = true, runConstructors = runConstructors)
} }
@@ -715,7 +786,11 @@ open class ObjClass(
instance.instanceScope.currentClassCtx = c instance.instanceScope.currentClassCtx = c
try { try {
for (initStmt in c.instanceInitializers) { for (initStmt in c.instanceInitializers) {
initStmt.execute(instance.instanceScope) if (initStmt is net.sergeych.lyng.Statement) {
executeBytecodeWithSeed(instance.instanceScope, initStmt, "instance init")
} else {
initStmt.callOn(instance.instanceScope)
}
} }
} finally { } finally {
instance.instanceScope.currentClassCtx = savedCtx instance.instanceScope.currentClassCtx = savedCtx
@@ -726,7 +801,7 @@ open class ObjClass(
c.instanceConstructor?.let { ctor -> c.instanceConstructor?.let { ctor ->
val execScope = val execScope =
instance.instanceScope.createChildScope(args = argsForThis ?: Arguments.EMPTY, newThisObj = instance) instance.instanceScope.createChildScope(args = argsForThis ?: Arguments.EMPTY, newThisObj = instance)
ctor.execute(execScope) ctor.callOn(execScope)
} }
} }
} }
@@ -931,9 +1006,9 @@ open class ObjClass(
isOverride: Boolean = false, isOverride: Boolean = false,
pos: Pos = Pos.builtIn, pos: Pos = Pos.builtIn,
methodId: Int? = null, methodId: Int? = null,
code: (suspend Scope.() -> Obj)? = null code: (suspend net.sergeych.lyng.ScopeFacade.() -> Obj)? = null
) { ) {
val stmt = code?.let { statement { it() } } ?: ObjNull val stmt = code?.let { ObjExternCallable.fromBridge { it() } } ?: ObjNull
createField( createField(
name, stmt, isMutable, visibility, writeVisibility, pos, declaringClass, name, stmt, isMutable, visibility, writeVisibility, pos, declaringClass,
isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride, isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride,
@@ -946,8 +1021,8 @@ open class ObjClass(
fun addProperty( fun addProperty(
name: String, name: String,
getter: (suspend Scope.() -> Obj)? = null, getter: (suspend net.sergeych.lyng.ScopeFacade.() -> Obj)? = null,
setter: (suspend Scope.(Obj) -> Unit)? = null, setter: (suspend net.sergeych.lyng.ScopeFacade.(Obj) -> Unit)? = null,
visibility: Visibility = Visibility.Public, visibility: Visibility = Visibility.Public,
writeVisibility: Visibility? = null, writeVisibility: Visibility? = null,
declaringClass: ObjClass? = this, declaringClass: ObjClass? = this,
@@ -958,8 +1033,8 @@ open class ObjClass(
prop: ObjProperty? = null, prop: ObjProperty? = null,
methodId: Int? = null methodId: Int? = null
) { ) {
val g = getter?.let { statement { it() } } val g = getter?.let { ObjExternCallable.fromBridge { it() } }
val s = setter?.let { statement { it(requiredArg(0)); ObjVoid } } val s = setter?.let { ObjExternCallable.fromBridge { it(requiredArg(0)); ObjVoid } }
val finalProp = prop ?: if (isAbstract) ObjNull else ObjProperty(name, g, s) val finalProp = prop ?: if (isAbstract) ObjNull else ObjProperty(name, g, s)
createField( createField(
name, finalProp, false, visibility, writeVisibility, pos, declaringClass, name, finalProp, false, visibility, writeVisibility, pos, declaringClass,
@@ -970,8 +1045,8 @@ open class ObjClass(
} }
fun addClassConst(name: String, value: Obj) = createClassField(name, value) fun addClassConst(name: String, value: Obj) = createClassField(name, value)
fun addClassFn(name: String, isOpen: Boolean = false, code: suspend Scope.() -> Obj) { fun addClassFn(name: String, isOpen: Boolean = false, code: suspend net.sergeych.lyng.ScopeFacade.() -> Obj) {
createClassField(name, statement { code() }, isOpen, type = ObjRecord.Type.Fun) createClassField(name, ObjExternCallable.fromBridge { code() }, isOpen, type = ObjRecord.Type.Fun)
} }
@@ -21,7 +21,6 @@ import kotlinx.datetime.*
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.miniast.addClassFnDoc import net.sergeych.lyng.miniast.addClassFnDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
@@ -47,14 +46,18 @@ class ObjDateTime(val instant: Instant, val timeZone: TimeZone) : Obj() {
if (rec != null) { if (rec != null) {
if (rec.type == ObjRecord.Type.Property) { if (rec.type == ObjRecord.Type.Property) {
val prop = rec.value as? ObjProperty val prop = rec.value as? ObjProperty
?: (rec.value as? Statement)?.execute(scope) as? ObjProperty
if (prop != null) { if (prop != null) {
return ObjRecord(prop.callGetter(scope, this, rec.declaringClass ?: cls), rec.isMutable) return ObjRecord(prop.callGetter(scope, this, rec.declaringClass ?: cls), rec.isMutable)
} }
} }
if (rec.type == ObjRecord.Type.Fun || rec.value is Statement) { if (rec.type == ObjRecord.Type.Fun) {
val s = rec.value as Statement val target = rec.value
return ObjRecord(net.sergeych.lyng.statement { s.execute(this.createChildScope(newThisObj = this@ObjDateTime)) }, rec.isMutable) return ObjRecord(
ObjExternCallable.fromBridge {
call(target, args, newThisObj = this@ObjDateTime)
},
rec.isMutable
)
} }
return resolveRecord(scope, rec, name, rec.declaringClass ?: cls) return resolveRecord(scope, rec, name, rec.declaringClass ?: cls)
} }
@@ -18,9 +18,7 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments import net.sergeych.lyng.Arguments
import net.sergeych.lyng.ClosureScope
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
class ObjDynamicContext(val delegate: ObjDynamic) : Obj() { class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
override val objClass: ObjClass get() = type override val objClass: ObjClass get() = type
@@ -52,7 +50,7 @@ class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
* Object that delegates all its field access/invocation operations to a callback. It is used to implement dynamic * Object that delegates all its field access/invocation operations to a callback. It is used to implement dynamic
* objects using "dynamic" keyword. * objects using "dynamic" keyword.
*/ */
open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: Statement? = null) : Obj() { open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = null) : Obj() {
override val objClass: ObjClass get() = type override val objClass: ObjClass get() = type
// Capture the lexical scope used to build this dynamic so callbacks can see outer locals // Capture the lexical scope used to build this dynamic so callbacks can see outer locals
@@ -63,8 +61,8 @@ open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: St
* with method invocation which is implemented separately in [invokeInstanceMethod] below. * with method invocation which is implemented separately in [invokeInstanceMethod] below.
*/ */
override suspend fun readField(scope: Scope, name: String): ObjRecord { override suspend fun readField(scope: Scope, name: String): ObjRecord {
val execBase = builderScope?.let { ClosureScope(scope, it) } ?: scope val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
return readCallback?.execute(execBase.createChildScope(Arguments(ObjString(name))))?.let { return readCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name))))?.let {
if (writeCallback != null) if (writeCallback != null)
it.asMutable it.asMutable
else else
@@ -83,33 +81,33 @@ open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: St
args: Arguments, args: Arguments,
onNotFoundResult: (suspend () -> Obj?)? onNotFoundResult: (suspend () -> Obj?)?
): Obj { ): Obj {
val execBase = builderScope?.let { ClosureScope(scope, it) } ?: scope val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
val over = readCallback?.execute(execBase.createChildScope(Arguments(ObjString(name)))) val over = readCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name))))
return over?.invoke(scope, scope.thisObj, args) return over?.invoke(scope, scope.thisObj, args)
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult) ?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
} }
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) { override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
val execBase = builderScope?.let { ClosureScope(scope, it) } ?: scope val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
writeCallback?.execute(execBase.createChildScope(Arguments(ObjString(name), newValue))) writeCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name), newValue)))
?: super.writeField(scope, name, newValue) ?: super.writeField(scope, name, newValue)
} }
override suspend fun getAt(scope: Scope, index: Obj): Obj { override suspend fun getAt(scope: Scope, index: Obj): Obj {
val execBase = builderScope?.let { ClosureScope(scope, it) } ?: scope val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
return readCallback?.execute(execBase.createChildScope(Arguments(index))) return readCallback?.callOn(execBase.createChildScope(Arguments(index)))
?: super.getAt(scope, index) ?: super.getAt(scope, index)
} }
override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) { override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
val execBase = builderScope?.let { ClosureScope(scope, it) } ?: scope val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
writeCallback?.execute(execBase.createChildScope(Arguments(index, newValue))) writeCallback?.callOn(execBase.createChildScope(Arguments(index, newValue)))
?: super.putAt(scope, index, newValue) ?: super.putAt(scope, index, newValue)
} }
companion object { companion object {
suspend fun create(scope: Scope, builder: Statement): ObjDynamic { suspend fun create(scope: Scope, builder: Obj): ObjDynamic {
val delegate = ObjDynamic() val delegate = ObjDynamic()
val context = ObjDynamicContext(delegate) val context = ObjDynamicContext(delegate)
// Capture the function's lexical scope (scope) so callbacks can see outer locals like parameters. // Capture the function's lexical scope (scope) so callbacks can see outer locals like parameters.
@@ -117,7 +115,7 @@ open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: St
val buildScope = scope.createChildScope(newThisObj = context) val buildScope = scope.createChildScope(newThisObj = context)
// Snapshot the caller scope to capture locals/args even if the runtime pools/reuses frames // Snapshot the caller scope to capture locals/args even if the runtime pools/reuses frames
delegate.builderScope = scope.snapshotForClosure() delegate.builderScope = scope.snapshotForClosure()
builder.execute(buildScope) builder.callOn(buildScope)
return delegate return delegate
} }
@@ -92,40 +92,54 @@ open class ObjException(
companion object { companion object {
private var stackTraceCaptureDepth = 0
suspend fun captureStackTrace(scope: Scope): ObjList { suspend fun captureStackTrace(scope: Scope): ObjList {
val result = ObjList() val result = ObjList()
val maybeCls = scope.get("StackTraceEntry")?.value as? ObjClass val nestedCapture = stackTraceCaptureDepth > 0
stackTraceCaptureDepth += 1
val maybeCls = if (nestedCapture) null else scope.get("StackTraceEntry")?.value as? ObjClass
var s: Scope? = scope var s: Scope? = scope
var lastPos: Pos? = null var lastPos: Pos? = null
while (s != null) { try {
val pos = s.pos while (s != null) {
if (pos != lastPos && !pos.currentLine.isEmpty()) { val pos = s.pos
if( (lastPos == null || (lastPos.source != pos.source || lastPos.line != pos.line)) ) { if (pos != lastPos && !pos.currentLine.isEmpty()) {
if (maybeCls != null) { if (lastPos == null || (lastPos.source != pos.source || lastPos.line != pos.line)) {
result.list += maybeCls.callWithArgs( val fallback =
scope, ObjString("#${pos.source.objSourceName}:${pos.line+1}:${pos.column+1}: ${pos.currentLine}")
pos.source.objSourceName, if (maybeCls != null) {
ObjInt(pos.line.toLong()), try {
ObjInt(pos.column.toLong()), result.list += maybeCls.callWithArgs(
ObjString(pos.currentLine) scope,
) pos.source.objSourceName,
} else { ObjInt(pos.line.toLong()),
// Fallback textual entry if StackTraceEntry class is not available in this scope ObjInt(pos.column.toLong()),
result.list += ObjString("#${pos.source.objSourceName}:${pos.line+1}:${pos.column+1}: ${pos.currentLine}") ObjString(pos.currentLine)
)
} catch (e: Throwable) {
// Fallback textual entry if StackTraceEntry fails to instantiate
result.list += fallback
}
} else {
// Fallback textual entry if StackTraceEntry class is not available in this scope
result.list += fallback
}
lastPos = pos
} }
lastPos = pos
} }
s = s.parent
} }
s = s.parent return result
} finally {
stackTraceCaptureDepth -= 1
} }
return result
} }
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) { class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
init { init {
constructorMeta = ArgsDeclaration( constructorMeta = ArgsDeclaration(
listOf(ArgsDeclaration.Item("message", defaultValue = statement { ObjString(name) })), listOf(ArgsDeclaration.Item("message", defaultValue = ObjExternCallable.fromBridge { ObjString(name) })),
Token.Type.RPAREN Token.Type.RPAREN
) )
} }
@@ -163,17 +177,17 @@ open class ObjException(
} }
val Root = ExceptionClass("Exception").apply { val Root = ExceptionClass("Exception").apply {
instanceInitializers.add(statement { instanceInitializers.add(ObjExternCallable.fromBridge {
if (thisObj is ObjInstance) { if (thisObj is ObjInstance) {
val msg = get("message")?.value ?: ObjString("Exception") val msg = get("message")?.value ?: ObjString("Exception")
(thisObj as ObjInstance).instanceScope.addItem("Exception::message", false, msg) (thisObj as ObjInstance).instanceScope.addItem("Exception::message", false, msg)
val stack = captureStackTrace(this) val stack = captureStackTrace(requireScope())
(thisObj as ObjInstance).instanceScope.addItem("Exception::stackTrace", false, stack) (thisObj as ObjInstance).instanceScope.addItem("Exception::stackTrace", false, stack)
} }
ObjVoid ObjVoid
}) })
instanceConstructor = statement { ObjVoid } instanceConstructor = ObjExternCallable.fromBridge { ObjVoid }
addPropertyDoc( addPropertyDoc(
name = "message", name = "message",
doc = "Human‑readable error message.", doc = "Human‑readable error message.",
@@ -230,7 +244,7 @@ open class ObjException(
is ObjInstance -> t.instanceScope.get("Exception::stackTrace")?.value as? ObjList ?: ObjList() is ObjInstance -> t.instanceScope.get("Exception::stackTrace")?.value as? ObjList ?: ObjList()
else -> ObjList() else -> ObjList()
} }
val at = stack.list.firstOrNull()?.toString(this) ?: ObjString("(unknown)") val at = stack.list.firstOrNull()?.let { toStringOf(it) } ?: ObjString("(unknown)")
ObjString("${thisObj.objClass.className}: $msg at $at") ObjString("${thisObj.objClass.className}: $msg at $at")
} }
} }
@@ -0,0 +1,47 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeBridge
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Statement
class ObjExternCallable private constructor(
private val target: Obj?,
private val fn: (suspend ScopeFacade.() -> Obj)?
) : Obj() {
override val objClass: ObjClass
get() = Statement.type
override suspend fun callOn(scope: Scope): Obj {
val facade = ScopeBridge(scope)
return when {
fn != null -> facade.fn()
target != null -> target.callOn(scope)
else -> ObjVoid
}
}
override fun toString(): String = "ExternCallable@${hashCode()}"
companion object {
fun wrap(target: Obj): ObjExternCallable = ObjExternCallable(target, null)
fun fromBridge(fn: suspend ScopeFacade.() -> Obj): ObjExternCallable = ObjExternCallable(null, fn)
}
}
@@ -71,13 +71,13 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
} }
} }
private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> { private fun createLyngFlowInput(scope: Scope, producer: Obj): ReceiveChannel<Obj> {
val channel = Channel<Obj>(Channel.RENDEZVOUS) val channel = Channel<Obj>(Channel.RENDEZVOUS)
val builder = ObjFlowBuilder(channel) val builder = ObjFlowBuilder(channel)
val builderScope = scope.createChildScope(newThisObj = builder) val builderScope = scope.createChildScope(newThisObj = builder)
globalLaunch { globalLaunch {
try { try {
producer.execute(builderScope) producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) { } catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK // premature flow closing, OK
} catch (x: Exception) { } catch (x: Exception) {
@@ -89,7 +89,7 @@ private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChann
return channel return channel
} }
class ObjFlow(val producer: Statement, val scope: Scope) : Obj() { class ObjFlow(val producer: Obj, val scope: Scope) : Obj() {
override val objClass get() = type override val objClass get() = type
@@ -106,8 +106,8 @@ class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val objFlow = thisAs<ObjFlow>() val objFlow = thisAs<ObjFlow>()
ObjFlowIterator(statement { ObjFlowIterator(ObjExternCallable.fromBridge {
objFlow.producer.execute(this) call(objFlow.producer)
}) })
} }
} }
@@ -115,7 +115,7 @@ class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
} }
class ObjFlowIterator(val producer: Statement) : Obj() { class ObjFlowIterator(val producer: Obj) : Obj() {
override val objClass: ObjClass get() = type override val objClass: ObjClass get() = type
@@ -164,7 +164,7 @@ class ObjFlowIterator(val producer: Statement) : Obj() {
doc = "Whether another element is available from the flow.", doc = "Whether another element is available from the flow.",
returns = type("lyng.Bool"), returns = type("lyng.Bool"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { thisAs<ObjFlowIterator>().hasNext(this).toObj() } ) { thisAs<ObjFlowIterator>().hasNext(requireScope()).toObj() }
addFnDoc( addFnDoc(
name = "next", name = "next",
doc = "Receive the next element from the flow or throw if completed.", doc = "Receive the next element from the flow or throw if completed.",
@@ -172,7 +172,7 @@ class ObjFlowIterator(val producer: Statement) : Obj() {
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val x = thisAs<ObjFlowIterator>() val x = thisAs<ObjFlowIterator>()
x.next(this) x.next(requireScope())
} }
addFnDoc( addFnDoc(
name = "cancelIteration", name = "cancelIteration",
@@ -29,6 +29,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
internal lateinit var instanceScope: Scope internal lateinit var instanceScope: Scope
internal var fieldSlots: Array<ObjRecord?> = emptyArray() internal var fieldSlots: Array<ObjRecord?> = emptyArray()
internal var methodSlots: Array<ObjRecord?> = emptyArray() internal var methodSlots: Array<ObjRecord?> = emptyArray()
internal var kotlinInstanceData: Any? = null
internal fun initFieldSlots(size: Int) { internal fun initFieldSlots(size: Int) {
fieldSlots = arrayOfNulls(size) fieldSlots = arrayOfNulls(size)
@@ -170,15 +171,17 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
} }
} }
del = del ?: scope.raiseError("Internal error: delegated property $name has no delegate") del = del ?: scope.raiseError("Internal error: delegated property $name has no delegate")
val getValueRec = del.objClass.getInstanceMemberOrNull("getValue") val getValueRec = when (del) {
is ObjInstance -> del.methodRecordForKey("getValue")
?: del.instanceScope.objects["getValue"]
?: del.objClass.getInstanceMemberOrNull("getValue")
else -> del.objClass.getInstanceMemberOrNull("getValue")
}
if (getValueRec == null || getValueRec.declaringClass?.className == "Delegate") { if (getValueRec == null || getValueRec.declaringClass?.className == "Delegate") {
val wrapper = object : Statement() { val wrapper = ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn val th2 = if (thisObj === ObjVoid) ObjNull else thisObj
override suspend fun execute(s: Scope): Obj { val allArgs = (listOf(th2, ObjString(name)) + args.list).toTypedArray()
val th2 = if (s.thisObj === ObjVoid) ObjNull else s.thisObj del.invokeInstanceMethod(requireScope(), "invoke", Arguments(*allArgs))
val allArgs = (listOf(th2, ObjString(name)) + s.args.list).toTypedArray()
return del.invokeInstanceMethod(s, "invoke", Arguments(*allArgs))
}
} }
return obj.copy(value = wrapper, type = ObjRecord.Type.Other) return obj.copy(value = wrapper, type = ObjRecord.Type.Other)
} }
@@ -364,6 +367,16 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
// Fast path for public members when outside any class context // Fast path for public members when outside any class context
if (caller == null) { if (caller == null) {
objClass.members[name]?.let { rec ->
if (rec.visibility == Visibility.Public && !rec.isAbstract) {
val decl = rec.declaringClass
if (rec.type == ObjRecord.Type.Property) {
if (args.isEmpty()) return (rec.value as ObjProperty).callGetter(scope, this, decl)
} else if (rec.type == ObjRecord.Type.Fun) {
return rec.value.invoke(instanceScope, this, args, decl)
}
}
}
objClass.publicMemberResolution[name]?.let { key -> objClass.publicMemberResolution[name]?.let { key ->
methodRecordForKey(key)?.let { rec -> methodRecordForKey(key)?.let { rec ->
if (rec.visibility == Visibility.Public && !rec.isAbstract) { if (rec.visibility == Visibility.Public && !rec.isAbstract) {
@@ -21,9 +21,7 @@ import kotlinx.datetime.*
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.miniast.addPropertyDoc
import net.sergeych.lyng.miniast.type
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonSettings import net.sergeych.lynon.LynonSettings
@@ -274,17 +272,29 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
// class members // class members
addClassConst("distantFuture", distantFuture) addClassConstDoc(
addClassConst("distantPast", distantPast) name = "distantFuture",
addClassFn("now") { value = distantFuture,
doc = "An instant in the distant future.",
type = type("lyng.Instant"),
moduleName = "lyng.time"
)
addClassConstDoc(
name = "distantPast",
value = distantPast,
doc = "An instant in the distant past.",
type = type("lyng.Instant"),
moduleName = "lyng.time"
)
addClassFnDoc(
name = "now",
doc = "Return the current instant from the system clock.",
returns = type("lyng.Instant"),
moduleName = "lyng.time"
) {
ObjInstant(Clock.System.now()) ObjInstant(Clock.System.now())
} }
// addFn("epochMilliseconds") {
// ObjInt(instant.toEpochMilliseconds())
// }
} }
} }
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -189,6 +189,7 @@ class ObjInt(val value: Long, override val isConst: Boolean = false) : Obj(), Nu
else -> scope.raiseIllegalState("illegal type code for Int: $lynonType") else -> scope.raiseIllegalState("illegal type code for Int: $lynonType")
} }
}.apply { }.apply {
isClosed = true
addFnDoc( addFnDoc(
name = "toInt", name = "toInt",
doc = "Returns this integer (identity operation).", doc = "Returns this integer (identity operation).",
@@ -18,7 +18,6 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Statement
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
@@ -42,10 +41,11 @@ val ObjIterable by lazy {
returns = type("lyng.List"), returns = type("lyng.List"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val scope = requireScope()
val result = mutableListOf<Obj>() val result = mutableListOf<Obj>()
val it = thisObj.invokeInstanceMethod(this, "iterator") val it = thisObj.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(this, "hasNext").toBool()) { while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
result.add(it.invokeInstanceMethod(this, "next")) result.add(it.invokeInstanceMethod(scope, "next"))
} }
ObjList(result) ObjList(result)
} }
@@ -59,10 +59,11 @@ val ObjIterable by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val scope = requireScope()
val obj = args.firstAndOnly() val obj = args.firstAndOnly()
val it = thisObj.invokeInstanceMethod(this, "iterator") val it = thisObj.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(this, "hasNext").toBool()) { while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
if (obj.equals(this, it.invokeInstanceMethod(this, "next"))) if (obj.equals(scope, it.invokeInstanceMethod(scope, "next")))
return@addFnDoc ObjTrue return@addFnDoc ObjTrue
} }
ObjFalse ObjFalse
@@ -76,11 +77,12 @@ val ObjIterable by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val scope = requireScope()
val obj = args.firstAndOnly() val obj = args.firstAndOnly()
var index = 0 var index = 0
val it = thisObj.invokeInstanceMethod(this, "iterator") val it = thisObj.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(this, "hasNext").toBool()) { while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
if (obj.equals(this, it.invokeInstanceMethod(this, "next"))) if (obj.equals(scope, it.invokeInstanceMethod(scope, "next")))
return@addFnDoc ObjInt(index.toLong()) return@addFnDoc ObjInt(index.toLong())
index++ index++
} }
@@ -97,9 +99,10 @@ val ObjIterable by lazy {
this.thisObj this.thisObj
else { else {
val result = mutableSetOf<Obj>() val result = mutableSetOf<Obj>()
val it = this.thisObj.invokeInstanceMethod(this, "iterator") val scope = requireScope()
while (it.invokeInstanceMethod(this, "hasNext").toBool()) { val it = this.thisObj.invokeInstanceMethod(scope, "iterator")
result.add(it.invokeInstanceMethod(this, "next")) while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
result.add(it.invokeInstanceMethod(scope, "next"))
} }
ObjSet(result) ObjSet(result)
} }
@@ -113,10 +116,11 @@ val ObjIterable by lazy {
moduleName = "lyng.stdlib", moduleName = "lyng.stdlib",
getter = { getter = {
val result = mutableMapOf<Obj, Obj>() val result = mutableMapOf<Obj, Obj>()
this.thisObj.enumerate(this) { pair -> val scope = requireScope()
this.thisObj.enumerate(scope) { pair ->
when (pair) { when (pair) {
is ObjMapEntry -> result[pair.key] = pair.value is ObjMapEntry -> result[pair.key] = pair.value
else -> result[pair.getAt(this, 0)] = pair.getAt(this, 1) else -> result[pair.getAt(scope, 0)] = pair.getAt(scope, 1)
} }
true true
} }
@@ -131,10 +135,10 @@ val ObjIterable by lazy {
returns = type("lyng.Map"), returns = type("lyng.Map"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val association = requireOnlyArg<Statement>() val association = requireOnlyArg<Obj>()
val result = ObjMap() val result = ObjMap()
thisObj.toFlow(this).collect { thisObj.toFlow(requireScope()).collect {
result.map[association.call(this, it)] = it result.map[call(association, Arguments(it))] = it
} }
result result
} }
@@ -146,11 +150,12 @@ val ObjIterable by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val it = thisObj.invokeInstanceMethod(this, "iterator") val scope = requireScope()
val fn = requiredArg<Statement>(0) val it = thisObj.invokeInstanceMethod(scope, "iterator")
while (it.invokeInstanceMethod(this, "hasNext").toBool()) { val fn = requiredArg<Obj>(0)
val x = it.invokeInstanceMethod(this, "next") while (it.invokeInstanceMethod(scope, "hasNext").toBool()) {
fn.execute(this.createChildScope(Arguments(listOf(x)))) val x = it.invokeInstanceMethod(scope, "next")
call(fn, Arguments(listOf(x)))
} }
ObjVoid ObjVoid
} }
@@ -163,10 +168,10 @@ val ObjIterable by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val fn = requiredArg<Statement>(0) val fn = requiredArg<Obj>(0)
val result = mutableListOf<Obj>() val result = mutableListOf<Obj>()
thisObj.toFlow(this).collect { thisObj.toFlow(requireScope()).collect {
result.add(fn.call(this, it)) result.add(call(fn, Arguments(it)))
} }
ObjList(result) ObjList(result)
} }
@@ -179,10 +184,10 @@ val ObjIterable by lazy {
isOpen = true, isOpen = true,
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val fn = requiredArg<Statement>(0) val fn = requiredArg<Obj>(0)
val result = mutableListOf<Obj>() val result = mutableListOf<Obj>()
thisObj.toFlow(this).collect { thisObj.toFlow(requireScope()).collect {
val transformed = fn.call(this, it) val transformed = call(fn, Arguments(it))
if( transformed != ObjNull) result.add(transformed) if( transformed != ObjNull) result.add(transformed)
} }
ObjList(result) ObjList(result)
@@ -198,7 +203,7 @@ val ObjIterable by lazy {
var n = requireOnlyArg<ObjInt>().value.toInt() var n = requireOnlyArg<ObjInt>().value.toInt()
val result = mutableListOf<Obj>() val result = mutableListOf<Obj>()
if (n > 0) { if (n > 0) {
thisObj.enumerate(this) { thisObj.enumerate(requireScope()) {
result.add(it) result.add(it)
--n > 0 --n > 0
} }
@@ -213,8 +218,8 @@ val ObjIterable by lazy {
moduleName = "lyng.stdlib", moduleName = "lyng.stdlib",
getter = { getter = {
ObjBool( ObjBool(
this.thisObj.invokeInstanceMethod(this, "iterator") this.thisObj.invokeInstanceMethod(requireScope(), "iterator")
.invokeInstanceMethod(this, "hasNext").toBool() .invokeInstanceMethod(requireScope(), "hasNext").toBool()
.not() .not()
) )
} }
@@ -227,10 +232,10 @@ val ObjIterable by lazy {
returns = type("lyng.List"), returns = type("lyng.List"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val list = thisObj.callMethod<ObjList>(this, "toList") val list = thisObj.callMethod<ObjList>(requireScope(), "toList")
val comparator = requireOnlyArg<Statement>() val comparator = requireOnlyArg<Obj>()
list.quicksort { a, b -> list.quicksort { a, b ->
comparator.call(this, a, b).toInt() call(comparator, Arguments(a, b)).toInt()
} }
list list
} }
@@ -241,7 +246,7 @@ val ObjIterable by lazy {
returns = type("lyng.List"), returns = type("lyng.List"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val list = thisObj.callMethod<ObjList>(this, "toList") val list = thisObj.callMethod<ObjList>(requireScope(), "toList")
list.list.reverse() list.list.reverse()
list list
} }
@@ -69,13 +69,12 @@ val ObjIterator by lazy {
) { ) {
val out = mutableListOf<Obj>() val out = mutableListOf<Obj>()
while (true) { while (true) {
val has = thisObj.invokeInstanceMethod(this, "hasNext").toBool() val has = thisObj.invokeInstanceMethod(requireScope(), "hasNext").toBool()
if (!has) break if (!has) break
val v = thisObj.invokeInstanceMethod(this, "next") val v = thisObj.invokeInstanceMethod(requireScope(), "next")
out += v out += v
} }
ObjList(out.toMutableList()) ObjList(out.toMutableList())
} }
} }
} }
@@ -22,6 +22,7 @@ package net.sergeych.lyng.obj
import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow import kotlinx.coroutines.flow.flow
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.bridge.LyngClassBridge
/** /**
* Iterator wrapper to allow Kotlin collections to be returned from Lyng objects; * Iterator wrapper to allow Kotlin collections to be returned from Lyng objects;
@@ -32,9 +33,33 @@ class ObjKotlinIterator(val iterator: Iterator<Any?>) : Obj() {
override val objClass get() = type override val objClass get() = type
companion object { companion object {
val type = ObjClass("KotlinIterator", ObjIterator).apply { private var boundType: ObjClass? = null
addFn("next") { thisAs<ObjKotlinIterator>().iterator.next().toObj() }
addFn("hasNext") { thisAs<ObjKotlinIterator>().iterator.hasNext().toObj() } val type: ObjClass
get() = boundType ?: error("KotlinIterator class is not bound; import lyng.stdlib first")
internal fun bindTo(cls: ObjClass) {
if (boundType != null) {
if (boundType === cls) return
return
}
boundType = cls
LyngClassBridge.bind(cls) {
addFun("next") { scope, self, _ ->
when (self) {
is ObjKotlinIterator -> self.iterator.next().toObj()
is ObjKotlinObjIterator -> self.iterator.next()
else -> scope.raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
}
}
addFun("hasNext") { scope, self, _ ->
when (self) {
is ObjKotlinIterator -> self.iterator.hasNext().toObj()
is ObjKotlinObjIterator -> self.iterator.hasNext().toObj()
else -> scope.raiseClassCastError("Expected KotlinIterator, got ${self.objClass.className}")
}
}
}
} }
} }
@@ -49,14 +74,8 @@ class ObjKotlinObjIterator(val iterator: Iterator<Obj>) : Obj() {
override val objClass get() = type override val objClass get() = type
companion object { companion object {
val type = ObjClass("KotlinIterator", ObjIterator).apply { val type: ObjClass
addFn("next") { get() = ObjKotlinIterator.type
thisAs<ObjKotlinObjIterator>().iterator.next()
}
addFn("hasNext") {
thisAs<ObjKotlinObjIterator>().iterator.hasNext().toObj()
}
}
} }
} }
@@ -75,4 +94,3 @@ fun Obj.toFlow(scope: Scope): Flow<Obj> = flow {
emit(next.invoke(scope, iterator)) emit(next.invoke(scope, iterator))
} }
} }
@@ -17,13 +17,18 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.* import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.Visibility
import net.sergeych.lyng.executeBytecodeWithSeed
/** /**
* Lazy delegate used by `val x by lazy { ... }`. * Lazy delegate used by `val x by lazy { ... }`.
*/ */
class ObjLazyDelegate( class ObjLazyDelegate(
private val builder: Statement, private val builder: Obj,
private val capturedScope: Scope, private val capturedScope: Scope,
) : Obj() { ) : Obj() {
override val objClass: ObjClass = type override val objClass: ObjClass = type
@@ -41,7 +46,11 @@ class ObjLazyDelegate(
"getValue" -> { "getValue" -> {
if (!calculated) { if (!calculated) {
val callScope = capturedScope.createChildScope(capturedScope.pos, args = Arguments.EMPTY) val callScope = capturedScope.createChildScope(capturedScope.pos, args = Arguments.EMPTY)
cachedValue = builder.callOn(callScope) cachedValue = if (builder is Statement) {
executeBytecodeWithSeed(callScope, builder, "lazy delegate")
} else {
builder.callOn(callScope)
}
calculated = true calculated = true
} }
cachedValue cachedValue
@@ -20,7 +20,7 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonArray import kotlinx.serialization.json.JsonArray
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement import net.sergeych.lyng.Arguments
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc import net.sergeych.lyng.miniast.addPropertyDoc
@@ -371,8 +371,10 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
params = listOf(ParamDoc("comparator")), params = listOf(ParamDoc("comparator")),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val comparator = requireOnlyArg<Statement>() val comparator = requireOnlyArg<Obj>()
thisAs<ObjList>().quicksort { a, b -> comparator.call(this, a, b).toInt() } thisAs<ObjList>().quicksort { a, b ->
call(comparator, Arguments(a, b)).toInt()
}
ObjVoid ObjVoid
} }
addFnDoc( addFnDoc(
@@ -391,6 +393,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
val self = thisAs<ObjList>() val self = thisAs<ObjList>()
val l = self.list val l = self.list
if (l.isEmpty()) return@addFnDoc ObjNull if (l.isEmpty()) return@addFnDoc ObjNull
val scope = requireScope()
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) { if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
// Fast path: all ints → accumulate as long // Fast path: all ints → accumulate as long
var i = 0 var i = 0
@@ -404,7 +407,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
// Fallback to generic dynamic '+' accumulation starting from current acc // Fallback to generic dynamic '+' accumulation starting from current acc
var res: Obj = ObjInt(acc) var res: Obj = ObjInt(acc)
while (i < l.size) { while (i < l.size) {
res = res.plus(this, l[i]) res = res.plus(scope, l[i])
i++ i++
} }
return@addFnDoc res return@addFnDoc res
@@ -416,7 +419,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
var res: Obj = l[0] var res: Obj = l[0]
var k = 1 var k = 1
while (k < l.size) { while (k < l.size) {
res = res.plus(this, l[k]) res = res.plus(scope, l[k])
k++ k++
} }
res res
@@ -428,6 +431,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
) { ) {
val l = thisAs<ObjList>().list val l = thisAs<ObjList>().list
if (l.isEmpty()) return@addFnDoc ObjNull if (l.isEmpty()) return@addFnDoc ObjNull
val scope = requireScope()
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) { if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
var i = 0 var i = 0
var hasOnlyInts = true var hasOnlyInts = true
@@ -448,7 +452,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
var i = 1 var i = 1
while (i < l.size) { while (i < l.size) {
val v = l[i] val v = l[i]
if (v.compareTo(this, res) < 0) res = v if (v.compareTo(scope, res) < 0) res = v
i++ i++
} }
res res
@@ -460,6 +464,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
) { ) {
val l = thisAs<ObjList>().list val l = thisAs<ObjList>().list
if (l.isEmpty()) return@addFnDoc ObjNull if (l.isEmpty()) return@addFnDoc ObjNull
val scope = requireScope()
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) { if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS) {
var i = 0 var i = 0
var hasOnlyInts = true var hasOnlyInts = true
@@ -480,7 +485,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
var i = 1 var i = 1
while (i < l.size) { while (i < l.size) {
val v = l[i] val v = l[i]
if (v.compareTo(this, res) > 0) res = v if (v.compareTo(scope, res) > 0) res = v
i++ i++
} }
res res
@@ -494,6 +499,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
) { ) {
val l = thisAs<ObjList>().list val l = thisAs<ObjList>().list
val needle = args.firstAndOnly() val needle = args.firstAndOnly()
val scope = requireScope()
if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS && needle is ObjInt) { if (net.sergeych.lyng.PerfFlags.PRIMITIVE_FASTOPS && needle is ObjInt) {
var i = 0 var i = 0
while (i < l.size) { while (i < l.size) {
@@ -505,7 +511,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
} }
var i = 0 var i = 0
while (i < l.size) { while (i < l.size) {
if (l[i].compareTo(this, needle) == 0) return@addFnDoc ObjInt(i.toLong()) if (l[i].compareTo(scope, needle) == 0) return@addFnDoc ObjInt(i.toLong())
i++ i++
} }
ObjInt((-1).toLong()) ObjInt((-1).toLong())
@@ -522,4 +528,3 @@ fun <T>MutableList<T>.swap(i: Int, j: Int) {
this[j] = temp this[j] = temp
} }
} }
@@ -20,7 +20,6 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject import kotlinx.serialization.json.JsonObject
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
@@ -261,8 +260,8 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
) { ) {
val key = requiredArg<Obj>(0) val key = requiredArg<Obj>(0)
thisAs<ObjMap>().map.getOrPut(key) { thisAs<ObjMap>().map.getOrPut(key) {
val lambda = requiredArg<Statement>(1) val lambda = requiredArg<Obj>(1)
lambda.execute(this) call(lambda)
} }
} }
addPropertyDoc( addPropertyDoc(
@@ -20,7 +20,6 @@ package net.sergeych.lyng.obj
import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.miniast.ParamDoc import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
@@ -41,11 +40,11 @@ class ObjMutex(val mutex: Mutex): Obj() {
returns = type("lyng.Any"), returns = type("lyng.Any"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val f = requiredArg<Statement>(0) val f = requiredArg<Obj>(0)
// Execute user lambda directly in the current scope to preserve the active scope // Execute user lambda directly in the current scope to preserve the active scope
// ancestry across suspension points. The lambda still constructs a ClosureScope // ancestry across suspension points. The lambda still constructs a closure scope
// on top of this frame, and parseLambdaExpression sets skipScopeCreation for its body. // on top of this frame, and parseLambdaExpression sets skipScopeCreation for its body.
thisAs<ObjMutex>().mutex.withLock { f.execute(this) } thisAs<ObjMutex>().mutex.withLock { call(f) }
} }
} }
} }
@@ -18,9 +18,11 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments import net.sergeych.lyng.Arguments
import net.sergeych.lyng.ClosureScope import net.sergeych.lyng.BytecodeBodyProvider
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement import net.sergeych.lyng.Statement
import net.sergeych.lyng.bytecode.BytecodeStatement
import net.sergeych.lyng.executeBytecodeWithSeed
/** /**
* Property accessor storage. Per instructions, properties do NOT have * Property accessor storage. Per instructions, properties do NOT have
@@ -28,28 +30,44 @@ import net.sergeych.lyng.Statement
*/ */
class ObjProperty( class ObjProperty(
val name: String, val name: String,
val getter: Statement?, val getter: Obj?,
val setter: Statement? val setter: Obj?
) : Obj() { ) : Obj() {
suspend fun callGetter(scope: Scope, instance: Obj, declaringClass: ObjClass? = null): Obj { suspend fun callGetter(scope: Scope, instance: Obj, declaringClass: ObjClass? = null): Obj {
val g = getter ?: scope.raiseError("property $name has no getter") val g = getter ?: scope.raiseError("property $name has no getter")
// Execute getter in a child scope of the instance with 'this' properly set // Execute getter in a child scope of the instance with 'this' properly set
// Use ClosureScope to match extension function behavior (access to instance scope + call scope) // Match extension function behavior (access to instance scope + call scope).
val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope) val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope)
val execScope = ClosureScope(scope, instanceScope).createChildScope(newThisObj = instance) val execScope = scope.applyClosure(instanceScope).createChildScope(newThisObj = instance)
execScope.currentClassCtx = declaringClass execScope.currentClassCtx = declaringClass
return g.execute(execScope) return when (g) {
is BytecodeStatement -> executeBytecodeWithSeed(execScope, g, "property getter")
is BytecodeBodyProvider -> {
val body = g.bytecodeBody()
if (body != null) executeBytecodeWithSeed(execScope, body, "property getter") else g.callOn(execScope)
}
is Statement -> g.callOn(execScope)
else -> g.callOn(execScope)
}
} }
suspend fun callSetter(scope: Scope, instance: Obj, value: Obj, declaringClass: ObjClass? = null) { suspend fun callSetter(scope: Scope, instance: Obj, value: Obj, declaringClass: ObjClass? = null) {
val s = setter ?: scope.raiseError("property $name has no setter") val s = setter ?: scope.raiseError("property $name has no setter")
// Execute setter in a child scope of the instance with 'this' properly set and the value as an argument // Execute setter in a child scope of the instance with 'this' properly set and the value as an argument
// Use ClosureScope to match extension function behavior // Match extension function behavior (access to instance scope + call scope).
val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope) val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope)
val execScope = ClosureScope(scope, instanceScope).createChildScope(args = Arguments(value), newThisObj = instance) val execScope = scope.applyClosure(instanceScope).createChildScope(args = Arguments(value), newThisObj = instance)
execScope.currentClassCtx = declaringClass execScope.currentClassCtx = declaringClass
s.execute(execScope) when (s) {
is BytecodeStatement -> executeBytecodeWithSeed(execScope, s, "property setter")
is BytecodeBodyProvider -> {
val body = s.bytecodeBody()
if (body != null) executeBytecodeWithSeed(execScope, body, "property setter") else s.callOn(execScope)
}
is Statement -> s.callOn(execScope)
else -> s.callOn(execScope)
}
} }
override fun toString(): String = "Property($name)" override fun toString(): String = "Property($name)"
@@ -270,7 +270,7 @@ class ObjRange(
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
val self = thisAs<ObjRange>() val self = thisAs<ObjRange>()
self.buildIterator(this) self.buildIterator(requireScope())
} }
} }
} }
@@ -65,10 +65,10 @@ class ObjRangeIterator(
companion object { companion object {
val type = ObjClass("RangeIterator", ObjIterator).apply { val type = ObjClass("RangeIterator", ObjIterator).apply {
addFn("hasNext") { addFn("hasNext") {
thisAs<ObjRangeIterator>().hasNext(this).toObj() thisAs<ObjRangeIterator>().hasNext(requireScope()).toObj()
} }
addFn("next") { addFn("next") {
thisAs<ObjRangeIterator>().next(this) thisAs<ObjRangeIterator>().next(requireScope())
} }
} }
} }
@@ -98,7 +98,7 @@ class ObjFastIntRangeIterator(private val start: Int, private val endExclusive:
companion object { companion object {
val type = ObjClass("FastIntRangeIterator", ObjIterator).apply { val type = ObjClass("FastIntRangeIterator", ObjIterator).apply {
addFn("hasNext") { thisAs<ObjFastIntRangeIterator>().hasNext().toObj() } addFn("hasNext") { thisAs<ObjFastIntRangeIterator>().hasNext().toObj() }
addFn("next") { thisAs<ObjFastIntRangeIterator>().next(this) } addFn("next") { thisAs<ObjFastIntRangeIterator>().next(requireScope()) }
} }
} }
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -19,12 +19,10 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonElement import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive import kotlinx.serialization.json.JsonPrimitive
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.addConstDoc import net.sergeych.lyng.miniast.addConstDoc
import net.sergeych.lyng.miniast.addFnDoc import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.type import net.sergeych.lyng.miniast.type
import net.sergeych.lyng.statement
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
@@ -123,11 +121,12 @@ data class ObjReal(val value: Double) : Obj(), Numeric {
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
of(decoder.unpackDouble()) of(decoder.unpackDouble())
}.apply { }.apply {
isClosed = true
// roundToInt: number rounded to the nearest integer // roundToInt: number rounded to the nearest integer
addConstDoc( addConstDoc(
name = "roundToInt", name = "roundToInt",
value = statement(Pos.builtIn) { value = ObjExternCallable.fromBridge {
(it.thisObj as ObjReal).value.roundToLong().toObj() (thisObj as ObjReal).value.roundToLong().toObj()
}, },
doc = "This real number rounded to the nearest integer.", doc = "This real number rounded to the nearest integer.",
type = type("lyng.Int"), type = type("lyng.Int"),
File diff suppressed because it is too large. Load diff
@@ -17,11 +17,13 @@
package net.sergeych.lyng.obj package net.sergeych.lyng.obj
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.PerfFlags import net.sergeych.lyng.PerfFlags
import net.sergeych.lyng.Pos import net.sergeych.lyng.Pos
import net.sergeych.lyng.RecordSlotRef
import net.sergeych.lyng.RegexCache import net.sergeych.lyng.RegexCache
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement import net.sergeych.lyng.requireScope
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
class ObjRegex(val regex: Regex) : Obj() { class ObjRegex(val regex: Regex) : Obj() {
@@ -29,7 +31,20 @@ class ObjRegex(val regex: Regex) : Obj() {
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj { override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
return regex.find(other.cast<ObjString>(scope).value)?.let { return regex.find(other.cast<ObjString>(scope).value)?.let {
scope.addOrUpdateItem("$~", ObjRegexMatch(it)) val match = ObjRegexMatch(it)
val record = scope.chainLookupIgnoreClosure("$~", followClosure = true)
if (record != null) {
if (!record.isMutable) {
scope.raiseIllegalAssignment("symbol is readonly: $~")
}
when (val value = record.value) {
is FrameSlotRef -> value.write(match)
is RecordSlotRef -> value.write(match)
else -> record.value = match
}
} else {
scope.addOrUpdateItem("$~", match)
}
ObjTrue ObjTrue
} ?: ObjFalse } ?: ObjFalse
} }
@@ -76,14 +91,11 @@ class ObjRegex(val regex: Regex) : Obj() {
} }
createField( createField(
name = "operatorMatch", name = "operatorMatch",
initialValue = object : Statement() { initialValue = ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn val other = args.firstAndOnly(Pos.builtIn)
val scope = requireScope()
override suspend fun execute(scope: Scope): Obj { val targetScope = scope.parent ?: scope
val other = scope.args.firstAndOnly(pos) (thisObj as ObjRegex).operatorMatch(targetScope, other)
val targetScope = scope.parent ?: scope
return (scope.thisObj as ObjRegex).operatorMatch(targetScope, other)
}
}, },
type = ObjRecord.Type.Fun type = ObjRecord.Type.Fun
) )
@@ -175,7 +175,7 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
returns = type("lyng.Set"), returns = type("lyng.Set"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisAs<ObjSet>().mul(this, args.firstAndOnly()) thisAs<ObjSet>().mul(requireScope(), args.firstAndOnly())
} }
addFnDoc( addFnDoc(
name = "iterator", name = "iterator",
@@ -192,7 +192,7 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
returns = type("lyng.Set"), returns = type("lyng.Set"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisAs<ObjSet>().plus(this, args.firstAndOnly()) thisAs<ObjSet>().plus(requireScope(), args.firstAndOnly())
} }
addFnDoc( addFnDoc(
name = "subtract", name = "subtract",
@@ -201,7 +201,7 @@ class ObjSet(val set: MutableSet<Obj> = mutableSetOf()) : Obj() {
returns = type("lyng.Set"), returns = type("lyng.Set"),
moduleName = "lyng.stdlib" moduleName = "lyng.stdlib"
) { ) {
thisAs<ObjSet>().minus(this, args.firstAndOnly()) thisAs<ObjSet>().minus(requireScope(), args.firstAndOnly())
} }
addFnDoc( addFnDoc(
name = "remove", name = "remove",
@@ -25,8 +25,8 @@ import net.sergeych.lyng.PerfFlags
import net.sergeych.lyng.Pos import net.sergeych.lyng.Pos
import net.sergeych.lyng.RegexCache import net.sergeych.lyng.RegexCache
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.requireScope
import net.sergeych.lynon.LynonDecoder import net.sergeych.lynon.LynonDecoder
import net.sergeych.lynon.LynonEncoder import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType import net.sergeych.lynon.LynonType
@@ -137,6 +137,7 @@ data class ObjString(val value: String) : Obj() {
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
ObjString(decoder.unpackBinaryData().decodeToString()) ObjString(decoder.unpackBinaryData().decodeToString())
}.apply { }.apply {
isClosed = true
addFnDoc( addFnDoc(
name = "iterator", name = "iterator",
doc = "Iterator over characters of this string.", doc = "Iterator over characters of this string.",
@@ -344,14 +345,10 @@ data class ObjString(val value: String) : Obj() {
name = "re", name = "re",
initialValue = ObjProperty( initialValue = ObjProperty(
name = "re", name = "re",
getter = object : Statement() { getter = ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn val pattern = (thisObj as ObjString).value
val re = if (PerfFlags.REGEX_CACHE) RegexCache.get(pattern) else pattern.toRegex()
override suspend fun execute(scope: Scope): Obj { ObjRegex(re)
val pattern = (scope.thisObj as ObjString).value
val re = if (PerfFlags.REGEX_CACHE) RegexCache.get(pattern) else pattern.toRegex()
return ObjRegex(re)
}
}, },
setter = null setter = null
), ),
@@ -359,14 +356,11 @@ data class ObjString(val value: String) : Obj() {
) )
createField( createField(
name = "operatorMatch", name = "operatorMatch",
initialValue = object : Statement() { initialValue = ObjExternCallable.fromBridge {
override val pos: Pos = Pos.builtIn val other = args.firstAndOnly(Pos.builtIn)
val scope = requireScope()
override suspend fun execute(scope: Scope): Obj { val targetScope = scope.parent ?: scope
val other = scope.args.firstAndOnly(pos) (thisObj as ObjString).operatorMatch(targetScope, other)
val targetScope = scope.parent ?: scope
return (scope.thisObj as ObjString).operatorMatch(targetScope, other)
}
}, },
type = ObjRecord.Type.Fun type = ObjRecord.Type.Fun
) )
@@ -0,0 +1,38 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.requireExactCount as coreRequireExactCount
import net.sergeych.lyng.requireNoArgs as coreRequireNoArgs
import net.sergeych.lyng.requireOnlyArg as coreRequireOnlyArg
import net.sergeych.lyng.requiredArg as coreRequiredArg
import net.sergeych.lyng.requireScope as coreRequireScope
import net.sergeych.lyng.thisAs as coreThisAs
inline fun <reified T : Obj> ScopeFacade.requiredArg(index: Int): T = coreRequiredArg(index)
inline fun <reified T : Obj> ScopeFacade.requireOnlyArg(): T = coreRequireOnlyArg()
fun ScopeFacade.requireExactCount(count: Int) = coreRequireExactCount(count)
fun ScopeFacade.requireNoArgs() = coreRequireNoArgs()
inline fun <reified T : Obj> ScopeFacade.thisAs(): T = coreThisAs()
internal fun ScopeFacade.requireScope(): Scope = coreRequireScope()
@@ -64,15 +64,27 @@ abstract class ImportProvider(
fun newModuleAt(pos: Pos): ModuleScope = fun newModuleAt(pos: Pos): ModuleScope =
ModuleScope(this, pos, "unknown") ModuleScope(this, pos, "unknown")
private var cachedStdScope = CachedExpression<Scope>() private data class StdScopeSeed(
val stdlib: ModuleScope,
val plan: Map<String, Int>
)
suspend fun newStdScope(pos: Pos = Pos.builtIn): Scope = private var cachedStdScope = CachedExpression<StdScopeSeed>()
cachedStdScope.get {
newModuleAt(pos).also { suspend fun newStdScope(pos: Pos = Pos.builtIn): Scope {
it.eval("import lyng.stdlib\n") val seed = cachedStdScope.get {
val stdlib = prepareImport(pos, "lyng.stdlib", null)
val plan = LinkedHashMap<String, Int>()
for ((name, record) in stdlib.objects) {
if (!record.visibility.isPublic) continue
plan[name] = plan.size
} }
}.createChildScope() StdScopeSeed(stdlib, plan)
}
val module = newModuleAt(pos)
if (seed.plan.isNotEmpty()) module.applySlotPlan(seed.plan)
seed.stdlib.importInto(module, null)
return module
}
} }
@@ -70,7 +70,7 @@ object CompileTimeResolver {
source, source,
importProvider, importProvider,
resolutionSink = collector, resolutionSink = collector,
useBytecodeStatements = false, compileBytecode = false,
allowUnresolvedRefs = true allowUnresolvedRefs = true
) )
return collector.buildReport() return collector.buildReport()
Loaded 100 of 141 files, more files were not shown because too many files have changed in this diff. Show more