feat: Add conditional debug template and computed goto optimization

- Add debug() template that compiles to nothing in release builds
- Add {.computedGoto.} pragma to VM interpreter loop
- Sync sieve.hrd benchmark to use limit=500 for consistent testing

The debug template uses when not defined(release) to completely
eliminate debug calls at compile time in production builds.

Author: gokr

bona_debug.log

@@ -29,18 +29,38 @@ task test, "Run all tests (automatic discovery via testament)":
     # testament pattern "tests/**/**/*.nim" || true
   """
 
-task local, "Build and copy binaries to root directory":
-  # Build REPL directly (nimble build has path conflicts with package name)
+task harding, "Build harding REPL (debug) in repo root":
+  # Build REPL in debug mode, output to repo root
+  exec "nim c -o:harding src/harding/repl/harding.nim"
+  echo "Binary available as ./harding (debug)"
+
+task harding_release, "Build harding REPL (release) in repo root":
+  # Build REPL in release mode, output to repo root
+  exec "nim c -d:release -o:harding src/harding/repl/harding.nim"
+  echo "Binary available as ./harding (release)"
+
+task bona, "Build bona IDE (debug) in repo root":
+  # Build GUI IDE in debug mode with GTK4 (default), output to repo root
+  exec "nim c -d:gtk4 -o:bona src/harding/gui/bona.nim"
+  echo "Binary available as ./bona (debug)"
+
+task bona_release, "Build bona IDE (release) in repo root":
+  # Build GUI IDE in release mode with GTK4, output to repo root
+  exec "nim c -d:release -d:gtk4 -o:bona src/harding/gui/bona.nim"
+  echo "Binary available as ./bona (release)"
+
+task local, "Build and copy binaries to root directory (legacy, use 'harding' instead)":
+  # Build REPL and granite compiler directly
   exec "nim c -o:harding src/harding/repl/harding.nim"
   exec "nim c -o:granite src/harding/compiler/granite.nim"
   echo "Binaries available in root directory as harding and granite"
 
-task gui, "Build the GUI IDE with GTK4":
+task gui, "Build the GUI IDE with GTK4 (legacy, use 'bona' instead)":
   # Build the GUI IDE with GTK4 (default)
   exec "nim c -d:gtk4 -o:bona src/harding/gui/bona.nim"
   echo "GUI binary available as bona (GTK4)"
 
-task gui3, "Build the GUI IDE with GTK3":
+task gui3, "Build the GUI IDE with GTK3 (legacy, use 'bona' instead)":
   # Build the GUI IDE with GTK3
   exec "nim c -o:bona src/harding/gui/bona.nim"
   echo "GUI binary available as bona (GTK3)"

harding.nimble

@@ -45,7 +45,7 @@ GtkSourceView>>buffer [
 ].
 
 # Text insertion convenience methods
-GtkSourceView>>insertTextAtEnd: aString [
+# GtkSourceView>>insertTextAtEnd: aString [
     # Insert text at the current cursor position
-    self insertTextAtSelectedEnd: aString.
-].
+#    self insertTextAtSelectedEnd: aString.
+#].

harding_granite

@@ -8,6 +8,7 @@ Transcript := Object derive: #(window box scrolledWindow sourceView owner)
 
 Transcript>>initialize [
   window := nil.
+  sourceView := nil.
   owner := nil
 ]
 
@@ -22,7 +23,7 @@ Transcript>>show: anObject [
 Transcript>>showCr: anObject [
   # Append anObject's printString followed by a newline.
   sourceView notNil ifTrue: [
-    sourceView insertTextAtEnd: ("Banana", (anObject printString)).
+    sourceView insertTextAtEnd: (anObject printString).
     sourceView insertTextAtEnd: "\n".
     self scrollToBottom
   ]
@@ -73,6 +74,14 @@ Transcript>>scrollToBottom [
   ]
 ]
 
+Transcript>>checkSourceView [
+  # Debug method to see which sourceView we're using
+  sourceView notNil ifTrue: [
+    ^ ("Transcript sourceView: ", sourceView text firstLine)
+  ].
+  ^ "Transcript sourceView: nil"
+]
+
 Transcript>>openWindowFor: anOwner [
   | mainBox buttonBox clearButton |
 

lib/harding/gui/Gtk4/SourceView.hrd

@@ -188,3 +188,8 @@ Workspace>>text: aString [
     # Set all text in the editor
     sourceView text: aString
 ].
+
+Workspace>>checkSourceView [
+  # Debug method to see which sourceView we're using
+  ^ ("Workspace sourceView: ", sourceView text firstLine)
+]

lib/harding/gui/Ide/Transcript.hrd

@@ -172,20 +172,21 @@ proc genMessage*(ctx: GenContext, node: MessageNode): string =
     return receiverCode
 
   of "println", "writeLine:":
-    # Print with newline
+    # Print with newline - generates a statement, not an expression
+    # This is a limitation - we need statement context for echo
     if node.arguments.len >= 1:
       let argCode = genExpression(ctx, node.arguments[0])
-      return fmt("(proc(): NodeValue = echo({argCode}).toString(); return {receiverCode})()")
+      return fmt("nt_println({argCode})")
     else:
-      return fmt("(proc(): NodeValue = echo({receiverCode}).toString(); return {receiverCode})()")
+      return fmt("nt_println({receiverCode})")
 
   of "print", "write:":
     # Print without newline
     if node.arguments.len >= 1:
       let argCode = genExpression(ctx, node.arguments[0])
-      return fmt("(proc(): NodeValue = stdout.write({argCode}).toString(); return {receiverCode})()")
+      return fmt("nt_print({argCode})")
     else:
-      return fmt("(proc(): NodeValue = stdout.write({receiverCode}).toString(); return {receiverCode})()")
+      return fmt("nt_print({receiverCode})")
 
   of "asString":
     # Convert to string
@@ -205,8 +206,7 @@ proc genMessage*(ctx: GenContext, node: MessageNode): string =
 
   else:
     # Generic message - for now return nil (compiled methods not yet fully supported)
-    # TODO: Generate direct method calls for known selectors
-    return "NodeValue(kind: vkNil)  # " & node.selector & " not yet compiled"
+    return "NodeValue(kind: vkNil)"
 
 proc genExpression*(ctx: GenContext, node: Node): string =
   ## Dispatch to appropriate expression generator

lib/harding/gui/Ide/Workspace.hrd

@@ -148,6 +148,12 @@ when defined(granite):
 
     output.add("\n")
     output.add("  " & cls.name & "* = ref " & cls.name & "Obj\n\n")
+
+    # Generate toValue converter for this type
+    output.add("proc toValue*(self: " & cls.name & "): NodeValue =\n")
+    output.add("  ## Convert " & cls.name & " to NodeValue\n")
+    output.add("  return NodeValue(kind: vkTable, tableVal: initTable[NodeValue, NodeValue]())\n\n")
+
     return output
 
   proc generateMethodImpl*(cls: Class, selector: string, meth: BlockNode): string =
@@ -223,6 +229,56 @@ when defined(granite):
     output.add("import ../src/harding/interpreter/[objects]\n")
     output.add("import ../src/harding/runtime/[runtime]\n\n")
 
+    # Add runtime helper methods
+    output.add("# Runtime Helper Methods\n")
+    output.add("# ======================\n")
+    output.add("proc nt_println*(value: NodeValue): NodeValue =\n")
+    output.add("  echo value.toString()\n")
+    output.add("  return value\n\n")
+    output.add("proc nt_print*(value: NodeValue): NodeValue =\n")
+    output.add("  stdout.write(value.toString())\n")
+    output.add("  return value\n\n")
+    output.add("proc nt_asString*(value: NodeValue): NodeValue =\n")
+    output.add("  return NodeValue(kind: vkString, strVal: value.toString())\n\n")
+    output.add("proc nt_comma*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  return NodeValue(kind: vkString, strVal: a.toString() & b.toString())\n\n")
+    output.add("proc callPrimitive*(name: string, args: seq[NodeValue]): NodeValue =\n")
+    output.add("  ## Stub for primitive calls\n")
+    output.add("  return NodeValue(kind: vkNil)\n\n")
+
+    # Add basic operators
+    output.add("# Basic Operators\n")
+    output.add("proc nt_eq*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  return NodeValue(kind: vkBool, boolVal: a.toString() == b.toString())\n\n")
+    output.add("proc nt_eqeq*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  return NodeValue(kind: vkBool, boolVal: a.toString() == b.toString())\n\n")
+    output.add("proc nt_tildeeq*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  return NodeValue(kind: vkBool, boolVal: a.toString() != b.toString())\n\n")
+    output.add("proc nt_lt*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkBool, boolVal: a.intVal < b.intVal)\n")
+    output.add("  return NodeValue(kind: vkBool, boolVal: false)\n\n")
+    output.add("proc nt_gt*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkBool, boolVal: a.intVal > b.intVal)\n")
+    output.add("  return NodeValue(kind: vkBool, boolVal: false)\n\n")
+    output.add("proc nt_plus*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkInt, intVal: a.intVal + b.intVal)\n")
+    output.add("  return NodeValue(kind: vkNil)\n\n")
+    output.add("proc nt_minus*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkInt, intVal: a.intVal - b.intVal)\n")
+    output.add("  return NodeValue(kind: vkNil)\n\n")
+    output.add("proc nt_star*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkInt, intVal: a.intVal * b.intVal)\n")
+    output.add("  return NodeValue(kind: vkNil)\n\n")
+    output.add("proc nt_slash*(a: NodeValue, b: NodeValue): NodeValue =\n")
+    output.add("  if a.kind == vkInt and b.kind == vkInt:\n")
+    output.add("    return NodeValue(kind: vkInt, intVal: a.intVal div b.intVal)\n")
+    output.add("  return NodeValue(kind: vkNil)\n\n")
+
     # Generate type definitions for each class
     output.add("# Class Type Definitions\n")
     output.add("# =====================\n\n")

src/harding/codegen/expression.nim

@@ -180,8 +180,8 @@ when defined(js):
       # Signal an error
       if args.len > 0:
         let msg = args[0].toString()
-        raise newException(EvalError, msg)
-      raise newException(EvalError, "Unknown error")
+        raise newException(ValueError, msg)
+      raise newException(ValueError, "Unknown error")
 
     of "primitiveValue":
       # Execute a block with no arguments
@@ -254,8 +254,6 @@ proc evalStatements*(interp: var Interpreter, source: string): (seq[NodeValue],
 proc installGlobalTableMethods*(globalTableClass: Class)
 proc installLibraryMethods*()
 proc initHardingGlobal*(interp: var Interpreter)
-when defined(js):
-  proc dispatchPrimitive(interp: var Interpreter, receiver: Instance, selector: string, args: seq[NodeValue]): NodeValue
 
 # ============================================================================
 # Stack Trace Printing
@@ -595,8 +593,9 @@ proc lookupVariableWithStatus(interp: Interpreter, name: string): LookupResult =
     # Check captured environment FIRST - captured variables from outer lexical scope
     # should take precedence over local temporaries in the current activation
     # This is the key difference: blocks capture variables from where they were defined,
-    # not where they're executed
-    if activation.currentMethod != nil and activation.currentMethod.capturedEnvInitialized and activation.currentMethod.capturedEnv.len > 0:
+    # not where they're executed. IMPORTANT: Only apply to blocks, NOT methods.
+    # Methods should access slots on the receiver, not captured lexical variables.
+    if activation.currentMethod != nil and activation.currentMethod.capturedEnvInitialized and activation.currentMethod.capturedEnv.len > 0 and not activation.currentMethod.isMethod:
       if name in activation.currentMethod.capturedEnv:
         let value = activation.currentMethod.capturedEnv[name].value
         debug("Found variable in captured environment: ", name, " = ", value.toString())
@@ -640,8 +639,9 @@ proc lookupVariableWithStatus(interp: Interpreter, name: string): LookupResult =
   if activation != nil:
     activation = activation.sender
   while activation != nil:
-    # Check captured environment
-    if activation.currentMethod != nil and activation.currentMethod.capturedEnvInitialized and activation.currentMethod.capturedEnv.len > 0:
+    # Check captured environment - IMPORTANT: Only for blocks, NOT methods
+    # Methods should access slots on the receiver, not captured lexical variables
+    if activation.currentMethod != nil and activation.currentMethod.capturedEnvInitialized and activation.currentMethod.capturedEnv.len > 0 and not activation.currentMethod.isMethod:
       if name in activation.currentMethod.capturedEnv:
         let value = activation.currentMethod.capturedEnv[name].value
         debug("Found variable in captured environment (parent): ", name, " = ", value.toString())
@@ -938,17 +938,27 @@ proc executeMethod(interp: var Interpreter, currentMethod: BlockNode,
 
   # Check for native implementation first
   when defined(js):
-    # JS builds: use selector-based dispatch for primitives
-    if currentMethod.selector.startsWith("primitive"):
-      debug("JS: Calling primitive via dispatcher: ", currentMethod.selector)
-      let savedReceiver = interp.currentReceiver
-      try:
-        let result = dispatchPrimitive(interp, receiver, currentMethod.selector, arguments)
-        if result.kind != vkNil or currentMethod.selector == "primitiveClone":  # Some primitives return nil legitimately
-          return result
-      except:
-        debug("JS: Primitive dispatcher failed, falling through")
-    elif nativeImplIsSet(currentMethod):
+    # JS builds: try primitive dispatch first, then nativeImpl if set
+    # Note: We don't have the selector here, so we try dispatching with a lookup
+    debug("JS: Checking for primitive dispatch")
+    var jsSavedReceiver = interp.currentReceiver
+    try:
+      # Try to find the selector by looking up the method in the class
+      var selector = ""
+      if definingClass != nil:
+        for sel, meth in definingClass.allMethods:
+          if meth == currentMethod:
+            selector = sel
+            break
+      if selector.startsWith("primitive"):
+        debug("JS: Calling primitive via dispatcher: ", selector)
+        let primResult = dispatchPrimitive(interp, receiver, selector, arguments)
+        if primResult.kind != vkNil or selector == "primitiveClone":
+          return primResult
+    except:
+      debug("JS: Primitive dispatcher failed, falling through")
+    jsSavedReceiver = interp.currentReceiver
+    if nativeImplIsSet(currentMethod):
       debug("Calling native implementation")
       let savedReceiver = interp.currentReceiver
       try: