Compare commits

..
30 Commits
Author SHA1 Message Date
sergeych 9735774efd v1.5.5 release 2026-04-23 15:18:47 +03:00
sergeych 14214e91e1 Fix escaping immutable closure captures 2026-04-22 18:50:49 +03:00
sergeychandClaude Sonnet 4.6 0f5343fa17 Add VPS deployment target and Ansible provisioning for lynglang.com
- deploy_site now defaults to new VPS (94.130.36.94, /var/www/lynglang);
  use --old to deploy to d.lynglang.com as before
- infra/setup_vps.yml: Ansible playbook installs nginx + certbot, obtains
  SSL cert for lynglang.com, fixes Debian buster EOL apt sources
- infra/inventory.ini and infra/templates/nginx_lynglang.conf.j2 included

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-04-22 12:31:01 +03:00
sergeych d0f51928de fixed wrong error message in val ++/-- 2026-04-22 08:56:02 +03:00
sergeych 0973a6afeb Fix JVM import caching and class/object bytecode dispatch 2026-04-21 23:25:07 +03:00
sergeych 953f237ca3 Optimize primitive list fill capacity and append 2026-04-21 21:37:04 +03:00
sergeych fbb5688696 Drive higher-order lambda inlining from call metadata 2026-04-21 20:51:16 +03:00
sergeych f4ab2ebab4 Extend lambda inlining to getOrPut and implicit it calls 2026-04-21 19:20:25 +03:00
sergeych 0c3242cbd8 Generalize higher-order lambda inlining 2026-04-21 19:12:16 +03:00
sergeych 1d5caaa836 Broaden lambda method inlining with captures 2026-04-21 19:07:05 +03:00
sergeych 3be2892025 Use fast compiled callbacks in dynamic and flow helpers 2026-04-21 18:06:31 +03:00
sergeych c80900c503 Prevent cross-script module slot aliasing 2026-04-21 17:34:00 +03:00
sergeych ee634c8dff Extend generic fast callable entry points 2026-04-21 17:26:53 +03:00
sergeych 6c91b77a85 Use fast lambda calls in scope facade 2026-04-21 16:43:02 +03:00
sergeych 3721ee8332 Fast-path compiled lambda calls with args 2026-04-21 16:04:04 +03:00
sergeych 97990f00ce Cover when-based exact callable fast paths 2026-04-21 14:37:27 +03:00
sergeych 80693e7690 Inline exact lambdas through wrapper expressions 2026-04-21 14:36:18 +03:00
sergeych 029fe874fa Propagate exact callable refs across expressions 2026-04-21 14:33:23 +03:00
sergeych ffa64d691b Use direct calls for constant constructors 2026-04-21 13:30:09 +03:00
sergeych 30c9a5a565 Propagate exact lambda refs across bytecode slots 2026-04-21 13:20:27 +03:00
sergeych db3a780645 Generalize bytecode fast-call dispatch 2026-04-21 13:09:50 +03:00
sergeych fc7d26ee4b Fast-path bytecode statement execution 2026-04-21 11:39:47 +03:00
sergeych a61b5a31be Add non-suspending fast calls for bytecode callables 2026-04-21 11:35:20 +03:00
sergeych 33d170f525 Optimize fast-path bytecode lambda invocation 2026-04-21 11:29:14 +03:00
sergeych f72cdfdf83 Inline simple lambdas in bytecode fast paths 2026-04-21 09:05:18 +03:00
sergeych 10fa4de4fa regression fix 2026-04-20 18:48:28 +03:00
sergeych 4acee56de8 small optimization of List.fill 2026-04-20 14:09:09 +03:00
sergeych 87060c7eb7 +inference bugs
+List.ensureCapacity
optimized List.fill
2026-04-20 13:56:47 +03:00
sergeych 6ba128f7ba fixed some more inference bugs 2026-04-20 12:23:17 +03:00
sergeych a8f73dc8bd added LaunchPool 2026-04-18 23:37:21 +03:00
60 changed files with 4606 additions and 455 deletions

No files matched your search

+37 -15
View File
@@ -9,24 +9,46 @@ History note:
## Unreleased
### Database access
- Added the portable `lyng.io.db` SQL contract and the first concrete provider, `lyng.io.db.sqlite`.
- Added SQLite support on JVM and Linux Native with:
- generic `openDatabase("sqlite:...")` dispatch
- typed `openSqlite(...)` helper
- real nested transactions via savepoints
- generated keys through `ExecutionResult.getGeneratedKeys()`
- strict schema-driven value conversion for `Bool`, `Decimal`, `Date`, `DateTime`, and `Instant`
- documented option handling for `readOnly`, `createIfMissing`, `foreignKeys`, and `busyTimeoutMillis`
- Added public docs for database usage and SQLite provider behavior.
- No unreleased entries yet.
### Time
- Added `Date` to `lyng.time` and the core library as a first-class calendar-date type.
- Added `Instant.toDate(...)`, `DateTime.date`, `DateTime.toDate()`, `Date.toDateTime(...)`, and related date arithmetic.
- Added docs, stdlib reference updates, serialization support, and comprehensive tests for `Date`.
## 1.5.5 (2026-04-23)
### Concurrency and collections
- Added coroutine coordination primitives and helpers for everyday parallel code:
- `Channel` for coroutine-to-coroutine communication
- `LaunchPool` for bounded-concurrency task execution
- `Iterable<Deferred>.joinAll()` to await a whole collection of deferreds in input order
- `CompletableDeferred.completeExceptionally(...)` and `Deferred.cancelAndJoin()`
- Added docs and examples for the new concurrency APIs, including `joinAll()` coverage in iterable and parallelism references.
### Database and time APIs
- Added the portable `lyng.io.db` SQL contract and the first concrete providers:
- `lyng.io.db.sqlite` on JVM and Linux Native
- `lyng.io.db.jdbc` on JVM
- Added SQLite/JDBC release hardening:
- nested transactions via savepoints
- detached materialized rows
- generated-key support through `ExecutionResult.getGeneratedKeys()`
- schema-driven value conversion for `Bool`, `Decimal`, `Date`, `DateTime`, and `Instant`
- portable SQLite linker/deployment fixes and documented runtime options
- Added `Date` to `lyng.time` and the core runtime as a first-class calendar-date type, plus conversions and arithmetic across `Instant`, `DateTime`, and `Date`.
### Language, stdlib, and tooling
- Added extensions on singleton `object` declarations, including object-scoped indexer overrides for bracket syntax.
- Added backtick string literals and formatter support.
- Added `lyng.legacy_digest` for SHA-1 compatibility work, `String.replace`, and `buffer.base64std`.
- Improved CLI/runtime behavior with `atExit` shutdown handlers, native release-binary work, and follow-up CLI packaging/import fixes.
- Expanded docs across the tutorial, stdlib references, database docs, networking docs, and release notes.
### Runtime/compiler stability and performance
- Extended exact-call and higher-order lambda inlining through the bytecode compiler, including compiled fast paths for simple lambdas, wrappers, captures, and common higher-order helpers.
- Fixed import caching and class/object bytecode dispatch on JVM.
- Fixed immutable `val` compound assignments so true mutating `*Assign` operations continue to work while fallback reassignments report the correct read-only error.
- Fixed closure/capture and import regressions across launched loops, singleton/object extensions, aliasing, transitive re-exports, and immutable capture escaping.
- Improved list-fill/list-append fast paths, nullable-let inference, Decimal/Complex interop, and related regression coverage.
### Release notes
- Full `:lyngio:jvmTest` and `:lyngio:linuxX64Test` pass on the release tree after SQLite hardening.
- Release metadata, homepage samples, docs, and README now point to `1.5.5`.
## 1.5.4 (2026-04-03)
+3 -3
View File
@@ -48,7 +48,7 @@ assertEquals(A.E.One, A.One)
- [Language home](https://lynglang.com)
- [introduction and tutorial](docs/tutorial.md) - start here please
- [Latest release notes (1.5.4)](docs/whats_new.md)
- [Latest release notes (1.5.5)](docs/whats_new.md)
- [What's New in 1.5](docs/whats_new_1_5.md)
- [Testing and Assertions](docs/Testing.md)
- [Filesystem and Processes (lyngio)](docs/lyngio.md)
@@ -66,7 +66,7 @@ assertEquals(A.E.One, A.One)
### Add dependency to your project
```kotlin
val lyngVersion = "1.5.4"
val lyngVersion = "1.5.5"
repositories {
// ...
@@ -186,7 +186,7 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
# Language Roadmap
The current stable release is **v1.5.4**: the 1.5 cycle is feature-complete, compiler/runtime stabilization work is in, and the language, tooling, and site are aligned around the current release.
The current stable release is **v1.5.5**: the 1.5 cycle now includes the database/date/concurrency additions as well as the latest compiler/runtime stabilization work, and the language, tooling, and site are aligned around this release.
Ready features:
+14 -11
View File
@@ -18,10 +18,12 @@
#
upload_only=false
target=vps # default: new server; use --old for d.lynglang.com
for arg in "$@"; do
if [[ "$arg" == "-u" || "$arg" == "--upload-only" ]]; then
upload_only=true
break
elif [[ "$arg" == "--old" ]]; then
target=com
fi
done
@@ -88,19 +90,20 @@ function updateIdeaPluginDownloadLink() {
fi
}
# default target settings
case "com" in
# target settings (-t com | -t vps)
case "$target" in
com)
SSH_HOST=sergeych@d.lynglang.com # host to deploy to
SSH_PORT=22 # ssh port on it
ROOT=/bigstore/sergeych_pub/lyng # directory to rsync to
SSH_HOST=sergeych@d.lynglang.com
SSH_PORT=22
ROOT=/bigstore/sergeych_pub/lyng
;;
vps)
SSH_HOST=sergeych@94.130.36.94
SSH_PORT=22
ROOT=/var/www/lynglang
;;
# com)
# SSH_HOST=vvk@front-01.neurodatalab.com
# ROOT=/home/vvk
# ;;
*)
echo "*** ERROR: target not specified (use deploy com | dev)"
echo "*** ERROR: unknown target '$target' (use -t com | -t vps)"
echo "*** stop"
exit 101
esac
+18
View File
@@ -55,6 +55,23 @@ Here is the sample:
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
>>> void
## joinAll
`joinAll()` is an `Iterable<Deferred>` helper that awaits every deferred in iteration order and returns a `List`
with the collected results.
val jobs = (1..4).map { n ->
launch { n * n }
}
assertEquals([1, 4, 9, 16], jobs.joinAll())
>>> void
Notes:
- it does not start any task by itself; it only awaits the deferreds already present in the iterable.
- awaiting happens in iteration order, so the result list keeps the same order as the input iterable.
- if any deferred fails or was cancelled, that `await()` error is propagated from `joinAll()`.
## `sum` and `sumOf`
These, again, does the thing:
@@ -184,6 +201,7 @@ Search for the first element that satisfies the given predicate:
| sortedWith(comparator) | sort using a comparator that compares elements (1) |
| sortedBy(predicate) | sort by comparing results of the predicate function |
| joinToString(s,t) | convert iterable to string, see (2) |
| joinAll() | for `Iterable<Deferred>`, await all items in order and collect results to [List] |
| reversed() | create a list containing items from this in reverse order |
| shuffled() | create a list of shuffled elements |
+110
View File
@@ -0,0 +1,110 @@
# LaunchPool
`LaunchPool` is a bounded-concurrency task pool: you submit lambdas with `launch`, and the pool runs them using a fixed number of worker coroutines.
## Constructor
```
LaunchPool(maxWorkers, maxQueueSize = Channel.UNLIMITED)
```
| Parameter | Description |
|-----------|-------------|
| `maxWorkers` | Maximum number of tasks that run in parallel. |
| `maxQueueSize` | Maximum number of tasks that may wait in the queue. When the queue is full, `launch` suspends the caller until space becomes available. Defaults to `Channel.UNLIMITED` (no bound). |
## Methods
### `launch(lambda): Deferred`
Schedules `lambda` for execution and returns a `Deferred` for its result.
- Suspends if the queue is full (`maxQueueSize` reached).
- Throws `IllegalStateException` if the pool is already closed or cancelled.
- Any exception thrown by `lambda` is captured in the returned `Deferred` and **does not escape the pool**.
```lyng
val pool = LaunchPool(4)
val d1 = pool.launch { computeSomething() }
val d2 = pool.launch { computeOther() }
pool.closeAndJoin()
println(d1.await())
println(d2.await())
```
### `closeAndJoin()`
Stops accepting new tasks and suspends until all queued and running tasks complete normally. After this call, any further `launch` throws `IllegalStateException`. Idempotent — safe to call multiple times.
### `cancel()`
Immediately closes the queue and cancels all worker coroutines. Queued but unstarted tasks are discarded. After this call, `launch` throws `IllegalStateException`. Idempotent.
### `cancelAndJoin()`
Like `cancel()`, but also suspends until all worker coroutines have stopped. Useful when you need to be sure no worker code is still running before proceeding. Idempotent.
## Exception handling
Exceptions from submitted lambdas are captured per-task in the returned `Deferred`. The pool itself continues running after a task failure:
```lyng
val pool = LaunchPool(2)
val good = pool.launch { 42 }
val bad = pool.launch { throw IllegalArgumentException("boom") }
pool.closeAndJoin()
assertEquals(42, good.await())
assertThrows(IllegalArgumentException) { bad.await() }
```
## Bounded queue / back-pressure
When `maxQueueSize` is set, the producer suspends if the queue fills up, providing automatic back-pressure:
```lyng
// 1 worker, queue of 2 — producer can be at most 2 tasks ahead of what's running
val pool = LaunchPool(1, 2)
val d1 = pool.launch { delay(10); "a" }
val d2 = pool.launch { delay(10); "b" }
val d3 = pool.launch { delay(10); "c" } // suspends until d1 is picked up by the worker
pool.closeAndJoin()
```
## Collecting all results
`launch` returns a `Deferred`, so you can collect results with `joinAll()`:
```lyng
val pool = LaunchPool(4)
val jobs = (1..10).map { n -> pool.launch { n * n } }
pool.closeAndJoin()
val results = jobs.joinAll()
// results == [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
```
## Concurrency limit in practice
With `maxWorkers = 2`, at most 2 tasks run simultaneously regardless of how many are queued:
```lyng
val mu = Mutex()
var active = 0
var maxSeen = 0
val pool = LaunchPool(2)
(1..8).map {
pool.launch {
mu.withLock { active++; if (active > maxSeen) maxSeen = active }
delay(5)
mu.withLock { active-- }
}
}
pool.closeAndJoin()
assert(maxSeen <= 2)
```
## See also
- [parallelism.md](parallelism.md) — `launch`, `Deferred`, `Mutex`, `Channel`, and coroutine basics
- [Channel.md](Channel.md) — the underlying channel primitive used by `LaunchPool`
+7
View File
@@ -175,6 +175,8 @@ List could be sorted in place, just like [Collection] provide sorted copies, in
| `[Range]` | get slice of the array (copy) | Range |
| `+=` | append element(s) (2) | List or Obj |
| `List.fill(size, block)` | build a new list from indices `0..<size` | Int, Callable |
| `List.fill(size,capacity,block)` | same, pre-allocating capacity slots | Int, Int, Callable |
| `ensureCapacity(count)` | pre-allocate storage for at least `count` elements without reallocation (5) | Int |
| `sort()` | in-place sort, natural order | void |
| `sortBy(predicate)` | in-place sort bu `predicate` call result (3) | void |
| `sortWith(comparator)` | in-place sort using `comarator` function (4) | void |
@@ -197,6 +199,11 @@ order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
positive if first is greater, and zero if they are equal. For example, the equvalent comparator
for `sort()` will be `sort { a, b -> a <=> b }
(5)
: if the current capacity is already ≥ `count`, this is a no-op. Otherwise the internal storage
is reallocated to hold at least `count` elements. Use this before a bulk `+=` loop to avoid
repeated reallocations. `List.fill(size, capacity, block)` calls this automatically.
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
## Observable list hooks
+1
View File
@@ -18,6 +18,7 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- `Deferred.cancel()` cancels an active task.
- `Deferred.await()` throws `CancellationException` if that task was cancelled.
- `Iterable<Deferred>.joinAll()` awaits every deferred in iteration order and returns a `List` of results.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
- These helpers also accept `lyng.decimal.Decimal`.
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
+32
View File
@@ -36,6 +36,17 @@ This example shows how to launch a coroutine with `launch` which returns [Deferr
Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
When you have an iterable of deferreds, use `joinAll()` to await all of them and collect results in input order:
val jobs = (1..4).map { n ->
launch {
delay(1)
n * 10
}
}
assertEquals([10, 20, 30, 40], jobs.joinAll())
>>> void
If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
var reached = false
@@ -257,6 +268,27 @@ Channels can also be buffered so the producer can run ahead:
For the full API — including `tryReceive`, `Channel.UNLIMITED`, and the fan-out / ping-pong patterns — see the [Channel] reference page.
## LaunchPool
When you need **bounded concurrency** — run at most *N* tasks at the same time without spawning a new coroutine per task — use [LaunchPool]:
```lyng
val pool = LaunchPool(4) // at most 4 tasks run in parallel
val jobs = (1..20).map { n ->
pool.launch { expensiveCompute(n) }
}
pool.closeAndJoin() // wait for all tasks to complete
val results = jobs.joinAll()
```
Exceptions thrown inside a submitted lambda are captured in the returned `Deferred` and do not crash the pool, so other tasks continue running normally.
See [LaunchPool] for the full API including bounded queues and cancellation.
[LaunchPool]: LaunchPool.md
| | Flow | Channel |
|---|---|---|
| **temperature** | cold (lazy) | hot (eager) |
+11 -8
View File
@@ -1,26 +1,29 @@
# What's New in Lyng
This document highlights the current Lyng release, **1.5.4**, and the broader additions from the 1.5 cycle.
This document highlights the current Lyng release, **1.5.5**, and the broader additions from the 1.5 cycle.
It is intentionally user-facing: new language features, new modules, new tools, and the practical things you can build with them.
For a programmer-focused migration summary across 1.5.x, see `docs/whats_new_1_5.md`.
## Release 1.5.4 Highlights
## Release 1.5.5 Highlights
- `1.5.4` is the stabilization release for the 1.5 feature set.
- `1.5.5` extends the 1.5 line with practical database APIs, first-class calendar dates, and better coroutine building blocks.
- The 1.5 line now brings together richer ranges and loops, interpolation, math modules, immutable and observable collections, richer `lyngio`, and much better CLI/IDE support.
- `1.5.4` specifically fixes user-visible issues around decimal arithmetic, mixed numeric flows, list behavior, and observable list hooks.
- `1.5.4` also fixes extension-member registration for named singleton `object` declarations, so `fun X.foo()` and `val X.bar` now work as expected.
- `1.5.4` also lets named singleton `object` declarations use scoped indexer extensions with bracket syntax, so patterns like `Storage["name"]` can be implemented with `override fun Storage.getAt(...)` / `putAt(...)`.
- `1.5.5` adds `Channel`, `LaunchPool`, and `joinAll()` so coroutine-heavy scripts can coordinate work more directly.
- `1.5.5` adds `Date`, the portable `lyng.io.db` layer, SQLite/JDBC providers, and a compatibility `lyng.legacy_digest` module.
- `1.5.5` also continues runtime/compiler hardening with better import dispatch, faster exact lambda calls, and correct `val +=`/`-=` behavior for mutating types versus real reassignment.
- The docs, homepage samples, and release metadata now point at the current stable version.
## User Highlights Across 1.5.x
- Descending ranges and loops with `downTo` / `downUntil`
- String interpolation with `$name` and `${expr}`
- Backtick string literals for raw-ish string text
- Decimal arithmetic, matrices/vectors, and complex numbers
- Calendar `Date` support in `lyng.time`
- `Channel`, `LaunchPool`, and `joinAll()` for coroutine workflows
- Immutable collections and opt-in `ObservableList`
- Rich `lyngio` modules for SQLite databases, console, HTTP, WebSocket, TCP, and UDP
- Rich `lyngio` modules for SQLite/JDBC databases, console, HTTP, WebSocket, TCP, and UDP
- Legacy SHA-1 compatibility helpers in `lyng.legacy_digest`
- CLI improvements including the built-in formatter `lyng fmt`
- Better IDE support and stronger docs around the released feature set
@@ -324,7 +327,7 @@ Singleton objects are declared using the `object` keyword. They provide a conven
```lyng
object Config {
val version = "1.5.4"
val version = "1.5.5"
fun show() = println("Config version: " + version)
}
View File
Whitespace-only changes.
+15
View File
@@ -0,0 +1,15 @@
import lyng.time
val n = 700_000
fun tm<T>(block: ()->T): T {
val t = Instant()
block().also {
println("tm: ${Instant() - t}")
}
}
val x = tm { List.fill(n) { it * 10 + 1 } }
val y = tm { List.fill(n, n + 10) { it * 10 + 1 } }
tm { x.add(-1) }
tm { y.add(-2) }
+2
View File
@@ -0,0 +1,2 @@
[vps]
94.130.36.94 ansible_user=sergeych
+100
View File
@@ -0,0 +1,100 @@
---
- name: Setup lynglang.com static site on VPS
hosts: vps
become: yes
vars:
domain: lynglang.com
web_root: /var/www/lynglang
deploy_user: sergeych
certbot_email: real.sergeych@gmail.com
tasks:
# Debian 10 buster is EOL; security/backports repos moved to archive.debian.org
- name: Fix sources.list for Debian buster EOL
copy:
dest: /etc/apt/sources.list
content: |
deb http://archive.debian.org/debian/ buster main contrib non-free
deb http://archive.debian.org/debian-security/ buster/updates main contrib non-free
deb http://archive.debian.org/debian/ buster-backports main contrib non-free
- name: Remove stale third-party sources (broken for buster EOL)
file:
path: "/etc/apt/sources.list.d/{{ item }}"
state: absent
loop:
- cassandra.list
- icinga.list
- postgres.list
- salt-stack.list
- yarn.list
- name: Install nginx, certbot, and python3-certbot-nginx
apt:
name:
- nginx
- certbot
- python3-certbot-nginx
state: present
update_cache: yes
- name: Create web root directory
file:
path: "{{ web_root }}/release/dist"
state: directory
owner: "{{ deploy_user }}"
group: www-data
mode: "0755"
recurse: yes
- name: Create distributables directory
file:
path: "{{ web_root }}/release/dist/distributables"
state: directory
owner: "{{ deploy_user }}"
group: www-data
mode: "0755"
- name: Deploy nginx site config (HTTP, pre-certbot)
template:
src: templates/nginx_lynglang.conf.j2
dest: /etc/nginx/sites-available/{{ domain }}
notify: reload nginx
- name: Enable nginx site
file:
src: /etc/nginx/sites-available/{{ domain }}
dest: /etc/nginx/sites-enabled/{{ domain }}
state: link
notify: reload nginx
- name: Disable default nginx site
file:
path: /etc/nginx/sites-enabled/default
state: absent
notify: reload nginx
- name: Ensure nginx is started
service:
name: nginx
state: started
enabled: yes
- name: Reload nginx before certbot
meta: flush_handlers
- name: Obtain SSL certificate via certbot (--nginx plugin)
command: >
certbot --nginx
-d {{ domain }} -d www.{{ domain }}
--non-interactive --agree-tos
--email {{ certbot_email }}
--redirect
args:
creates: /etc/letsencrypt/live/{{ domain }}/fullchain.pem
handlers:
- name: reload nginx
service:
name: nginx
state: reloaded
+24
View File
@@ -0,0 +1,24 @@
server {
listen 80;
server_name {{ domain }} www.{{ domain }};
root {{ web_root }}/release/dist;
index index.html;
# SPA fallback
location / {
try_files $uri $uri/ /index.html;
}
# Distributables served directly
location /distributables/ {
try_files $uri =404;
autoindex on;
}
# Long-lived cache for hashed assets
location ~* \.(js|css|woff2?|ttf|eot|svg|png|jpg|ico)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
}
+1 -4
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych"
version = "1.5.5-SNAPSHOT"
version = "1.5.5"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -302,8 +302,6 @@ android {
}
}
dependencies {
implementation(libs.firebase.crashlytics.buildtools)
implementation(libs.compiler)
}
publishing {
@@ -345,7 +343,6 @@ tasks.withType<org.gradle.api.tasks.testing.Test> {
// Make the flag visible inside tests if they want to branch on it
systemProperty("LYNG_BENCHMARKS", benchmarksEnabled.toString())
if (!benchmarksEnabled) {
// Exclude all JVM tests whose class name ends with or contains BenchmarkTest
// This keeps CI fast and avoids noisy timing logs by default.
@@ -434,6 +434,57 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
}
}
fun supportsFastFrameBinding(arguments: Arguments): Boolean {
if (arguments.named.isNotEmpty() || arguments.tailBlockMode) return false
return params.none { it.isEllipsis || it.defaultValue != null }
}
fun assignToFrameFast(
scope: Scope,
arguments: Arguments = scope.args,
paramSlotPlan: Map<String, Int>,
frame: FrameAccess,
slotOffset: Int = 0
) {
if (!supportsFastFrameBinding(arguments)) {
scope.raiseIllegalState("fast frame binding is not supported for this call shape")
}
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 assign(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)
}
}
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 slot = slotFor(params[i].name)
val value = if (i < arguments.list.size) arguments.list[i] else ObjNull
assign(slot, value.byValueCopy())
}
}
/**
* Single argument declaration descriptor.
*
@@ -16,4 +16,12 @@
package net.sergeych.lyng
interface BytecodeCallable
import net.sergeych.lyng.obj.Obj
interface BytecodeCallable {
fun callOnFast(scope: Scope): Obj? = null
}
interface BytecodeArgCallable {
fun callWithArgsFast(scope: Scope, args: Arguments): Obj? = null
}
@@ -28,6 +28,7 @@ internal suspend fun executeBytecodeWithSeed(scope: Scope, stmt: Statement, labe
else -> null
} ?: scope.raiseIllegalState("$label requires bytecode statement")
scope.pos = bytecode.pos
bytecode.callOnFast(scope)?.let { return it }
return CmdVm().execute(bytecode.bytecodeFunction(), scope, scope.args) { frame, _ ->
seedFrameLocalsFromScope(frame, scope)
}
@@ -20,5 +20,30 @@ package net.sergeych.lyng
* Compile-time call metadata for known functions. Used to select lambda receiver semantics.
*/
data class CallSignature(
val tailBlockReceiverType: String? = null
)
val tailBlockReceiverType: String? = null,
val inlineHigherOrder: HigherOrderInline? = null
) {
data class HigherOrderInline(
val kind: Kind,
val result: ResultMode,
val argCount: Int = 1,
val lambdaArgIndex: Int = 0
)
enum class Kind {
UNARY_ARGUMENT,
RECEIVER,
ITERABLE,
MAP_GET_OR_PUT
}
enum class ResultMode {
BLOCK_RESULT,
RETURN_RECEIVER,
FOR_EACH,
MAP,
FILTER,
MAP_NOT_NULL,
ASSOCIATE_BY
}
}
@@ -1,5 +1,5 @@
/*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -24,7 +24,10 @@ sealed class CodeContext {
val implicitThisMembers: Boolean = false,
val implicitThisTypeName: String? = null,
val typeParams: Set<String> = emptySet(),
val typeParamDecls: List<TypeDecl.TypeParam> = emptyList()
val typeParamDecls: List<TypeDecl.TypeParam> = emptyList(),
/** True for static methods and top-level functions: they have no implicit `this`,
* so class-body field initializers inside them should not inherit the class name. */
val noImplicitThis: Boolean = false
): CodeContext()
class ClassBody(val name: String, val isExtern: Boolean = false): CodeContext() {
var typeParams: Set<String> = emptySet()
@@ -187,7 +187,9 @@ class Compiler(
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val callableReturnTypeDeclByName: MutableMap<String, TypeDecl> = mutableMapOf()
private val callSignatureByName: MutableMap<String, CallSignature> = mutableMapOf()
private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
private val exactLambdaRefByScopeId: MutableMap<Int, MutableMap<Int, LambdaFnRef>> = mutableMapOf()
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
mutableMapOf()
private val classFieldTypesByName: MutableMap<String, MutableMap<String, ObjClass>> = mutableMapOf()
@@ -264,6 +266,11 @@ class Compiler(
if (plan.slots.containsKey(name)) continue
declareSlotNameIn(plan, name, record.isMutable, record.type == ObjRecord.Type.Delegated)
scopeSeedNames.add(name)
record.callSignature?.let { signature ->
if (!callSignatureByName.containsKey(name)) {
callSignatureByName[name] = signature
}
}
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
if (nameObjClass[name] == null) {
@@ -290,6 +297,11 @@ class Compiler(
)
scopeSeedNames.add(getterName)
}
record.callSignature?.let { signature ->
if (!callSignatureByName.containsKey(getterName)) {
callSignatureByName[getterName] = signature
}
}
val prop = record.value as? ObjProperty
if (prop?.setter != null) {
val setterName = extensionPropertySetterName(cls.className, name)
@@ -315,6 +327,11 @@ class Compiler(
)
scopeSeedNames.add(callableName)
}
record.callSignature?.let { signature ->
if (!callSignatureByName.containsKey(callableName)) {
callSignatureByName[callableName] = signature
}
}
}
}
}
@@ -346,6 +363,11 @@ class Compiler(
record.type == ObjRecord.Type.Delegated
)
scopeSeedNames.add(name)
record.callSignature?.let { signature ->
if (!callSignatureByName.containsKey(name)) {
callSignatureByName[name] = signature
}
}
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
if (nameObjClass[name] == null) {
@@ -761,6 +783,29 @@ class Compiler(
?: importManager.rootScope.getLocalRecordDirect(name)?.callSignature
}
private fun declaredCallSignature(name: String, extTypeName: String?, actualExtern: Boolean): CallSignature? {
val imported = if (actualExtern) {
importManager.rootScope.getLocalRecordDirect(name)?.callSignature
} else {
null
}
val inferred = when {
extTypeName == "Iterable" && name == "filter" -> CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.ITERABLE,
result = CallSignature.ResultMode.FILTER
)
)
else -> null
}
return when {
imported == null -> inferred
inferred == null -> imported
imported.inlineHigherOrder != null -> imported
else -> imported.copy(inlineHigherOrder = inferred.inlineHigherOrder)
}
}
internal data class MemberIds(val fieldId: Int?, val methodId: Int?)
private fun resolveMemberIds(name: String, pos: Pos, qualifier: String? = null): MemberIds {
@@ -812,8 +857,18 @@ class Compiler(
private fun currentImplicitThisTypeName(): String? {
for (ctx in codeContexts.asReversed()) {
val fn = ctx as? CodeContext.Function ?: continue
if (fn.implicitThisTypeName != null) return fn.implicitThisTypeName
when (ctx) {
is CodeContext.Function -> {
if (ctx.implicitThisTypeName != null) return ctx.implicitThisTypeName
// A static method or top-level function explicitly has no implicit `this`.
// Stop here — do not fall through to an enclosing ClassBody.
if (ctx.noImplicitThis) return null
}
// Class field initializers are compiled directly under ClassBody with no wrapping
// Function. Lambdas inside those initializers must still see `this` as the class.
is CodeContext.ClassBody -> return ctx.name
else -> {}
}
}
return null
}
@@ -1418,6 +1473,11 @@ class Compiler(
}
private fun seedImportTypeMetadata(name: String, record: ObjRecord) {
record.callSignature?.let { signature ->
if (!callSignatureByName.containsKey(name)) {
callSignatureByName[name] = signature
}
}
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
}
@@ -1884,14 +1944,16 @@ class Compiler(
forcedLocalSlotInfo = forcedLocalInfo,
forcedLocalScopeId = forcedLocalScopeId,
slotTypeByScopeId = slotTypeByScopeId,
exactLambdaRefByScopeId = exactLambdaRefByScopeId,
slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownClassMapForBytecode(),
knownClassNames = knownClassNamesForBytecode(),
knownObjectNames = objectDeclNames,
knownObjectNames = knownObjectNamesForBytecode(),
classFieldTypesByName = classFieldTypesByName,
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
callSignatureByName = callSignatureByName,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
@@ -2086,12 +2148,19 @@ class Compiler(
plan.captureOwners[name] = slotLoc
plan.captures += capture
if (!plan.slotPlan.slots.containsKey(name)) {
val newSlot = plan.slotPlan.nextIndex
plan.slotPlan.slots[name] = SlotEntry(
plan.slotPlan.nextIndex,
newSlot,
isMutable = slotLoc.isMutable,
isDelegated = slotLoc.isDelegated
)
plan.slotPlan.nextIndex += 1
slotTypeByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { cls ->
slotTypeByScopeId.getOrPut(plan.slotPlan.id) { mutableMapOf() }[newSlot] = cls
}
slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { decl ->
slotTypeDeclByScopeId.getOrPut(plan.slotPlan.id) { mutableMapOf() }[newSlot] = decl
}
}
}
@@ -2208,6 +2277,23 @@ class Compiler(
return result
}
private fun knownObjectNamesForBytecode(): Set<String> {
val result = LinkedHashSet<String>()
fun addScope(scope: Scope?) {
if (scope == null) return
for ((name, rec) in scope.objects) {
if (rec.value is ObjInstance) result.add(name)
}
}
addScope(seedScope)
addScope(importManager.rootScope)
for (module in importedModules) {
addScope(module.scope)
}
result.addAll(objectDeclNames)
return result
}
private fun wrapBytecode(stmt: Statement): Statement {
if (codeContexts.lastOrNull() is CodeContext.Module) return stmt
if (codeContexts.lastOrNull() is CodeContext.ClassBody) return stmt
@@ -2232,14 +2318,16 @@ class Compiler(
scopeSlotNameSet = scopeSlotNameSet,
moduleScopeId = moduleScopeId,
slotTypeByScopeId = slotTypeByScopeId,
exactLambdaRefByScopeId = exactLambdaRefByScopeId,
slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownClassMapForBytecode(),
knownClassNames = knownClassNamesForBytecode(),
knownObjectNames = objectDeclNames,
knownObjectNames = knownObjectNamesForBytecode(),
classFieldTypesByName = classFieldTypesByName,
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
callSignatureByName = callSignatureByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
@@ -2265,14 +2353,16 @@ class Compiler(
scopeSlotNameSet = scopeSlotNameSet,
moduleScopeId = moduleScopeId,
slotTypeByScopeId = slotTypeByScopeId,
exactLambdaRefByScopeId = exactLambdaRefByScopeId,
slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownClassMapForBytecode(),
knownClassNames = knownClassNamesForBytecode(),
knownObjectNames = objectDeclNames,
knownObjectNames = knownObjectNamesForBytecode(),
classFieldTypesByName = classFieldTypesByName,
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
callSignatureByName = callSignatureByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
@@ -2323,14 +2413,16 @@ class Compiler(
globalSlotInfo = globalSlotInfo,
globalSlotScopeId = globalSlotScopeId,
slotTypeByScopeId = slotTypeByScopeId,
exactLambdaRefByScopeId = exactLambdaRefByScopeId,
slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownNames,
knownClassNames = knownClassNamesForBytecode(),
knownObjectNames = objectDeclNames,
knownObjectNames = knownObjectNamesForBytecode(),
classFieldTypesByName = classFieldTypesByName,
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
callSignatureByName = callSignatureByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
@@ -3407,6 +3499,10 @@ class Compiler(
index < expectedParams.size
) {
expectedParams[index]
} else if (param.type == TypeDecl.TypeAny && index == 0 && argsDeclaration.params.size == 1 &&
implicitItType != null
) {
implicitItType
} else {
param.type
}
@@ -3518,14 +3614,91 @@ class Compiler(
body
}
val bytecodeFn = (fnStatements as? BytecodeStatement)?.bytecodeFunction()
val inlineBodyRef = argsDeclaration?.let { null } ?: extractInlineLambdaBodyRef(body)
val supportsDirectInvokeFastPath = bytecodeFn != null &&
bytecodeFn.scopeSlotCount == 0 &&
expectedReceiverType == null &&
!wrapAsExtensionCallable &&
!containsDelegatedRefs(body)
val ref = LambdaFnRef(
valueFn = { closureScope ->
val captureRecords = closureScope.captureRecords
val stmt = object : Statement(), BytecodeBodyProvider {
val stmt = object : Statement(), BytecodeBodyProvider, BytecodeCallable {
override val pos: Pos = fnStatements.pos
override fun bytecodeBody(): BytecodeStatement? = fnStatements as? BytecodeStatement
override fun callOnFast(scope: Scope): Obj? {
val context = scope.applyClosureForBytecode(closureScope, preferredThisType = expectedReceiverType).also {
it.args = scope.args
}
if (captureSlots.isNotEmpty()) {
if (captureRecords != null) {
context.captureRecords = captureRecords
context.captureNames = captureSlots.map { it.name }
} else {
val resolvedRecords = ArrayList<ObjRecord>(captureSlots.size)
val resolvedNames = ArrayList<String>(captureSlots.size)
for (capture in captureSlots) {
val rec = resolveStableCaptureRecord(
closureScope,
capture.name,
context.currentClassCtx
) ?: closureScope.raiseSymbolNotFound("symbol ${capture.name} not found")
resolvedRecords.add(freezeImmutableCaptureRecord(rec))
resolvedNames.add(capture.name)
}
context.captureRecords = resolvedRecords
context.captureNames = resolvedNames
}
}
val bytecodeBody = fnStatements as? BytecodeStatement ?: return null
val bytecodeFn = bytecodeBody.bytecodeFunction()
if (!supportsDirectInvokeFastPath || !bytecodeFn.fastOnly) return null
val fastPreboundNames = if (argsDeclaration == null) {
setOf("it")
} else {
argsDeclaration.params.mapTo(LinkedHashSet()) { it.name }
}
val declaredNames = bytecodeFn.constants
.mapNotNull { it as? BytecodeConst.LocalDecl }
.mapTo(mutableSetOf()) { it.name }
if (!canFastSeedUndeclaredLocals(bytecodeFn, declaredNames, fastPreboundNames)) return null
if (argsDeclaration != null && !argsDeclaration.supportsFastFrameBinding(scope.args)) return null
val slotPlan = bytecodeFn.localSlotPlanByName()
val binder: (net.sergeych.lyng.bytecode.CmdFrame, Arguments) -> Unit = { frame, arguments ->
if (argsDeclaration == null) {
val l = arguments.list
val itValue: Obj = when (l.size) {
0 -> ObjVoid
1 -> l[0]
else -> ObjList(l.toMutableList())
}
val itSlot = slotPlan["it"]
if (itSlot != null) {
when (itValue) {
is ObjInt -> frame.frame.setInt(itSlot, itValue.value)
is ObjReal -> frame.frame.setReal(itSlot, itValue.value)
is ObjBool -> frame.frame.setBool(itSlot, itValue.value)
else -> frame.frame.setObj(itSlot, itValue)
}
}
} else {
argsDeclaration.assignToFrameFast(
context,
arguments,
slotPlan,
frame.frame
)
}
}
return try {
net.sergeych.lyng.bytecode.CmdVm().executeFastOnlyNoSuspend(bytecodeFn, context, scope.args, binder)
} catch (e: ReturnException) {
if (e.label == null || returnLabels.contains(e.label)) e.result else throw e
}
}
override suspend fun execute(scope: Scope): Obj {
val context = scope.applyClosureForBytecode(closureScope, preferredThisType = expectedReceiverType).also {
it.args = scope.args
@@ -3600,6 +3773,8 @@ class Compiler(
argsDeclaration = argsDeclaration,
captureEntries = captureEntries,
inferredReturnClass = returnClass,
inlineBodyRef = inlineBodyRef,
supportsDirectInvokeFastPath = supportsDirectInvokeFastPath,
preferredThisType = expectedReceiverType,
wrapAsExtensionCallable = wrapAsExtensionCallable,
returnLabels = returnLabels,
@@ -3614,6 +3789,18 @@ class Compiler(
return ref
}
private fun extractInlineLambdaBodyRef(statement: Statement): ObjRef? {
val target = if (statement is BytecodeStatement) statement.original else statement
return when (target) {
is ExpressionStatement -> target.ref
is BlockStatement -> {
val statements = target.statements()
if (statements.size == 1) extractInlineLambdaBodyRef(statements[0]) else null
}
else -> null
}
}
private suspend fun parseArrayLiteral(): List<ListEntry> {
// it should be called after Token.Type.LBRACKET is consumed
val entries = mutableListOf<ListEntry>()
@@ -4947,6 +5134,26 @@ class Compiler(
?: slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { resolveTypeDeclObjClass(it) }
}
private fun lookupExactLambdaRefByName(name: String): LambdaFnRef? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return exactLambdaRefByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
}
private fun resolveExactLambdaRef(ref: ObjRef?): LambdaFnRef? {
return when (ref) {
is LambdaFnRef -> ref
is LocalVarRef -> lookupExactLambdaRefByName(ref.name)
is FastLocalVarRef -> lookupExactLambdaRefByName(ref.name)
is LocalSlotRef -> {
val ownerScopeId = ref.captureOwnerScopeId ?: ref.scopeId
val ownerSlot = ref.captureOwnerSlot ?: ref.slot
exactLambdaRefByScopeId[ownerScopeId]?.get(ownerSlot)
?: ref.name.takeIf { it.isNotEmpty() }?.let(::lookupExactLambdaRefByName)
}
else -> null
}
}
private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? {
return when (ref) {
is LocalSlotRef -> {
@@ -9071,7 +9278,7 @@ class Compiler(
val extensionWrapperName = extTypeName?.let { extensionCallableName(it, name) }
val classCtx = codeContexts.asReversed().firstOrNull { it is CodeContext.ClassBody } as? CodeContext.ClassBody
var memberMethodId = if (extTypeName == null) classCtx?.memberMethodIds?.get(name) else null
val externCallSignature = if (actualExtern) importManager.rootScope.getLocalRecordDirect(name)?.callSignature else null
val externCallSignature = declaredCallSignature(name, extTypeName, actualExtern)
val declKind = if (parentContext is CodeContext.ClassBody) SymbolKind.MEMBER else SymbolKind.FUNCTION
resolutionSink?.declareSymbol(name, declKind, isMutable = false, pos = nameStartPos, isOverride = isOverride)
@@ -9093,7 +9300,9 @@ class Compiler(
}
if (extensionWrapperName != null) {
declareLocalName(extensionWrapperName, isMutable = false)
externCallSignature?.let { callSignatureByName[extensionWrapperName] = it }
}
externCallSignature?.let { callSignatureByName[name] = it }
if (actualExtern && declKind != SymbolKind.MEMBER) {
externCallableNames.add(name)
}
@@ -9214,13 +9423,17 @@ class Compiler(
parentContext is CodeContext.ClassBody && !isStatic -> parentContext.name
else -> null
}
// Static methods and top-level functions have no implicit `this`; mark them so that
// currentImplicitThisTypeName() does not fall through to an enclosing ClassBody.
val noImplicitThis = implicitThisTypeName == null && extTypeName == null
return inCodeContext(
CodeContext.Function(
name,
implicitThisMembers = implicitThisMembers,
implicitThisTypeName = implicitThisTypeName,
typeParams = typeParams,
typeParamDecls = typeParamDecls
typeParamDecls = typeParamDecls,
noImplicitThis = noImplicitThis
)
) {
cc.labels.add(name)
@@ -9372,9 +9585,8 @@ class Compiler(
val fnBody = object : Statement(), BytecodeBodyProvider {
override val pos: Pos = start
override fun bytecodeBody(): BytecodeStatement? = fnStatements as? BytecodeStatement
override suspend fun execute(scope: Scope): Obj {
scope.pos = start
override suspend fun execute(scope: Scope): Obj {
// restore closure where the function was defined, and making a copy of it
// for local space. If there is no closure, we are in, say, class context where
// the closure is in the class initialization and we needn't more:
@@ -9383,6 +9595,7 @@ class Compiler(
it.args = scope.args
}
} ?: scope
context.pos = start
// Capacity hint: parameters + declared locals + small overhead
val capacityHint = paramNames.size + fnLocalDecls + 4
@@ -10332,6 +10545,9 @@ class Compiler(
if (initClass != null) {
classFieldTypesByName.getOrPut(declaringClassNameCaptured) { mutableMapOf() }[name] = initClass
}
if (!isDelegate && varTypeDecl is TypeDecl.Generic) {
classMemberTypeDeclByName.getOrPut(declaringClassNameCaptured) { mutableMapOf() }[name] = varTypeDecl
}
}
// Emit MiniValDecl for this declaration (before execution wiring), attach doc if any
@@ -10387,6 +10603,15 @@ class Compiler(
encodedPayloadTypeByName[name] = payloadClass
}
}
if (slotIndex != null && scopeId != null) {
val exactLambdaRef = if (!isMutable) resolveExactLambdaRef(directRef) else null
val scopeMap = exactLambdaRefByScopeId.getOrPut(scopeId) { mutableMapOf() }
if (exactLambdaRef != null) {
scopeMap[slotIndex] = exactLambdaRef
} else {
scopeMap.remove(slotIndex)
}
}
if (initObjClass != null) {
if (slotIndex != null && scopeId != null) {
slotTypeByScopeId.getOrPut(scopeId) { mutableMapOf() }[slotIndex] = initObjClass
@@ -118,7 +118,14 @@ internal suspend fun executeFunctionDecl(
scope.addExtension(
type,
spec.name,
ObjRecord(ObjUnset, isMutable = false, visibility = spec.visibility, declaringClass = null, type = ObjRecord.Type.Delegated).apply {
ObjRecord(
ObjUnset,
isMutable = false,
visibility = spec.visibility,
declaringClass = null,
type = ObjRecord.Type.Delegated,
callSignature = spec.externCallSignature
).apply {
delegate = finalDelegate
}
)
@@ -135,7 +142,8 @@ internal suspend fun executeFunctionDecl(
null,
spec.startPos,
isTransient = spec.isTransient,
type = ObjRecord.Type.Delegated
type = ObjRecord.Type.Delegated,
callSignature = spec.externCallSignature
).apply {
delegate = finalDelegate
}
@@ -204,6 +212,7 @@ internal suspend fun executeFunctionDecl(
visibility = spec.visibility,
pos = spec.startPos,
type = ObjRecord.Type.Fun,
callSignature = spec.externCallSignature,
)
} else {
scope.addExtension(
@@ -215,6 +224,7 @@ internal suspend fun executeFunctionDecl(
visibility = spec.visibility,
declaringClass = null,
type = ObjRecord.Type.Fun,
callSignature = spec.externCallSignature,
typeDecl = spec.typeDecl
)
)
@@ -227,6 +237,7 @@ internal suspend fun executeFunctionDecl(
wrapper,
spec.visibility,
recordType = ObjRecord.Type.Fun,
callSignature = spec.externCallSignature,
typeDecl = spec.typeDecl
)
} ?: run {
@@ -245,7 +256,8 @@ internal suspend fun executeFunctionDecl(
isOverride = spec.isOverride,
type = ObjRecord.Type.Fun,
methodId = spec.memberMethodId,
typeDecl = spec.typeDecl
typeDecl = spec.typeDecl,
callSignature = spec.externCallSignature
)
val memberValue = cls.members[spec.name]?.value ?: compiledFnBody
scope.addItem(
@@ -66,7 +66,11 @@ internal class ScopeBridge(internal val scope: Scope) : ScopeFacade {
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))
if (newThisObj == null) {
(callee as? BytecodeArgCallable)?.callWithArgsFast(scope, args)?.let { return it }
}
val child = scope.createChildScope(scope.pos, args = args, newThisObj = newThisObj)
return (callee as? BytecodeCallable)?.callOnFast(child) ?: callee.callOn(child)
}
override suspend fun toStringOf(obj: Obj, forInspect: Boolean): ObjString = obj.toString(scope, forInspect)
override suspend fun inspect(obj: Obj): String = obj.inspect(scope)
@@ -108,11 +108,7 @@ class Script(
seedImportBindings(scope, seedScope)
}
if (moduleSlotPlan.isNotEmpty()) {
scope.applySlotPlan(moduleSlotPlan)
for (name in moduleSlotPlan.keys) {
val record = scope.objects[name] ?: scope.localBindings[name] ?: continue
scope.updateSlotFor(name, record)
}
installModuleSlotPlan(scope)
}
}
@@ -120,12 +116,26 @@ class Script(
if (importBindings.isEmpty() && importedModules.isEmpty()) return
seedImportBindings(scope, seedScope)
if (moduleSlotPlan.isNotEmpty()) {
scope.applySlotPlan(moduleSlotPlan)
for (name in moduleSlotPlan.keys) {
val record = scope.objects[name] ?: scope.localBindings[name] ?: continue
scope.updateSlotFor(name, record)
installModuleSlotPlan(scope)
}
}
private fun installModuleSlotPlan(scope: Scope) {
for ((name, index) in moduleSlotPlan) {
if (scope.getSlotIndexOf(name) != null) continue
if (scope.hasSlotPlanConflict(mapOf(name to index))) {
val record = scope.objects[name]
?: scope.localBindings[name]
?: ObjRecord(ObjUnset, isMutable = true)
scope.allocateSlotFor(name, record)
} else {
scope.applySlotPlan(mapOf(name to index))
}
}
for (name in moduleSlotPlan.keys) {
val record = scope.objects[name] ?: scope.localBindings[name] ?: continue
scope.updateSlotFor(name, record)
}
}
private suspend fun seedModuleLocals(
File diff suppressed because it is too large. Load diff
@@ -40,6 +40,7 @@ sealed class BytecodeConst {
val captureNames: List<String>,
val paramSlotPlan: Map<String, Int>,
val argsDeclaration: ArgsDeclaration?,
val supportsDirectInvokeFastPath: Boolean,
val preferredThisType: String?,
val wrapAsExtensionCallable: Boolean,
val returnLabels: Set<String>,
@@ -18,27 +18,41 @@
package net.sergeych.lyng.bytecode
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ValueFnRef
import net.sergeych.lyng.obj.*
class BytecodeStatement private constructor(
val original: Statement,
private val function: CmdFunction,
) : Statement(original.isStaticConst, original.isConst, original.returnType) {
) : Statement(original.isStaticConst, original.isConst, original.returnType), BytecodeCallable {
override val pos: Pos = original.pos
private val declaredLocalNames: Set<String> by lazy(LazyThreadSafetyMode.NONE) {
function.constants
.mapNotNull { it as? BytecodeConst.LocalDecl }
.mapTo(mutableSetOf()) { it.name }
}
override fun callOnFast(scope: Scope): Obj? {
scope.pos = pos
if (!function.fastOnly) return null
if (!canFastSeedUndeclaredLocals(function, declaredLocalNames, emptySet())) return null
val binder: (CmdFrame, Arguments) -> Unit = { frame, _ ->
if (!trySeedFrameLocalsFromScopeFast(frame, scope)) {
scope.raiseIllegalState("fast local seeding is not available")
}
}
return CmdVm().executeFastOnlyNoSuspend(function, scope, scope.args, binder)
}
override suspend fun execute(scope: Scope): Obj {
scope.pos = pos
val declaredNames = function.constants
.mapNotNull { it as? BytecodeConst.LocalDecl }
.mapTo(mutableSetOf()) { it.name }
val fastResult = callOnFast(scope)
if (fastResult != null) return fastResult
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, _ ->
val localNames = frame.fn.localSlotNames
for (i in localNames.indices) {
val name = localNames[i] ?: continue
if (declaredNames.contains(name)) continue
if (declaredLocalNames.contains(name)) continue
val slotType = frame.getLocalSlotTypeCode(i)
if (slotType != SlotType.UNKNOWN.code && slotType != SlotType.OBJ.code) {
continue
@@ -84,6 +98,7 @@ class BytecodeStatement private constructor(
globalSlotInfo: Map<String, ForcedLocalSlotInfo> = emptyMap(),
globalSlotScopeId: Int? = null,
slotTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
exactLambdaRefByScopeId: Map<Int, Map<Int, LambdaFnRef>> = emptyMap(),
knownNameObjClass: Map<String, ObjClass> = emptyMap(),
knownClassNames: Set<String> = emptySet(),
knownObjectNames: Set<String> = emptySet(),
@@ -91,6 +106,7 @@ class BytecodeStatement private constructor(
enumEntriesByName: Map<String, List<String>> = emptyMap(),
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
callSignatureByName: Map<String, CallSignature> = emptyMap(),
externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(),
preparedModuleBindingNames: Set<String> = emptySet(),
@@ -122,6 +138,7 @@ class BytecodeStatement private constructor(
globalSlotInfo = globalSlotInfo,
globalSlotScopeId = globalSlotScopeId,
slotTypeByScopeId = slotTypeByScopeId,
exactLambdaRefByScopeId = exactLambdaRefByScopeId,
slotTypeDeclByScopeId = slotTypeDeclByScopeId,
knownNameObjClass = knownNameObjClass,
knownClassNames = knownClassNames,
@@ -130,6 +147,7 @@ class BytecodeStatement private constructor(
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
callSignatureByName = callSignatureByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
preparedModuleBindingNames = preparedModuleBindingNames,
@@ -112,6 +112,7 @@ class CmdBuilder {
}
cmds.add(createCmd(ins.op, operands, scopeSlotCount, localSlotCaptures))
}
val cmdArray = cmds.toTypedArray()
return CmdFunction(
name = name,
localCount = localCount,
@@ -128,8 +129,9 @@ class CmdBuilder {
localSlotDelegated = localSlotDelegated,
localSlotCaptures = localSlotCaptures,
constants = constPool.toList(),
cmds = cmds.toTypedArray(),
posByIp = posByInstr.toTypedArray()
cmds = cmdArray,
posByIp = posByInstr.toTypedArray(),
fastOnly = computeFastOnlyBytecode(scopeSlotCount, cmdArray)
)
}
@@ -231,8 +233,16 @@ class CmdBuilder {
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.SET_INDEX_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_NEW_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_FILL_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_IOTA_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_NEW_INT_CAP ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_FILL_INT_CAP ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.MAKE_RANGE ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_LITERAL ->
@@ -835,7 +845,11 @@ class CmdBuilder {
Opcode.SET_INDEX -> CmdSetIndex(operands[0], operands[1], operands[2])
Opcode.GET_INDEX_INT -> CmdGetIndexInt(operands[0], operands[1], operands[2])
Opcode.SET_INDEX_INT -> CmdSetIndexInt(operands[0], operands[1], operands[2])
Opcode.LIST_NEW_INT -> CmdListNewInt(operands[0], operands[1])
Opcode.LIST_FILL_INT -> CmdListFillInt(operands[0], operands[1], operands[2])
Opcode.LIST_IOTA_INT -> CmdListIotaInt(operands[0], operands[1])
Opcode.LIST_NEW_INT_CAP -> CmdListNewIntCap(operands[0], operands[1], operands[2])
Opcode.LIST_FILL_INT_CAP -> CmdListFillIntCap(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.SET_MEMBER_SLOT -> CmdSetMemberSlot(operands[0], operands[1], operands[2], operands[3])
@@ -495,7 +495,11 @@ object CmdDisassembler {
is CmdSetIndex -> Opcode.SET_INDEX to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.valueSlot)
is CmdGetIndexInt -> Opcode.GET_INDEX_INT to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.dst)
is CmdSetIndexInt -> Opcode.SET_INDEX_INT to intArrayOf(cmd.targetSlot, cmd.indexSlot, cmd.valueSlot)
is CmdListNewInt -> Opcode.LIST_NEW_INT to intArrayOf(cmd.sizeSlot, cmd.dst)
is CmdListFillInt -> Opcode.LIST_FILL_INT to intArrayOf(cmd.sizeSlot, cmd.callableSlot, cmd.dst)
is CmdListIotaInt -> Opcode.LIST_IOTA_INT to intArrayOf(cmd.sizeSlot, cmd.dst)
is CmdListNewIntCap -> Opcode.LIST_NEW_INT_CAP to intArrayOf(cmd.sizeSlot, cmd.capacitySlot, cmd.dst)
is CmdListFillIntCap -> Opcode.LIST_FILL_INT_CAP to intArrayOf(cmd.sizeSlot, cmd.capacitySlot, cmd.callableSlot, 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 CmdSetMemberSlot -> Opcode.SET_MEMBER_SLOT to intArrayOf(cmd.recvSlot, cmd.fieldId, cmd.methodId, cmd.valueSlot)
@@ -619,8 +623,16 @@ object CmdDisassembler {
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.SET_INDEX_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_NEW_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_FILL_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_IOTA_INT ->
listOf(OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_NEW_INT_CAP ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_FILL_INT_CAP ->
listOf(OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT, OperandKind.SLOT)
Opcode.LIST_LITERAL ->
listOf(OperandKind.CONST, OperandKind.SLOT, OperandKind.COUNT, OperandKind.SLOT)
Opcode.GET_MEMBER_SLOT ->
@@ -35,6 +35,7 @@ data class CmdFunction(
val constants: List<BytecodeConst>,
val cmds: Array<Cmd>,
val posByIp: Array<net.sergeych.lyng.Pos?>,
val fastOnly: Boolean = false,
) {
init {
require(scopeSlotIndices.size == scopeSlotCount) { "scopeSlotIndices size mismatch" }
@@ -71,3 +72,118 @@ data class CmdFunction(
}
}
internal fun computeFastOnlyBytecode(scopeSlotCount: Int, cmds: Array<Cmd>): Boolean {
if (scopeSlotCount != 0) return false
return cmds.all(::supportsFastOnlyExecution)
}
private fun supportsFastOnlyExecution(cmd: Cmd): Boolean {
return when (cmd) {
is CmdMoveIntLocal,
is CmdMoveRealLocal,
is CmdMoveBoolLocal,
is CmdConstObj,
is CmdConstInt,
is CmdConstIntLocal,
is CmdConstReal,
is CmdConstBool,
is CmdConstNull,
is CmdUnboxIntObjLocal,
is CmdUnboxRealObjLocal,
is CmdIntToRealLocal,
is CmdRealToIntLocal,
is CmdBoolToIntLocal,
is CmdIntToBoolLocal,
is CmdAddIntLocal,
is CmdSubIntLocal,
is CmdMulIntLocal,
is CmdDivIntLocal,
is CmdModIntLocal,
is CmdNegIntLocal,
is CmdIncIntLocal,
is CmdDecIntLocal,
is CmdAddRealLocal,
is CmdSubRealLocal,
is CmdMulRealLocal,
is CmdDivRealLocal,
is CmdNegRealLocal,
is CmdAndIntLocal,
is CmdOrIntLocal,
is CmdXorIntLocal,
is CmdShlIntLocal,
is CmdShrIntLocal,
is CmdUshrIntLocal,
is CmdInvIntLocal,
is CmdCmpEqIntLocal,
is CmdCmpNeqIntLocal,
is CmdCmpLtIntLocal,
is CmdCmpLteIntLocal,
is CmdCmpGtIntLocal,
is CmdCmpGteIntLocal,
is CmdCmpEqRealLocal,
is CmdCmpNeqRealLocal,
is CmdCmpLtRealLocal,
is CmdCmpLteRealLocal,
is CmdCmpGtRealLocal,
is CmdCmpGteRealLocal,
is CmdCmpEqBoolLocal,
is CmdCmpNeqBoolLocal,
is CmdCmpEqIntRealLocal,
is CmdCmpEqRealIntLocal,
is CmdCmpLtIntRealLocal,
is CmdCmpLtRealIntLocal,
is CmdCmpLteIntRealLocal,
is CmdCmpLteRealIntLocal,
is CmdCmpGtIntRealLocal,
is CmdCmpGtRealIntLocal,
is CmdCmpGteIntRealLocal,
is CmdCmpGteRealIntLocal,
is CmdCmpNeqIntRealLocal,
is CmdCmpNeqRealIntLocal,
is CmdCmpEqStrLocal,
is CmdCmpNeqStrLocal,
is CmdCmpLtStrLocal,
is CmdCmpLteStrLocal,
is CmdCmpGtStrLocal,
is CmdCmpGteStrLocal,
is CmdCmpEqIntObjLocal,
is CmdCmpNeqIntObjLocal,
is CmdCmpLtIntObjLocal,
is CmdCmpLteIntObjLocal,
is CmdCmpGtIntObjLocal,
is CmdCmpGteIntObjLocal,
is CmdCmpEqRealObjLocal,
is CmdCmpNeqRealObjLocal,
is CmdCmpLtRealObjLocal,
is CmdCmpLteRealObjLocal,
is CmdCmpGtRealObjLocal,
is CmdCmpGteRealObjLocal,
is CmdAddIntObjLocal,
is CmdSubIntObjLocal,
is CmdMulIntObjLocal,
is CmdDivIntObjLocal,
is CmdModIntObjLocal,
is CmdAddRealObjLocal,
is CmdSubRealObjLocal,
is CmdMulRealObjLocal,
is CmdDivRealObjLocal,
is CmdModRealObjLocal,
is CmdNotBoolLocal,
is CmdAndBoolLocal,
is CmdOrBoolLocal,
is CmdJmp,
is CmdJmpIfTrueLocal,
is CmdJmpIfFalseLocal,
is CmdJmpIfEqIntLocal,
is CmdJmpIfNeqIntLocal,
is CmdJmpIfLtIntLocal,
is CmdJmpIfLteIntLocal,
is CmdJmpIfGtIntLocal,
is CmdJmpIfGteIntLocal,
is CmdRet,
is CmdRetVoid -> true
else -> false
}
}
@@ -57,6 +57,64 @@ class CmdVm {
suspend fun execute(fn: CmdFunction, scope0: Scope, args: List<Obj>): Obj {
return execute(fn, scope0, Arguments.from(args))
}
fun executeFastOnlyNoSuspend(
fn: CmdFunction,
scope0: Scope,
args: Arguments,
binder: ((CmdFrame, Arguments) -> Unit)? = null
): Obj {
require(fn.fastOnly) { "fast-only execution requested for non-fast function ${fn.name}" }
result = null
val frame = CmdFrame(this, fn, scope0, args.list)
frame.applyCaptureRecords()
binder?.invoke(frame, args)
val cmds = fn.cmds
try {
while (result == null) {
val cmd = cmds[frame.ip++]
if (!cmd.performFast(frame)) {
error("fast-only command not supported: ${cmd::class.simpleName}")
}
}
} catch (e: Throwable) {
throw frame.normalizeThrowableFast(e)
}
return result ?: ObjVoid
}
suspend fun executeFastOnly(
fn: CmdFunction,
scope0: Scope,
args: Arguments,
binder: ((CmdFrame, Arguments) -> Unit)? = null
): Obj {
require(fn.fastOnly) { "fast-only execution requested for non-fast function ${fn.name}" }
result = null
val frame = CmdFrame(this, fn, scope0, args.list)
frame.applyCaptureRecords()
binder?.invoke(frame, args)
val cmds = fn.cmds
while (true) {
try {
while (result == null) {
val cmd = cmds[frame.ip++]
if (!cmd.performFast(frame)) {
error("fast-only command not supported: ${cmd::class.simpleName}")
}
}
break
} catch (e: Throwable) {
val throwable = frame.normalizeThrowable(e)
if (!frame.handleException(throwable)) {
frame.cancelIterators()
throw throwable
}
}
}
frame.cancelIterators()
return result ?: ObjVoid
}
}
sealed class Cmd {
@@ -280,6 +338,11 @@ class CmdMakeRange(
}
class CmdConstNull(internal val dst: Int) : Cmd() {
override fun performFast(frame: CmdFrame): Boolean {
frame.setObj(dst, ObjNull)
return true
}
override suspend fun perform(frame: CmdFrame) {
frame.setObj(dst, ObjNull)
return
@@ -2141,8 +2204,8 @@ class CmdAssignOpObj(
}
if (result == null) {
val name = (frame.fn.constants.getOrNull(nameId) as? BytecodeConst.StringVal)?.value
if (name != null) frame.ensureScope().raiseIllegalAssignment("symbol is readonly: $name")
frame.ensureScope().raiseIllegalAssignment("symbol is readonly")
if (name != null) frame.ensureScope().raiseIllegalAssignment("can't reassign val $name")
frame.ensureScope().raiseIllegalAssignment("can't reassign val")
}
frame.storeObjResult(dst, result)
return
@@ -2301,6 +2364,11 @@ class CmdJmpIfGteIntLocal(internal val a: Int, internal val b: Int, internal val
}
class CmdRet(internal val slot: Int) : Cmd() {
override fun performFast(frame: CmdFrame): Boolean {
frame.vm.result = frame.storedSlotObj(slot)
return true
}
override suspend fun perform(frame: CmdFrame) {
frame.vm.result = frame.slotToObj(slot)
return
@@ -2322,6 +2390,11 @@ class CmdRetLabel(internal val labelId: Int, internal val slot: Int) : Cmd() {
}
class CmdRetVoid : Cmd() {
override fun performFast(frame: CmdFrame): Boolean {
frame.vm.result = ObjVoid
return true
}
override suspend fun perform(frame: CmdFrame) {
frame.vm.result = ObjVoid
return
@@ -3217,10 +3290,21 @@ class CmdCallDirect(
frame.ensureScope().raiseIllegalState("bytecode runtime cannot call non-bytecode Statement")
}
}
val result = if (PerfFlags.SCOPE_POOL) {
frame.ensureScope().withChildFrame(args) { child -> callee.callOn(child) }
val directFastResult = (callee as? BytecodeArgCallable)?.callWithArgsFast(frame.ensureScope(), args)
val result = if (directFastResult != null) {
directFastResult
} else if (PerfFlags.SCOPE_POOL) {
frame.ensureScope().withChildFrame(args) { child ->
(callee as? BytecodeCallable)?.callOnFast(child) ?: callee.callOn(child)
}
} else {
callee.callOn(frame.ensureScope().createChildScope(frame.ensureScope().pos, args = args))
val scope = frame.ensureScope()
if (callee is BytecodeLambdaCallable && callee.supportsDirectInvokeFastPath()) {
callee.invokeWithArgsFast(scope, args) ?: callee.invokeWithArgs(scope, args)
} else {
val child = scope.createChildScope(scope.pos, args = args)
(callee as? BytecodeCallable)?.callOnFast(child) ?: callee.callOn(child)
}
}
frame.storeObjResult(dst, result)
return
@@ -3247,18 +3331,28 @@ class CmdCallSlot(
frame.ensureScope().raiseUnset(message)
}
val args = frame.buildArguments(argBase, argCount)
val scope = frame.ensureScope()
val directFastResult = (callee as? BytecodeArgCallable)?.callWithArgsFast(scope, args)
val canPool = PerfFlags.SCOPE_POOL && callee !is Statement
val result = if (canPool) {
frame.ensureScope().withChildFrame(args) { child -> callee.callOn(child) }
val result = if (directFastResult != null) {
directFastResult
} else if (canPool) {
frame.ensureScope().withChildFrame(args) { child ->
(callee as? BytecodeCallable)?.callOnFast(child) ?: callee.callOn(child)
}
} else {
val scope = frame.ensureScope()
if (callee is Statement) {
val bytecodeBody = (callee as? BytecodeBodyProvider)?.bytecodeBody()
if (callee !is BytecodeStatement && callee !is BytecodeCallable && bytecodeBody == null) {
scope.raiseIllegalState("bytecode runtime cannot call non-bytecode Statement")
}
}
callee.callOn(scope.createChildScope(scope.pos, args = args))
if (callee is BytecodeLambdaCallable && callee.supportsDirectInvokeFastPath()) {
callee.invokeWithArgsFast(scope, args) ?: callee.invokeWithArgs(scope, args)
} else {
val child = scope.createChildScope(scope.pos, args = args)
(callee as? BytecodeCallable)?.callOnFast(child) ?: callee.callOn(child)
}
}
frame.storeObjResult(dst, result)
return
@@ -3341,10 +3435,53 @@ class CmdListFillInt(
val scope = frame.ensureScope()
val result = ObjList(LongArray(size))
for (i in 0 until size) {
val args = Arguments(ObjInt.of(i.toLong()))
val value = if (callable is BytecodeLambdaCallable && callable.supportsImplicitIntFillFastPath()) {
callable.invokeImplicitIntArg(scope, i.toLong())
callable.invokeImplicitIntArgFast(scope, i.toLong()) ?: callable.invokeImplicitIntArg(scope, i.toLong())
} else if (callable is BytecodeArgCallable) {
callable.callWithArgsFast(scope, args) ?: run {
val child = scope.createChildScope(scope.pos, args = args)
(callable as? BytecodeCallable)?.callOnFast(child) ?: callable.callOn(child)
}
} else {
callable.callOn(scope.createChildScope(scope.pos, args = Arguments(ObjInt.of(i.toLong()))))
val child = scope.createChildScope(scope.pos, args = args)
(callable as? BytecodeCallable)?.callOnFast(child) ?: callable.callOn(child)
}
val intValue = (value as? ObjInt)?.value ?: scope.raiseClassCastError("expected Int fill result")
result.setIntAtFast(i, intValue)
}
frame.storeObjResult(dst, result)
return
}
}
class CmdListFillIntCap(
internal val sizeSlot: Int,
internal val capacitySlot: Int,
internal val callableSlot: Int,
internal val dst: Int,
) : Cmd() {
override suspend fun perform(frame: CmdFrame) {
val size = frame.getInt(sizeSlot).toInt()
if (size < 0) frame.ensureScope().raiseIllegalArgument("list size must be non-negative")
val capacity = frame.getInt(capacitySlot).toInt()
val actualCapacity = maxOf(size, capacity)
if (actualCapacity < 0) frame.ensureScope().raiseIllegalArgument("list capacity must be non-negative")
val callable = frame.storedSlotObj(callableSlot)
val scope = frame.ensureScope()
val result = ObjList(LongArray(actualCapacity), size)
for (i in 0 until size) {
val args = Arguments(ObjInt.of(i.toLong()))
val value = if (callable is BytecodeLambdaCallable && callable.supportsImplicitIntFillFastPath()) {
callable.invokeImplicitIntArgFast(scope, i.toLong()) ?: callable.invokeImplicitIntArg(scope, i.toLong())
} else if (callable is BytecodeArgCallable) {
callable.callWithArgsFast(scope, args) ?: run {
val child = scope.createChildScope(scope.pos, args = args)
(callable as? BytecodeCallable)?.callOnFast(child) ?: callable.callOn(child)
}
} else {
val child = scope.createChildScope(scope.pos, args = args)
(callable as? BytecodeCallable)?.callOnFast(child) ?: callable.callOn(child)
}
val intValue = (value as? ObjInt)?.value ?: scope.raiseClassCastError("expected Int fill result")
result.setIntAtFast(i, intValue)
@@ -3730,6 +3867,50 @@ class CmdCallMemberSlot(
}
}
class CmdListIotaInt(
internal val sizeSlot: Int,
internal val dst: Int,
) : Cmd() {
override suspend fun perform(frame: CmdFrame) {
val size = frame.getInt(sizeSlot).toInt()
if (size < 0) frame.ensureScope().raiseIllegalArgument("list size must be non-negative")
val values = LongArray(size)
for (i in 0 until size) {
values[i] = i.toLong()
}
frame.storeObjResult(dst, ObjList(values))
return
}
}
class CmdListNewInt(
internal val sizeSlot: Int,
internal val dst: Int,
) : Cmd() {
override suspend fun perform(frame: CmdFrame) {
val size = frame.getInt(sizeSlot).toInt()
if (size < 0) frame.ensureScope().raiseIllegalArgument("list size must be non-negative")
frame.storeObjResult(dst, ObjList(LongArray(size)))
return
}
}
class CmdListNewIntCap(
internal val sizeSlot: Int,
internal val capacitySlot: Int,
internal val dst: Int,
) : Cmd() {
override suspend fun perform(frame: CmdFrame) {
val size = frame.getInt(sizeSlot).toInt()
if (size < 0) frame.ensureScope().raiseIllegalArgument("list size must be non-negative")
val capacity = frame.getInt(capacitySlot).toInt()
val actualCapacity = maxOf(size, capacity)
if (actualCapacity < 0) frame.ensureScope().raiseIllegalArgument("list capacity must be non-negative")
frame.storeObjResult(dst, ObjList(LongArray(actualCapacity), size))
return
}
}
class CmdGetIndex(
internal val targetSlot: Int,
internal val indexSlot: Int,
@@ -3834,6 +4015,7 @@ class CmdMakeLambda(internal val id: Int, internal val dst: Int) : Cmd() {
captureNames = lambdaConst.captureNames,
paramSlotPlan = lambdaConst.paramSlotPlan,
argsDeclaration = lambdaConst.argsDeclaration,
supportsDirectInvokeFastPath = lambdaConst.supportsDirectInvokeFastPath,
preferredThisType = lambdaConst.preferredThisType,
returnLabels = lambdaConst.returnLabels,
pos = lambdaConst.pos
@@ -3855,10 +4037,18 @@ class BytecodeLambdaCallable(
private val captureNames: List<String>,
private val paramSlotPlan: Map<String, Int>,
private val argsDeclaration: ArgsDeclaration?,
private val supportsDirectInvokeFastPath: Boolean,
private val preferredThisType: String?,
private val returnLabels: Set<String>,
override val pos: Pos,
) : Statement(), BytecodeCallable {
) : Statement(), BytecodeCallable, BytecodeArgCallable {
private val slotPlanByName: Map<String, Int> by lazy(LazyThreadSafetyMode.NONE) { fn.localSlotPlanByName() }
private val declaredLocalNames: Set<String> by lazy(LazyThreadSafetyMode.NONE) {
fn.constants
.mapNotNull { it as? BytecodeConst.LocalDecl }
.mapTo(mutableSetOf()) { it.name }
}
private fun freezeRecord(record: ObjRecord): ObjRecord {
if (record.isMutable) return record
val raw = record.value as Obj?
@@ -3890,6 +4080,7 @@ class BytecodeLambdaCallable(
captureNames = captureNames,
paramSlotPlan = paramSlotPlan,
argsDeclaration = argsDeclaration,
supportsDirectInvokeFastPath = supportsDirectInvokeFastPath,
preferredThisType = preferredThisType,
returnLabels = returnLabels,
pos = pos
@@ -3906,6 +4097,7 @@ class BytecodeLambdaCallable(
captureNames = captureNames,
paramSlotPlan = paramSlotPlan,
argsDeclaration = argsDeclaration,
supportsDirectInvokeFastPath = supportsDirectInvokeFastPath,
preferredThisType = preferredThisType,
returnLabels = returnLabels,
pos = pos
@@ -3914,9 +4106,29 @@ class BytecodeLambdaCallable(
fun supportsImplicitIntFillFastPath(): Boolean = argsDeclaration == null
suspend fun invokeImplicitIntArg(scope: Scope, arg: Long): Obj {
val context = scope.applyClosureForBytecode(closureScope, preferredThisType).also {
it.args = Arguments.EMPTY
fun supportsDirectInvokeFastPath(): Boolean = supportsDirectInvokeFastPath
private val fastPreboundLocalNames: Set<String> by lazy(LazyThreadSafetyMode.NONE) {
if (argsDeclaration == null) {
setOf("it")
} else {
argsDeclaration.params.mapTo(LinkedHashSet()) { it.name }
}
}
private val supportsFastUndeclaredLocalInit: Boolean by lazy(LazyThreadSafetyMode.NONE) {
canFastSeedUndeclaredLocals(fn, declaredLocalNames, fastPreboundLocalNames)
}
private fun supportsFastOnlyVm(arguments: Arguments): Boolean {
if (!supportsDirectInvokeFastPath || !fn.fastOnly) return false
if (!supportsFastUndeclaredLocalInit) return false
return argsDeclaration == null || argsDeclaration.supportsFastFrameBinding(arguments)
}
private fun buildContext(callScope: Scope, args: Arguments): Scope {
val context = callScope.applyClosureForBytecode(closureScope, preferredThisType).also {
it.args = args
}
if (captureRecords != null) {
context.captureRecords = captureRecords
@@ -3924,98 +4136,161 @@ class BytecodeLambdaCallable(
} else if (captureNames.isNotEmpty()) {
closureScope.raiseIllegalState("bytecode lambda capture records missing")
}
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, _ ->
paramSlotPlan["it"]?.let { itSlot ->
return context
}
private fun bindArgumentsFast(frame: CmdFrame, context: Scope, arguments: Arguments) {
if (argsDeclaration == null) {
val l = arguments.list
val itValue: Obj = when (l.size) {
0 -> ObjVoid
1 -> l[0]
else -> ObjList(l.toMutableList())
}
val itSlot = slotPlanByName["it"]
if (itSlot != null) {
when (itValue) {
is ObjInt -> frame.frame.setInt(itSlot, itValue.value)
is ObjReal -> frame.frame.setReal(itSlot, itValue.value)
is ObjBool -> frame.frame.setBool(itSlot, itValue.value)
else -> frame.frame.setObj(itSlot, itValue)
}
}
} else {
argsDeclaration.assignToFrameFast(
context,
arguments,
slotPlanByName,
frame.frame
)
}
}
private suspend fun bindArguments(frame: CmdFrame, context: Scope, arguments: Arguments) {
if (argsDeclaration == null) {
bindArgumentsFast(frame, context, arguments)
} else {
argsDeclaration.assignToFrame(
context,
arguments,
slotPlanByName,
frame.frame
)
}
}
private suspend fun seedUndeclaredLocals(frame: CmdFrame, context: Scope) {
val localNames = frame.fn.localSlotNames
for (i in localNames.indices) {
val name = localNames[i] ?: continue
if (declaredLocalNames.contains(name)) 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 = context.getLocalRecordDirect(name)
?: context.parent?.get(name)
?: context.get(name)
?: continue
val value =
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, name)
} else {
when (val direct = record.value) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read(context, name)
is ScopeSlotRef -> direct.read()
else -> direct
}
}
frame.frame.setObj(i, value)
}
}
suspend fun invokeImplicitIntArg(scope: Scope, arg: Long): Obj {
val context = buildContext(scope, Arguments.EMPTY)
val fastBinder: (CmdFrame, Arguments) -> Unit = { frame, _ ->
slotPlanByName["it"]?.let { itSlot ->
frame.frame.setInt(itSlot, arg)
}
}
return try {
CmdVm().execute(fn, context, Arguments.EMPTY, binder)
val vm = CmdVm()
if (supportsFastOnlyVm(Arguments.EMPTY)) {
vm.executeFastOnly(fn, context, Arguments.EMPTY, fastBinder)
} else {
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, _ ->
slotPlanByName["it"]?.let { itSlot ->
frame.frame.setInt(itSlot, arg)
}
}
vm.execute(fn, context, Arguments.EMPTY, binder)
}
} catch (e: ReturnException) {
if (e.label == null || returnLabels.contains(e.label)) e.result
else throw e
}
}
override suspend fun execute(scope: Scope): Obj {
val context = scope.applyClosureForBytecode(closureScope, preferredThisType).also {
it.args = scope.args
}
if (captureRecords != null) {
context.captureRecords = captureRecords
context.captureNames = captureNames
} else if (captureNames.isNotEmpty()) {
closureScope.raiseIllegalState("bytecode lambda capture records missing")
}
if (argsDeclaration == null) {
// Bound in the bytecode entry binder.
} else {
// args bound into frame slots in the bytecode entry binder
fun invokeImplicitIntArgFast(scope: Scope, arg: Long): Obj? {
if (!supportsFastOnlyVm(Arguments.EMPTY)) return null
val context = buildContext(scope, Arguments.EMPTY)
val binder: (CmdFrame, Arguments) -> Unit = { frame, _ ->
slotPlanByName["it"]?.let { itSlot ->
frame.frame.setInt(itSlot, arg)
}
}
return try {
val declaredNames = fn.constants
.mapNotNull { it as? BytecodeConst.LocalDecl }
.mapTo(mutableSetOf()) { it.name }
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, arguments ->
val slotPlan = fn.localSlotPlanByName()
if (argsDeclaration == null) {
val l = arguments.list
val itValue: Obj = when (l.size) {
0 -> ObjVoid
1 -> l[0]
else -> ObjList(l.toMutableList())
}
val itSlot = slotPlan["it"]
if (itSlot != null) {
when (itValue) {
is ObjInt -> frame.frame.setInt(itSlot, itValue.value)
is ObjReal -> frame.frame.setReal(itSlot, itValue.value)
is ObjBool -> frame.frame.setBool(itSlot, itValue.value)
else -> frame.frame.setObj(itSlot, itValue)
}
}
} else {
argsDeclaration.assignToFrame(
context,
arguments,
slotPlan,
frame.frame
)
}
val localNames = frame.fn.localSlotNames
for (i in localNames.indices) {
val name = localNames[i] ?: continue
if (declaredNames.contains(name)) 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 = context.getLocalRecordDirect(name)
?: context.parent?.get(name)
?: context.get(name)
?: continue
val value =
if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, name)
} else {
when (val direct = record.value) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read(context, name)
is ScopeSlotRef -> direct.read()
else -> direct
}
}
frame.frame.setObj(i, value)
}
}
CmdVm().execute(fn, context, scope.args, binder)
CmdVm().executeFastOnlyNoSuspend(fn, context, Arguments.EMPTY, binder)
} catch (e: ReturnException) {
if (e.label == null || returnLabels.contains(e.label)) e.result else throw e
}
}
suspend fun invokeWithArgs(scope: Scope, args: Arguments): Obj {
val context = buildContext(scope, args)
return try {
val vm = CmdVm()
if (supportsFastOnlyVm(args)) {
val binder: (CmdFrame, Arguments) -> Unit = { frame, arguments ->
bindArgumentsFast(frame, context, arguments)
}
vm.executeFastOnly(fn, context, args, binder)
} else {
val binder: suspend (CmdFrame, Arguments) -> Unit = { frame, arguments ->
bindArguments(frame, context, arguments)
seedUndeclaredLocals(frame, context)
}
vm.execute(fn, context, args, binder)
}
} catch (e: ReturnException) {
if (e.label == null || returnLabels.contains(e.label)) e.result else throw e
}
}
fun invokeWithArgsFast(scope: Scope, args: Arguments): Obj? {
if (!supportsFastOnlyVm(args)) return null
val context = buildContext(scope, args)
val binder: (CmdFrame, Arguments) -> Unit = { frame, arguments ->
bindArgumentsFast(frame, context, arguments)
}
return try {
CmdVm().executeFastOnlyNoSuspend(fn, context, args, binder)
} catch (e: ReturnException) {
if (e.label == null || returnLabels.contains(e.label)) e.result else throw e
}
}
override fun callWithArgsFast(scope: Scope, args: Arguments): Obj? = invokeWithArgsFast(scope, args)
override fun callOnFast(scope: Scope): Obj? = invokeWithArgsFast(scope, scope.args)
override suspend fun execute(scope: Scope): Obj {
return invokeWithArgs(scope, scope.args)
}
}
class CmdIterPush(internal val iterSlot: Int) : Cmd() {
@@ -4174,10 +4449,15 @@ class CmdFrame(
} else {
val value = record.value
if (!record.isMutable && value is FrameSlotRef) {
val resolved = value.peekValue()
val resolved = value.resolvedCaptureValueOrNull()
if (resolved != null) {
if (value.refersTo(frame, localIndex)) continue
frame.setObj(localIndex, value.read())
when (resolved) {
is ObjInt -> frame.setInt(localIndex, resolved.value)
is ObjReal -> frame.setReal(localIndex, resolved.value)
is ObjBool -> frame.setBool(localIndex, resolved.value)
else -> frame.setObj(localIndex, resolved)
}
} else {
frame.setObj(localIndex, value)
}
@@ -4213,9 +4493,14 @@ class CmdFrame(
} else {
val value = record.value
if (!record.isMutable && value is FrameSlotRef) {
val resolved = value.peekValue()
val resolved = value.resolvedCaptureValueOrNull()
if (resolved != null) {
frame.setObj(idx, value.read())
when (resolved) {
is ObjInt -> frame.setInt(idx, resolved.value)
is ObjReal -> frame.setReal(idx, resolved.value)
is ObjBool -> frame.setBool(idx, resolved.value)
else -> frame.setObj(idx, resolved)
}
} else {
frame.setObj(idx, value)
}
@@ -4267,7 +4552,7 @@ class CmdFrame(
type = inherited.type
)
copied.delegate = inherited.delegate
return@mapIndexed copied
return@mapIndexed freezeImmutableCaptureRecord(copied)
}
}
val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: false
@@ -4279,15 +4564,25 @@ class CmdFrame(
}
} else {
val raw = frame.getRawObj(localIndex)
if (raw == null && name != null) {
// For primitive-typed slots (INT/REAL/BOOL), getRawObj returns null
// but the value exists in the typed slot array. Skip the scope name
// lookup to avoid finding a same-named symbol higher in the scope chain
// (e.g., a List.size property when capturing a `size: Int` parameter).
val isPrimitiveSlot = when (frame.getSlotTypeCode(localIndex)) {
SlotType.INT.code, SlotType.REAL.code, SlotType.BOOL.code -> true
else -> false
}
if (raw == null && name != null && !isPrimitiveSlot) {
val record = findNamedExistingRecord(scope, name)
if (record != null) {
val value = record.value
return@mapIndexed when (value) {
return@mapIndexed freezeImmutableCaptureRecord(
when (value) {
is FrameSlotRef -> ObjRecord(value, isMutable)
is RecordSlotRef -> ObjRecord(value, isMutable)
else -> ObjRecord(value, isMutable)
}
}
)
}
if (hasNamedScopeBinding(scope, name)) {
throw ScriptError(
@@ -4296,11 +4591,13 @@ class CmdFrame(
)
}
}
when (raw) {
is FrameSlotRef -> ObjRecord(raw, isMutable)
is RecordSlotRef -> ObjRecord(raw, isMutable)
else -> ObjRecord(FrameSlotRef(frame, localIndex), isMutable)
}
freezeImmutableCaptureRecord(
when (raw) {
is FrameSlotRef -> ObjRecord(raw, isMutable)
is RecordSlotRef -> ObjRecord(raw, isMutable)
else -> ObjRecord(FrameSlotRef(frame, localIndex), isMutable)
}
)
}
}
@@ -4446,6 +4743,19 @@ class CmdFrame(
return ExecutionError(errorObject, pos, message, t)
}
fun normalizeThrowableFast(t: Throwable): Throwable {
if (t is ExecutionError || t is ReturnException || t is LoopBreakContinueException) return t
val parentScope = ensureScope()
val pos = (t as? ScriptError)?.pos ?: currentErrorPos() ?: parentScope.pos
val throwScope = parentScope.createChildScope(pos = pos)
val message = when (t) {
is ScriptError -> t.errorMessage
else -> t.message ?: t.toString()
}
val errorObject = ObjUnknownException(throwScope, message)
return ExecutionError(errorObject, pos, message, t)
}
suspend fun handleException(t: Throwable): Boolean {
val handler = tryStack.lastOrNull() ?: return false
vmIterDebug {
@@ -5400,6 +5710,14 @@ class CmdFrame(
if (index < target.slotCount) return index
return index
}
if (target.hasSlotPlanConflict(mapOf(name to index))) {
val record = target.getLocalRecordDirect(name)
?: target.localBindings[name]
?: target.parent?.get(name)
?: target.get(name)
?: ObjRecord(ObjUnset, isMutable = true)
return target.allocateSlotFor(name, record)
}
target.applySlotPlan(mapOf(name to index))
val existing = target.getLocalRecordDirect(name) ?: target.localBindings[name]
if (existing != null) {
@@ -175,6 +175,8 @@ enum class Opcode(val code: Int) {
CALL_SLOT(0x93),
CALL_BRIDGE_SLOT(0x94),
LIST_NEW_INT(0xA0),
LIST_IOTA_INT(0xA1),
GET_INDEX(0xA2),
SET_INDEX(0xA3),
GET_INDEX_INT(0xA4),
@@ -188,6 +190,8 @@ enum class Opcode(val code: Int) {
GET_DYNAMIC_MEMBER(0xAC),
SET_DYNAMIC_MEMBER(0xAD),
CALL_DYNAMIC_MEMBER(0xAE),
LIST_NEW_INT_CAP(0xAF),
LIST_FILL_INT_CAP(0xB0),
RESOLVE_SCOPE_SLOT(0xB1),
LOAD_OBJ_ADDR(0xB2),
@@ -17,7 +17,58 @@
package net.sergeych.lyng.bytecode
import net.sergeych.lyng.Scope
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.RecordSlotRef
import net.sergeych.lyng.ScopeSlotRef
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjProperty
internal fun canFastSeedUndeclaredLocals(
fn: CmdFunction,
declaredLocalNames: Set<String>,
preboundLocalNames: Set<String>
): Boolean {
if (fn.localSlotNames.isEmpty()) return true
for (i in fn.localSlotNames.indices) {
val name = fn.localSlotNames[i] ?: continue
if (declaredLocalNames.contains(name)) continue
if (fn.localSlotCaptures.getOrNull(i) == true) continue
if (preboundLocalNames.contains(name)) continue
return false
}
return true
}
internal fun trySeedFrameLocalsFromScopeFast(frame: CmdFrame, scope: Scope): Boolean {
val localNames = frame.fn.localSlotNames
if (localNames.isEmpty()) return true
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 = when {
record.type == ObjRecord.Type.Delegated -> return false
record.type == ObjRecord.Type.Property -> return false
record.value is ObjProperty -> return false
else -> when (val direct = record.value) {
is FrameSlotRef -> direct.resolvedCaptureValueOrNull() ?: return false
is RecordSlotRef -> direct.resolvedCaptureValueOrNull() ?: return false
is ScopeSlotRef -> direct.resolvedCaptureValueOrNull() ?: return false
else -> direct
}
}
if (value is FrameSlotRef && value.refersTo(frame.frame, i)) {
continue
}
frame.setObjUnchecked(base + i, value)
}
return true
}
internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
val localNames = frame.fn.localSlotNames
@@ -99,10 +99,11 @@ fun ObjClass.addFnDoc(
visibility: Visibility = Visibility.Public,
tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null,
callSignature: net.sergeych.lyng.CallSignature? = null,
code: suspend ScopeFacade.() -> Obj
) {
// Register runtime method
addFn(name, isOpen, visibility, code = code)
addFn(name, isOpen, visibility, callSignature = callSignature, code = code)
// Register docs for the member under this class
BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) {
classDoc(this@addFnDoc.className, doc = "") {
@@ -137,9 +138,10 @@ fun ObjClass.addClassFnDoc(
isOpen: Boolean = false,
tags: Map<String, List<String>> = emptyMap(),
moduleName: String? = null,
callSignature: net.sergeych.lyng.CallSignature? = null,
code: suspend ScopeFacade.() -> Obj
) {
addClassFn(name, isOpen, code)
addClassFn(name, isOpen, callSignature, code)
BuiltinDocRegistry.module(moduleName ?: ownerModuleNameFromClassOrUnknown()) {
classDoc(this@addClassFnDoc.className, doc = "") {
method(name = name, doc = doc, params = params, returns = returns, isStatic = true, tags = tags)
@@ -30,6 +30,8 @@ class LambdaFnRef(
val argsDeclaration: ArgsDeclaration?,
val captureEntries: List<LambdaCaptureEntry>,
val inferredReturnClass: ObjClass?,
val inlineBodyRef: ObjRef?,
val supportsDirectInvokeFastPath: Boolean,
val preferredThisType: String?,
val wrapAsExtensionCallable: Boolean,
val returnLabels: Set<String>,
@@ -24,6 +24,7 @@ import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonNull
import kotlinx.serialization.serializer
import net.sergeych.lyng.BytecodeCallable
import net.sergeych.lyng.*
import net.sergeych.lyng.InteropOperator
import net.sergeych.lyng.OperatorInteropRegistry
@@ -723,40 +724,39 @@ open class Obj {
scope.raiseNotImplemented()
}
suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments, declaringClass: ObjClass? = null): Obj {
val usePool = PerfFlags.SCOPE_POOL && this !is Statement
private suspend fun invokeWithBoundScope(
scope: Scope,
args: Arguments,
thisObj: Obj,
declaringClass: ObjClass? = null,
atPos: Pos = scope.pos
): Obj {
val usePool = PerfFlags.SCOPE_POOL && this !is Statement && atPos == scope.pos
return if (usePool) {
scope.withChildFrame(args, newThisObj = thisObj) { child ->
if (declaringClass != null) child.currentClassCtx = declaringClass
callOn(child)
(this as? BytecodeCallable)?.callOnFast(child) ?: callOn(child)
}
} else {
callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj).also {
val child = scope.createChildScope(atPos, args = args, newThisObj = thisObj).also {
if (declaringClass != null) it.currentClassCtx = declaringClass
})
}
(this as? BytecodeCallable)?.callOnFast(child) ?: callOn(child)
}
}
suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments, declaringClass: ObjClass? = null): Obj {
return invokeWithBoundScope(scope, args, thisObj, declaringClass)
}
suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
callOn(
scope.createChildScope(
scope.pos,
args = Arguments(args.toList()),
newThisObj = thisObj
)
)
invokeWithBoundScope(scope, Arguments(args.toList()), thisObj)
suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
callOn(
scope.createChildScope(
scope.pos,
args = Arguments.EMPTY,
newThisObj = thisObj
)
)
invokeWithBoundScope(scope, Arguments.EMPTY, thisObj)
suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
callOn(scope.createChildScope(atPos, args = args, newThisObj = thisObj))
invokeWithBoundScope(scope, args, thisObj, atPos = atPos)
val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
@@ -828,7 +828,13 @@ open class Obj {
name = "let",
doc = "Calls the specified function block with `this` value as its argument and returns its result.",
params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.UNARY_ARGUMENT,
result = CallSignature.ResultMode.BLOCK_RESULT
)
)
) {
call(args.firstAndOnly(), Arguments(thisObj))
}
@@ -836,7 +842,13 @@ open class Obj {
name = "apply",
doc = "Calls the specified function block with `this` value as its receiver and returns `this` value.",
params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.RECEIVER,
result = CallSignature.ResultMode.RETURN_RECEIVER
)
)
) {
val body = args.firstAndOnly()
val scope = requireScope()
@@ -852,7 +864,13 @@ open class Obj {
name = "also",
doc = "Calls the specified function block with `this` value as its argument and returns `this` value.",
params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.UNARY_ARGUMENT,
result = CallSignature.ResultMode.RETURN_RECEIVER
)
)
) {
call(args.firstAndOnly(), Arguments(thisObj))
thisObj
@@ -861,7 +879,13 @@ open class Obj {
name = "run",
doc = "Calls the specified function block with `this` value as its receiver and returns its result.",
params = listOf(ParamDoc("block")),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.RECEIVER,
result = CallSignature.ResultMode.BLOCK_RESULT
)
)
) {
call(args.firstAndOnly())
}
@@ -809,7 +809,8 @@ open class ObjClass(
if (initStmt is net.sergeych.lyng.Statement) {
executeBytecodeWithSeed(instance.instanceScope, initStmt, "instance init")
} else {
initStmt.callOn(instance.instanceScope)
(initStmt as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(instance.instanceScope)
?: initStmt.callOn(instance.instanceScope)
}
}
} finally {
@@ -821,13 +822,14 @@ open class ObjClass(
c.instanceConstructor?.let { ctor ->
val execScope =
instance.instanceScope.createChildScope(args = argsForThis ?: Arguments.EMPTY, newThisObj = instance)
ctor.callOn(execScope)
(ctor as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(execScope) ?: ctor.callOn(execScope)
}
}
}
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
return callOn(scope.createChildScope(Arguments(*plainArgs)))
val child = scope.createChildScope(Arguments(*plainArgs))
return (this as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(child) ?: callOn(child)
}
@@ -847,6 +849,7 @@ open class ObjClass(
fieldId: Int? = null,
methodId: Int? = null,
typeDecl: net.sergeych.lyng.TypeDecl? = null,
callSignature: net.sergeych.lyng.CallSignature? = null,
): ObjRecord {
// Validation of override rules: only for non-system declarations
var existing: ObjRecord? = null
@@ -947,6 +950,7 @@ open class ObjClass(
isOverride = isOverride,
isTransient = isTransient,
type = type,
callSignature = callSignature,
typeDecl = typeDecl,
memberName = name,
fieldId = effectiveFieldId,
@@ -959,7 +963,7 @@ open class ObjClass(
}
private fun initClassScope(): Scope {
if (classScope == null) classScope = Scope()
if (classScope == null) classScope = Scope(parent = null)
return classScope!!
}
@@ -973,7 +977,8 @@ open class ObjClass(
isTransient: Boolean = false,
type: ObjRecord.Type = ObjRecord.Type.Field,
fieldId: Int? = null,
methodId: Int? = null
methodId: Int? = null,
callSignature: net.sergeych.lyng.CallSignature? = null
): ObjRecord {
initClassScope()
val existing = classScope!!.objects[name]
@@ -1014,6 +1019,7 @@ open class ObjClass(
writeVisibility,
recordType = type,
isTransient = isTransient,
callSignature = callSignature,
fieldId = effectiveFieldId,
methodId = effectiveMethodId
)
@@ -1033,6 +1039,7 @@ open class ObjClass(
isOverride: Boolean = false,
pos: Pos = Pos.builtIn,
methodId: Int? = null,
callSignature: net.sergeych.lyng.CallSignature? = null,
code: (suspend net.sergeych.lyng.ScopeFacade.() -> Obj)? = null
) {
val stmt = code?.let { ObjExternCallable.fromBridge { it() } } ?: ObjNull
@@ -1040,7 +1047,8 @@ open class ObjClass(
name, stmt, isMutable, visibility, writeVisibility, pos, declaringClass,
isAbstract = isAbstract, isClosed = isClosed, isOverride = isOverride,
type = ObjRecord.Type.Fun,
methodId = methodId
methodId = methodId,
callSignature = callSignature
)
}
@@ -1072,8 +1080,19 @@ open class ObjClass(
}
fun addClassConst(name: String, value: Obj) = createClassField(name, value)
fun addClassFn(name: String, isOpen: Boolean = false, code: suspend net.sergeych.lyng.ScopeFacade.() -> Obj) {
createClassField(name, ObjExternCallable.fromBridge { code() }, isOpen, type = ObjRecord.Type.Fun)
fun addClassFn(
name: String,
isOpen: Boolean = false,
callSignature: net.sergeych.lyng.CallSignature? = null,
code: suspend net.sergeych.lyng.ScopeFacade.() -> Obj
) {
createClassField(
name,
ObjExternCallable.fromBridge { code() },
isOpen,
type = ObjRecord.Type.Fun,
callSignature = callSignature
)
}
@@ -142,7 +142,7 @@ object ObjDecimalSupport {
}
val child = requireScope().createChildScope()
child.addConst(decimalContextVar, context)
block.callOn(child)
(block as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(child) ?: block.callOn(child)
}
registerBuiltinConversions(decimalClass)
registerInterop(decimalClass)
@@ -64,13 +64,19 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
return (callback as? BytecodeLambdaCallable)?.rebindClosure(context) ?: callback
}
private suspend fun callCallback(callback: Obj, child: Scope): Obj {
return (callback as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(child) ?: callback.callOn(child)
}
/**
* Use read callback to dynamically resolve the field name. Note that it does not work
* with method invocation which is implemented separately in [invokeInstanceMethod] below.
*/
override suspend fun readField(scope: Scope, name: String): ObjRecord {
val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
return readCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name))))?.let {
return readCallback?.let { callback ->
callCallback(callback, execBase.createChildScope(Arguments(ObjString(name))))
}?.let {
if (writeCallback != null)
it.asMutable
else
@@ -90,26 +96,34 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
onNotFoundResult: (suspend () -> Obj?)?
): Obj {
val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
val over = readCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name))))
val over = readCallback?.let { callback ->
callCallback(callback, execBase.createChildScope(Arguments(ObjString(name))))
}
return over?.invoke(scope, scope.thisObj, args)
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
writeCallback?.callOn(execBase.createChildScope(Arguments(ObjString(name), newValue)))
writeCallback?.let { callback ->
callCallback(callback, execBase.createChildScope(Arguments(ObjString(name), newValue)))
}
?: super.writeField(scope, name, newValue)
}
override suspend fun getAt(scope: Scope, index: Obj): Obj {
val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
return readCallback?.callOn(execBase.createChildScope(Arguments(index)))
return readCallback?.let { callback ->
callCallback(callback, execBase.createChildScope(Arguments(index)))
}
?: super.getAt(scope, index)
}
override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
val execBase = builderScope?.let { scope.applyClosure(it) } ?: scope
writeCallback?.callOn(execBase.createChildScope(Arguments(index, newValue)))
writeCallback?.let { callback ->
callCallback(callback, execBase.createChildScope(Arguments(index, newValue)))
}
?: super.putAt(scope, index, newValue)
}
@@ -124,7 +138,7 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
// Snapshot the caller scope to capture locals/args even if the runtime pools/reuses frames.
// Module scope should stay late-bound to allow extern class rebinding and similar updates.
delegate.builderScope = if (scope is net.sergeych.lyng.ModuleScope) null else scope.snapshotForClosure()
builder.callOn(buildScope)
(builder as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(buildScope) ?: builder.callOn(buildScope)
return delegate
}
@@ -395,8 +395,17 @@ suspend fun Obj.getLyngExceptionMessageWithStackTrace(scope: Scope? = null,showD
var at = "unknown"
val stack = if (!trace.list.isEmpty()) {
val first = trace.list[0]
at = (first.readField(s, "at").value as ObjString).value
"\n" + trace.list.map { " at " + it.toString(s).value }.joinToString("\n")
suspend fun formatTraceEntry(entry: Obj): String {
return when (entry) {
is ObjString -> entry.value.removePrefix("#")
else -> entry.toString(s).value
}
}
at = when (first) {
is ObjString -> formatTraceEntry(first)
else -> (first.readField(s, "at").value as ObjString).value
}
"\n" + trace.list.map { " at " + formatTraceEntry(it) }.joinToString("\n")
} else {
val pos = s.pos
if (pos.source.fileName.isNotEmpty() && pos.currentLine.isNotEmpty()) {
@@ -81,7 +81,7 @@ private suspend fun createLyngFlowInput(scope: Scope, producer: Obj, ownerSessio
val runProducer: suspend CoroutineScope.() -> Unit = {
var failure: Throwable? = null
try {
producer.callOn(builderScope)
(producer as? net.sergeych.lyng.BytecodeCallable)?.callOnFast(builderScope) ?: producer.callOn(builderScope)
} catch (x: ScriptFlowIsNoMoreCollected) {
// premature flow closing, OK
} catch (x: Throwable) {
@@ -18,6 +18,7 @@
package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.CallSignature
import net.sergeych.lyng.miniast.ParamDoc
import net.sergeych.lyng.miniast.addFnDoc
import net.sergeych.lyng.miniast.addPropertyDoc
@@ -189,7 +190,13 @@ val ObjIterable by lazy {
doc = "Build a map from elements using the lambda result as key.",
params = listOf(ParamDoc("keySelector")),
returns = type("lyng.Map"),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.ITERABLE,
result = CallSignature.ResultMode.ASSOCIATE_BY
)
)
) {
val association = requireOnlyArg<Obj>()
val result = ObjMap()
@@ -204,7 +211,13 @@ val ObjIterable by lazy {
doc = "Apply the lambda to each element in iteration order.",
params = listOf(ParamDoc("action")),
isOpen = true,
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.ITERABLE,
result = CallSignature.ResultMode.FOR_EACH
)
)
) {
val scope = requireScope()
val it = thisObj.invokeInstanceMethod(scope, "iterator")
@@ -222,7 +235,13 @@ val ObjIterable by lazy {
params = listOf(ParamDoc("transform")),
returns = type("lyng.List"),
isOpen = true,
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.ITERABLE,
result = CallSignature.ResultMode.MAP
)
)
) {
val fn = requiredArg<Obj>(0)
val result = mutableListOf<Obj>()
@@ -238,7 +257,13 @@ val ObjIterable by lazy {
params = listOf(ParamDoc("transform")),
returns = type("lyng.List"),
isOpen = true,
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.ITERABLE,
result = CallSignature.ResultMode.MAP_NOT_NULL
)
)
) {
val fn = requiredArg<Obj>(0)
val result = mutableListOf<Obj>()
@@ -30,19 +30,27 @@ import net.sergeych.lynon.LynonEncoder
import net.sergeych.lynon.LynonType
open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
private var boxedList: MutableList<Obj>? = null
private var primitiveIntList: LongArray? = null
internal var boxedList: MutableList<Obj>? = null
internal var primitiveIntList: LongArray? = null
// Logical size of primitiveIntList; capacity = primitiveIntList!!.size
internal var primitiveIntSize: Int = 0
init {
if (!adoptPrimitiveIntList(initialList)) {
boxedList = initialList
if (initialList.isNotEmpty()) {
if (!adoptPrimitiveIntList(initialList)) {
boxedList = initialList
}
}
// Empty initialList: both null — lazy mode, avoids boxing on first append
}
val list: MutableList<Obj>
get() = ensureBoxedList()
internal fun sizeFast(): Int = primitiveIntList?.size ?: boxedList?.size ?: 0
internal fun sizeFast(): Int = when {
primitiveIntList != null -> primitiveIntSize
else -> boxedList?.size ?: 0
}
internal fun getObjAtFast(index: Int): Obj =
primitiveIntList?.let { ObjInt.of(it[index]) } ?: boxedList!![index]
@@ -80,9 +88,24 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
internal fun appendFast(value: Obj) {
val ints = primitiveIntList
if (ints != null && value is ObjInt) {
primitiveIntList = ints.copyOf(ints.size + 1).also { it[ints.size] = value.value }
return
if (value is ObjInt) {
if (ints != null) {
// Primitive mode: amortized growth (no copy when capacity allows)
if (primitiveIntSize < ints.size) {
ints[primitiveIntSize++] = value.value
} else {
val grown = ints.copyOf(maxOf(ints.size * 2, 16))
grown[primitiveIntSize++] = value.value
primitiveIntList = grown
}
return
}
if (boxedList == null) {
// Lazy empty state: first int element starts primitive mode
primitiveIntList = LongArray(16).also { it[0] = value.value }
primitiveIntSize = 1
return
}
}
ensureBoxedList().add(value)
}
@@ -91,10 +114,12 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
val ints = primitiveIntList
val otherInts = other.primitiveIntList
if (ints != null && otherInts != null) {
primitiveIntList = LongArray(ints.size + otherInts.size).also {
ints.copyInto(it, 0, 0, ints.size)
otherInts.copyInto(it, ints.size, 0, otherInts.size)
}
val otherSize = other.primitiveIntSize
val newSize = primitiveIntSize + otherSize
val dest = if (newSize <= ints.size) ints else ints.copyOf(newSize)
otherInts.copyInto(dest, primitiveIntSize, 0, otherSize)
primitiveIntList = dest
primitiveIntSize = newSize
return
}
ensureBoxedList().addAll(other.list)
@@ -108,6 +133,7 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
ints[i] = value.value
}
primitiveIntList = ints
primitiveIntSize = ints.size
boxedList = null
return true
}
@@ -120,12 +146,13 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
boxedList = empty
return empty
}
val materialized = ArrayList<Obj>(ints.size)
for (value in ints) {
materialized.add(ObjInt.of(value))
val materialized = ArrayList<Obj>(primitiveIntSize)
for (i in 0..<primitiveIntSize) {
materialized.add(ObjInt.of(ints[i]))
}
boxedList = materialized
primitiveIntList = null
primitiveIntSize = 0
return materialized
}
@@ -138,8 +165,9 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
}
}
internal constructor(intValues: LongArray) : this(mutableListOf()) {
internal constructor(intValues: LongArray, size: Int = intValues.size) : this(mutableListOf()) {
primitiveIntList = intValues
primitiveIntSize = size
boxedList = null
}
@@ -253,9 +281,11 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
val ints = primitiveIntList
val otherInts = other.primitiveIntList
if (ints != null && otherInts != null) {
ObjList(LongArray(ints.size + otherInts.size).also {
ints.copyInto(it, 0, 0, ints.size)
otherInts.copyInto(it, ints.size, 0, otherInts.size)
val mySize = primitiveIntSize
val otherSize = other.primitiveIntSize
ObjList(LongArray(mySize + otherSize).also {
ints.copyInto(it, 0, 0, mySize)
otherInts.copyInto(it, mySize, 0, otherSize)
})
} else {
ObjList((list + other.list).toMutableList())
@@ -276,7 +306,9 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
open override suspend fun plusAssign(scope: Scope, other: Obj): Obj {
if (other is ObjList) {
if (other is ObjInt || other is ObjString || other is ObjBool || other is ObjReal || other is ObjNull) {
appendFast(other)
} else if (other is ObjList) {
appendAllFast(other)
} else if (!shouldTreatAsSingleElement(scope, other) && other.isInstanceOf(ObjIterable)) {
val otherList = (other.invokeInstanceMethod(scope, "toList") as ObjList).list
@@ -327,8 +359,8 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
override suspend fun contains(scope: Scope, other: Obj): Boolean {
val ints = primitiveIntList
if (ints != null && other is ObjInt) {
for (value in ints) {
if (value == other.value) return true
for (i in 0..<primitiveIntSize) {
if (ints[i] == other.value) return true
}
return false
}
@@ -351,8 +383,8 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
override suspend fun enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
val ints = primitiveIntList
if (ints != null) {
for (value in ints) {
if (!callback(ObjInt.of(value))) break
for (i in 0..<primitiveIntSize) {
if (!callback(ObjInt.of(ints[i]))) break
}
return
}
@@ -366,7 +398,7 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
override suspend fun toKotlin(scope: Scope): Any {
val ints = primitiveIntList
if (ints != null) return ints.map { it }
if (ints != null) return (0..<primitiveIntSize).map { ints[it] }
return list.map { it.toKotlin(scope) }
}
@@ -398,19 +430,24 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
}
override fun hashCode(): Int {
return primitiveIntList?.contentHashCode() ?: list.hashCode()
val ints = primitiveIntList
return if (ints != null) {
var result = 1
for (i in 0..<primitiveIntSize) result = 31 * result + ints[i].hashCode()
result
} else list.hashCode()
}
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (other == null || this::class != other::class) return false
other as ObjList
val ints = primitiveIntList
val otherInts = other.primitiveIntList
return if (ints != null && otherInts != null) {
ints.contentEquals(otherInts)
if (primitiveIntSize != other.primitiveIntSize) return false
for (i in 0..<primitiveIntSize) if (ints[i] != otherInts[i]) return false
true
} else {
list == other.list
}
@@ -419,7 +456,9 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
val ints = primitiveIntList
if (ints != null) {
encoder.encodeAnyList(scope, ints.mapTo(ArrayList(ints.size)) { ObjInt.of(it) })
val boxed = ArrayList<Obj>(primitiveIntSize)
for (i in 0..<primitiveIntSize) boxed.add(ObjInt.of(ints[i]))
encoder.encodeAnyList(scope, boxed)
return
}
encoder.encodeAnyList(scope, list)
@@ -430,7 +469,7 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
override suspend fun toJson(scope: Scope): JsonElement {
val ints = primitiveIntList
if (ints != null) {
return JsonArray(ints.map { ObjInt.of(it).toJson(scope) })
return JsonArray((0..<primitiveIntSize).map { ObjInt.of(ints[it]).toJson(scope) })
}
return JsonArray(list.map { it.toJson(scope) })
}
@@ -441,9 +480,9 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
var first = true
val ints = primitiveIntList
if (ints != null) {
for (v in ints) {
for (i in 0..<primitiveIntSize) {
if (first) first = false else append(",")
append(v)
append(ints[i])
}
} else {
for (v in list) {
@@ -480,8 +519,8 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
doc = "Append one or more elements to the end of this list.",
moduleName = "lyng.stdlib"
) {
val l = thisAs<ObjList>().list
for (a in args) l.add(a)
val l = thisAs<ObjList>()
for (a in args) l.appendFast(a)
ObjVoid
}
addFnDoc(
@@ -528,6 +567,28 @@ open class ObjList(initialList: MutableList<Obj> = mutableListOf()) : Obj() {
} else self.list.removeLast()
self
}
addFnDoc(
name= "ensureCapacity",
doc = """
ensure the list capacity allows storing specified amount if items without reallocation.
If current capacity is greater or equal to `count`, does nothing. Note that possible reallocation
could be a costly operation,
""".trimIndent(),
params = listOf(ParamDoc("count", type("lyng.Int"))),
moduleName = "lyng.stdlib"
) {
val self = thisAs<ObjList>()
val count = requireOnlyArg<ObjInt>().value.toInt()
if (count > 0) {
val ints = self.primitiveIntList
when {
ints != null -> if (ints.size < count) self.primitiveIntList = ints.copyOf(count)
self.boxedList == null -> { self.primitiveIntList = LongArray(count); self.primitiveIntSize = 0 }
else -> (self.boxedList as? ArrayList)?.ensureCapacity(count)
}
}
self
}
addFnDoc(
name = "removeRange",
@@ -19,6 +19,7 @@ package net.sergeych.lyng.obj
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonObject
import net.sergeych.lyng.CallSignature
import net.sergeych.lyng.Scope
import net.sergeych.lyng.miniast.*
import net.sergeych.lynon.LynonDecoder
@@ -262,7 +263,15 @@ class ObjMap(val map: MutableMap<Obj, Obj> = mutableMapOf()) : Obj() {
doc = "Get value by key or compute, store, and return the default from a lambda.",
params = listOf(ParamDoc("key"), ParamDoc("default")),
returns = type("lyng.Any"),
moduleName = "lyng.stdlib"
moduleName = "lyng.stdlib",
callSignature = CallSignature(
inlineHigherOrder = CallSignature.HigherOrderInline(
kind = CallSignature.Kind.MAP_GET_OR_PUT,
result = CallSignature.ResultMode.BLOCK_RESULT,
argCount = 2,
lambdaArgIndex = 1
)
)
) {
val key = requiredArg<Obj>(0)
thisAs<ObjMap>().map.getOrPut(key) {
@@ -18,6 +18,7 @@
package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.BytecodeCallable
import net.sergeych.lyng.BytecodeBodyProvider
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
@@ -41,14 +42,16 @@ class ObjProperty(
val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope)
val execScope = scope.applyClosure(instanceScope).createChildScope(newThisObj = instance)
execScope.currentClassCtx = declaringClass
(g as? BytecodeCallable)?.callOnFast(execScope)?.let { return it }
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)
if (body != null) executeBytecodeWithSeed(execScope, body, "property getter")
else (g as? BytecodeCallable)?.callOnFast(execScope) ?: g.callOn(execScope)
}
is Statement -> g.callOn(execScope)
else -> g.callOn(execScope)
is Statement -> (g as? BytecodeCallable)?.callOnFast(execScope) ?: g.callOn(execScope)
else -> (g as? BytecodeCallable)?.callOnFast(execScope) ?: g.callOn(execScope)
}
}
@@ -59,14 +62,16 @@ class ObjProperty(
val instanceScope = (instance as? ObjInstance)?.instanceScope ?: instance.autoInstanceScope(scope)
val execScope = scope.applyClosure(instanceScope).createChildScope(args = Arguments(value), newThisObj = instance)
execScope.currentClassCtx = declaringClass
(s as? BytecodeCallable)?.callOnFast(execScope)?.let { return }
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)
if (body != null) executeBytecodeWithSeed(execScope, body, "property setter")
else (s as? BytecodeCallable)?.callOnFast(execScope) ?: s.callOn(execScope)
}
is Statement -> s.callOn(execScope)
else -> s.callOn(execScope)
is Statement -> (s as? BytecodeCallable)?.callOnFast(execScope) ?: s.callOn(execScope)
else -> (s as? BytecodeCallable)?.callOnFast(execScope) ?: s.callOn(execScope)
}
}
@@ -38,17 +38,26 @@ class ImportManager(
val packageNames: List<String> get() = imports.keys.toList()
private class CacheCell(var scope: ModuleScope? = null)
private inner class Entry(
val packageName: String,
val builder: suspend (ModuleScope) -> Unit,
var cachedScope: ModuleScope? = null
val cacheCell: CacheCell = CacheCell()
) {
suspend fun getScope(pos: Pos): ModuleScope {
cachedScope?.let { return it }
return ModuleScope(inner, pos, packageName).apply {
cachedScope = this
builder(this)
cacheCell.scope?.let { return it }
val module = ModuleScope(inner, pos, packageName)
cacheCell.scope = module
return try {
builder(module)
module
} catch (e: Throwable) {
if (cacheCell.scope === module) {
cacheCell.scope = null
}
throw e
}
}
}
@@ -152,14 +161,14 @@ class ImportManager(
op.withLock {
ImportManager(rootScope, securityManager).apply {
for ((name, entry) in this@ImportManager.imports) {
imports[name] = Entry(entry.packageName, entry.builder, entry.cachedScope)
imports[name] = Entry(entry.packageName, entry.builder, entry.cacheCell)
}
}
}
fun invalidatePackageCache(name: String) {
op.withLock {
imports[name]?.cachedScope = null
imports[name]?.cacheCell?.scope = null
}
}
@@ -58,7 +58,10 @@ abstract class Statement(
val type = ObjClass("Callable")
}
suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.createChildScope(args = Arguments(*args)))
suspend fun call(scope: Scope, vararg args: Obj): Obj {
val child = scope.createChildScope(args = Arguments(*args))
return (this as? BytecodeCallable)?.callOnFast(child) ?: execute(child)
}
protected fun bytecodeOnly(scope: Scope, label: String): Nothing {
return scope.raiseIllegalState("bytecode-only execution is required; $label needs compiled bytecode")
@@ -17,8 +17,10 @@
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.*
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.toInt
import kotlin.test.Test
import kotlin.test.assertFalse
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
@@ -161,7 +163,7 @@ class BytecodeRecentOpsTest {
}
@Test
fun listFillIntUsesPrimitiveFillBytecode() = runTest {
fun listFillConstantExpressionUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
@@ -172,26 +174,626 @@ class BytecodeRecentOpsTest {
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("LIST_FILL_INT"), disasm)
assertTrue(disasm.contains("LIST_NEW_INT"), disasm)
assertFalse(disasm.contains("LIST_FILL_INT"), disasm)
assertEquals(4, scope.eval("calc()").toInt())
}
@Test
fun listFillIntWithIndexLambdaKeepsSemantics() = runTest {
fun listFillCapturedExpressionUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val xs = List.fill(5) { it * 3 }
val k = 3
val xs = List.fill(5) { it * k }
xs[0] + xs[4]
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("LIST_FILL_INT"), disasm)
assertTrue(disasm.contains("LIST_NEW_INT"), disasm)
assertFalse(disasm.contains("LIST_FILL_INT"), disasm)
assertEquals(12, scope.eval("calc()").toInt())
}
@Test
fun listFillIdentityUsesIotaBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val xs = List.fill(5) { it }
xs[0] + xs[4]
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("LIST_IOTA_INT"), disasm)
assertEquals(4, scope.eval("calc()").toInt())
}
@Test
fun listFillWithCapacityUsesPrimitiveCapacityBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val xs = List.fill(5, 12) { it * 2 }
xs.add(99)
xs[0] + xs[4] + xs[5]
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("LIST_NEW_INT_CAP"), disasm)
assertFalse(disasm.contains("LIST_FILL_INT_CAP"), disasm)
assertEquals(107, scope.eval("calc()").toInt())
}
@Test
fun directLambdaLiteralCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
{ x -> x + 1 }(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("MAKE_LAMBDA_FN"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun capturedLambdaCanCallListFillOnCapturedClassReceiver() = runTest {
val scope = Script.newScope()
val result = scope.eval(
"""
fun calc(n: Int) {
val xs = { List.fill(n) { it } }()
xs[4]
}
calc(5)
""".trimIndent()
)
assertEquals(4, result.toInt())
}
@Test
fun directLambdaLiteralCallWithCaptureUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val k = 3
{ x -> x * k }(4)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("MAKE_LAMBDA_FN"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(12, scope.eval("calc()").toInt())
}
@Test
fun localImmutableLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val f = { x -> x + 1 }
f(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun localImmutableCapturedLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val k = 3
val f = { x -> x * k }
f(4)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(12, scope.eval("calc()").toInt())
}
@Test
fun aliasedImmutableLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val f = { x -> x + 1 }
val g = f
g(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun topLevelImmutableLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val f = { x -> x + 1 }
fun calc() {
f(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun topLevelAliasedImmutableLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val f = { x -> x + 1 }
val g = f
fun calc() {
g(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun topLevelCapturedLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val k = 3
val f = { x -> x * k }
fun calc() {
f(4)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(12, scope.eval("calc()").toInt())
}
@Test
fun nestedInlineLambdaParamCallAvoidsCallSlot() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
{ g -> g(10) }({ x -> x + 1 })
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun optionalExactLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
type IntFn = (Int)->Int
fun calc() {
val f: IntFn? = { x -> x + 1 }
f?(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun conditionalExactLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val base = { x -> x + 1 }
fun calc(flag: Bool) {
(if(flag) base else base)(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc(true)").toInt())
}
@Test
fun elvisExactLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val base = { x -> x + 1 }
fun calc() {
(null ?: base)(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun castExactLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
type IntFn = (Int)->Int
val base: IntFn = { x -> x + 1 }
fun calc() {
(base as IntFn)(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun whenExactLambdaCallUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val base = { x -> x + 1 }
fun calc(flag: Bool) {
(when(flag) {
true -> base
else -> base
})(10)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(11, scope.eval("calc(true)").toInt())
}
@Test
fun letLiteralUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
10.let { it + 1 }
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun letAliasedLambdaUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val k = 3
val f = { x -> x * k }
4.let(f)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(12, scope.eval("calc()").toInt())
}
@Test
fun alsoLiteralUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
var acc = 0
val result = 10.also { x ->
acc = x + 1
}
acc + result
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(21, scope.eval("calc()").toInt())
}
@Test
fun optionalLetLiteralUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc(flag: Bool) {
val x: Int? = if(flag) 10 else null
x?.let { it + 1 }
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(11, scope.eval("calc(true)").toInt())
assertEquals(ObjNull, scope.eval("calc(false)"))
}
@Test
fun applyReceiverLambdaUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
class Box(value: Int)
fun calc() {
val box = Box(10).apply { value += 1 }
box.value
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun runReceiverLambdaUsesInlineBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
class Box(value: Int)
fun calc() {
Box(10).run { value + 1 }
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(11, scope.eval("calc()").toInt())
}
@Test
fun forEachUsesInlineLoopBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
[1, 2, 3, 4].forEach { it + 1 }
5
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("ITER_PUSH"), disasm)
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(5, scope.eval("calc()").toInt())
}
@Test
fun mapUsesInlineLoopBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val f = { x -> x * 2 }
val xs = [1, 2, 3].map(f)
xs[0] + xs[2]
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("ITER_PUSH"), disasm)
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(8, scope.eval("calc()").toInt())
}
@Test
fun filterUsesInlineLoopBytecode() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val xs = [1, 2, 3, 4].filter { it % 2 == 0 }
xs[0] + xs[1]
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("ITER_PUSH"), disasm)
assertFalse(disasm.contains("CALL_DYNAMIC_MEMBER"), disasm)
assertEquals(6, scope.eval("calc()").toInt())
}
@Test
fun mapLiteralUsesDirectConstructorCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val m = { a: 1, b: 2 }
m.size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(2, scope.eval("calc()").toInt())
}
@Test
fun mapEntryLiteralUsesDirectConstructorCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val e = "a" => 2
e.value
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(2, scope.eval("calc()").toInt())
}
@Test
fun constructorNameUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
Map().size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(0, scope.eval("calc()").toInt())
}
@Test
fun constructorAliasUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val ctor = Map
val m = ctor() as Map
m.size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(0, scope.eval("calc()").toInt())
}
@Test
fun ifExpressionConstructorAliasUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc(flag: Bool) {
val ctor = if(flag) Map else Map
val m = ctor() as Map
m.size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(0, scope.eval("calc(true)").toInt())
}
@Test
fun elvisConstructorAliasUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
val ctor = null ?: Map
val m = ctor() as Map
m.size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(0, scope.eval("calc()").toInt())
}
@Test
fun whenConstructorAliasUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc(flag: Bool) {
val ctor = when(flag) {
true -> Map
else -> Map
}
val m = ctor() as Map
m.size
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(0, scope.eval("calc(true)").toInt())
}
@Test
fun localNamedFunctionUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
fun twice(x: Int) { x * 2 }
twice(3)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(6, scope.eval("calc()").toInt())
}
@Test
fun localNamedFunctionAliasUsesDirectCall() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun calc() {
fun twice(x: Int) { x * 2 }
val f = twice
f(3)
}
""".trimIndent()
)
val disasm = scope.disassembleSymbol("calc")
assertTrue(disasm.contains("CALL_DIRECT"), disasm)
assertFalse(disasm.contains("CALL_SLOT"), disasm)
assertEquals(6, scope.eval("calc()").toInt())
}
@Test
fun optionalIndexPreIncSkipsOnNullReceiver() = runTest {
eval(
@@ -16,11 +16,17 @@
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.Statement
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.obj.ObjDynamic
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjList
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.pacman.ImportManager
@@ -68,6 +74,235 @@ class CompilerVmReviewRegressionTest {
assertContains(ex.errorMessage, "module binding 'answer'")
}
@Test
fun facadeCallUsesPreparedLambdaWithArgs() = runTest {
val lambda = Compiler.compile(
Source(
"<facade-call-lambda>",
"""
val base = 2
{ x -> x + base }
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val callable = lambda.execute(scope)
assertEquals(42, scope.asFacade().call(callable, Arguments(ObjInt.of(40))).toInt())
}
@Test
fun genericInvokeHelpersUsePreparedLambdaEntryPoints() = runTest {
val unaryLambda = Compiler.compile(
Source(
"<generic-invoke-unary>",
"""
val delta = 2
{ x -> x + delta }
""".trimIndent()
),
Script.defaultImportManager
)
val nullaryLambda = Compiler.compile(
Source(
"<generic-invoke-nullary>",
"""
val base = 7
{ base }
""".trimIndent()
),
Script.defaultImportManager
)
val unaryScope = Script.newScope()
val nullaryScope = Script.newScope()
val unaryCallable = unaryLambda.execute(unaryScope)
val nullaryCallable = nullaryLambda.execute(nullaryScope)
assertEquals(42, unaryCallable.invoke(unaryScope, ObjString("receiver"), ObjInt.of(40)).toInt())
assertEquals(7, nullaryCallable.invoke(nullaryScope, ObjString("receiver")).toInt())
assertEquals(
42,
unaryCallable.invoke(
unaryScope,
Pos(Source("<generic-invoke-pos>", ""), 0, 0),
ObjString("receiver"),
Arguments(ObjInt.of(40))
).toInt()
)
}
@Test
fun statementCallUsesPreparedLambdaFastPath() = runTest {
val unaryLambda = Compiler.compile(
Source(
"<statement-call-unary>",
"""
val delta = 2
{ x -> x + delta }
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val callable = unaryLambda.execute(scope) as Statement
assertEquals(42, callable.call(scope, ObjInt.of(40)).toInt())
}
@Test
fun preparedLambdaKeepsImmutableModuleCaptureAcrossOtherScriptsInSameScope() = runTest {
val unaryLambda = Compiler.compile(
Source(
"<cross-script-capture-unary>",
"""
val delta = 2
{ x -> x + delta }
""".trimIndent()
),
Script.defaultImportManager
)
val unrelatedScript = Compiler.compile(
Source(
"<cross-script-capture-unrelated>",
"""
val base = 7
base
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val callable = unaryLambda.execute(scope) as Statement
unrelatedScript.execute(scope)
assertEquals(42, callable.call(scope, ObjInt.of(40)).toInt())
assertEquals(42, scope.asFacade().call(callable, Arguments(ObjInt.of(40))).toInt())
}
@Test
fun dynamicCallbacksUsePreparedLambdaFastPath() = runTest {
val script = Compiler.compile(
Source(
"<dynamic-fast-callbacks>",
"""
var seen = ""
dynamic {
get { name -> name + seen }
set { name, value -> seen = name + "=" + value }
}
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val dynamic = script.execute(scope) as ObjDynamic
assertEquals("foo", (dynamic.readField(scope, "foo").value as ObjString).value)
dynamic.writeField(scope, "foo", ObjInt.of(7))
assertEquals("barfoo=7", (dynamic.getAt(scope, ObjString("bar")) as ObjString).value)
}
@Test
fun higherOrderMethodInliningSupportsCapturedValues() = runTest {
val script = Compiler.compile(
Source(
"<higher-order-inline-captures>",
"""
val suffix = "!"
val offset = 10
var sum = 0
val letResult = "a".let { it + suffix }
val applyResult = List<Int>().apply { add(offset); add(offset + 1) }
val mapped = [1, 2, 3].map { it + offset }
val filtered = [1, 2, 3].filter { it + offset >= 12 }
val notNull = [1, 2, 3].mapNotNull { if (it + offset >= 12) it + offset else null }
val associated = [1, 2, 3].associateBy { "k" + (it + offset) }
[1, 2, 3].forEach { sum += it + offset }
[letResult, applyResult, mapped, filtered, notNull, associated, sum]
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val result = script.execute(scope) as ObjList
assertEquals("a!", (result.list[0] as ObjString).value)
val applied = result.list[1] as ObjList
assertEquals(listOf(10, 11), applied.list.map { it.toInt() })
val mapped = result.list[2] as ObjList
assertEquals(listOf(11, 12, 13), mapped.list.map { it.toInt() })
val filtered = result.list[3] as ObjList
assertEquals(listOf(2, 3), filtered.list.map { it.toInt() })
val notNull = result.list[4] as ObjList
assertEquals(listOf(12, 13), notNull.list.map { it.toInt() })
val associated = result.list[5].toString(scope).value
assertContains(associated, "\"k11\" => 1")
assertContains(associated, "\"k12\" => 2")
assertContains(associated, "\"k13\" => 3")
assertEquals(36, result.list[6].toInt())
}
@Test
fun directLambdaInliningMatchesImplicitItInvocationSemantics() = runTest {
val script = Compiler.compile(
Source(
"<direct-inline-it-semantics>",
"""
val zeroFn = { if (it == void) 1 else 0 }
val multiFn = { it }
val zero = zeroFn()
val multi = multiFn(1, 2, 3)
[zero, multi]
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val result = script.execute(scope) as ObjList
assertEquals(1, result.list[0].toInt())
val multi = result.list[1] as ObjList
assertEquals(listOf(1, 2, 3), multi.list.map { it.toInt() })
}
@Test
fun mapGetOrPutUsesInlineDefaultLambda() = runTest {
val script = Compiler.compile(
Source(
"<map-get-or-put-inline>",
"""
val offset = 10
val m = Map()
val first = m.getOrPut("k") { offset + 1 }
val second = m.getOrPut("k") { offset + 2 }
[first, second, m["k"]]
""".trimIndent()
),
Script.defaultImportManager
)
val scope = Script.newScope()
val result = script.execute(scope) as ObjList
assertEquals(11, result.list[0].toInt())
assertEquals(11, result.list[1].toInt())
assertEquals(11, result.list[2].toInt())
}
@Test
fun subjectlessWhenReportsScriptError() = runTest {
val ex = assertFailsWith<ScriptError> {
@@ -0,0 +1,189 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import kotlin.test.Test
import net.sergeych.lyng.eval as lyngEval
class LaunchPoolTest {
private suspend fun eval(code: String) = withTimeout(2_000L) { lyngEval(code) }
@Test
fun testBasicExecution() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
val d1 = pool.launch { 1 + 1 }
val d2 = pool.launch { "hello" }
pool.closeAndJoin()
assertEquals(2, d1.await())
assertEquals("hello", d2.await())
""".trimIndent())
}
@Test
fun testResultsCollected() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(4)
val jobs = (1..10).map { n -> pool.launch { n * n } }
pool.closeAndJoin()
val results = jobs.map { (it as Deferred).await() }
assertEquals([1,4,9,16,25,36,49,64,81,100], results)
""".trimIndent())
}
@Test
fun testConcurrencyLimit() = runBlocking<Unit> {
eval("""
// With maxWorkers=2, at most 2 tasks run at the same time.
val mu = Mutex()
var active = 0
var maxSeen = 0
val pool = LaunchPool(2)
val jobs = (1..8).map {
pool.launch {
mu.withLock { active++; if (active > maxSeen) maxSeen = active }
delay(5)
mu.withLock { active-- }
}
}
pool.closeAndJoin()
assert(maxSeen <= 2) { "maxSeen was " + maxSeen + ", expected <= 2" }
""".trimIndent())
}
@Test
fun testExceptionCapturedInDeferred() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
val good = pool.launch { 42 }
val bad = pool.launch { throw IllegalArgumentException("boom") }
pool.closeAndJoin()
assertEquals(42, good.await())
assertThrows(IllegalArgumentException) { bad.await() }
""".trimIndent())
}
@Test
fun testPoolContinuesAfterLambdaException() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(1)
val bad = pool.launch { throw IllegalArgumentException("fail") }
val good = pool.launch { "ok" }
pool.closeAndJoin()
assertThrows(IllegalArgumentException) { bad.await() }
assertEquals("ok", good.await())
""".trimIndent())
}
@Test
fun testLaunchAfterCloseAndJoinThrows() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
pool.launch { 1 }
pool.closeAndJoin()
assertThrows(IllegalStateException) { pool.launch { 2 } }
""".trimIndent())
}
@Test
fun testLaunchAfterCancelThrows() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
pool.cancel()
assertThrows(IllegalStateException) { pool.launch { 1 } }
""".trimIndent())
}
@Test
fun testCancelAndJoinWaitsForWorkers() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
pool.launch { delay(5) }
pool.cancelAndJoin()
// pool is now closed — further launches must throw
assertThrows(IllegalStateException) { pool.launch { 1 } }
""".trimIndent())
}
@Test
fun testCloseAndJoinDrainsQueue() = runBlocking<Unit> {
eval("""
val mu = Mutex()
val results = []
val pool = LaunchPool(1) // single worker to force sequential execution
(1..5).forEach { n ->
pool.launch {
delay(1)
mu.withLock { results += n }
}
}
pool.closeAndJoin() // waits for all 5 to complete
assertEquals(5, results.size)
""".trimIndent())
}
@Test
fun testBoundedQueueSuspendsProducer() = runBlocking<Unit> {
eval("""
// queue of 2 + 1 worker; producer can only be 1 ahead of what's running
val pool = LaunchPool(1, 2)
val order = []
val mu = Mutex()
// fill the queue
val d1 = pool.launch { delay(5); mu.withLock { order += 1 } }
val d2 = pool.launch { delay(3); mu.withLock { order += 2 } }
val d3 = pool.launch { delay(3); mu.withLock { order += 3 } }
pool.closeAndJoin()
assertEquals(3, order.size)
""".trimIndent())
}
@Test
fun testUnlimitedQueueDefault() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(4)
val jobs = (1..50).map { n -> pool.launch { n } }
pool.closeAndJoin()
var sum = 0
for (j in jobs) { sum += (j as Deferred).await() }
assertEquals(1275, sum) // 1+2+...+50
""".trimIndent())
}
@Test
fun testIdempotentClose() = runBlocking<Unit> {
eval("""
val pool = LaunchPool(2)
pool.closeAndJoin()
pool.closeAndJoin() // calling again must not throw
pool.cancel() // mixing close calls must not throw either
""".trimIndent())
}
}
@@ -436,4 +436,36 @@ class StdlibTest {
assertEquals(2, x)
""".trimIndent())
}
@Test
fun testListFill() = runTest {
eval("""
val x = List.fill(5) { i -> i * 10 }
assertEquals([0, 10, 20, 30, 40], x)
""".trimIndent())
}
@Test
fun testListFill2() = runTest {
eval("""
val b: List<Int> = List.fill(5,10) { it }
println(b)
assertEquals(b, [0,1,2,3,4])
""".trimIndent())
}
@Test
fun testTypedParamCaptureInClosure() = runTest {
// Regression: typed (Int) parameters lost their value when captured into a closure
// because peekValue() returned null for INT-typed frame slots, causing the capture
// to store a FrameSlotRef as OBJ while bytecode expected INT type.
eval("""
fun makeList(n: Int): List<Int> {
List<Int>().also {
for( i in 0..<n ) it += i
}
}
assertEquals([0,1,2,3,4], makeList(5))
assertEquals([], makeList(0))
""".trimIndent())
}
}
@@ -0,0 +1,107 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.eval
import kotlin.test.Test
/**
* Regression tests for type inference of class fields accessed inside nested closures.
*
* A class field declared as `val foo = SomeType(...)` should have its type inferred as
* `SomeType` everywhere inside the class body, including inside lambdas and closures
* that capture the field via the implicit `this` receiver.
*/
class TypeInferenceTest {
/** Channel field type inferred from constructor — accessed in a launch closure */
@Test
fun testChannelFieldInLaunchClosure() = runBlocking<Unit> {
eval("""
class Foo {
private val ch = Channel(Channel.UNLIMITED)
private val worker = launch {
var item = ch.receive()
while (item != null) {
item = ch.receive()
}
}
fun start() {
ch.send(1)
ch.close()
(worker as Deferred).await()
}
}
Foo().start()
""".trimIndent())
}
/** Mutex field type inferred from constructor — used directly in a method body */
@Test
fun testMutexFieldDirectUse() = runBlocking<Unit> {
eval("""
class Bar {
private val mu = Mutex()
private var count = 0
fun inc() { mu.withLock { count++ } }
fun get() { count }
}
val b = Bar()
b.inc()
b.inc()
assertEquals(2, b.get())
""".trimIndent())
}
/** CompletableDeferred field type inferred — complete/await used directly */
@Test
fun testCompletableDeferredFieldDirectUse() = runBlocking<Unit> {
eval("""
class Baz {
private val d = CompletableDeferred()
fun complete(v) { d.complete(v) }
fun result() { (d as Deferred).await() }
}
val baz = Baz()
launch { baz.complete(42) }
assertEquals(42, baz.result())
""".trimIndent())
}
/** Channel field accessed inside a map closure within class initializer */
@Test
fun testChannelFieldInMapAndLaunchClosure() = runBlocking<Unit> {
eval("""
class Pool(n) {
private val ch = Channel(Channel.UNLIMITED)
private val workers = (1..n).map {
launch {
var item = ch.receive()
while (item != null) {
item = ch.receive()
}
}
}
fun closeAll() {
ch.close()
for (w in workers) { (w as Deferred).await() }
}
}
Pool(2).closeAll()
""".trimIndent())
}
}
@@ -104,14 +104,14 @@ class WebsiteSamplesTest {
val name = "Lyng"
val base = { id:, name: } // Shorthand for id: id, name: name
val full = { ...base, version: "1.5.4", status: "stable" }
val full = { ...base, version: "1.5.5", status: "stable" }
full
""".trimIndent())
assertTrue(result is ObjMap)
val m = result.map
assertEquals(101L, (m[ObjString("id")] as ObjInt).value)
assertEquals("Lyng", (m[ObjString("name")] as ObjString).value)
assertEquals("1.5.4", (m[ObjString("version")] as ObjString).value)
assertEquals("1.5.5", (m[ObjString("version")] as ObjString).value)
assertEquals("stable", (m[ObjString("status")] as ObjString).value)
}
@@ -19,6 +19,8 @@ package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertFailsWith
class OperatorOverloadingTest {
@Test
@@ -63,6 +65,24 @@ class OperatorOverloadingTest {
""".trimIndent())
}
@Test
fun testBuiltinListPlusAssignOnVal() = runTest {
eval("""
val list = [1, 2]
list += 3
assertEquals([1, 2, 3], list)
""".trimIndent())
}
@Test
fun testBuiltinListMinusAssignOnVal() = runTest {
eval("""
val list = [1, 2, 3]
list -= 2
assertEquals([1, 3], list)
""".trimIndent())
}
@Test
fun testPlusAssignFallback() = runTest {
eval("""
@@ -76,6 +96,130 @@ class OperatorOverloadingTest {
""".trimIndent())
}
@Test
fun testPlusAssignFallbackOnValReportsReadonlyError() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
class Vector(var x: Int, var y: Int) {
fun plus(other: Vector) = Vector(this.x + other.x, this.y + other.y)
fun equals(other: Vector) = this.x == other.x && this.y == other.y
}
val v = Vector(1, 2)
v += Vector(3, 4)
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val v")
}
@Test
fun testMinusAssignOverloadingOnVal() = runTest {
eval("""
class Counter(var n: Int) {
fun minusAssign(x: Int) { this.n = this.n - x }
}
val c = Counter(10)
c -= 3
assertEquals(7, c.n)
""".trimIndent())
}
@Test
fun testMinusAssignFallbackOnValReportsReadonlyError() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
class Counter(var n: Int) {
fun minus(x: Int) = Counter(this.n - x)
}
val c = Counter(10)
c -= 3
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val c")
}
@Test
fun testMulAssignOverloadingOnVal() = runTest {
eval("""
class Counter(var n: Int) {
fun mulAssign(x: Int) { this.n = this.n * x }
}
val c = Counter(10)
c *= 3
assertEquals(30, c.n)
""".trimIndent())
}
@Test
fun testMulAssignFallbackOnValReportsReadonlyError() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
class Counter(var n: Int) {
fun times(x: Int) = Counter(this.n * x)
}
val c = Counter(10)
c *= 3
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val c")
}
@Test
fun testDivAssignOverloadingOnVal() = runTest {
eval("""
class Counter(var n: Int) {
fun divAssign(x: Int) { this.n = this.n / x }
}
val c = Counter(21)
c /= 3
assertEquals(7, c.n)
""".trimIndent())
}
@Test
fun testDivAssignFallbackOnValReportsReadonlyError() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
class Counter(var n: Int) {
fun div(x: Int) = Counter(this.n / x)
}
val c = Counter(21)
c /= 3
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val c")
}
@Test
fun testModAssignOverloadingOnVal() = runTest {
eval("""
class Counter(var n: Int) {
fun modAssign(x: Int) { this.n = this.n % x }
}
val c = Counter(23)
c %= 5
assertEquals(3, c.n)
""".trimIndent())
}
@Test
fun testModAssignFallbackOnValReportsReadonlyError() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
class Counter(var n: Int) {
fun mod(x: Int) = Counter(this.n % x)
}
val c = Counter(23)
c %= 5
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val c")
}
@Test
fun testCompareOverloading() = runTest {
eval("""
@@ -0,0 +1,137 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.obj.toInt
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.time.TimeSource
class OptTest {
@Test
fun testAddToArray() = runTest {
val scope = Script.newScope()
scope.eval(
"""
fun buildArray(n: Int) {
val a: List<Int> = List.fill(n) { it * 10 + 1 }
a.size
}
""".trimIndent()
)
repeat(3) { pass ->
val size = scope.eval("buildArray(200000)").toInt()
assertEquals(200000, size, "warmup pass ${pass + 1} failed")
}
val passes = 4
var bestMs = Long.MAX_VALUE
var totalMs = 0L
repeat(passes) { pass ->
val start = TimeSource.Monotonic.markNow()
val size = scope.eval("buildArray(10000000)").toInt()
val elapsedMs = start.elapsedNow().inWholeMilliseconds
assertEquals(10000000, size, "measured pass ${pass + 1} failed")
bestMs = minOf(bestMs, elapsedMs)
totalMs += elapsedMs
println("add-to-array pass ${pass + 1}/$passes: ${elapsedMs}ms size=$size")
}
println("add-to-array best=${bestMs}ms avg=${totalMs / passes}ms after warmup")
}
@Test
fun testAddToArray2() = runTest {
eval(
$$"""
import lyng.time
val n = 700_000
fun tm<T>(block: ()->T): T {
val t = Instant()
block().also {
println("tm: ${Instant() - t}")
}
}
val x = tm { List.fill(n) { it * 10 + 1 } }
val y = tm { List.fill(n, n + 10) { it * 10 + 1 } }
tm { x.add(-1) }
tm { y.add(-2) }
""".trimIndent()
)
}
@Test
fun testErrorMessage() = runTest {
val ex = assertFailsWith<ScriptError> {
eval("""
val a = 1
a++
""".trimIndent())
}
assertContains(ex.errorMessage, "can't reassign val a")
}
@Test
fun testAssignOpErrorMessageFromExample() = runTest {
val source = Source(
"examples/error1.lyng",
"""
val a = 1
a += 2
""".trimIndent()
)
val ex = assertFailsWith<ScriptError> {
Script.newScope().eval(source)
}
assertContains(ex.errorMessage, "can't reassign val a")
}
@Test
fun testClosuresInLaunchPool() = runTest {
eval($$"""
val result = Set()
val mu = Mutex()
fn doSomething(value) {
delay(100)
println(value)
mu.withLock {
result += value
}
}
val lp = LaunchPool(4, 1000)
for (i in 1 .. 10) {
val ii: Int = i
lp.launch {
doSomething( ii )
}
}
println("all tasks were placed into lauchpool")
lp.closeAndJoin()
println("ALL DONE: $result")
assertEquals((1..10).toSet(), result)
""".trimIndent())
}
}
+80 -19
View File
@@ -432,11 +432,18 @@ fun List<T>.sort(): void {
sortWith { a, b -> a <=> b }
}
/* Build a new list of `size` elements by calling `block(index)` for each index. */
static fun List<T>.fill(size: Int, block: (Int)->T): List<T> {
val result = List<T>()
for( i in 0..<size ) result += block(i)
result
/*
Build a new list of `size` elements by calling `block(index)` for each index.
`capacity` less than size is ignored (size will be used as capacity).
*/
static fun List<T>.fill(size: Int, capacity = -1, block: (Int)->T): List<T> {
require(size >= 0, "size must not be negative")
List<T>().also {
if( size > 0 ) {
it.ensureCapacity(capacity < size ? size : capacity)
for( i in 0..<size ) it += block(i)
}
}
}
/* Print this exception and its stack trace to standard output. */
@@ -543,6 +550,18 @@ class StackTraceEntry(
"%s: %s"(at, sourceString)
}
}
// Private helper: starts one LaunchPool worker coroutine for the given queue.
// Defined outside LaunchPool so the global `launch` is not shadowed by the method.
private fun _launchPoolWorker(ch: Channel): Deferred {
launch {
var task = ch.receive()
while (task != null) {
task()
task = ch.receive()
}
}
}
/*
A pool of coroutines that execute submitted tasks with bounded concurrency.
@@ -554,37 +573,79 @@ class StackTraceEntry(
Any exception thrown inside a submitted lambda is captured in the returned
`Deferred` and never escapes the pool itself.
Once `cancel()` or `closeAndJoin()` is called, any further `launch` call
(including one suspended waiting for queue space) throws `IllegalStateException`.
Once `cancel()`, `cancelAndJoin()`, or `closeAndJoin()` is called, any further
`launch` call (including one that was suspended waiting for queue space) throws
`IllegalStateException`.
*/
extern class LaunchPool(maxWorkers: Int, maxQueueSize: Int = Channel.UNLIMITED) {
class LaunchPool(maxWorkers, maxQueueSize = Channel.UNLIMITED) {
private val queue = Channel(maxQueueSize)
private var isClosed = false
private val mu = Mutex()
private val workers = (1..maxWorkers).map { _launchPoolWorker(queue) }
/*
Schedule a lambda for execution and return a Deferred for its result.
Suspends the caller if the queue is full.
Throws `IllegalStateException` if the pool is cancelled or closing.
Suspends the caller if the queue is full (maxQueueSize reached).
Throws `IllegalStateException` if the pool is closed or cancelled.
Any exception thrown by the lambda is captured in the returned Deferred
and does not escape the pool.
*/
extern fun launch<T>( lambda: ()->T ): Deferred<T>
fun launch(lambda) {
mu.withLock {
if (isClosed) throw IllegalStateException("LaunchPool is closed")
}
val d = CompletableDeferred()
val wrapper = {
try { d.complete(lambda()) }
catch(e) { d.completeExceptionally(e) }
}
// send may suspend if the queue is full; throws if pool is closed meanwhile
try {
queue.send(wrapper)
} catch(e: IllegalStateException) {
throw IllegalStateException("LaunchPool is closed")
}
d
}
private fun closeQueue() {
mu.withLock {
if (!isClosed) {
isClosed = true
queue.close()
}
}
}
/*
Immediately cancel all workers and discard any queued tasks.
Running tasks are interrupted via coroutine cancellation.
Tasks suspended at an IO point are interrupted via coroutine cancellation.
After this call, `launch` throws `IllegalStateException`.
*/
extern fun cancel()
fun cancel() {
closeQueue()
workers.forEach { it.cancel() }
}
/*
Like `cancel`, but also waits until any currently-running task has
finished (they will not be interrupted mid-execution).
Useful when workers hold resources (connections, file handles) that
must be released before the caller continues.
Like `cancel`, but cancels all workers and suspends until they all stop.
Worker cancellations are silent — exceptions from cancelled workers are ignored.
After this call, `launch` throws `IllegalStateException`.
*/
extern fun cancelAndJoin()
fun cancelAndJoin() {
closeQueue()
workers.forEach { it.cancel() }
}
/*
Stop accepting new tasks and suspend until all queued and running
tasks have completed normally.
After this call, `launch` throws `IllegalStateException`.
*/
extern fun closeAndJoin()
fun closeAndJoin() {
closeQueue()
for (w in workers) {
w.await()
}
}
}
+5
View File
@@ -13,6 +13,11 @@ Current focus
Key recent changes
- Updated AI helper docs to reflect static typing, type expressions, and compile-time-only name resolution.
- Added stdlib random API: `Random` and deterministic `SeededRandom` with `nextInt`, `nextFloat`, and generic `next(range)`.
- Generalized primitive list optimization for compiler-generated `List.fill`:
- `List.fill(size) { intExpr }` and `List.fill(size, capacity) { intExpr }` now both have bytecode fast paths.
- Added `LIST_NEW_INT_CAP` / `LIST_FILL_INT_CAP` for the 3-arg capacity-preserving form.
- Fixed `ObjList.add(...)` to preserve primitive-int backing storage instead of forcing boxing through `.list`.
- `OptTest.testAddToArray2` no longer shows the old 10x anomaly for `List.fill(n, n + 10)` or append-to-extended-list.
Known failing tests
- None in :lynglib:jvmTest after Random/SeededRandom integration.
+12 -5
View File
@@ -22,18 +22,25 @@ Candidates (not started)
6) Box/unbox audit (done)
- Unbox ObjInt/ObjReal in assign-op when target is INT/REAL to avoid boxing + obj ops.
- MixedCompareBenchmarkTest: 240 ms -> 234 ms.
7) Mixed compare coverage
7) Primitive list fill with capacity (done)
- Extended the compiler/runtime fast path from `List.fill(size) { intExpr }` to `List.fill(size, capacity) { intExpr }`.
- Added `LIST_NEW_INT_CAP` and `LIST_FILL_INT_CAP` so the 3-arg form keeps primitive-int storage instead of falling back to generic stdlib code.
- `OptTest.testAddToArray2`: `List.fill(n, n + 10) { ... }` dropped from the prior anomaly (~10x slower than 2-arg fill) to the same range as `List.fill(n) { ... }`, roughly `56-67 ms` vs `46-75 ms` after warmup.
8) Primitive list append preservation (done)
- Fixed `ObjList.add(...)` to append through the primitive-aware fast path instead of forcing `.list` and boxing the backing storage.
- `OptTest.testAddToArray2`: appending to the pre-extended list dropped from the prior anomaly (~10x slower) to sub-millisecond / low-millisecond timings (`~0.05-0.16 ms` for the extended list path, `~1.6-4.3 ms` for the baseline path, depending on warmup).
9) Mixed compare coverage
- Emit CMP_*_REAL when one operand is known ObjReal in more expression forms (not just assign-op).
- Verify with disassembly that fast cmp opcodes are emitted.
8) Range-loop invariant hoist
10) Range-loop invariant hoist
- Cache range end/step into temps once per loop; avoid repeated slot reads/boxing in body.
- Confirm no extra CONST_OBJ in hot path.
9) Boxing elision pass
11) Boxing elision pass
- Remove redundant BOX_OBJ when value feeds only primitive ops afterward (local liveness).
- Ensure no impact on closures/escaping values.
10) Closed-type fast paths expansion
12) Closed-type fast paths expansion
- Apply closed-type trust for ObjBool/ObjInt/ObjReal/ObjString in ternaries and conditional chains.
- Guard with exact non-null temp/slot checks only.
11) VM hot op micro-optimizations
13) VM hot op micro-optimizations
- Reduce frame reads/writes in ADD_INT, MUL_REAL, CMP_*_INT/REAL when operands are temps.
- Compare against baseline; revert if regression after 10-run median.
@@ -0,0 +1,146 @@
# Non-Suspending Call Optimization Plan
## Current state
Completed in the current phase:
- Higher-order lambda inlining is now metadata-driven through `CallSignature`.
- Built-in member methods (`let`, `also`, `apply`, `run`, `forEach`, `map`, `mapNotNull`, `associateBy`, `getOrPut`) publish inline metadata at declaration sites.
- Lyng extension wrappers now preserve and expose `callSignature`, so extension methods such as `Iterable.filter` use the same inlining path as built-in members.
- `BytecodeCompiler` no longer relies on a backend hardcoded name table for these higher-order inlining cases.
- JVM tests are green after the metadata move.
Primary motivation remains unchanged: suspend call overhead is still significant, and lambda inlining only removes part of it.
## Constraints
- Keep source positions, stack traces, and throw-site reporting correct.
- Do not reintroduce one-off special cases tied to specific stdlib method names.
- Prefer declaration metadata and reusable compiler/runtime mechanisms.
- Preserve Kotlin Multiplatform compatibility in `commonMain`.
- Avoid changing public language semantics just to optimize the runtime path.
## Why this is the next step
Lambda inlining helps when the callee body is directly available at the call site.
The next large remaining cost is calling compiled functions through suspend entry points even when the generated body never suspends.
That suggests a second optimization track:
1. detect bytecode callables that are safe to execute through a non-suspending fast path;
2. route direct calls to that path when the caller can prove it is safe;
3. keep the suspend path as the fallback for correctness.
## Proposed phases
### Phase 1: Define "non-suspending compiled callable"
Add explicit metadata on compiled functions / lambdas indicating whether their bytecode body may suspend.
Requirements:
- Computed once during bytecode generation.
- Conservative: false negatives are acceptable; false positives are not.
- Must account for:
- direct suspend-capable call opcodes;
- flow / coroutine constructs;
- delegated runtime helpers that may suspend;
- nested lambda creation if invocation may suspend.
Likely implementation direction:
- store `maySuspend` or `fastOnly`-adjacent metadata on `CmdFunction` or the callable wrapper;
- derive it from emitted bytecode opcodes and embedded lambda constants.
### Phase 2: Add a direct non-suspending invoke path
For bytecode callables proven non-suspending, add an execution entry point that avoids suspend machinery for ordinary direct calls.
Requirements:
- Reuse as much of the existing fast frame setup as possible.
- Keep exception translation and source mapping identical to the suspend path.
- Do not depend on JVM-only tricks.
Potential direction:
- extend `BytecodeCallable` with a capability query or richer fast-call API;
- let call sites choose among:
- inline body
- non-suspending compiled call
- existing suspend call
### Phase 3: Teach bytecode call sites to use it
Apply the new path only where the callee is known precisely.
Initial targets:
- direct lambda invocation where exact lambda ref is known but inlining is not possible;
- direct local function calls where the binding resolves to a compiled callable;
- extension wrapper calls where wrapper binding is known and non-suspending.
Do not start with dynamic dispatch or reflective calls.
### Phase 4: Validate behavioral fidelity
Must explicitly verify:
- thrown exceptions still report the same Lyng source positions;
- stack traces remain useful enough for debugging;
- optional calls / null propagation are unchanged;
- captures and implicit `this` still bind correctly.
### Phase 5: Measure before broadening
Benchmark after each widening step, especially:
- `OptTest.testAddToArray`
- iterable pipeline samples using `filter` / `map`
- direct lambda call microbenchmarks
- closure-heavy samples with captures
## Open technical questions
1. Where should non-suspending capability live?
- `CmdFunction`
- `BytecodeStatement`
- callable wrapper object
- `CallSignature`-adjacent metadata
2. Should the compiler emit a separate opcode for known non-suspending compiled calls, or should runtime dispatch pick the fast path from a normal call opcode?
3. Can we preserve the current error/stack behavior if we bypass suspend wrappers entirely, or do we need a thin compatibility layer?
4. Should capture-free and capture-heavy compiled lambdas share the same direct-call mechanism, or should captured callables stay on the safer path initially?
## Suggested order of execution
1. Add conservative `maySuspend` analysis for compiled bytecode functions.
2. Expose a non-suspending direct-call capability on compiled callables.
3. Use it for exact direct lambda calls first.
4. Extend to exact local function calls.
5. Re-measure.
6. Only then consider broader dispatch sites.
## Validation checklist
- `./gradlew :lynglib:compileKotlinJvm --console=plain`
- `./gradlew :lynglib:jvmTest --tests net.sergeych.lyng.OptTest.testAddToArray --console=plain`
- `./gradlew :lynglib:jvmTest --tests StdlibTest.testIterableFilter --tests CompilerVmReviewRegressionTest --console=plain`
- `./gradlew :lynglib:jvmTest --console=plain`
## Notes from the completed phase
Relevant current commits before this follow-up work:
- `3be2892` Use fast compiled callbacks in dynamic and flow helpers
- `1d5caaa` Broaden lambda method inlining with captures
- `0c3242c` Generalize higher-order lambda inlining
- `f4ab2eb` Extend lambda inlining to getOrPut and implicit it calls
Current working tree phase adds:
- metadata-driven higher-order inlining through member and extension signatures;
- extension wrapper signature propagation;
- removal of the compiler-side higher-order name table fallback.
+1 -1
View File
@@ -159,7 +159,7 @@ fun HomePage() {
val id = 101
val name = "Lyng"
val base = { id:, name: }
val full = { ...base, version: "1.5.4", status: "stable", tags: ["typed", "portable"] }
val full = { ...base, version: "1.5.5", status: "stable", tags: ["typed", "portable"] }
println(full)
""".trimIndent()