Switch statements using gotos

lolleko · lolleko · commit a6e1dcc0193c · 2018-09-05T15:46:07.000+02:00
Added test for jump local scope
Added test for returns inside switches
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -585,70 +585,69 @@ export abstract class LuaTranspiler {
 
         let result = this.indent + "-------Switch statement start-------\n";
 
-        const jumpTableName = "____switch" + this.genVarCounter;
+        const switchVarName = "____switch" + this.genVarCounter;
         this.genVarCounter++;
 
-        result += this.indent + `local ${jumpTableName} = {}\n`;
+        result += this.indent + `local ${switchVarName} = ${expression}\n`;
+
+        let hasDefaultClause = false;
 
         // If statement to go to right entry label
         clauses.forEach((clause, index) => {
             if (ts.isCaseClause(clause)) {
-                result += this.indent + `-- case:\n`;
                 result += this.indent +
-                          `${jumpTableName}[${this.transpileExpression(clause.expression, true)}] = function()\n`;
-            }
-            if (ts.isDefaultClause(clause)) {
-                result += this.indent + `-- default:\n`;
-                result += this.indent + `${jumpTableName}["____default${this.genVarCounter}"] = function()\n`;
+                          `if ${this.transpileExpression(clause.expression, true)} == ${switchVarName} then\n`;
+
+                this.pushIndent();
+                result += this.indent + `goto ${switchVarName}_case_${index}\n`;
+                this.popIndent();
+
+                result += this.indent + "end\n";
+            } else if (ts.isDefaultClause(clause)) {
+                hasDefaultClause = true;
             }
-            this.pushIndent();
+        });
 
+        result += "\n";
+
+        // If no case condition is matched jump to end or default immediately
+        if (hasDefaultClause) {
+            result += this.indent + `goto ${switchVarName}_default\n`;
+        } else {
+            result += this.indent + `goto ${switchVarName}_end\n`;
+        }
+
+        result += "\n";
+
+        const transpileClauseBody = (clause: ts.CaseOrDefaultClause) => {
             this.transpilingSwitch++;
+            result += this.indent + "do\n";
+            this.pushIndent();
             result += this.transpileBlock(ts.createBlock(clause.statements));
+            this.popIndent();
+            result += this.indent + "end\n";
             this.transpilingSwitch--;
+        };
 
-            let i = index + 1;
-            if (i < clauses.length
-                && !tsHelper.containsStatement(clause.statements, ts.SyntaxKind.BreakStatement)
-                && !tsHelper.containsStatement(clause.statements, ts.SyntaxKind.ReturnStatement)
-            ) {
-                let nextClause = clauses[i];
-                while (i < clauses.length
-                    && ts.isCaseClause(nextClause)
-                    && nextClause.statements.length === 0
-                ) {
-                    i++;
-                    nextClause = clauses[i];
-                }
+        clauses.forEach((clause, index) => {
+            if (ts.isCaseClause(clause)) {
+                result += this.indent + `::${switchVarName}_case_${index}::\n`;
 
-                if (i !== index && nextClause) {
-                    if (ts.isCaseClause(nextClause)) {
-                        const nextValue = this.transpileExpression(nextClause.expression, true);
-                        result += this.indent + `return ${jumpTableName}[${nextValue}]()\n`;
-                    } else {
-                        result += this.indent + `${jumpTableName}["____default${this.genVarCounter}"]()\n`;
-                    }
+                transpileClauseBody(clause);
+
+                if (tsHelper.containsStatement(clause.statements, ts.SyntaxKind.BreakStatement)) {
+                    result += this.indent + `goto ${switchVarName}_end\n`;
                 }
-            } else {
-                result += this.indent + `-- break;\n`;
+            } else if (ts.isDefaultClause(clause)) {
+                result += this.indent + `::${switchVarName}_default::\n`;
+
+                transpileClauseBody(clause);
             }
+        });
 
-            this.popIndent();
+        result += this.indent + `::${switchVarName}_end::\n`;
+        result += this.indent + "-------Switch statement end-------\n";
 
-            result += this.indent + `end\n`;
-        });
-        result += this.indent + `if ${jumpTableName}[${expression}] then\n`
-            + this.indent + `   local ${jumpTableName}Return = ${jumpTableName}[${expression}]()\n`
-            + this.indent + `   if ${jumpTableName}Return ~= nil then return ${jumpTableName}Return end\n`;
-        result += this.indent + `elseif ${jumpTableName}["____default${this.genVarCounter}"] then\n`
-            + this.indent + `   local ${jumpTableName}Return = ${jumpTableName}["____default${this.genVarCounter}"]()\n`
-            + this.indent + `   if ${jumpTableName}Return ~= nil then return ${jumpTableName}Return end\n`
-            + this.indent + `end\n`;
-        result += this.indent +
-                  "--------Switch statement end--------\n";
-
-        // Increment counter for next switch statement
-        this.genVarCounter += clauses.length;
         return result;
     }
 
diff --git a/test/unit/conditionals.spec.ts b/test/unit/conditionals.spec.ts
@@ -252,6 +252,65 @@ export class LuaConditionalsTests {
         Expect(result).toBe(expected);
     }
 
+    @Test("switchLocalScope")
+    @TestCase(0, 0)
+    @TestCase(1, 2)
+    @TestCase(2, 2)
+    public switchLocalScope(inp: number, expected: number): void {
+        // Transpile
+        const lua = util.transpileString(
+            `let result = -1;
+
+            switch (${inp}) {
+                case 0:
+                    let x = 0;
+                    result = 0;
+                    break;
+                case 1:
+                    let x = 1;
+                    result = x;
+                case 2:
+                    let x = 2;
+                    result = x;
+                    break;
+            }
+            return result;`
+        );
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(expected);
+    }
+
+    @Test("switchReturn")
+    @TestCase(0, 0)
+    @TestCase(1, 1)
+    @TestCase(2, 2)
+    public switchReturn(inp: number, expected: number): void {
+        // Transpile
+        const lua = util.transpileString(
+            `switch (${inp}) {
+                case 0:
+                    return 0;
+                    break;
+                case 1:
+                    return 1;
+                case 2:
+                    return 2;
+                    break;
+            }
+            return result;`
+        );
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(expected);
+    }
+
     @Test("If dead code after return")
     public ifDeadCodeAfterReturn(): void {
         const result = util.transpileAndExecute(
