2363 lines
50 KiB
TypeScript
2363 lines
50 KiB
TypeScript
import { test, expect } from "bun:test"
|
|
import { VM } from "#vm"
|
|
import { toBytecode } from "#bytecode"
|
|
import { toValue, toNumber, toString } from "#value"
|
|
|
|
test("LOAD - basic function call", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD add
|
|
PUSH 5
|
|
PUSH 10
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Register a Value-based function
|
|
vm.setValueFunction('add', (a, b) => {
|
|
return toValue(toNumber(a) + toNumber(b))
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 15 })
|
|
})
|
|
|
|
test("LOAD - function with string manipulation", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD concat
|
|
PUSH "hello"
|
|
PUSH "world"
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('concat', (a, b) => {
|
|
const aStr = a.type === 'string' ? a.value : toString(a)
|
|
const bStr = b.type === 'string' ? b.value : toString(b)
|
|
return toValue(aStr + ' ' + bStr)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'hello world' })
|
|
})
|
|
|
|
test("LOAD - async function", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD asyncDouble
|
|
PUSH 42
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('asyncDouble', async (a) => {
|
|
// Simulate async operation
|
|
await new Promise(resolve => setTimeout(resolve, 1))
|
|
return toValue(toNumber(a) * 2)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 84 })
|
|
})
|
|
|
|
test("LOAD - function with no arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD getAnswer
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('getAnswer', () => {
|
|
return toValue(42)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
|
|
test("LOAD - function with multiple arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD sum
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH 4
|
|
PUSH 3
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('sum', (...args) => {
|
|
const total = args.reduce((acc, val) => acc + toNumber(val), 0)
|
|
return toValue(total)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 9 })
|
|
})
|
|
|
|
test("LOAD - function returns array", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD makeRange
|
|
PUSH 3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('makeRange', (n) => {
|
|
const count = toNumber(n)
|
|
const arr = []
|
|
for (let i = 0; i < count; i++) {
|
|
arr.push(toValue(i))
|
|
}
|
|
return { type: 'array', value: arr }
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value.length).toBe(3)
|
|
expect(result.value).toEqual([
|
|
toValue(0),
|
|
toValue(1),
|
|
toValue(2)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("LOAD - function not found", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD nonexistent
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
expect(vm.run()).rejects.toThrow('Undefined variable: nonexistent')
|
|
})
|
|
|
|
test("LOAD - using result in subsequent operations", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD triple
|
|
PUSH 5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
PUSH 10
|
|
ADD
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setValueFunction('triple', (n) => {
|
|
return toValue(toNumber(n) * 3)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 25 })
|
|
})
|
|
|
|
test("Native function wrapping - basic sync function with native types", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD add
|
|
PUSH 5
|
|
PUSH 10
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Register with native TypeScript types - auto-wraps!
|
|
vm.set('add', (a: number, b: number) => {
|
|
return a + b
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 15 })
|
|
})
|
|
|
|
test("Native function wrapping - async function with native types", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD asyncDouble
|
|
PUSH 42
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Async native function
|
|
vm.set('asyncDouble', async (n: number) => {
|
|
await new Promise(resolve => setTimeout(resolve, 1))
|
|
return n * 2
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 84 })
|
|
})
|
|
|
|
test("Native function wrapping - string manipulation", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD concat
|
|
PUSH "hello"
|
|
PUSH "world"
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native string function
|
|
vm.set('concat', (a: string, b: string) => {
|
|
return a + ' ' + b
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'hello world' })
|
|
})
|
|
|
|
test("Native function wrapping - with default parameters", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD ls
|
|
PUSH "/home/user"
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Function with default parameter (like NOSE commands)
|
|
vm.set('ls', (path: string, link = false) => {
|
|
return link ? `listing ${path} with links` : `listing ${path}`
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'listing /home/user' })
|
|
})
|
|
|
|
test("Native function wrapping - returns array", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD makeRange
|
|
PUSH 3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Return native array - auto-converts to Value array
|
|
vm.set('makeRange', (n: number) => {
|
|
return Array.from({ length: n }, (_, i) => i)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value.length).toBe(3)
|
|
expect(result.value).toEqual([
|
|
toValue(0),
|
|
toValue(1),
|
|
toValue(2)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Native function wrapping - returns object (becomes dict)", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD makeUser
|
|
PUSH "Alice"
|
|
PUSH 30
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Return plain object - auto-converts to dict
|
|
vm.set('makeUser', (name: string, age: number) => {
|
|
return { name, age }
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('Alice'))
|
|
expect(result.value.get('age')).toEqual(toValue(30))
|
|
}
|
|
})
|
|
|
|
test("Native function wrapping - mixed with manual Value functions", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD nativeAdd
|
|
PUSH 5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
STORE sum
|
|
LOAD manualDouble
|
|
LOAD sum
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function (auto-wrapped by set)
|
|
vm.set('nativeAdd', (n: number) => n + 10)
|
|
|
|
// Manual Value function (use setValueFunction)
|
|
vm.setValueFunction('manualDouble', (v) => {
|
|
return toValue(toNumber(v) * 2)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 30 })
|
|
})
|
|
|
|
test("Named arguments - basic named arg", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD greet
|
|
PUSH "name"
|
|
PUSH "Alice"
|
|
PUSH 0
|
|
PUSH 1
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('greet', (name: string) => `Hello, ${name}!`)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'Hello, Alice!' })
|
|
})
|
|
|
|
test("Named arguments - mixed positional and named", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD makeUser
|
|
PUSH "Alice"
|
|
PUSH "age"
|
|
PUSH 30
|
|
PUSH 1
|
|
PUSH 1
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('makeUser', (name: string, age: number) => {
|
|
return { name, age }
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('Alice'))
|
|
expect(result.value.get('age')).toEqual(toValue(30))
|
|
}
|
|
})
|
|
|
|
test("Named arguments - named takes priority over positional", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD add
|
|
PUSH 100
|
|
PUSH "a"
|
|
PUSH 5
|
|
PUSH "b"
|
|
PUSH 10
|
|
PUSH 1
|
|
PUSH 2
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('add', (a: number, b: number) => a + b)
|
|
|
|
const result = await vm.run()
|
|
// Named args should be: a=5, b=10
|
|
// Positional arg (100) is provided but named args take priority
|
|
expect(result).toEqual({ type: 'number', value: 15 })
|
|
})
|
|
|
|
test("Named arguments - with defaults", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD greet
|
|
PUSH "name"
|
|
PUSH "Bob"
|
|
PUSH 0
|
|
PUSH 1
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('greet', (name: string, greeting = 'Hello') => {
|
|
return `${greeting}, ${name}!`
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'Hello, Bob!' })
|
|
})
|
|
|
|
test("Named arguments - override defaults with named args", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD greet
|
|
PUSH "name"
|
|
PUSH "Bob"
|
|
PUSH "greeting"
|
|
PUSH "Hi"
|
|
PUSH 0
|
|
PUSH 2
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('greet', (name: string, greeting = 'Hello') => {
|
|
return `${greeting}, ${name}!`
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'Hi, Bob!' })
|
|
})
|
|
|
|
test("Named arguments - with variadic function", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD sum
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH "multiplier"
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH 1
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('sum', (multiplier: number, ...nums: number[]) => {
|
|
const total = nums.reduce((acc, n) => acc + n, 0)
|
|
return total * multiplier
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 12 }) // (1 + 2 + 3) * 2
|
|
})
|
|
|
|
test("Named arguments - works with both wrapped and non-wrapped functions", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Test wrapped function (vm.set)
|
|
LOAD wrappedAdd
|
|
PUSH "a"
|
|
PUSH 5
|
|
PUSH "b"
|
|
PUSH 10
|
|
PUSH 0
|
|
PUSH 2
|
|
CALL
|
|
STORE result1
|
|
|
|
; Test non-wrapped function (vm.setValueFunction)
|
|
LOAD valueAdd
|
|
PUSH "a"
|
|
PUSH 3
|
|
PUSH "b"
|
|
PUSH 7
|
|
PUSH 0
|
|
PUSH 2
|
|
CALL
|
|
STORE result2
|
|
|
|
; Return both results
|
|
LOAD result1
|
|
LOAD result2
|
|
ADD
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Wrapped function - auto-converts types
|
|
vm.set('wrappedAdd', (a: number, b: number) => a + b)
|
|
|
|
// Non-wrapped function - works directly with Values
|
|
vm.setValueFunction('valueAdd', (a, b) => {
|
|
return toValue(toNumber(a) + toNumber(b))
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 25 }) // 15 + 10
|
|
})
|
|
|
|
test("@named pattern - basic atNamed parameter", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD greet
|
|
PUSH "name"
|
|
PUSH "Alice"
|
|
PUSH "greeting"
|
|
PUSH "Hi"
|
|
PUSH "extra"
|
|
PUSH "value"
|
|
PUSH 0
|
|
PUSH 3
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('greet', (atNamed: any = {}) => {
|
|
const name = atNamed.name || 'Unknown'
|
|
const greeting = atNamed.greeting || 'Hello'
|
|
const extra = atNamed.extra || ''
|
|
return `${greeting}, ${name}! Extra: ${extra}`
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'Hi, Alice! Extra: value' })
|
|
})
|
|
|
|
test('@named pattern - atNamed parameters with varadic args', async () => {
|
|
const bytecode = toBytecode(`
|
|
TRY_LOAD cmd
|
|
TRY_LOAD rest1
|
|
TRY_LOAD rest2
|
|
PUSH 'named'
|
|
TRY_LOAD named-value
|
|
PUSH 2
|
|
PUSH 1
|
|
CALL
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('cmd', (atNamed: any = {}, ...rest: string[]) => {
|
|
return { rest, namedArg: atNamed['named'] }
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (!(result.value instanceof Map)) throw new Error('Expected dict')
|
|
expect(result.value.get('rest')).toEqual(toValue(['rest1', 'rest2']))
|
|
expect(result.value.get('namedArg')).toEqual(toValue('named-value'))
|
|
})
|
|
|
|
test("@named pattern - mixed positional and atOptions", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD configure
|
|
PUSH "app"
|
|
PUSH "debug"
|
|
PUSH true
|
|
PUSH "port"
|
|
PUSH 8080
|
|
PUSH 1
|
|
PUSH 2
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('configure', (name: string, atOptions: any = {}) => {
|
|
return {
|
|
name,
|
|
debug: atOptions.debug || false,
|
|
port: atOptions.port || 3000
|
|
}
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('app'))
|
|
expect(result.value.get('debug')).toEqual(toValue(true))
|
|
expect(result.value.get('port')).toEqual(toValue(8080))
|
|
}
|
|
})
|
|
|
|
test("@named pattern - with default empty object", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD build
|
|
PUSH "project"
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('build', (name: string, atConfig: any = {}) => {
|
|
return `Building ${name} with ${Object.keys(atConfig).length} options`
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'Building project with 0 options' })
|
|
})
|
|
|
|
test("@named pattern - collects only unmatched named args", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD process
|
|
PUSH "file"
|
|
PUSH "test.txt"
|
|
PUSH "mode"
|
|
PUSH "read"
|
|
PUSH "extra1"
|
|
PUSH "value1"
|
|
PUSH "extra2"
|
|
PUSH "value2"
|
|
PUSH 0
|
|
PUSH 4
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('process', (file: string, mode: string, atOptions: any = {}) => {
|
|
// file and mode are matched, extra1 and extra2 go to atOptions
|
|
return {
|
|
file,
|
|
mode,
|
|
optionCount: Object.keys(atOptions).length,
|
|
extra1: atOptions.extra1,
|
|
extra2: atOptions.extra2
|
|
}
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('file')).toEqual(toValue('test.txt'))
|
|
expect(result.value.get('mode')).toEqual(toValue('read'))
|
|
expect(result.value.get('optionCount')).toEqual(toValue(2))
|
|
expect(result.value.get('extra1')).toEqual(toValue('value1'))
|
|
expect(result.value.get('extra2')).toEqual(toValue('value2'))
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef function as callback - basic map", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that doubles a number
|
|
MAKE_FUNCTION (x) .double_body
|
|
STORE double
|
|
JUMP .skip_double
|
|
.double_body:
|
|
LOAD x
|
|
PUSH 2
|
|
MUL
|
|
RETURN
|
|
.skip_double:
|
|
|
|
; Call native 'map' with array and Reef function
|
|
LOAD map
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
LOAD double
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that takes an array and a callback
|
|
vm.set('map', async (array: any[], callback: Function) => {
|
|
const results = []
|
|
for (const item of array) {
|
|
results.push(await callback(item))
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(2),
|
|
toValue(4),
|
|
toValue(6)
|
|
])
|
|
} else {
|
|
expect(true).toBe(false)
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef function - iterator pattern with each", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that adds to a sum
|
|
MAKE_FUNCTION (item) .add_to_sum_body
|
|
STORE add_to_sum
|
|
JUMP .skip_add_to_sum
|
|
.add_to_sum_body:
|
|
LOAD sum
|
|
LOAD item
|
|
ADD
|
|
STORE sum
|
|
RETURN
|
|
.skip_add_to_sum:
|
|
|
|
; Initialize sum
|
|
PUSH 0
|
|
STORE sum
|
|
|
|
; Call native 'each' with array and Reef function
|
|
LOAD each
|
|
PUSH 10
|
|
PUSH 20
|
|
PUSH 30
|
|
MAKE_ARRAY #3
|
|
LOAD add_to_sum
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
|
|
; Return the sum
|
|
LOAD sum
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native 'each' function (like Ruby's each)
|
|
vm.set('each', async (array: any[], callback: Function) => {
|
|
for (const item of array) {
|
|
await callback(item)
|
|
}
|
|
return null
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 60 })
|
|
})
|
|
|
|
test("Native function receives Reef function - filter pattern", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that checks if number > 5
|
|
MAKE_FUNCTION (x) .is_greater_body
|
|
STORE is_greater
|
|
JUMP .skip_is_greater
|
|
.is_greater_body:
|
|
LOAD x
|
|
PUSH 5
|
|
GT
|
|
RETURN
|
|
.skip_is_greater:
|
|
|
|
; Call native 'filter' with array and Reef function
|
|
LOAD filter
|
|
PUSH 3
|
|
PUSH 7
|
|
PUSH 2
|
|
PUSH 9
|
|
PUSH 1
|
|
MAKE_ARRAY #5
|
|
LOAD is_greater
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native filter function
|
|
vm.set('filter', async (array: any[], predicate: Function) => {
|
|
const results = []
|
|
for (const item of array) {
|
|
if (await predicate(item)) {
|
|
results.push(item)
|
|
}
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(7),
|
|
toValue(9)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef function - closure capturing", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Store a multiplier in scope
|
|
PUSH 10
|
|
STORE multiplier
|
|
|
|
; Define a Reef function that uses the closure variable
|
|
MAKE_FUNCTION (x) .multiply_body
|
|
STORE multiply_by_ten
|
|
JUMP .skip_multiply
|
|
.multiply_body:
|
|
LOAD x
|
|
LOAD multiplier
|
|
MUL
|
|
RETURN
|
|
.skip_multiply:
|
|
|
|
; Call native 'map' with the closure function
|
|
LOAD map
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
LOAD multiply_by_ten
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.set('map', async (array: any[], callback: Function) => {
|
|
const results = []
|
|
for (const item of array) {
|
|
results.push(await callback(item))
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(10),
|
|
toValue(20),
|
|
toValue(30)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef function - multiple arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that takes two args
|
|
MAKE_FUNCTION (a b) .add_body
|
|
STORE add
|
|
JUMP .skip_add
|
|
.add_body:
|
|
LOAD a
|
|
LOAD b
|
|
ADD
|
|
RETURN
|
|
.skip_add:
|
|
|
|
; Call native 'reduce' with array, initial value, and Reef function
|
|
LOAD reduce
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH 4
|
|
MAKE_ARRAY #4
|
|
PUSH 0
|
|
LOAD add
|
|
PUSH 3
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native reduce function (accumulator, array, callback)
|
|
vm.set('reduce', async (array: any[], initial: any, callback: Function) => {
|
|
let acc = initial
|
|
for (const item of array) {
|
|
acc = await callback(acc, item)
|
|
}
|
|
return acc
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
|
|
test("Native function receives Reef function - returns non-primitive", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that returns a dict
|
|
MAKE_FUNCTION (name) .make_user_body
|
|
STORE make_user
|
|
JUMP .skip_make_user
|
|
.make_user_body:
|
|
PUSH "name"
|
|
LOAD name
|
|
PUSH "active"
|
|
PUSH true
|
|
MAKE_DICT #2
|
|
RETURN
|
|
.skip_make_user:
|
|
|
|
; Call native 'map' to create users
|
|
LOAD map
|
|
PUSH "Alice"
|
|
PUSH "Bob"
|
|
MAKE_ARRAY #2
|
|
LOAD make_user
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.set('map', async (array: any[], callback: Function) => {
|
|
const results = []
|
|
for (const item of array) {
|
|
results.push(await callback(item))
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value.length).toBe(2)
|
|
|
|
const first = result.value[0]
|
|
expect(first?.type).toBe('dict')
|
|
if (first?.type === 'dict') {
|
|
expect(first.value.get('name')).toEqual(toValue('Alice'))
|
|
expect(first.value.get('active')).toEqual(toValue(true))
|
|
}
|
|
|
|
const second = result.value[1]
|
|
expect(second?.type).toBe('dict')
|
|
if (second?.type === 'dict') {
|
|
expect(second.value.get('name')).toEqual(toValue('Bob'))
|
|
expect(second.value.get('active')).toEqual(toValue(true))
|
|
}
|
|
}
|
|
})
|
|
|
|
test("Native function calls Reef function - basic", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function that doubles a number
|
|
MAKE_FUNCTION (x) .double_body
|
|
STORE double
|
|
JUMP .skip_double
|
|
.double_body:
|
|
LOAD x
|
|
PUSH 2
|
|
MUL
|
|
RETURN
|
|
.skip_double:
|
|
|
|
; Call native function that will call the Reef function
|
|
LOAD process
|
|
PUSH 5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('process', async function (n: number) {
|
|
return await this.call('double', n)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
|
|
test("Native function calls multiple Reef functions", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define helper functions
|
|
MAKE_FUNCTION (x) .double_body
|
|
STORE double
|
|
JUMP .skip_double
|
|
.double_body:
|
|
LOAD x
|
|
PUSH 2
|
|
MUL
|
|
RETURN
|
|
.skip_double:
|
|
|
|
MAKE_FUNCTION (x) .triple_body
|
|
STORE triple
|
|
JUMP .skip_triple
|
|
.triple_body:
|
|
LOAD x
|
|
PUSH 3
|
|
MUL
|
|
RETURN
|
|
.skip_triple:
|
|
|
|
; Call native orchestrator
|
|
LOAD orchestrate
|
|
PUSH 5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('orchestrate', async function (n: number) {
|
|
const doubled = await this.call('double', n)
|
|
const tripled = await this.call('triple', n)
|
|
|
|
return doubled + tripled
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 25 })
|
|
})
|
|
|
|
test("Native function conditionally calls Reef functions", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define validation functions
|
|
MAKE_FUNCTION (x) .is_positive_body
|
|
STORE is_positive
|
|
JUMP .skip_is_positive
|
|
.is_positive_body:
|
|
LOAD x
|
|
PUSH 0
|
|
GT
|
|
RETURN
|
|
.skip_is_positive:
|
|
|
|
MAKE_FUNCTION (x) .negate_body
|
|
STORE negate
|
|
JUMP .skip_negate
|
|
.negate_body:
|
|
PUSH 0
|
|
LOAD x
|
|
SUB
|
|
RETURN
|
|
.skip_negate:
|
|
|
|
; Test with positive number
|
|
LOAD validate
|
|
PUSH 5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
STORE result1
|
|
|
|
; Test with negative number
|
|
LOAD validate
|
|
PUSH -3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
STORE result2
|
|
|
|
; Return sum
|
|
LOAD result1
|
|
LOAD result2
|
|
ADD
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('validate', async function (n: number) {
|
|
const isPositive = await this.call('is_positive', n)
|
|
|
|
if (isPositive) {
|
|
return n // Already positive
|
|
} else {
|
|
return await this.call('negate', n) // Make it positive
|
|
}
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 8 }) // 5 + 3
|
|
})
|
|
|
|
test("Native function calls Reef function with closure", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Set up a multiplier in scope
|
|
PUSH 10
|
|
STORE multiplier
|
|
|
|
; Define a Reef function that uses the closure variable
|
|
MAKE_FUNCTION (x) .multiply_body
|
|
STORE multiply_by_ten
|
|
JUMP .skip_multiply
|
|
.multiply_body:
|
|
LOAD x
|
|
LOAD multiplier
|
|
MUL
|
|
RETURN
|
|
.skip_multiply:
|
|
|
|
; Native function calls the closure
|
|
LOAD transform
|
|
PUSH 7
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('transform', async function (n: number) {
|
|
return await this.call('multiply_by_ten', n)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 70 })
|
|
})
|
|
|
|
test("Native function uses Reef function as filter predicate", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a predicate function
|
|
MAKE_FUNCTION (x) .is_even_body
|
|
STORE is_even
|
|
JUMP .skip_is_even
|
|
.is_even_body:
|
|
LOAD x
|
|
PUSH 2
|
|
MOD
|
|
PUSH 0
|
|
EQ
|
|
RETURN
|
|
.skip_is_even:
|
|
|
|
; Call native filter
|
|
LOAD filter_evens
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH 4
|
|
PUSH 5
|
|
MAKE_ARRAY #5
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('filter_evens', async function (array: any[]) {
|
|
const results = []
|
|
for (const item of array) {
|
|
if (await this.call('is_even', item)) {
|
|
results.push(item)
|
|
}
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(2),
|
|
toValue(4)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Reef calls native calls Reef - roundtrip", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function that squares a number
|
|
MAKE_FUNCTION (x) .square_body
|
|
STORE square
|
|
JUMP .skip_square
|
|
.square_body:
|
|
LOAD x
|
|
LOAD x
|
|
MUL
|
|
RETURN
|
|
.skip_square:
|
|
|
|
; Reef function that calls native which calls back to Reef
|
|
MAKE_FUNCTION (x) .process_body
|
|
STORE process
|
|
JUMP .skip_process
|
|
.process_body:
|
|
LOAD native_helper
|
|
LOAD x
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
RETURN
|
|
.skip_process:
|
|
|
|
; Call the Reef function
|
|
LOAD process
|
|
PUSH 3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('native_helper', async function (n: number) {
|
|
const squared = await this.call('square', n)
|
|
return squared + 1 // Add 1 to the squared result
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 10 }) // 3^2 + 1 = 10
|
|
})
|
|
|
|
test("Native function calls Reef function with multiple arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function that adds three numbers
|
|
MAKE_FUNCTION (a b c) .add_three_body
|
|
STORE add_three
|
|
JUMP .skip_add_three
|
|
.add_three_body:
|
|
LOAD a
|
|
LOAD b
|
|
ADD
|
|
LOAD c
|
|
ADD
|
|
RETURN
|
|
.skip_add_three:
|
|
|
|
; Native function that calls it
|
|
LOAD calculate
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('calculate', async function () {
|
|
return await this.call('add_three', 10, 20, 30)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 60 })
|
|
})
|
|
|
|
test("Native function calls Reef function that returns complex type", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function that creates a user dict
|
|
MAKE_FUNCTION (name age) .make_user_body
|
|
STORE make_user
|
|
JUMP .skip_make_user
|
|
.make_user_body:
|
|
PUSH "name"
|
|
LOAD name
|
|
PUSH "age"
|
|
LOAD age
|
|
PUSH "active"
|
|
PUSH true
|
|
MAKE_DICT #3
|
|
RETURN
|
|
.skip_make_user:
|
|
|
|
; Native function calls it
|
|
LOAD create_user
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('create_user', async function () {
|
|
return await this.call('make_user', "Alice", 30)
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('Alice'))
|
|
expect(result.value.get('age')).toEqual(toValue(30))
|
|
expect(result.value.get('active')).toEqual(toValue(true))
|
|
}
|
|
})
|
|
|
|
test("Native function calls non-existent Reef function - throws error", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD bad_caller
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
vm.setFunction('bad_caller', async function () {
|
|
return await this.call('nonexistent', 42)
|
|
})
|
|
|
|
await expect(vm.run()).rejects.toThrow()
|
|
})
|
|
|
|
test("Native function calls Reef function with named arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with default parameters
|
|
MAKE_FUNCTION (name greeting='Hello') .greet_body
|
|
STORE greet
|
|
JUMP .skip_greet
|
|
.greet_body:
|
|
LOAD greeting
|
|
PUSH " "
|
|
LOAD name
|
|
PUSH "!"
|
|
STR_CONCAT #4
|
|
RETURN
|
|
.skip_greet:
|
|
|
|
LOAD call_greet
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
call_greet: async function () {
|
|
// Call with named argument as last positional (object)
|
|
return await this.call('greet', "Alice", { greeting: "Hi" })
|
|
}
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: "Hi Alice!" })
|
|
})
|
|
test("vm.call() with only named arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with default parameters
|
|
MAKE_FUNCTION (name greeting='Hello') .greet_body
|
|
STORE greet
|
|
JUMP .skip_greet
|
|
.greet_body:
|
|
LOAD greeting
|
|
PUSH " "
|
|
LOAD name
|
|
PUSH "!"
|
|
STR_CONCAT #4
|
|
RETURN
|
|
.skip_greet:
|
|
|
|
LOAD call_greet
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
call_greet: async function () {
|
|
// Call with ONLY named arguments (no positional)
|
|
return await this.call('greet', { name: "Bob", greeting: "Hey" })
|
|
}
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: "Hey Bob!" })
|
|
})
|
|
|
|
test("Native function receives Reef closure with default params - calls with named args", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with default parameters
|
|
MAKE_FUNCTION (x multiplier=2) .transform_body
|
|
STORE transform
|
|
JUMP .skip_transform
|
|
.transform_body:
|
|
LOAD x
|
|
LOAD multiplier
|
|
MUL
|
|
RETURN
|
|
.skip_transform:
|
|
|
|
; Pass to native map function
|
|
LOAD map
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
LOAD transform
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that calls the Reef closure with named arguments
|
|
vm.set('map', async (array: any[], callback: Function) => {
|
|
const results = []
|
|
for (const item of array) {
|
|
// Call with named argument to override the default
|
|
results.push(await callback(item, { multiplier: 10 }))
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(10), // 1 * 10
|
|
toValue(20), // 2 * 10
|
|
toValue(30) // 3 * 10
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef closure with variadic parameters", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with variadic params
|
|
MAKE_FUNCTION (...nums) .sum_body
|
|
STORE sum_all
|
|
JUMP .skip_sum
|
|
.sum_body:
|
|
PUSH 0
|
|
STORE total
|
|
LOAD nums
|
|
STORE items
|
|
PUSH 0
|
|
STORE idx
|
|
|
|
.loop:
|
|
LOAD idx
|
|
LOAD items
|
|
ARRAY_LEN
|
|
LT
|
|
JUMP_IF_FALSE .done
|
|
|
|
LOAD total
|
|
LOAD items
|
|
LOAD idx
|
|
ARRAY_GET
|
|
ADD
|
|
STORE total
|
|
|
|
LOAD idx
|
|
PUSH 1
|
|
ADD
|
|
STORE idx
|
|
JUMP .loop
|
|
|
|
.done:
|
|
LOAD total
|
|
RETURN
|
|
.skip_sum:
|
|
|
|
; Pass to native function
|
|
LOAD process
|
|
LOAD sum_all
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that calls the variadic Reef closure with multiple args
|
|
vm.set('process', async (callback: Function) => {
|
|
// Call with varying number of arguments
|
|
const result1 = await callback(1, 2, 3)
|
|
const result2 = await callback(10, 20)
|
|
return result1 + result2
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 36 }) // (1+2+3) + (10+20) = 6 + 30
|
|
})
|
|
|
|
test("Native function receives Reef closure with @named parameter", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with @named parameter
|
|
MAKE_FUNCTION (message @options) .format_body
|
|
STORE format_message
|
|
JUMP .skip_format
|
|
.format_body:
|
|
; Get uppercase option (default false)
|
|
LOAD options
|
|
PUSH "uppercase"
|
|
DICT_GET
|
|
STORE use_upper
|
|
|
|
; Get prefix option (default empty)
|
|
LOAD options
|
|
PUSH "prefix"
|
|
DICT_GET
|
|
STORE prefix_val
|
|
|
|
; Build result
|
|
LOAD prefix_val
|
|
LOAD message
|
|
STR_CONCAT #2
|
|
RETURN
|
|
.skip_format:
|
|
|
|
; Pass to native function
|
|
LOAD format_messages
|
|
PUSH "hello"
|
|
PUSH "world"
|
|
MAKE_ARRAY #2
|
|
LOAD format_message
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that calls Reef closure with named arguments
|
|
vm.set('format_messages', async (messages: any[], formatter: Function) => {
|
|
const results = []
|
|
for (const msg of messages) {
|
|
// Call with named arguments
|
|
results.push(await formatter(msg, { prefix: "[LOG] ", uppercase: true }))
|
|
}
|
|
return results
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue('[LOG] hello'),
|
|
toValue('[LOG] world')
|
|
])
|
|
}
|
|
})
|
|
|
|
test("Native function receives Reef closure - calls with only named arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function expecting named arguments
|
|
MAKE_FUNCTION (x=0 y=0 z=0) .add_body
|
|
STORE add_coords
|
|
JUMP .skip_add
|
|
.add_body:
|
|
LOAD x
|
|
LOAD y
|
|
ADD
|
|
LOAD z
|
|
ADD
|
|
RETURN
|
|
.skip_add:
|
|
|
|
; Pass to native function
|
|
LOAD compute
|
|
LOAD add_coords
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that calls Reef closure with ONLY named arguments
|
|
vm.set('compute', async (callback: Function) => {
|
|
// First call with all named args
|
|
const result1 = await callback({ x: 10, y: 20, z: 30 })
|
|
|
|
// Second call with partial named args (rest use defaults)
|
|
const result2 = await callback({ x: 5, z: 15 })
|
|
|
|
return result1 + result2
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 80 }) // (10+20+30) + (5+0+15) = 60 + 20
|
|
})
|
|
|
|
test("Native function receives Reef closure with mixed positional and variadic", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Reef function with fixed param and variadic
|
|
MAKE_FUNCTION (multiplier ...nums) .scale_body
|
|
STORE scale_numbers
|
|
JUMP .skip_scale
|
|
.scale_body:
|
|
PUSH 0
|
|
STORE total
|
|
LOAD nums
|
|
STORE items
|
|
PUSH 0
|
|
STORE idx
|
|
|
|
.loop:
|
|
LOAD idx
|
|
LOAD items
|
|
ARRAY_LEN
|
|
LT
|
|
JUMP_IF_FALSE .done
|
|
|
|
LOAD total
|
|
LOAD items
|
|
LOAD idx
|
|
ARRAY_GET
|
|
LOAD multiplier
|
|
MUL
|
|
ADD
|
|
STORE total
|
|
|
|
LOAD idx
|
|
PUSH 1
|
|
ADD
|
|
STORE idx
|
|
JUMP .loop
|
|
|
|
.done:
|
|
LOAD total
|
|
RETURN
|
|
.skip_scale:
|
|
|
|
; Pass to native function
|
|
LOAD process_numbers
|
|
LOAD scale_numbers
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Native function that calls Reef closure with mixed args
|
|
vm.set('process_numbers', async (calculator: Function) => {
|
|
// Call with fixed multiplier and variadic numbers
|
|
const result1 = await calculator(10, 1, 2, 3) // 10 * (1+2+3) = 60
|
|
const result2 = await calculator(5, 4, 6) // 5 * (4+6) = 50
|
|
return result1 + result2
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 110 }) // 60 + 50
|
|
})
|
|
|
|
test("vm.call() with native function - basic sync", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
add: (a: number, b: number) => a + b
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
// Call native function via vm.call()
|
|
const result = await vm.call('add', 10, 20)
|
|
expect(result).toEqual({ type: 'number', value: 30 })
|
|
})
|
|
|
|
test("vm.call() with native function - async", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
asyncDouble: async (n: number) => {
|
|
await new Promise(resolve => setTimeout(resolve, 1))
|
|
return n * 2
|
|
}
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
const result = await vm.call('asyncDouble', 21)
|
|
expect(result).toEqual({ type: 'number', value: 42 })
|
|
})
|
|
|
|
test("vm.call() with native function - returns array", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
makeRange: (n: number) => Array.from({ length: n }, (_, i) => i)
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
const result = await vm.call('makeRange', 4)
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(0),
|
|
toValue(1),
|
|
toValue(2),
|
|
toValue(3)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("vm.call() with native function - returns object (becomes dict)", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
makeUser: (name: string, age: number) => ({ name, age })
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
const result = await vm.call('makeUser', "Alice", 30)
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('Alice'))
|
|
expect(result.value.get('age')).toEqual(toValue(30))
|
|
}
|
|
})
|
|
|
|
test("vm.call() with native function - named arguments", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
greet: (name: string, greeting = 'Hello') => `${greeting}, ${name}!`
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
// Call with positional
|
|
const result1 = await vm.call('greet', "Alice")
|
|
expect(result1).toEqual({ type: 'string', value: "Hello, Alice!" })
|
|
|
|
// Call with named args
|
|
const result2 = await vm.call('greet', "Bob", { greeting: "Hi" })
|
|
expect(result2).toEqual({ type: 'string', value: "Hi, Bob!" })
|
|
})
|
|
|
|
test("vm.call() with native function - variadic parameters", async () => {
|
|
const bytecode = toBytecode(`
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
sum: (...nums: number[]) => nums.reduce((acc, n) => acc + n, 0)
|
|
})
|
|
|
|
await vm.run()
|
|
|
|
const result = await vm.call('sum', 1, 2, 3, 4, 5)
|
|
expect(result).toEqual({ type: 'number', value: 15 })
|
|
})
|
|
|
|
test("builtin global functions are placed into a higher level scope", async () => {
|
|
const bytecode = toBytecode(`
|
|
PUSH 1
|
|
STORE x
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
sum: (...nums: number[]) => nums.reduce((acc, n) => acc + n, 0),
|
|
greet: (name: string, greeting = 'Hello') => `${greeting}, ${name}!`
|
|
})
|
|
await vm.run()
|
|
|
|
const locals = Array.from(vm.scope.locals.entries()).map(([name,]) => name)
|
|
const globals = Array.from(vm.scope.parent!.locals.entries()).map(([name,]) => name)
|
|
|
|
expect(globals).toEqual(['sum', 'greet'])
|
|
expect(locals).toEqual(['x'])
|
|
})
|
|
|
|
|
|
test("builtin global scope can be values too", async () => {
|
|
const bytecode = toBytecode(`
|
|
PUSH 1
|
|
STORE x
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode, {
|
|
pi: 3.14,
|
|
universe: true,
|
|
algorithms: {
|
|
bigOne: () => false,
|
|
}
|
|
})
|
|
await vm.run()
|
|
|
|
const locals = Array.from(vm.scope.locals.entries()).map(([name,]) => name)
|
|
const globals = Array.from(vm.scope.parent!.locals.entries()).map(([name,]) => name)
|
|
|
|
expect(globals).toEqual(['pi', 'universe', 'algorithms'])
|
|
expect(locals).toEqual(['x'])
|
|
})
|
|
|
|
// Raw flag tests - functions that work directly with Values
|
|
|
|
test("raw flag - basic raw function receives Values directly", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawAdd
|
|
PUSH 5
|
|
PUSH 10
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Raw function that works directly with Value types
|
|
const rawAdd = (a: any, b: any) => {
|
|
// Verify we receive Value objects, not unwrapped numbers
|
|
expect(a).toEqual({ type: 'number', value: 5 })
|
|
expect(b).toEqual({ type: 'number', value: 10 })
|
|
|
|
return toValue(toNumber(a) + toNumber(b))
|
|
}
|
|
rawAdd.raw = true
|
|
|
|
vm.set('rawAdd', rawAdd)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 15 })
|
|
})
|
|
|
|
test("raw flag - async raw function", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD asyncRawDouble
|
|
PUSH 42
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const asyncRawDouble = async (a: any) => {
|
|
await new Promise(resolve => setTimeout(resolve, 1))
|
|
expect(a).toEqual({ type: 'number', value: 42 })
|
|
return toValue(toNumber(a) * 2)
|
|
}
|
|
asyncRawDouble.raw = true
|
|
|
|
vm.set('asyncRawDouble', asyncRawDouble)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 84 })
|
|
})
|
|
|
|
test("raw flag - raw function with string Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawConcat
|
|
PUSH "hello"
|
|
PUSH "world"
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawConcat = (a: any, b: any) => {
|
|
// Verify we receive Value objects
|
|
expect(a.type).toBe('string')
|
|
expect(b.type).toBe('string')
|
|
|
|
return toValue(toString(a) + ' ' + toString(b))
|
|
}
|
|
rawConcat.raw = true
|
|
|
|
vm.set('rawConcat', rawConcat)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'hello world' })
|
|
})
|
|
|
|
test("raw flag - raw function with array Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawArrayLength
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawArrayLength = (arr: any) => {
|
|
// Verify we receive a Value object with type 'array'
|
|
expect(arr.type).toBe('array')
|
|
expect(Array.isArray(arr.value)).toBe(true)
|
|
|
|
return toValue(arr.value.length)
|
|
}
|
|
rawArrayLength.raw = true
|
|
|
|
vm.set('rawArrayLength', rawArrayLength)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 3 })
|
|
})
|
|
|
|
test("raw flag - raw function with dict Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawDictKeys
|
|
PUSH "name"
|
|
PUSH "Alice"
|
|
PUSH "age"
|
|
PUSH 30
|
|
MAKE_DICT #2
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawDictKeys = (dict: any) => {
|
|
// Verify we receive a Value object with type 'dict'
|
|
expect(dict.type).toBe('dict')
|
|
expect(dict.value instanceof Map).toBe(true)
|
|
|
|
// Return number of keys
|
|
return toValue(dict.value.size)
|
|
}
|
|
rawDictKeys.raw = true
|
|
|
|
vm.set('rawDictKeys', rawDictKeys)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 2 })
|
|
})
|
|
|
|
test("raw flag - raw function with variadic parameters", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawSum
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
PUSH 4
|
|
PUSH 4
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawSum = (...args: any[]) => {
|
|
// All args should be Value objects
|
|
let total = 0
|
|
for (const arg of args) {
|
|
expect(arg.type).toBe('number')
|
|
total += toNumber(arg)
|
|
}
|
|
return toValue(total)
|
|
}
|
|
rawSum.raw = true
|
|
|
|
vm.set('rawSum', rawSum)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 10 })
|
|
})
|
|
|
|
test("raw flag - compare raw vs wrapped function behavior", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Call wrapped function
|
|
LOAD wrappedAdd
|
|
PUSH 5
|
|
PUSH 10
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
STORE result1
|
|
|
|
; Call raw function
|
|
LOAD rawAdd
|
|
PUSH 5
|
|
PUSH 10
|
|
PUSH 2
|
|
PUSH 0
|
|
CALL
|
|
STORE result2
|
|
|
|
; Both should give same result
|
|
LOAD result1
|
|
LOAD result2
|
|
EQ
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Wrapped function receives native JS types
|
|
vm.set('wrappedAdd', (a: number, b: number) => {
|
|
// These are native numbers, not Values
|
|
expect(typeof a).toBe('number')
|
|
expect(typeof b).toBe('number')
|
|
return a + b
|
|
})
|
|
|
|
// Raw function receives Values
|
|
const rawAdd = (a: any, b: any) => {
|
|
// These are Value objects
|
|
expect(a.type).toBe('number')
|
|
expect(b.type).toBe('number')
|
|
return toValue(toNumber(a) + toNumber(b))
|
|
}
|
|
rawAdd.raw = true
|
|
vm.set('rawAdd', rawAdd)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
|
|
test("raw flag - raw function with null Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawCheckNull
|
|
PUSH null
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawCheckNull = (val: any) => {
|
|
// Verify we receive a null Value
|
|
expect(val).toEqual({ type: 'null', value: null })
|
|
return toValue(val.type === 'null')
|
|
}
|
|
rawCheckNull.raw = true
|
|
|
|
vm.set('rawCheckNull', rawCheckNull)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
|
|
test("raw flag - raw function with boolean Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawNegate
|
|
PUSH true
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawNegate = (val: any) => {
|
|
// Verify we receive a boolean Value
|
|
expect(val.type).toBe('boolean')
|
|
expect(val.value).toBe(true)
|
|
return toValue(!val.value)
|
|
}
|
|
rawNegate.raw = true
|
|
|
|
vm.set('rawNegate', rawNegate)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'boolean', value: false })
|
|
})
|
|
|
|
test("raw flag - mixed raw and wrapped functions", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Call wrapped first
|
|
LOAD wrapped
|
|
PUSH 10
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
STORE temp
|
|
|
|
; Call raw with result
|
|
LOAD raw
|
|
LOAD temp
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
// Wrapped function
|
|
vm.set('wrapped', (n: number) => {
|
|
expect(typeof n).toBe('number')
|
|
return n * 2
|
|
})
|
|
|
|
// Raw function
|
|
const raw = (val: any) => {
|
|
expect(val.type).toBe('number')
|
|
return toValue(toNumber(val) + 5)
|
|
}
|
|
raw.raw = true
|
|
vm.set('raw', raw)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'number', value: 25 }) // (10 * 2) + 5
|
|
})
|
|
|
|
test("raw flag - raw function can manipulate Value structure directly", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawTransform
|
|
PUSH 1
|
|
PUSH 2
|
|
PUSH 3
|
|
MAKE_ARRAY #3
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawTransform = (arr: any) => {
|
|
// Direct manipulation of Value structure
|
|
expect(arr.type).toBe('array')
|
|
|
|
// Transform array by doubling each element
|
|
const doubled = arr.value.map((v: any) => toValue(toNumber(v) * 2))
|
|
|
|
return { type: 'array', value: doubled } as any
|
|
}
|
|
rawTransform.raw = true
|
|
|
|
vm.set('rawTransform', rawTransform)
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('array')
|
|
if (result.type === 'array') {
|
|
expect(result.value).toEqual([
|
|
toValue(2),
|
|
toValue(4),
|
|
toValue(6)
|
|
])
|
|
}
|
|
})
|
|
|
|
test("raw flag - raw function receives Reef function as Value", async () => {
|
|
const bytecode = toBytecode(`
|
|
; Define a Reef function
|
|
MAKE_FUNCTION (x) .double_body
|
|
STORE double
|
|
JUMP .skip_double
|
|
.double_body:
|
|
LOAD x
|
|
PUSH 2
|
|
MUL
|
|
RETURN
|
|
.skip_double:
|
|
|
|
; Pass it to raw function
|
|
LOAD rawInspect
|
|
LOAD double
|
|
PUSH 1
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawInspect = (fn: any) => {
|
|
// Verify we receive a function Value
|
|
expect(fn.type).toBe('function')
|
|
return toValue(true)
|
|
}
|
|
rawInspect.raw = true
|
|
|
|
vm.set('rawInspect', rawInspect)
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'boolean', value: true })
|
|
})
|
|
|
|
test("raw flag - raw function can return any Value type", async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD rawMakeComplex
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
|
|
const rawMakeComplex = () => {
|
|
// Return a complex nested structure
|
|
const innerArray = [toValue(1), toValue(2), toValue(3)]
|
|
const dict = new Map()
|
|
dict.set('numbers', { type: 'array', value: innerArray })
|
|
dict.set('name', toValue('test'))
|
|
|
|
return { type: 'dict', value: dict } as any
|
|
}
|
|
rawMakeComplex.raw = true
|
|
|
|
vm.set('rawMakeComplex', rawMakeComplex)
|
|
|
|
const result = await vm.run()
|
|
expect(result.type).toBe('dict')
|
|
if (result.type === 'dict') {
|
|
expect(result.value.get('name')).toEqual(toValue('test'))
|
|
const numbers = result.value.get('numbers')
|
|
expect(numbers?.type).toBe('array')
|
|
if (numbers?.type === 'array') {
|
|
expect(numbers.value).toEqual([toValue(1), toValue(2), toValue(3)])
|
|
}
|
|
}
|
|
})
|
|
|
|
test('native function error caught by try/catch - direct call', async () => {
|
|
const bytecode = toBytecode(`
|
|
PUSH_TRY .catch
|
|
LOAD failing_fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
POP_TRY
|
|
JUMP .end
|
|
|
|
.catch:
|
|
STORE err
|
|
PUSH 'caught: '
|
|
LOAD err
|
|
STR_CONCAT #2
|
|
JUMP .end
|
|
|
|
.end:
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('failing_fn', () => {
|
|
throw new Error('native error')
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'caught: native error' })
|
|
})
|
|
|
|
test('native function error caught by try/catch - inside reef function', async () => {
|
|
const bytecode = toBytecode(`
|
|
MAKE_FUNCTION () .try_body
|
|
STORE call_native
|
|
JUMP .after_try_body
|
|
|
|
.try_body:
|
|
LOAD failing_fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
RETURN
|
|
|
|
.after_try_body:
|
|
|
|
PUSH_TRY .catch
|
|
LOAD call_native
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
POP_TRY
|
|
JUMP .end
|
|
|
|
.catch:
|
|
STORE err
|
|
PUSH 'caught: '
|
|
LOAD err
|
|
STR_CONCAT #2
|
|
JUMP .end
|
|
|
|
.end:
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('failing_fn', () => {
|
|
throw new Error('native error')
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'caught: native error' })
|
|
})
|
|
|
|
test('async native function error caught by try/catch', async () => {
|
|
const bytecode = toBytecode(`
|
|
PUSH_TRY .catch
|
|
LOAD async_fail
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
POP_TRY
|
|
JUMP .end
|
|
|
|
.catch:
|
|
STORE err
|
|
PUSH 'async caught: '
|
|
LOAD err
|
|
STR_CONCAT #2
|
|
JUMP .end
|
|
|
|
.end:
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('async_fail', async () => {
|
|
await new Promise(resolve => setTimeout(resolve, 1))
|
|
throw new Error('async error')
|
|
})
|
|
|
|
const result = await vm.run()
|
|
expect(result).toEqual({ type: 'string', value: 'async caught: async error' })
|
|
})
|
|
|
|
test('native function error with finally block', async () => {
|
|
const bytecode = toBytecode(`
|
|
PUSH 0
|
|
STORE cleanup_count
|
|
|
|
PUSH_TRY .catch
|
|
PUSH_FINALLY .finally
|
|
LOAD failing_fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
POP_TRY
|
|
JUMP .finally
|
|
|
|
.catch:
|
|
STORE err
|
|
PUSH 'error handled'
|
|
JUMP .finally
|
|
|
|
.finally:
|
|
LOAD cleanup_count
|
|
PUSH 1
|
|
ADD
|
|
STORE cleanup_count
|
|
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('failing_fn', () => {
|
|
throw new Error('native error')
|
|
})
|
|
|
|
await vm.run()
|
|
const cleanupCount = vm.scope.get('cleanup_count')
|
|
expect(cleanupCount).toEqual({ type: 'number', value: 1 })
|
|
})
|
|
|
|
test('uncaught native function error crashes VM', async () => {
|
|
const bytecode = toBytecode(`
|
|
LOAD failing_fn
|
|
PUSH 0
|
|
PUSH 0
|
|
CALL
|
|
HALT
|
|
`)
|
|
|
|
const vm = new VM(bytecode)
|
|
vm.set('failing_fn', () => {
|
|
throw new Error('uncaught error')
|
|
})
|
|
|
|
await expect(vm.run()).rejects.toThrow('uncaught error')
|
|
}) |