Fix upvalues

docs/index.papyri

@@ -42,6 +42,11 @@ This will create a JAR file in `metis-app/build/libs` that can be run with `java
 
 @h2 Changelog
 
+@h2 { 0.3.0 }
+[
+    {Fixed upvalues having the wrong value when the function is passed as an argument},
+]
+
 @h2 { 0.2.0 }
 [
     {Fixed a bug where reporting errors would break because the lexer kept a global position, instead of a local one},

metis-lang/src/main/kotlin/io/github/seggan/metis/compilation/Compiler.kt

@@ -12,6 +12,8 @@ import io.github.seggan.metis.runtime.chunk.Insn
 import io.github.seggan.metis.runtime.chunk.Upvalue
 import io.github.seggan.metis.util.pop
 import io.github.seggan.metis.util.push
+import java.util.*
+import kotlin.collections.ArrayDeque
 
 /**
  * A compiler for Metis code. You may not call [compileCode] more than once.
@@ -32,7 +34,7 @@ class Compiler private constructor(
     private val loopStack = ArrayDeque<LoopInfo>()
     private val errorScopeStack = ArrayDeque<Int>()
 
-    private val depth: Int = enclosingCompiler?.depth ?: 0
+    private val id = UUID.randomUUID()
 
     private var scope = 0
 
@@ -56,7 +58,7 @@ class Compiler private constructor(
             backpatch(compiled, marker.first as Insn.Label)
         }
         val (insns, spans) = compiled.unzip()
-        return Chunk(name, insns, Arity(args.size, args.firstOrNull() == "self"), upvalues, spans)
+        return Chunk(name, insns, Arity(args.size, args.firstOrNull() == "self"), upvalues, id, spans)
     }
 
     private fun backpatch(insns: MutableList<FullInsn>, label: Insn.Label) {
@@ -427,7 +429,7 @@ class Compiler private constructor(
         val local = enclosingCompiler.resolveLocal(name)
         if (local != null) {
             if (local.capturing == null) {
-                local.capturing = Upvalue(name, local.index, enclosingCompiler.depth)
+                local.capturing = Upvalue(name, local.index, enclosingCompiler.id)
             }
             val upvalue = local.capturing!!
             upvalues.add(upvalue)

metis-lang/src/main/kotlin/io/github/seggan/metis/debug/Debugger.kt

@@ -112,4 +112,4 @@ class Debugger(private val state: State, private val sourceName: String) {
     }
 }
 
-private val locationRegex = """(?<name>[a-zA-Z0-9_.]+:)?(?<line>[0-9]+)""".toRegex()
+private val locationRegex = """(?:(?<name>[a-zA-Z0-9_.]+):)?(?<line>[0-9]+)""".toRegex()

metis-lang/src/main/kotlin/io/github/seggan/metis/runtime/State.kt

@@ -11,11 +11,20 @@ import io.github.seggan.metis.runtime.chunk.Chunk
 import io.github.seggan.metis.runtime.chunk.StepResult
 import io.github.seggan.metis.runtime.chunk.Upvalue
 import io.github.seggan.metis.runtime.intrinsics.*
-import io.github.seggan.metis.util.*
+import io.github.seggan.metis.util.Stack
+import io.github.seggan.metis.util.getFromTop
+import io.github.seggan.metis.util.peek
+import io.github.seggan.metis.util.pop
+import io.github.seggan.metis.util.push
 import java.io.InputStream
 import java.io.OutputStream
 import java.nio.file.FileSystem
 import java.nio.file.FileSystems
+import java.util.*
+import kotlin.collections.ArrayDeque
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.set
 
 /**
  * Represents the state of a Metis virtual machine. This is the class that is used to run Metis code.
@@ -220,7 +229,7 @@ class State(parentState: State? = null) {
                         break
                     }
                 }
-                val (executor, bottom, span) = callStack.peek()
+                val (executor, bottom, id, span) = callStack.peek()
                 if (span != null) {
                     err.addStackFrame(span)
                 }
@@ -239,7 +248,7 @@ class State(parentState: State? = null) {
                     }
                     for (i in stack.lastIndex downTo bottom) {
                         val upvalue = openUpvalues.firstOrNull {
-                            it.template.callDepth == callStack.size && it.template.index == i
+                            it.template.function == id && it.template.index == i
                         }
                         if (upvalue != null) {
                             upvalue.close(this)
@@ -428,7 +437,14 @@ class State(parentState: State? = null) {
                     }
                 )
             }
-            callStack.push(CallFrame(executor, stackBottom, span))
+            callStack.push(
+                CallFrame(
+                    executor,
+                    stackBottom,
+                    (value as? Chunk.Instance)?.id,
+                    span
+                )
+            )
         }
     }
 
@@ -511,7 +527,12 @@ class State(parentState: State? = null) {
     }
 }
 
-internal data class CallFrame(val executing: CallableValue.Executor, val stackBottom: Int, val span: Span?)
+internal data class CallFrame(
+    val executing: CallableValue.Executor,
+    val stackBottom: Int,
+    val id: UUID?,
+    val span: Span?
+)
 
 private val metatableString = Value.String("metatable")
 private val indexString = Value.String("__index__")

metis-lang/src/main/kotlin/io/github/seggan/metis/runtime/chunk/Chunk.kt

@@ -9,21 +9,24 @@ import io.github.seggan.metis.parsing.Span
 import io.github.seggan.metis.runtime.*
 import io.github.seggan.metis.runtime.intrinsics.initChunk
 import io.github.seggan.metis.util.*
+import java.util.*
+import kotlin.collections.ArrayDeque
+import kotlin.collections.set
 
 /**
  * A chunk is a compiled piece of code.
  *
  * @property name The name of the chunk.
  * @property insns The instructions of the chunk.
  * @property arity The arity of the chunk.
- * @property upvalues The upvalues of the chunk.
  * @property spans The spans of the chunk. Must be the same size as [insns].
  */
 class Chunk(
     val name: String,
     val insns: List<Insn>,
     val arity: Arity,
-    val upvalues: List<Upvalue>,
+    private val upvalues: List<Upvalue>,
+    private val id: UUID,
     val spans: List<Span>
 ) {
 
@@ -60,6 +63,8 @@ class Chunk(
 
         override val arity = this@Chunk.arity
 
+        val id = this@Chunk.id
+
         /**
          * The upvalue instances of the chunk instance.
          */

metis-lang/src/main/kotlin/io/github/seggan/metis/runtime/chunk/Upvalue.kt

@@ -4,18 +4,19 @@ import io.github.seggan.metis.runtime.State
 import io.github.seggan.metis.runtime.Value
 import io.github.seggan.metis.util.pop
 import io.github.seggan.metis.util.push
+import java.util.*
 
 /**
  * An upvalue. Used in the implementation of closures.
  *
  * @property name The name of the upvalue.
  * @property index The index of the upvalue's local variable.
- * @property callDepth The call depth of the upvalue's function.
+ * @property function The [UUID] of the function that owns the upvalue.
  */
 data class Upvalue(
     val name: String,
     val index: Int,
-    val callDepth: Int
+    val function: UUID
 ) {
 
     /**
@@ -30,7 +31,8 @@ data class Upvalue(
                 return upvalue
             }
         }
-        val instance = Instance(null)
+        val bottom = state.callStack.first { it.id == function }.stackBottom
+        val instance = Instance(null, bottom)
         state.openUpvalues.addFirst(instance)
         return instance
     }
@@ -40,21 +42,20 @@ data class Upvalue(
      *
      * @see Upvalue.newInstance
      */
-    inner class Instance internal constructor(internal var value: Value?) {
+    inner class Instance internal constructor(internal var value: Value?, private val stackBottom: Int) {
 
-        val template: Upvalue
-            get() = this@Upvalue
+        val template: Upvalue = this@Upvalue
 
         fun get(state: State) {
-            state.stack.push(value ?: state.stack[state.callStack[callDepth].stackBottom + index])
+            state.stack.push(value ?: state.stack[stackBottom + index])
         }
 
         fun set(state: State) {
             val toSet = state.stack.pop()
             if (value != null) {
                 value = toSet
             } else {
-                state.stack[state.callStack[callDepth].stackBottom + index] = toSet
+                state.stack[stackBottom + index] = toSet
             }
         }
 

metis-lang/src/main/kotlin/io/github/seggan/metis/runtime/intrinsics/ValueInit.kt

@@ -271,9 +271,29 @@ internal fun initList() = buildTable { table ->
         self.listValue().removeAt(index.intValue())
     }
     table["slice"] = threeArgFunction(true) { self, start, end ->
+        if (start.intValue() < 0) {
+            throw MetisRuntimeException(
+                "ValueError",
+                "Start index cannot be negative",
+                buildTable { table ->
+                    table["start"] = start
+                    table["end"] = end
+                }
+            )
+        }
         if (end == Value.Null) {
             self.listValue().subList(start.intValue(), self.listValue().size).metisValue()
         } else {
+            if (end.intValue() > self.listValue().size) {
+                throw MetisRuntimeException(
+                    "ValueError",
+                    "End index cannot be greater than list size",
+                    buildTable { table ->
+                        table["start"] = start
+                        table["end"] = end
+                    }
+                )
+            }
             self.listValue().subList(start.intValue(), end.intValue()).metisValue()
         }
     }