continued improvements to vararg and multi-return displays

Author: tomblind

debugger/debugger.ts

@@ -467,8 +467,6 @@ export namespace Debugger {
         return stack;
     }
 
-    const varArgTable: LuaDebug.VarArgTable = "{...}";
-
     let breakAtDepth = -1;
     let breakInThread: Thread | undefined;
     let updateHook: { (): void };
@@ -619,11 +617,11 @@ export namespace Debugger {
                 const locs = getLocals(frame + frameOffset, currentThread !== activeThread ? currentThread : undefined);
                 mapVarNames(locs.vars, sourceMap);
                 if (locs.varargs) {
-                    const varargVals: unknown[] = [];
+                    const varArgVals: unknown[] = [];
                     for (const vararg of locs.varargs) {
-                        table.insert(varargVals, vararg.val);
+                        table.insert(varArgVals, vararg.val);
                     }
-                    locs.vars[varArgTable] = {val: varargVals, index: -1, type: "table"};
+                    locs.vars["..."] = {val: varArgVals, index: -1, type: "table"};
                 }
                 Send.vars(locs.vars);
 

debugger/protocol.d.ts

@@ -108,8 +108,6 @@ declare namespace LuaDebug {
 
     type Message = Error | DebugBreak | Result | Stack | Variables | Properties | Breakpoints | Threads;
 
-    type VarArgTable = "{...}";
-
     type StartToken = "@lldbg|";
     type EndToken = "|lldbg@";
 

debugger/send.ts

@@ -80,6 +80,14 @@ export namespace Send {
         return dbgVar;
     }
 
+    function buildVarArgs(name: string, values: unknown[]): LuaDebug.Variable {
+        const valueStrs: string[] = [];
+        for (const [_, val] of ipairs(values)) {
+            table.insert(valueStrs, getPrintableValue(val));
+        }
+        return {type: "table", name, value: table.concat(valueStrs, ", "), length: values.length};
+    }
+
     function send(message: LuaDebug.MessageBase) {
         outputFile.write(`${startToken}${Format.asJson(message)}${endToken}`);
     }
@@ -134,7 +142,7 @@ export namespace Send {
             variables: Format.makeExplicitArray()
         };
         for (const [name, info] of pairs(varsObj)) {
-            const dbgVar = buildVariable(name, info.val);
+            const dbgVar = name === "..." ? buildVarArgs(name, info.val as unknown[]) : buildVariable(name, info.val);
             table.insert(dbgVariables.variables, dbgVar);
         }
         send(dbgVariables);

extension/luaDebugSession.ts

@@ -68,7 +68,6 @@ const enum OutputCategory {
 const maxStackCount = 100;
 const metatableDisplayName = "[[metatable]]";
 const tableLengthDisplayName = "[[length]]";
-const varArgTable: LuaDebug.VarArgTable = "{...}";
 const envVariable = "LOCAL_LUA_DEBUGGER_VSCODE";
 const filePathEnvVariable = "LOCAL_LUA_DEBUGGER_FILEPATH";
 const scriptRootsEnvVariable: LuaDebug.ScriptRootsEnv = "LOCAL_LUA_DEBUGGER_SCRIPT_ROOTS";
@@ -686,11 +685,12 @@ export class LuaDebugSession extends LoggingDebugSession {
             } else if (msg.results.length === 1) {
                 const result = msg.results[0];
                 const variablesReference = result.type === "table" ? this.variableHandles.create(expression) : 0;
-                const value = `${typeof result.value !== "undefined" ? result.value : `[${result.type}]`}`;
+                const value = result.value ?? `[${result.type}]`;
                 return {success: true, value, variablesReference};
             } else {
                 const variablesReference = this.variableHandles.create(`@({${expression}})`);
-                return {success: true, value: `[${msg.results.length}]`, variablesReference};
+                const value = `(${msg.results.map(r => r.value ?? `[${r.type}]`).join(", ")})`;
+                return {success: true, value, variablesReference};
             }
 
         } else if (msg.type === "error") {
@@ -706,26 +706,18 @@ export class LuaDebugSession extends LoggingDebugSession {
     private buildVariable(variable: LuaDebug.Variable | LuaDebug.Value, refName: string, variableName?: string) {
         let valueStr: string;
         let ref: number | undefined;
-        let name: string | undefined;
-        if (variable.type === "table") {
-            if (refName === varArgTable) {
-                valueStr = typeof variable.length !== "undefined" ? `[${variable.length}]` : "";
-                name = "...";
-                refName = `@(${refName})`;
-            } else if (typeof variable.value !== "undefined") {
-                valueStr = variable.value;
-            } else {
-                valueStr = "[table]";
-            }
+        if (refName === "...") {
+            valueStr = `(${variable.value ?? ""})`;
+            ref = variable.type === "table" ? this.variableHandles.create("@({...})") : 0;
+        } else if (variable.type === "table") {
+            valueStr = variable.value ?? "[table]";
             ref = this.variableHandles.create(refName);
         } else if (typeof variable.value === "undefined") {
             valueStr = `[${variable.type}]`;
         } else {
             valueStr = variable.value;
         }
-        if (typeof name === "undefined") {
-            name = typeof variableName !== "undefined" ? variableName : (variable as LuaDebug.Variable).name;
-        }
+        const name = typeof variableName !== "undefined" ? variableName : (variable as LuaDebug.Variable).name;
         const indexedVariables = typeof variable.length !== "undefined" && variable.length > 0
             ? variable.length + 1
             : variable.length;

tests/arg/main.lua

@@ -26,10 +26,14 @@ function baz(a, ...)
 end
 
 foo("a")
+foo("a", "b")
 foo("a", "b", {c = "d"})
 
 bar("a")
+bar("a", "b")
 bar("a", "b", {c = "d"})
 
 baz("a")
+baz("a", "b")
+baz("a", {b = "c"})
 baz("a", "b", {c = "d"})