Compare commits

...
6 Commits
20 changed files with 751 additions and 133 deletions

No files matched your search

+22
View File
@@ -72,6 +72,14 @@ For module-level APIs, the default workflow is:
1. declare globals in Lyng using `extern fun` / `extern val` / `extern var`;
2. bind Kotlin implementation via `ModuleScope.globalBinder()`.
This is also the recommended way to expose a Kotlin-backed value that should behave like a true
Lyng global variable/property. If you need `x` to read/write through Kotlin on every access, use
`extern var` / `extern val` plus `bindGlobalVar(...)`.
Do not use `addConst(...)` for this case: `addConst(...)` installs a value, not a Kotlin-backed
property accessor. It is appropriate for fixed values and objects, but not for a global that should
delegate reads/writes back into Kotlin state.
```kotlin
import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt
@@ -117,6 +125,12 @@ assertEquals("changed", globalProp)
assertEquals("1.0.0", globalVersion)
```
Minimal rule of thumb:
- use `bindGlobalFun(...)` for global functions
- use `bindGlobalVar(...)` for Kotlin-backed global variables/properties
- use `addConst(...)` only for fixed values/objects that do not need getter/setter behavior
For custom argument handling and full runtime access:
```kotlin
@@ -462,14 +476,21 @@ im.addPackage("my.tools") { module: ModuleScope ->
module.eval(
"""
extern val version: String
extern var status: String
extern fun triple(x: Int): Int
""".trimIndent()
)
val binder = module.globalBinder()
var status = "ready"
binder.bindGlobalVar(
name = "version",
get = { "1.0" }
)
binder.bindGlobalVar(
name = "status",
get = { status },
set = { status = it }
)
binder.bindGlobalFun1<Int>("triple") { x ->
ObjInt.of((x * 3).toLong())
}
@@ -479,6 +500,7 @@ im.addPackage("my.tools") { module: ModuleScope ->
scope.eval("""
import my.tools.*
val v = triple(14)
status = "busy"
""")
val v = scope.eval("v").toKotlin(scope) // -> 42
```
@@ -184,6 +184,7 @@ class Compiler(
private val encodedPayloadTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val objectDeclNames: MutableSet<String> = mutableSetOf()
private val externCallableNames: MutableSet<String> = mutableSetOf()
private val externBindingNames: MutableSet<String> = mutableSetOf()
private val moduleDeclaredNames: MutableSet<String> = mutableSetOf()
private var seedingSlotPlan: Boolean = false
@@ -192,6 +193,7 @@ class Compiler(
if (plan.slots.isEmpty()) return emptyMap()
val result = LinkedHashMap<String, ForcedLocalSlotInfo>(plan.slots.size)
for ((name, entry) in plan.slots) {
if (externBindingNames.contains(name)) continue
result[name] = ForcedLocalSlotInfo(
index = entry.index,
isMutable = entry.isMutable,
@@ -581,7 +583,7 @@ class Compiler(
val baseNames = cls.directParents.map { it.className }
val nextFieldId = (fieldIds.values.maxOrNull() ?: -1) + 1
val nextMethodId = (methodIds.values.maxOrNull() ?: -1) + 1
return CompileClassInfo(name, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames)
return CompileClassInfo(name, cls.logicalPackageName, fieldIds, methodIds, nextFieldId, nextMethodId, baseNames)
}
private data class BaseMemberIds(
@@ -885,6 +887,7 @@ class Compiler(
name = declaredName,
isMutable = false,
visibility = Visibility.Public,
actualExtern = false,
initializer = initStmt,
isTransient = false,
typeDecl = null,
@@ -1550,6 +1553,7 @@ class Compiler(
private data class CompileClassInfo(
val name: String,
val packageName: String?,
val fieldIds: Map<String, Int>,
val methodIds: Map<String, Int>,
val nextFieldId: Int,
@@ -1751,6 +1755,7 @@ class Compiler(
enumEntriesByName = enumEntriesByName,
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) as BytecodeStatement
unwrapped to bytecodeStmt.bytecodeFunction()
@@ -1957,6 +1962,9 @@ class Compiler(
val scopeIndex = slotPlanStack.indexOfLast { it.id == slotLoc.scopeId }
if (functionIndex >= 0 && scopeIndex >= functionIndex) return null
val modulePlan = moduleSlotPlan()
if (modulePlan != null && slotLoc.scopeId == modulePlan.id && externBindingNames.contains(name)) {
return null
}
if (useScopeSlots && modulePlan != null && slotLoc.scopeId == modulePlan.id) {
return null
}
@@ -2075,6 +2083,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
)
}
@@ -2105,6 +2114,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
)
}
@@ -2160,6 +2170,7 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
)
}
@@ -2343,6 +2354,7 @@ class Compiler(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.actualExtern,
init,
stmt.isTransient,
stmt.typeDecl,
@@ -6446,7 +6458,7 @@ class Compiler(
WhenStatement(value, cases, elseCase, whenPos)
} else {
// when { cond -> ... }
TODO("when without object is not yet implemented")
throw ScriptError(t.pos, "when without subject is not implemented")
}
return wrapBytecode(stmt)
}
@@ -6699,6 +6711,7 @@ class Compiler(
)
compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName,
packageName = packageName,
fieldIds = fieldIds,
methodIds = methodIds,
nextFieldId = fieldIds.size,
@@ -6821,6 +6834,7 @@ class Compiler(
classCtx?.let { ctx ->
compileClassInfos[className] = CompileClassInfo(
name = className,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId,
@@ -6862,6 +6876,7 @@ class Compiler(
val baseIds = collectBaseMemberIds(baseSpecs.map { it.name })
compileClassInfos[className] = CompileClassInfo(
name = className,
packageName = packageName,
fieldIds = baseIds.fieldIds,
methodIds = baseIds.methodIds,
nextFieldId = baseIds.nextFieldId,
@@ -7110,6 +7125,7 @@ class Compiler(
}
compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId,
@@ -7125,6 +7141,7 @@ class Compiler(
classCtx?.let { ctx ->
compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId,
@@ -7211,6 +7228,7 @@ class Compiler(
}
compileClassInfos[qualifiedName] = CompileClassInfo(
name = qualifiedName,
packageName = packageName,
fieldIds = ctx.memberFieldIds.toMap(),
methodIds = ctx.memberMethodIds.toMap(),
nextFieldId = ctx.nextFieldId,
@@ -8390,7 +8408,7 @@ class Compiler(
is ImplicitThisMethodCallRef -> {
when (directRef.methodName()) {
"iterator" -> ObjIterator
"lazy" -> ObjLazyDelegate.type
"lazy" -> resolveClassByName("lazy") ?: inferMethodCallReturnClass(directRef.methodName())
else -> inferMethodCallReturnClass(directRef.methodName())
}
}
@@ -8409,7 +8427,7 @@ class Compiler(
when {
target is LocalSlotRef -> {
when (target.name) {
"lazy" -> ObjLazyDelegate.type
"lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator
"flow" -> ObjFlow.type
"launch" -> ObjDeferred.type
@@ -8420,7 +8438,7 @@ class Compiler(
}
target is LocalVarRef -> {
when (target.name) {
"lazy" -> ObjLazyDelegate.type
"lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator
"flow" -> ObjFlow.type
"launch" -> ObjDeferred.type
@@ -8459,7 +8477,9 @@ class Compiler(
?: unwrapDirectRef(initializer)?.let { inferObjClassFromRef(it) }
?: throw ScriptError(initializer.pos, "Delegate type must be known at compile time")
if (initClass !== delegateClass &&
initClass.logicalName != delegateClass.logicalName &&
!initClass.allParentsSet.contains(delegateClass) &&
!initClass.allParentsSet.any { it.logicalName == delegateClass.logicalName } &&
!initClass.allImplementingNames.contains(delegateClass.className)
) {
throw ScriptError(
@@ -8549,7 +8569,9 @@ class Compiler(
if (closedParent != null) {
throw ScriptError(Pos.builtIn, "can't inherit from closed class ${closedParent.className}")
}
ObjInstanceClass(info.name, *parents.toTypedArray())
ObjInstanceClass(info.name, *parents.toTypedArray()).apply {
logicalPackageNameOverride = info.packageName
}
}
if (stub is ObjInstanceClass) {
for ((fieldName, fieldId) in info.fieldIds) {
@@ -8893,7 +8915,7 @@ class Compiler(
val effectiveEqToken = if (isProperty) null else eqToken
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
if (!isStatic && declaringClassNameCaptured == null) declareLocalName(name, isMutable)
if (!isStatic && declaringClassNameCaptured == null && !actualExtern) declareLocalName(name, isMutable)
val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) {
SymbolKind.MEMBER
} else {
@@ -8902,6 +8924,8 @@ class Compiler(
resolutionSink?.declareSymbol(name, declKind, isMutable, nameStartPos, isOverride = isOverride)
if (declKind == SymbolKind.MEMBER && extTypeName == null) {
(codeContexts.lastOrNull() as? CodeContext.ClassBody)?.declaredMembers?.add(name)
} else if (actualExtern) {
externBindingNames.add(name)
}
val isDelegate = if (isAbstract || actualExtern) {
@@ -8967,7 +8991,11 @@ class Compiler(
if (isDelegate && initialExpression != null) {
ensureDelegateType(initialExpression)
if (isMutable && resolveInitializerObjClass(initialExpression) == ObjLazyDelegate.type) {
val lazyClass = resolveClassByName("lazy")
if (isMutable &&
lazyClass != null &&
resolveInitializerObjClass(initialExpression)?.logicalName == lazyClass.logicalName
) {
throw ScriptError(initialExpression.pos, "lazy delegate is read-only")
}
}
@@ -9059,6 +9087,7 @@ class Compiler(
name,
isMutable,
visibility,
actualExtern,
initialExpression,
isTransient,
declaredType,
@@ -46,6 +46,28 @@ class Script(
// private val catchReturn: Boolean = false,
) : Statement() {
fun statements(): List<Statement> = statements
/**
* Explicitly apply this script's import/module bindings to [scope] without executing the script.
* This is intended for embedding scenarios where the host owns scope lifecycle and wants
* script-specific imports to be a separate, opt-in preparation step.
*/
suspend fun importInto(scope: Scope, seedScope: Scope = scope): Scope {
prepareScriptScope(scope, seedScope)
return scope
}
/**
* Create a fresh raw module scope and apply this script's import/module bindings to it.
* If [seedScope] is provided, its import provider is reused and seed-bound imports resolve from it.
*/
suspend fun instantiateModule(seedScope: Scope? = null, pos: Pos = this.pos): ModuleScope {
val provider = seedScope?.currentImportProvider ?: defaultImportManager
val module = provider.newModuleAt(pos)
prepareScriptScope(module, seedScope ?: module)
return module
}
override suspend fun execute(scope: Scope): Obj {
scope.pos = pos
val execScope = resolveModuleScope(scope) ?: scope
@@ -75,6 +97,19 @@ class Script(
return ObjVoid
}
private suspend fun prepareScriptScope(scope: Scope, seedScope: Scope) {
if (importBindings.isNotEmpty() || importedModules.isNotEmpty()) {
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)
}
}
}
private suspend fun seedModuleSlots(scope: Scope, seedScope: Scope) {
if (importBindings.isEmpty() && importedModules.isEmpty()) return
seedImportBindings(scope, seedScope)
@@ -505,10 +540,6 @@ class Script(
cachedValue
}
}
addFn("lazy") {
val builder = requireOnlyArg<Obj>()
ObjLazyDelegate(builder, requireScope())
}
addVoidFn("delay") {
val a = args.firstAndOnly()
when (a) {
@@ -24,6 +24,7 @@ class VarDeclStatement(
val name: String,
val isMutable: Boolean,
val visibility: Visibility,
val actualExtern: Boolean,
val initializer: Statement?,
val isTransient: Boolean,
val typeDecl: TypeDecl?,
@@ -42,6 +42,7 @@ class BytecodeCompiler(
private val callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
private val externCallableNames: Set<String> = emptySet(),
private val externBindingNames: Set<String> = emptySet(),
private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
) {
private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
@@ -1088,7 +1089,6 @@ class BytecodeCompiler(
private fun isDelegateClass(receiverClass: ObjClass): Boolean =
receiverClass.className == "Delegate" ||
receiverClass.className == "LazyDelegate" ||
receiverClass.implementingNames.contains("Delegate")
private fun operatorMemberName(op: BinOp): String? = when (op) {
@@ -4508,7 +4508,7 @@ class BytecodeCompiler(
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved)
}
if (useScopeSlots && allowedScopeNames?.contains(name) == true) {
if (useScopeSlots && isPreparedScopeName(name)) {
scopeSlotIndexByName[name]?.let { slot ->
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved)
@@ -8073,7 +8073,7 @@ class BytecodeCompiler(
slotInitClassByKey[ScopeSlotKey(scopeId, slotIndex)] = cls
}
}
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) {
if (allowLocalSlots && slotIndex != null && (stmt.actualExtern || !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = false))) {
val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) {
@@ -8100,7 +8100,7 @@ class BytecodeCompiler(
val scopeId = stmt.spec.scopeId ?: 0
if (slotIndex != null) {
val key = ScopeSlotKey(scopeId, slotIndex)
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId)) {
if (allowLocalSlots && !shouldUseScopeSlotFor(scopeId, stmt.spec.name, isDelegated = false)) {
if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(stmt.spec.name, isMutable = false, isDelegated = false)
}
@@ -8117,7 +8117,7 @@ class BytecodeCompiler(
is DelegatedVarDeclStatement -> {
val slotIndex = stmt.slotIndex
val scopeId = stmt.scopeId ?: 0
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId)) {
if (allowLocalSlots && slotIndex != null && !shouldUseScopeSlotFor(scopeId, stmt.name, isDelegated = true)) {
val key = ScopeSlotKey(scopeId, slotIndex)
declaredLocalKeys.add(key)
if (!localSlotInfoMap.containsKey(key)) {
@@ -8283,15 +8283,26 @@ class BytecodeCompiler(
private fun isModuleSlot(scopeId: Int, name: String?): Boolean {
if (moduleScopeId != null && scopeId != moduleScopeId) return false
val scopeNames = allowedScopeNames ?: scopeSlotNameSet
if (scopeNames == null || name == null) return false
return scopeNames.contains(name)
return isPreparedScopeName(name)
}
private fun shouldUseScopeSlotFor(scopeId: Int): Boolean {
return useScopeSlots && moduleScopeId != null && scopeId == moduleScopeId
}
private fun shouldUseScopeSlotFor(scopeId: Int, name: String, isDelegated: Boolean): Boolean {
if (moduleScopeId == null || scopeId != moduleScopeId) return false
if (isDelegated) return false
if (externBindingNames.contains(name)) return true
return useScopeSlots && isPreparedScopeName(name)
}
private fun isPreparedScopeName(name: String?): Boolean {
if (name == null) return false
if (scopeSlotNameSet?.contains(name) == true) return true
return allowedScopeNames?.contains(name) == true
}
private fun collectLoopVarNames(stmt: Statement) {
if (stmt is BytecodeStatement) {
collectLoopVarNames(stmt.original)
@@ -8400,8 +8411,9 @@ class BytecodeCompiler(
captureSlotKeys.add(key)
return
}
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, ref.name, ref.isDelegated)
val isModuleSlot = if (ref.isDelegated) false else isModuleSlot(scopeId, ref.name)
if (allowLocalSlots && !isModuleSlot) {
if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(ref.name, ref.isMutable, ref.isDelegated)
}
@@ -8448,8 +8460,9 @@ class BytecodeCompiler(
}
captureSlotKeys.add(key)
} else {
val forceScopeSlot = shouldUseScopeSlotFor(scopeId, target.name, target.isDelegated)
val isModuleSlot = if (target.isDelegated) false else isModuleSlot(scopeId, target.name)
if (allowLocalSlots && !isModuleSlot) {
if (allowLocalSlots && !isModuleSlot && !forceScopeSlot) {
if (!localSlotInfoMap.containsKey(key)) {
localSlotInfoMap[key] = LocalSlotInfo(target.name, target.isMutable, target.isDelegated)
}
@@ -87,6 +87,7 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId: Map<Int, Map<Int, ObjClass>> = emptyMap(),
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement {
@@ -122,6 +123,7 @@ class BytecodeStatement private constructor(
callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames,
externBindingNames = externBindingNames,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
)
val compiled = compiler.compileStatement(nameHint, statement)
@@ -236,6 +238,7 @@ class BytecodeStatement private constructor(
stmt.name,
stmt.isMutable,
stmt.visibility,
stmt.actualExtern,
stmt.initializer?.let { unwrapDeep(it) },
stmt.isTransient,
stmt.typeDecl,
@@ -2392,8 +2392,13 @@ class CmdDeclLocal(internal val constId: Int, internal val slot: Int) : Cmd() {
?: error("DECL_LOCAL expects LocalDecl at $constId")
if (slot < frame.fn.scopeSlotCount) {
val target = frame.scopeTarget(slot)
frame.ensureScopeSlot(target, slot)
val value = frame.slotToObj(slot).byValueCopy()
val index = frame.ensureScopeSlot(target, slot)
val raw = target.getSlotRecord(index).value
val value = when (raw) {
is FrameSlotRef -> raw.read()
is RecordSlotRef -> raw.read()
else -> raw
}.byValueCopy()
target.updateSlotFor(
decl.name,
ObjRecord(
@@ -3930,7 +3935,7 @@ class CmdFrame(
} else {
val raw = frame.getRawObj(localIndex)
if (raw == null && name != null) {
val record = scope.get(name)
val record = findNamedExistingRecord(scope, name)
if (record != null) {
val value = record.value
return@mapIndexed when (value) {
@@ -3939,6 +3944,12 @@ class CmdFrame(
else -> ObjRecord(value, isMutable)
}
}
if (hasNamedScopeBinding(scope, name)) {
throw ScriptError(
ensureScope().pos,
"captured binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
}
}
when (raw) {
is FrameSlotRef -> ObjRecord(raw, isMutable)
@@ -3952,22 +3963,27 @@ class CmdFrame(
val target = moduleScope
val name = captureNames?.getOrNull(index)
if (name != null) {
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return@mapIndexed it }
target.getSlotIndexOf(name)?.let { return@mapIndexed target.getSlotRecord(it) }
target.get(name)?.let { return@mapIndexed it }
findNamedExistingRecord(target, name)?.let { return@mapIndexed it }
// Fallback to current scope in case the module scope isn't in the parent chain
// or doesn't carry the imported symbol yet.
scope.tryGetLocalRecord(scope, name, scope.currentClassCtx)?.let { return@mapIndexed it }
scope.get(name)?.let { return@mapIndexed it }
findNamedExistingRecord(scope, name)?.let { return@mapIndexed it }
}
if (slotId < target.slotCount) {
return@mapIndexed target.getSlotRecord(slotId)
val existing = target.getSlotRecord(slotId)
if (name == null || existing.value !== ObjUnset || hasResolvedNamedScopeBinding(target, name)) {
return@mapIndexed existing
}
}
if (name != null) {
target.applySlotPlan(mapOf(name to slotId))
return@mapIndexed target.getSlotRecord(slotId)
throw ScriptError(
ensureScope().pos,
"module capture '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
}
error("Missing module capture slot $slotId")
throw ScriptError(
ensureScope().pos,
"missing module capture slot $slotId"
)
}
}
}
@@ -4546,7 +4562,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot)
}
fun setAddrObj(addrSlot: Int, value: Obj) {
suspend fun setAddrObj(addrSlot: Int, value: Obj) {
setScopeSlotValueAtAddr(addrSlot, value)
}
@@ -4554,7 +4570,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toLong()
}
fun setAddrInt(addrSlot: Int, value: Long) {
suspend fun setAddrInt(addrSlot: Int, value: Long) {
setScopeSlotValueAtAddr(addrSlot, ObjInt.of(value))
}
@@ -4562,7 +4578,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toDouble()
}
fun setAddrReal(addrSlot: Int, value: Double) {
suspend fun setAddrReal(addrSlot: Int, value: Double) {
setScopeSlotValueAtAddr(addrSlot, ObjReal.of(value))
}
@@ -4570,7 +4586,7 @@ class CmdFrame(
return getScopeSlotValueAtAddr(addrSlot).toBool()
}
fun setAddrBool(addrSlot: Int, value: Boolean) {
suspend fun setAddrBool(addrSlot: Int, value: Boolean) {
setScopeSlotValueAtAddr(addrSlot, if (value) ObjTrue else ObjFalse)
}
@@ -4776,12 +4792,13 @@ class CmdFrame(
private suspend fun getScopeSlotValue(slot: Int): Obj {
val target = scopeTarget(slot)
val name = fn.scopeSlotNames[slot]
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val index = ensureScopeSlot(target, slot)
val record = target.getSlotRecord(index)
val direct = record.value
if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) return direct.read()
val name = fn.scopeSlotNames[slot]
if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name)
if (resolved != null) {
@@ -4802,9 +4819,15 @@ class CmdFrame(
return direct
}
if (name == null) return record.value
val resolved = target.get(name) ?: return record.value
val resolved = target.get(name)
if (resolved == null) {
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, record)
return record.value
}
if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slot, name, hadNamedBinding, resolved)
}
return resolved.value
}
@@ -4812,12 +4835,13 @@ class CmdFrame(
private suspend fun getScopeSlotValueAtAddr(addrSlot: Int): Obj {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot]
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
val hadNamedBinding = name != null && hasResolvedNamedScopeBinding(target, name)
val record = target.getSlotRecord(index)
val direct = record.value
if (direct is FrameSlotRef) return direct.read()
if (direct is RecordSlotRef) return direct.read()
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
if (name != null && record.memberName != null && record.memberName != name) {
val resolved = target.get(name)
if (resolved != null) {
@@ -4838,16 +4862,29 @@ class CmdFrame(
return direct
}
if (name == null) return record.value
val resolved = target.get(name) ?: return record.value
val resolved = target.get(name)
if (resolved == null) {
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, record)
return record.value
}
if (resolved.value !== ObjUnset) {
target.updateSlotFor(name, resolved)
} else {
failMissingPreparedModuleBinding(slotId, name, hadNamedBinding, resolved)
}
return resolved.value
}
private fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
private suspend fun setScopeSlotValueAtAddr(addrSlot: Int, value: Obj) {
val target = addrScopes[addrSlot] ?: error("Address slot $addrSlot is not resolved")
val index = addrIndices[addrSlot]
val record = target.getSlotRecord(index)
val slotId = addrScopeSlots[addrSlot]
val name = fn.scopeSlotNames.getOrNull(slotId)
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty)) {
target.assign(record, name, value)
return
}
target.setSlotValue(index, value)
}
@@ -4875,6 +4912,41 @@ class CmdFrame(
return index
}
private fun hasNamedScopeBinding(target: Scope, name: String): Boolean {
if (target.tryGetLocalRecord(target, name, target.currentClassCtx) != null) return true
if (target.getSlotIndexOf(name) != null) return true
if (target.get(name) != null) return true
return false
}
private fun hasResolvedNamedScopeBinding(target: Scope, name: String): Boolean =
findNamedExistingRecord(target, name) != null
private fun findNamedExistingRecord(target: Scope, name: String): ObjRecord? {
target.tryGetLocalRecord(target, name, target.currentClassCtx)?.let { return it }
target.get(name)?.let { record ->
if (record.value !== ObjUnset || record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) {
return record
}
}
return null
}
private fun failMissingPreparedModuleBinding(
slot: Int,
name: String,
hadNamedBinding: Boolean,
record: ObjRecord
) {
if (hadNamedBinding) return
if (record.value !== ObjUnset) return
if (fn.scopeSlotIsModule.getOrNull(slot) != true) return
throw ScriptError(
ensureScope().pos,
"module binding '$name' is not available in the execution scope; prepare the script imports/module bindings explicitly"
)
}
private fun ensureLocalMutable(localIndex: Int) {
val name = fn.localSlotNames.getOrNull(localIndex) ?: return
val isMutable = fn.localSlotMutables.getOrNull(localIndex) ?: true
@@ -36,7 +36,7 @@ internal suspend fun seedFrameLocalsFromScope(frame: CmdFrame, scope: Scope) {
} else {
record.value
}
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, base + i)) {
if (value is net.sergeych.lyng.FrameSlotRef && value.refersTo(frame.frame, i)) {
continue
}
frame.setObjUnchecked(base + i, value)
@@ -106,10 +106,20 @@ open class ObjClass(
vararg parents: ObjClass,
) : Obj() {
private fun declaringModulePackageName(scope: Scope?): String? {
var current = scope
while (current != null) {
if (current is ModuleScope) return current.packageName
current = current.parent
}
return null
}
var isAnonymous: Boolean = false
var isAbstract: Boolean = false
var isClosed: Boolean = false
var logicalPackageNameOverride: String? = null
// Stable identity and simple structural version for PICs
val classId: Long = ClassIdGen.nextId()
@@ -169,6 +179,16 @@ open class ObjClass(
*/
var classScope: Scope? = null
/**
* Stable logical identity for class matching across separately instantiated modules.
* Uses declaring module package plus class name when available.
*/
val logicalPackageName: String?
get() = logicalPackageNameOverride ?: declaringModulePackageName(classScope)
val logicalName: String
get() = logicalPackageName?.let { "$it::$className" } ?: className
/** Direct parents in declaration order (kept deterministic). */
val directParents: List<ObjClass> = parents.toList()
@@ -129,6 +129,7 @@ open class ObjDynamic(var readCallback: Obj? = null, var writeCallback: Obj? = n
}
val type = object : ObjClass("Delegate") {}.apply {
logicalPackageNameOverride = "lyng.stdlib"
addFn("getValue") { raiseError("Delegate.getValue is not implemented") }
addFn("setValue") { raiseError("Delegate.setValue is not implemented") }
addFn("invoke") { raiseError("Delegate.invoke is not implemented") }
@@ -1,86 +0,0 @@
/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package net.sergeych.lyng.obj
import net.sergeych.lyng.Arguments
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Statement
import net.sergeych.lyng.Visibility
import net.sergeych.lyng.executeBytecodeWithSeed
/**
* Lazy delegate used by `val x by lazy { ... }`.
*/
class ObjLazyDelegate(
private val builder: Obj,
private val capturedScope: Scope,
) : Obj() {
override val objClass: ObjClass = type
private var calculated = false
private var cachedValue: Obj = ObjVoid
override suspend fun invokeInstanceMethod(
scope: Scope,
name: String,
args: Arguments,
onNotFoundResult: (suspend () -> Obj?)?,
): Obj {
return when (name) {
"getValue" -> {
if (!calculated) {
val callScope = capturedScope.createChildScope(capturedScope.pos, args = Arguments.EMPTY)
cachedValue = if (builder is Statement) {
executeBytecodeWithSeed(callScope, builder, "lazy delegate")
} else {
builder.callOn(callScope)
}
calculated = true
}
cachedValue
}
"setValue" -> scope.raiseIllegalAssignment("lazy delegate is read-only")
else -> super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
}
}
companion object {
val type = ObjClass("LazyDelegate").apply {
implementingNames.add("Delegate")
createField(
"getValue",
ObjNull,
isMutable = false,
visibility = Visibility.Public,
pos = Pos.builtIn,
declaringClass = this,
type = ObjRecord.Type.Fun
)
createField(
"setValue",
ObjNull,
isMutable = false,
visibility = Visibility.Public,
pos = Pos.builtIn,
declaringClass = this,
type = ObjRecord.Type.Fun
)
}
}
}
@@ -0,0 +1,88 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.pacman.ImportManager
import kotlin.test.Test
import kotlin.test.assertContains
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
class CompilerVmReviewRegressionTest {
@Test
fun missingModuleCaptureFailsFastInsteadOfBecomingUnset() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<missing-module-capture>",
"""
import foo
fun make() = { answer }
make()
""".trimIndent()
),
manager
)
val prepared = manager.newModule()
script.importInto(prepared)
val preparedLambda = script.execute(prepared)
assertEquals(42, prepared.asFacade().call(preparedLambda).toInt())
val rawModule = manager.newModule()
val hostScope = Scope(parent = rawModule, thisObj = ObjString("receiver"))
val lambda = script.execute(hostScope)
val ex = assertFailsWith<ScriptError> {
hostScope.asFacade().call(lambda)
}
assertContains(ex.errorMessage, "module binding 'answer'")
}
@Test
fun subjectlessWhenReportsScriptError() = runTest {
val ex = assertFailsWith<ScriptError> {
Compiler.compile(
Source(
"<when-without-subject>",
"""
when {
true -> 1
}
""".trimIndent()
),
Script.defaultImportManager
)
}
assertContains(ex.errorMessage, "when without subject")
}
}
@@ -0,0 +1,52 @@
/*
* 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.bridge.bindGlobalVar
import net.sergeych.lyng.bridge.globalBinder
import kotlin.test.Test
import kotlin.test.assertEquals
class GlobalPropertyCaptureRegressionTest {
@Test
fun externGlobalVarAssignmentInsideFunctionShouldCallBoundSetter() = runTest {
val scope = Script.newScope()
var x = 1.0
scope.eval(
"""
extern var X: Real
fun main() {
X = X + 1.0
}
""".trimIndent()
)
scope.globalBinder().bindGlobalVar(
name = "X",
get = { x },
set = { x = it }
)
scope.eval("main()")
assertEquals(2.0, x, "bound extern var should stay live inside function bodies")
}
}
@@ -0,0 +1,87 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Script
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.toInt
import net.sergeych.lyng.pacman.ImportManager
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertNull
class ScriptImportPreparationTest {
@Test
fun scriptImportIntoExplicitlyPreparesExistingScope() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<prepare-scope>",
"""
import foo
answer
""".trimIndent()
),
manager
)
val scope = manager.newModule()
assertNull(scope["answer"])
script.importInto(scope)
val record = assertNotNull(scope["answer"])
assertEquals(42, scope.resolve(record, "answer").toInt())
}
@Test
fun scriptInstantiateModuleUsesSeedScopeImportProvider() = runTest {
val manager = ImportManager()
manager.addTextPackages(
"""
package foo
val answer = 42
""".trimIndent()
)
val script = Compiler.compile(
Source(
"<instantiate-module>",
"""
import foo
answer
""".trimIndent()
),
manager
)
val seedScope = manager.newModule()
val module = script.instantiateModule(seedScope)
val record = assertNotNull(module["answer"])
assertEquals(42, module.resolve(record, "answer").toInt())
}
}
@@ -0,0 +1,60 @@
/*
* Copyright 2026 Sergey S. Chernov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import kotlinx.coroutines.test.runTest
import net.sergeych.lyng.FrameSlotRef
import net.sergeych.lyng.Pos
import net.sergeych.lyng.Scope
import net.sergeych.lyng.bytecode.BytecodeConst
import net.sergeych.lyng.bytecode.CmdFrame
import net.sergeych.lyng.bytecode.CmdFunction
import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.bytecode.seedFrameLocalsFromScope
import kotlin.test.Test
import kotlin.test.assertNull
class SeedLocalsRegressionTest {
@Test
fun seedFrameLocalsSkipsSelfReferentialFrameSlotRef() = runTest {
val fn = CmdFunction(
name = "seed-self-ref",
localCount = 1,
addrCount = 0,
returnLabels = emptySet(),
scopeSlotCount = 1,
scopeSlotIndices = intArrayOf(0),
scopeSlotNames = arrayOf(null),
scopeSlotIsModule = booleanArrayOf(false),
localSlotNames = arrayOf("x"),
localSlotMutables = booleanArrayOf(true),
localSlotDelegated = booleanArrayOf(false),
localSlotCaptures = booleanArrayOf(false),
constants = listOf(BytecodeConst.IntVal(0)),
cmds = emptyArray(),
posByIp = emptyArray()
)
val scope = Scope(null, pos = Pos.builtIn)
val record = scope.addConst("x", net.sergeych.lyng.obj.ObjInt.of(1))
val frame = CmdFrame(CmdVm(), fn, scope, emptyList())
record.value = FrameSlotRef(frame.frame, 0)
scope.updateSlotFor("x", record)
seedFrameLocalsFromScope(frame, scope)
assertNull(frame.frame.getRawObj(0))
}
}
@@ -212,6 +212,96 @@ class DelegationTest {
assertTrue(badThrown)
}
@Test
fun testPureLyngLazyPreservesReceiverAndClosure() = runTest {
val scope = Script.newScope()
scope.eval(
"""
val GLOBAL_NUMBERS = [1,2,3]
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset
override fun bind(name: String, access, thisRef: ThisRefType): Object = this
override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset)
value = creator(thisRef)
value as T
}
}
fun pureLazy<T,ThisRefType=Object>(creator: ThisRefType.()->T): Delegate<T,ThisRefType> = PureLazy(creator)
class A {
val numbers = [1,2,3]
val fromThis: List by pureLazy { this.numbers }
val fromScope: List by pureLazy { GLOBAL_NUMBERS }
}
class B {
val a: A by pureLazy { A() }
val test: List by pureLazy { (a as A).fromThis + [4] }
}
assertEquals([1,2,3], A().fromThis)
assertEquals([1,2,3], A().fromScope)
assertEquals([1,2,3,4], B().test)
""".trimIndent()
)
}
@Test
fun testImportedPureLyngLazyPreservesReceiverAndClosure() = runTest {
val scope = Script.newScope()
scope.importManager.addTextPackages(
"""
package repro.lazy
import lyng.stdlib
class PureLazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
if (access != DelegateAccess.Val) throw "lazy delegate can only be used with 'val'"
this
}
override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset)
value = with(thisRef, creator)
value as T
}
}
""".trimIndent()
)
scope.eval(
"""
import repro.lazy
val GLOBAL_NUMBERS = [1,2,3]
class A {
val numbers = [1,2,3]
val fromThis: List by PureLazy { this.numbers }
val fromScope: List by PureLazy { GLOBAL_NUMBERS }
}
class B {
val a: A by PureLazy { A() }
val test: List by PureLazy { (a as A).fromThis + [4] }
}
assertEquals([1,2,3], A().fromThis)
assertEquals([1,2,3], A().fromScope)
assertEquals([1,2,3,4], B().test)
""".trimIndent()
)
}
@Test
fun testLazyIsDelegate() = runTest {
eval("""
+1 -2
View File
@@ -421,7 +421,6 @@ fun with<T,R>(self: T, block: T.()->R): R {
Can only be used with 'val' properties.
*/
class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,ThisRefType> {
private val creator: ThisRefType.()->T = creatorParam
private var value = Unset
override fun bind(name: String, access: DelegateAccess, thisRef: ThisRefType): Object {
@@ -431,7 +430,7 @@ class lazy<T,ThisRefType=Object>(creatorParam: ThisRefType.()->T) : Delegate<T,T
override fun getValue(thisRef: ThisRefType, name: String): T {
if (value == Unset)
value = with(thisRef,creator)
value = with(thisRef, creatorParam)
value as T
}
}
@@ -0,0 +1,69 @@
# :lynglib Compiler and VM Review (2026-03-26)
## Scope
- Reviewed `:lynglib` compiler and bytecode VM paths, focusing on compile/execution correctness.
- Read core files around `Compiler`, `Script`, `BytecodeCompiler`, `CmdRuntime`, `Scope`, `ModuleScope`, and capture/slot plumbing.
- Ran `./gradlew :lynglib:jvmTest` on 2026-03-26: PASS.
## Findings
### 1. High: local seeding uses the wrong slot index when checking for self-referential `FrameSlotRef`
- Status: fixed in worktree on 2026-03-26; covered by `SeedLocalsRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/SeedLocals.kt:39`
- The self-reference guard compares `FrameSlotRef` against `base + i`, but `FrameSlotRef` stores the underlying `BytecodeFrame` local slot index, not the VM absolute slot id.
- The same slot is then written using `setObjUnchecked(base + i, value)` at `SeedLocals.kt:42`, which means a self-reference is not filtered out before being reinserted.
- Impact: this can seed a local with a reference to itself, creating recursive `FrameSlotRef` chains. Reads then recurse through `BytecodeFrame.getObj()` / `FrameSlotRef.read()` instead of resolving to a value, which is a realistic path to stack overflow or non-terminating execution in bytecode-only helper execution (`executeBytecodeWithSeed`).
- Why this looks real: the equivalent check in `CmdFrame.applyCaptureRecords()` uses the local index directly (`CmdRuntime.kt:3867`), and `Script.seedModuleLocals()` also compares with the local index, not `scopeSlotCount + i` (`Script.kt:109`).
- Suggested fix: compare with `i`, not `base + i`, and add a regression test around `executeBytecodeWithSeed` seeding a scope that already contains a `FrameSlotRef` to the same local.
### 2. Design note: script-specific import/module preparation should stay explicit, not hidden in `execute(scope)`
- Status: resolved by API addition, without changing `Script.execute(scope)` semantics.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt:51-57`
- `shouldSeedModule` is only true when `execScope` is a `ModuleScope` or `thisObj === ObjVoid`.
- If a compiled script is executed against a non-module scope with a real receiver object, `seedModuleSlots()` is skipped entirely, so script imports and explicit module bindings are never installed into `moduleTarget`.
- Original concern: top-level bytecode that expects imported names or module globals can see different behavior depending on whether the host prepared the target scope explicitly.
- Resolution taken: do **not** change `Script.execute(scope)`, because in this codebase it is expected to run on exactly the provided scope and many embedding flows already rely on explicit scope setup via `Script.newScope()`, `Scope.eval(...)`, `addFn(...)`, `addConst(...)`, and direct import-manager configuration.
- New explicit APIs added instead:
- `Script.importInto(scope, seedScope = scope)`
- `Script.instantiateModule(seedScope = null, pos = script.pos)`
- This keeps existing execution behavior stable while giving hosts an opt-in way to apply a script's import/module bindings when they actually want that preparation step.
- Coverage added: `ScriptImportPreparationTest`.
### 3. Medium: missing module captures are silently converted into fresh `Unset` slots
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/bytecode/CmdRuntime.kt:3950-3970`
- In `CmdFrame.buildCaptureRecords()`, the module-capture path first tries several lookups. If the requested `slotId` is missing but the capture has a `name`, it calls `target.applySlotPlan(mapOf(name to slotId))` and immediately returns `target.getSlotRecord(slotId)`.
- That record is a newly created placeholder from `Scope.applySlotPlan()` (`Scope.kt:460-471`) and defaults to `ObjUnset`.
- Impact: a compiler/runtime disagreement in capture resolution is masked as a normal capture of `Unset`, so the failure moves far away from closure creation and becomes data corruption or an unrelated later exception. This will be difficult to debug when it happens.
- Resolution taken: the VM now refuses to treat synthetic placeholder slots as real module/captured bindings. Reads and capture construction fail with a source-positioned `ScriptError` when the execution scope was not prepared with the script's required module/import bindings.
### 4. Medium: subject-less `when { ... }` still crashes through a raw Kotlin `TODO`
- Status: fixed in worktree on 2026-03-27; covered by `CompilerVmReviewRegressionTest`.
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt:6447-6449`
- The unsupported branch uses `TODO("when without object is not yet implemented")`.
- Current docs explicitly say subject-less `when` is not implemented, so the language limitation itself is documented. The problem is the failure mode: the compiler throws a raw Kotlin `NotImplementedError` instead of a normal `ScriptError` or a feature diagnostic.
- Impact: IDE/embedding callers get an implementation exception rather than a source-positioned language error, which is especially bad across non-JVM targets and for editor tooling.
- Resolution taken: the parser now throws a normal `ScriptError` at the `when` position with an explicit "when without subject is not implemented" message.
## Risks Worth Checking Next
### 5. Medium risk: module frame growth only retargets records stored in `objects`/`localBindings`
- File: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/ModuleScope.kt:39-67`
- When `ensureModuleFrame()` replaces the old `BytecodeFrame` with a larger one, it retargets `FrameSlotRef`s only in `objects` and `localBindings`.
- Existing closures/capture records that already hold `FrameSlotRef(oldFrame, slot)` are not retargeted here.
- Impact: if a module scope survives across recompilation/re-execution with a larger local frame, previously exported closures can keep reading stale values from the old frame instance.
- Confidence is lower because this depends on module reuse across differing compiled shapes, but the reference-retargeting logic is clearly incomplete for that scenario.
- Suggested check: add a regression covering module re-execution with increased local count and an exported closure captured before the resize.
## Test Status
- `./gradlew :lynglib:jvmTest` passed during this review.
- `./gradlew :lynglib:jvmTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after the fixes/API additions.
- `./gradlew :lynglib:jvmTest --tests CompilerVmReviewRegressionTest --tests ScriptImportPreparationTest --tests SeedLocalsRegressionTest` passed after fixing findings 3 and 4.
- Finding 1 is covered directly; finding 2 is covered by explicit preparation API tests.
## Suggested Fix Order
1. Fix finding 1 first: it is a concrete slot-index bug with likely recursive failure modes. Done.
2. Keep `Script.execute(scope)` semantics stable and use explicit preparation APIs where script-owned import/module setup is needed. Done.
3. Tighten finding 3 next: fail fast on capture mismatches. Done.
4. Replace the raw `TODO` in finding 4 so unsupported syntax produces normal diagnostics. Done.
5. Decide whether finding 5 matters for current module-reload workflows; add a regression before changing behavior.
+46
View File
@@ -0,0 +1,46 @@
WASM использует стековую модель памяти. Lyng стеки не использует. В чем разница?
Стек это очень древняя структура, была придумана в 1955 (магазинная память Бауэра и Самельсона), и приняла современную форму в 1960, благодаря Барбаре Лисокв, вполседствии лауреата премии Тьюринга, которого, в свою очередь, за выдающийся вклад в развитие IT кастрировали, формально, за гомосексуализм, но в британии, где на трех джентльменов приходилось тогда, и приходится и теперь, четыре гомосексуала, все понимают, что это был просто предлог.
Стек был прекрасен в 60е годы, когда IBM планировала продавать по компьютеру в год в лучшем случае, а за идеи о микропроцессорах или ядрах можно было устроиться только пациентом психушки. Стек это заранее жестко выделенная область памяти, которая обычно вообще не используется, и по ней в одну сторону растет используемая область, которая хранит локальные переменные, адреса возврата и иногда состояние процессора.
Она крайне плохо подходит для многозадачности. Представь себе что у тебя есть wasm процесс, со своим стеком, и ему надо переключиться, остановив текущий поток исполнения (например, он ждет ответа от сети). Тогда тебе придется создать _новый стек_ — пока еще пустой, переключиться на него и исполнять там другую задачу. Сколько потоков - столько и стеков. И все они по большей части не используются — там просто запас памяти "на вырост", если исполнение потребует. А оценить заранее адекватно почти невозможно, дают с запасом.
Далее, васм использует фиксированную память выделенную на процесс. Ее тоже приходится брать "с запасом", так как если по ходу не хватит, процесс вылетит. И она тоже в изрядной части пустая. Ну и назасладочку, васм был задуман однозадачным, и все попытки туда хотя бы треды засунуть, получаются очень кривыми.
Линг использует фреймы и сопрограммы. Линг вообще треды не использует. Основная команда исполнения программы на линге - сопрограмма (coroutine), ей не нужен стейк, она им не пользуется. Вместо этого каждый вызов в линге, грубо говоря, это вызов сопрограммы. Для него формируется фрейм (не на стеке, а в динамической памяти!), которого гарантировано достаточно для исполнения собственно кода. Он заменяет собой "стековый фрейм", но его размер известен заранее, и его можно распределять и освобождать проще, как обычную динамическую память.
Далее, линг использует ту же динамическую память, что и его родительская платформа. Если он работает на Java, то использует память со сборкой мусора JVM, на Javascript - память машины JS, в нативных машинах - специальнй менеджер памяти со сборкой мусора, от Kotlin Native (довольно хороший и очень быстро развивающийся). В результате, запустить одновременно десять, или сто тысяч программ на лигне, которые будут исполняться конкурентно, вполне реально. Просто попытка запустить 10к васм-машин на v8 или другом движке скорее всего убьет систему, да и 10 тысяч тредов редко какой сервер приложению даст. Огромный перерасход ресурсов и тормоза.
Далее. Васм СТЕКОВАЯ машина со стековыми командами, он без стека вообще не может. Посмотрим как он считает примитивное выражение:
```wasm
(module
;; Экспортируем функцию, чтобы её можно было вызвать из JS
(func (export "calc") (param $a i32) (param $b i32) (param $c i32) (param $d i32) (result i32)
;; --- вычисление (a + b) / c * d ---
local.get $a ;; помещаем a на стек
local.get $b ;; помещаем b на стек
i32.add ;; складываем: стек содержит (a+b)
local.get $c ;; помещаем c
i32.div_s ;; знаковое деление: стек содержит ((a+b) / c)
local.get $d ;; помещаем d
i32.mul ;; умножение: стек содержит (((a+b)/c) * d)
;; результат остаётся на стеке — это возвращаемое значение функции
)
)
```
На ВМ Линга нет стека, он трехадресный универсальный ассемблер, если можно так сказать:
```
add_int s1, s2 -> s5 // a + b -> s5
div_int s5, s3 -> s5 // s5 -> s5 / c
mul_int s5, s4 -> s5 // s5 -> s5 * d
return s5
```
Этот код крайне эффективно реализуется на любом реальном процессоре, и хорошо оптимизируется. Исполняется он без всякого стека.
+21
View File
@@ -0,0 +1,21 @@
Почему не WASM?
- wasm очень громоздкий и неудобный для разработки, он проектировался очень давно и с другими целями, так что сейчас его безуспешно пытаются "перезаточить" в современные области, но он поддается с трудом. Компилировать в wasm была бы задача по сложности превосходящая весь проект, а результат был бы уныл: мы и так имеем все достоинсва wasm, полезные для Lyng, но не имеем многих его недостатков.
Виртуалка lyng легкая, и доступна на всех платформах уже сейчас, а вот прикрутить скажем wasm машину к котлину на сервере, чтобы она работала как сопрограммы первого класса вместе с котлинскими, задача сейчас неразрешимая.
То есть, преимущества wasm что он доступен на многих платформах, для нас неважно - мы и так на тех же платформах имеем полную поддержку.
- Lyng VM изначально заточена на исполнение именно сопрограмм со сборкой мусора. Эти два ключевых механизма линга практически отсутствуют в wasm, их мучительно прикручивают как расширения, и они довольно слабо поддерживаются.
- LyngVM заточен на исполнение программ с гибридной ООП-ФП моделью, она хорошо поддерживает множественное наследование, делегацию, работу со сложными списками аргументов (ФП фичи, подстановки, деструктурирование), на васме это очень непросто написать, будет медленно и громоздко.
- одна из целей Lyng была получить быстрое безопасное и очень мощное скриптовое решение для вклучения в проекты на Java/Kotlin multiplatform. На wasm это в принципе невозможно - его включение это кошмар, он громоздкий. К тому же требует компиляции, а Lyng работает с JIT (исполняет прямо исходник, компилируя его на лету, как JS), и может использоваться как скрипт (wasm не может)
- типы данных которые мы используем в Lyng в WASM отсутстсвтуют, их бы пришлось добавлять
В результате если бы мы компилировали Lyng->WASM мы бы получили огромный и медленный код. Для которого потребовалась бы огромная wasm VM. Практического смысла в этом нет.
Если же ты рассматриваешь идею в единой платформе использовать разные языки, а wasm как промежуточный язых совместимости, то это собственно противоречит идее использовать общую кодовую базу и интерфейсы. Разные языки имеют несовпадающие, несовместимые интерфейсы вызовов, так что приходится писать руками биндинги, которые не добавляют скорости и добавляют ошибки, к тому же, разные языки предоставляют часто вообще несовместимые модели программирования (например прототипы в JS, множественное наследование С++ или Линга и кошмар на улице вязов от руста, в владением ссылками).
Платформ на васме полно, и там и ловить нечего, и неинтересно. Я же предлагаю вылезти в другой класс. Навеяно реальным опоытом переносов контрактов из старого золота в мольтпей, которое получается на удивление хорошо