feat(chunk): add OP_SWAP opcode to swap top two stack elements for better stack manipulation

feat(compiler): implement logic for handling reference type assignments and updates for global variables
feat(vm): add support for OP_SWAP in the virtual machine to facilitate stack operations
docs(ref_example): create examples demonstrating reference updates and rebindings in the language
docs(test_global_ref): add test case for verifying reference updates on global variables

Author: estevaofon

internal/chunk/chunk.go

@@ -76,6 +76,7 @@ const (
 	OP_STORE_VIA_REF
 	OP_STORE_REF
 	OP_SET_PROPERTY_DEREF
+	OP_SWAP
 	OP_COPY
 )
 
@@ -409,6 +410,8 @@ func (c *Chunk) disassembleInstruction(offset int) int {
 		return c.simpleInstruction("OP_STORE_REF", offset)
 	case OP_SET_PROPERTY_DEREF:
 		return c.constantInstruction("OP_SET_PROPERTY_DEREF", offset)
+	case OP_SWAP:
+		return c.simpleInstruction("OP_SWAP", offset)
 	case OP_COPY:
 		return c.simpleInstruction("OP_COPY", offset)
 	default:

internal/compiler/compiler.go

@@ -239,6 +239,65 @@ func (c *Compiler) Compile(node ast.Node) (*chunk.Chunk, ast.NoxyType, error) {
 			} else {
 				// Global Logic
 				if globalType, exists := c.globals[ident.Value]; exists {
+					// Check if global is a reference type
+					if refType, isRef := globalType.(*ast.RefType); isRef {
+						// Type-Based Assignment for Global Refs
+						_, isRefVal := valType.(*ast.RefType)
+						if isRefVal || valType == nil {
+							// REBIND: ref = ref -> Just update the global with new ref
+							if valType != nil && !c.areTypesCompatible(globalType, valType) {
+								return nil, nil, fmt.Errorf("[line %d] type mismatch in rebind to global '%s': expected %s, got %s", c.currentLine, ident.Value, globalType.String(), valType.String())
+							}
+							// Standard global set (rebind)
+							nameConstant := c.makeConstant(value.NewString(ident.Value))
+							c.emitBytes(byte(chunk.OP_SET_GLOBAL), byte(nameConstant))
+							c.emitByte(byte(chunk.OP_POP))
+						} else {
+							// UPDATE: ref = val -> Write value to target
+							if !c.areTypesCompatible(refType.ElementType, valType) {
+								return nil, nil, fmt.Errorf("[line %d] type mismatch in update to global '%s': expected %s (rebind) or %s (update), got %s", c.currentLine, ident.Value, refType.String(), refType.ElementType.String(), valType.String())
+							}
+							// Emit: Get global ref, then store value into it
+							nameConstant := c.makeConstant(value.NewString(ident.Value))
+							c.emitBytes(byte(chunk.OP_GET_GLOBAL), byte(nameConstant))
+							// Stack: [val, ref] - need to swap
+							// Use OP_STORE_REF which expects [ref, val]
+							// But we have [val, ref]. We need to emit differently.
+							// Actually, we compiled Value first, then GET_GLOBAL.
+							// Stack: [val, ref]
+							// OP_STORE_REF expects: pop val, pop ref. So [ref, val] order.
+							// We have [val, ref]. We need OP_STORE_REF_SWAPPED or different approach.
+							// Alternative: Emit GET_GLOBAL first, then compile value.
+							// But we already compiled value. Can't undo.
+							// Use OP_STORE_REF with swapped logic? Or add OP_SWAP?
+							// For now, let's just emit the global name and use a new opcode.
+							// Actually, I'll recompile: emit GET first, then value.
+							// NO - value already compiled.
+							// HACK: pop both, swap, push back? No such ops.
+							// Simplest: Just do the store in VM with swapped operands.
+							// I'll create OP_STORE_GLOBAL_DEREF which takes name as operand.
+							// Stack: [val] -> reads global ref, writes val to it.
+							// That's cleaner. Let's use that.
+							// Actually, I don't have that opcode. Let me improvise.
+							// Emit: swap then store_ref? No swap opcode.
+							// For now, just error and require wrapping in function.
+							// TODO: Add proper support later.
+							// Actually, simpler: just use existing logic but different stack order.
+							// Re-emit: POP val (save in temp), GET_GLOBAL, push val back, STORE_REF
+							// No temp storage in VM.
+							// Let's just emit correct order by recompiling:
+							// This is hacky but works: emit a synthetic sequence.
+							// GET_GLOBAL pushes ref. Then we need val on top.
+							// We already have val on stack. GET_GLOBAL added ref.
+							// Stack: [val, ref]. STORE_REF wants [ref, val].
+							// I'll add a simple OP_SWAP.
+							c.emitByte(byte(chunk.OP_SWAP))
+							c.emitByte(byte(chunk.OP_STORE_REF))
+							// No OP_POP needed - STORE_REF consumes both values
+						}
+						return c.currentChunk, nil, nil
+					}
+					// Standard type check for non-ref globals
 					if !c.areTypesCompatible(globalType, valType) {
 						return nil, nil, fmt.Errorf("[line %d] type mismatch in assignment to global '%s': expected %s, got %s", c.currentLine, ident.Value, globalType.String(), valType.String())
 					}

internal/vm/vm.go

@@ -4426,6 +4426,13 @@ func (vm *VM) run(minFrameCount int) error {
 			}
 			vm.push(val)
 
+		case chunk.OP_SWAP:
+			// Swap top two stack elements: [a, b] -> [b, a]
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(b)
+			vm.push(a)
+
 		case chunk.OP_COPY:
 			val := vm.pop()
 			vm.push(vm.copyValue(val))

noxy_examples/ref_example.nx

@@ -0,0 +1,32 @@
+struct Box
+    val: ref int
+end
+let x: int = 10
+let y: int = 20
+
+print("Step 1: Calling update(ref x)")
+func update(r: ref int)
+    r = 99  // UPDATE: escreve 99 no alvo
+end
+update(ref x)  // x agora é 99
+print(fmt("After update: x = %d", x))
+
+print("Step 2: Local ref operations")
+let local_ref: ref int = ref x
+local_ref = 50       // UPDATE: x = 50
+print(fmt("After local_ref = 50: x = %d", x))
+
+local_ref = ref y    // REBIND: agora aponta para y
+local_ref = 100      // UPDATE: y = 100
+print(fmt("After local_ref = 100: y = %d", y))
+
+print("Step 3: Struct field operations")
+let box: Box = Box(ref x)
+box.val = 200        // UPDATE: x = 200
+print(fmt("After box.val = 200: x = %d", x))
+
+box.val = ref y      // REBIND: agora aponta para y
+box.val = 300        // UPDATE: y = 300
+print(fmt("After box.val = 300: y = %d", y))
+
+print("Done!")

noxy_examples/test_global_ref.nx

@@ -0,0 +1,7 @@
+let x: int = 10
+let r: ref int = ref x
+
+// This should UPDATE x
+r = 50
+
+print(fmt("x = %d (expected 50)", x))