Compare commits
30
Commits
145c3ae34a
...
1.5.5
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
9735774efd | ||
|
|
14214e91e1 | ||
|
|
0f5343fa17 | ||
|
|
d0f51928de | ||
|
|
0973a6afeb | ||
|
|
953f237ca3 | ||
|
|
fbb5688696 | ||
|
|
f4ab2ebab4 | ||
|
|
0c3242cbd8 | ||
|
|
1d5caaa836 | ||
|
|
3be2892025 | ||
|
|
c80900c503 | ||
|
|
ee634c8dff | ||
|
|
6c91b77a85 | ||
|
|
3721ee8332 | ||
|
|
97990f00ce | ||
|
|
80693e7690 | ||
|
|
029fe874fa | ||
|
|
ffa64d691b | ||
|
|
30c9a5a565 | ||
|
|
db3a780645 | ||
|
|
fc7d26ee4b | ||
|
|
a61b5a31be | ||
|
|
33d170f525 | ||
|
|
f72cdfdf83 | ||
|
|
10fa4de4fa | ||
|
|
4acee56de8 | ||
|
|
87060c7eb7 | ||
|
|
6ba128f7ba | ||
|
|
a8f73dc8bd |
No files matched your search
+37
-15
@@ -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)
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
|
||||
@@ -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 |
|
||||
|
||||
|
||||
@@ -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`
|
||||
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
Whitespace-only changes.
@@ -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) }
|
||||
@@ -0,0 +1,2 @@
|
||||
[vps]
|
||||
94.130.36.94 ansible_user=sergeych
|
||||
@@ -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
|
||||
@@ -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";
|
||||
}
|
||||
}
|
||||
@@ -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())
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -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.
|
||||
@@ -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()
|
||||
|
||||
Reference in new issue
Block a user