Add MultiReturn support

README.md

@@ -114,7 +114,7 @@ module.exports = {
             child_process: false,
             crypto: false,
             url: false,
-            module: false
+            module: false,
         },
     },
 }

package.json

@@ -6,8 +6,8 @@
     "scripts": {
         "build:wasm:dev": "./build.sh dev",
         "build:wasm": "./build.sh",
-        "build:wasm:docker:dev": "docker run --rm -v $(pwd):/wasmoon emscripten/emsdk /wasmoon/build.sh dev",
-        "build:wasm:docker": "docker run --rm -v $(pwd):/wasmoon emscripten/emsdk /wasmoon/build.sh",
+        "build:wasm:docker:dev": "docker run --rm -v .:/wasmoon emscripten/emsdk /wasmoon/build.sh dev",
+        "build:wasm:docker": "docker run --rm -v .:/wasmoon emscripten/emsdk /wasmoon/build.sh",
         "start": "rollup -c -w",
         "test": "mocha --parallel --require ./test/boot.js test/*.test.js",
         "luatests": "node --experimental-import-meta-resolve test/luatests.mjs",

src/engine.ts

@@ -51,15 +51,11 @@ export default class LuaEngine {
     }
 
     public doStringSync(script: string): any {
-        this.global.loadString(script)
-        const result = this.global.runSync()
-        return result[0]
+        return this.callByteCodeSync((global) => global.loadString(script))
     }
 
     public doFileSync(filename: string): any {
-        this.global.loadFile(filename)
-        const result = this.global.runSync()
-        return result[0]
+        return this.callByteCodeSync((global) => global.loadFile(filename))
     }
 
     // WARNING: It will not wait for open handles and can potentially cause bugs if JS code tries to reference Lua after executed
@@ -72,10 +68,25 @@ export default class LuaEngine {
             if (result.length > 0) {
                 this.cmodule.lua_xmove(thread.address, this.global.address, result.length)
             }
+
+            if (result.length > 1) {
+                return result // support for multi return values
+            }
+
             return result[0]
         } finally {
             // Pop the read on success or failure
             this.global.remove(threadIndex)
         }
     }
+
+    private callByteCodeSync(loader: (global: Global) => void): any {
+        const global = this.global
+        loader(global)
+        const result = global.runSync()
+        if (result.length > 1) {
+            return result // support for multi return values
+        }
+        return result[0]
+    }
 }

src/type-extensions/function.ts

@@ -1,5 +1,5 @@
 import { BaseDecorationOptions, Decoration } from '../decoration'
-import { LUA_REGISTRYINDEX, LuaReturn, LuaState, LuaType, PointerSize } from '../types'
+import { LUA_MULTRET, LUA_REGISTRYINDEX, LuaReturn, LuaState, LuaType, PointerSize } from '../types'
 import Global from '../global'
 import MultiReturn from '../multireturn'
 import RawResult from '../raw-result'
@@ -158,7 +158,7 @@ class FunctionTypeExtension extends TypeExtension<FunctionType, FunctionDecorati
         thread.lua.lua_pushvalue(thread.address, index)
         const func = thread.lua.luaL_ref(thread.address, LUA_REGISTRYINDEX)
 
-        const jsFunc = (...args: any[]): any => {
+        const jsFunc = (...args: any[]): MultiReturn | any => {
             if (thread.isClosed()) {
                 console.warn('Tried to call a function after closing lua state')
                 return
@@ -173,19 +173,26 @@ class FunctionTypeExtension extends TypeExtension<FunctionType, FunctionDecorati
                 }
             }
 
+            const oldTop = thread.getTop()
+
             for (const arg of args) {
                 thread.pushValue(arg)
             }
 
-            const status = thread.lua.lua_pcallk(thread.address, args.length, 1, 0, 0, null)
+            const status = thread.lua.lua_pcallk(thread.address, args.length, LUA_MULTRET, 0, 0, null)
+            const newTop = thread.lua.lua_gettop(thread.address)
             if (status === LuaReturn.Yield) {
                 throw new Error('cannot yield in callbacks from javascript')
             }
             thread.assertOk(status)
-
-            const result = thread.getValue(-1)
-
-            thread.pop()
+            const deltaTop = newTop - (oldTop - 1)
+            let result = null
+            if (deltaTop > 1) {
+                result = thread.getStackValues(oldTop - 1)
+            } else {
+                result = thread.getValue(-1)
+            }
+            thread.pop(deltaTop)
             return result
         }
 

test/engine.test.js

@@ -168,13 +168,14 @@ describe('Engine', () => {
         expect(sum(10, 50)).to.be.equal(60)
     })
 
+    // TEST OFTEN BREAKS
     it('scheduled lua calls should succeed', async () => {
         const engine = await getEngine()
         engine.global.set('setInterval', setInterval)
 
         await engine.doString(`
             test = ""
-            setInterval(function()
+            setInterval(function ()
                 test = test .. "i"
             end, 1)
         `)
@@ -238,6 +239,54 @@ describe('Engine', () => {
         expect(returns.at(-1)).to.be.a('function')
     })
 
+    it('doString with multiple returns should succeed', async () => {
+        const engine = await getEngine()
+
+        const returns = await engine.doString(`
+            return 1, x, y, "Hello World", {}, function() end, {1,2,3}, {a = 1, b = 2, c = 3};
+        `)
+
+        expect(returns).to.be.a('array')
+        expect(returns).to.have.length(8)
+        expect(returns[5]).to.be.a('function')
+        expect(returns[6]).to.be.a('array')
+        expect(returns[7]).to.be.a('object')
+    })
+
+    it('call lua function with multiple returns should succeed', async () => {
+        const engine = await getEngine()
+
+        const fn = await engine.doString(`
+            return function (x, y)
+                return 1, x, y, function () end, {1,2,3}, {a = 1, b = 2};
+            end
+        `)
+
+        expect(fn).to.be.a('function')
+
+        const returns = fn(4, 5)
+        const [func, arr, obj] = returns.slice(3)
+        expect(returns).to.have.length(6)
+        expect(func).to.be.a('function')
+        expect(arr).to.be.a('array')
+        expect(obj).to.be.a('object')
+    })
+
+    it('call lua function with single returns array should succeed', async () => {
+        const engine = await getEngine()
+
+        const fn = await engine.doString(`
+            return function (a, b, c)
+                return {a, b, c};
+            end
+        `)
+
+        expect(fn).to.be.a('function')
+        const array = fn(3, 4, 5)
+        expect(array).to.be.an('array')
+        expect(array).to.have.length(3)
+    })
+
     it('get a lua thread should succeed', async () => {
         const engine = await getEngine()
 

test/filesystem.test.js

@@ -17,7 +17,8 @@ describe('Filesystem', () => {
         await factory.mountFile('yolo/sofancy/test.lua', 'return 42')
         const engine = await factory.createEngine()
 
-        const value = await engine.doString('return require("yolo/sofancy/test")')
+        // second parameter is path to module
+        const [value] = await engine.doString('return require("yolo/sofancy/test")')
 
         expect(value).to.be.equal(42)
     })
@@ -27,7 +28,8 @@ describe('Filesystem', () => {
         await factory.mountFile('hello/init.lua', 'return 42')
         const engine = await factory.createEngine()
 
-        const value = await engine.doString('return require("hello")')
+        // second parameter is path to module
+        const [value] = await engine.doString('return require("hello")')
 
         expect(value).to.be.equal(42)
     })