Basic Luau target (#1608)

vurvdev · web-flow · commit 7cb97ad7233c · 2024-12-29T15:44:37.000+01:00
* Initial Luau implementation

* Add support for luau specific transformation fixtures

Also fixed not providing Luau to the `expectEachVersionExceptJit` function. It seems to work properly in the test suite but I need to make sure that this is intended or if the function should be renamed to something else (like `expectOnlyPUC`) and exclude Luau as well.

* Refactor target specific fixtures

Now stored in separate folders. Future proof and doesn't feel gross.
Also disabled Luau in expectEachVersionExceptJit. Ideally the function would be renamed but the change would be too large here (not necessary either).

* Add remaining Luau test suite cases

Luau supports both math.atan &amp; math.atan2 so having a certain result isn't important. Same goes for table.unpack and unpack.

Had to pass an empty function for the continue case where luau wouldn't make a label at all since it has a proper continue statement.

* Fix eslint issue
diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -62,6 +62,7 @@ export enum LuaTarget {
     Lua53 = "5.3",
     Lua54 = "5.4",
     LuaJIT = "JIT",
+    Luau = "Luau",
 }
 
 export enum BuildMode {
diff --git a/src/LuaAST.ts b/src/LuaAST.ts
@@ -25,6 +25,7 @@ export enum SyntaxKind {
     LabelStatement,
     ReturnStatement,
     BreakStatement,
+    ContinueStatement, // Luau only.
     ExpressionStatement,
 
     // Expression
@@ -45,6 +46,7 @@ export enum SyntaxKind {
     Identifier,
     TableIndexExpression,
     ParenthesizedExpression,
+    ConditionalExpression, // Luau only
 
     // Operators
 
@@ -488,6 +490,18 @@ export function createBreakStatement(tsOriginal?: ts.Node): BreakStatement {
     return createNode(SyntaxKind.BreakStatement, tsOriginal) as BreakStatement;
 }
 
+export interface ContinueStatement extends Statement {
+    kind: SyntaxKind.ContinueStatement;
+}
+
+export function isContinueStatement(node: Node): node is ContinueStatement {
+    return node.kind === SyntaxKind.ContinueStatement;
+}
+
+export function createContinueStatement(tsOriginal?: ts.Node): ContinueStatement {
+    return createNode(SyntaxKind.ContinueStatement, tsOriginal) as ContinueStatement;
+}
+
 export interface ExpressionStatement extends Statement {
     kind: SyntaxKind.ExpressionStatement;
     expression: Expression;
@@ -861,3 +875,26 @@ export function createParenthesizedExpression(expression: Expression, tsOriginal
     parenthesizedExpression.expression = expression;
     return parenthesizedExpression;
 }
+
+export type ConditionalExpression = Expression & {
+    condition: Expression;
+    whenTrue: Expression;
+    whenFalse: Expression;
+};
+
+export function isConditionalExpression(node: Node): node is ConditionalExpression {
+    return node.kind === SyntaxKind.ConditionalExpression;
+}
+
+export function createConditionalExpression(
+    condition: Expression,
+    whenTrue: Expression,
+    whenFalse: Expression,
+    tsOriginal?: ts.Node
+): ConditionalExpression {
+    const conditionalExpression = createNode(SyntaxKind.ConditionalExpression, tsOriginal) as ConditionalExpression;
+    conditionalExpression.condition = condition;
+    conditionalExpression.whenTrue = whenTrue;
+    conditionalExpression.whenFalse = whenFalse;
+    return conditionalExpression;
+}
diff --git a/src/LuaPrinter.ts b/src/LuaPrinter.ts
@@ -396,6 +396,8 @@ export class LuaPrinter {
                 return this.printReturnStatement(statement as lua.ReturnStatement);
             case lua.SyntaxKind.BreakStatement:
                 return this.printBreakStatement(statement as lua.BreakStatement);
+            case lua.SyntaxKind.ContinueStatement:
+                return this.printContinueStatement(statement as lua.ContinueStatement);
             case lua.SyntaxKind.ExpressionStatement:
                 return this.printExpressionStatement(statement as lua.ExpressionStatement);
             default:
@@ -574,6 +576,10 @@ export class LuaPrinter {
         return this.createSourceNode(statement, this.indent("break"));
     }
 
+    public printContinueStatement(statement: lua.ContinueStatement): SourceNode {
+        return this.createSourceNode(statement, this.indent("continue"));
+    }
+
     public printExpressionStatement(statement: lua.ExpressionStatement): SourceNode {
         return this.createSourceNode(statement, [this.indent(), this.printExpression(statement.expression)]);
     }
@@ -614,6 +620,8 @@ export class LuaPrinter {
                 return this.printTableIndexExpression(expression as lua.TableIndexExpression);
             case lua.SyntaxKind.ParenthesizedExpression:
                 return this.printParenthesizedExpression(expression as lua.ParenthesizedExpression);
+            case lua.SyntaxKind.ConditionalExpression:
+                return this.printConditionalExpression(expression as lua.ConditionalExpression);
             default:
                 throw new Error(`Tried to print unknown statement kind: ${lua.SyntaxKind[expression.kind]}`);
         }
@@ -828,6 +836,17 @@ export class LuaPrinter {
         return this.createSourceNode(expression, ["(", this.printExpression(expression.expression), ")"]);
     }
 
+    public printConditionalExpression(expression: lua.ConditionalExpression): SourceNode {
+        return this.createSourceNode(expression, [
+            "if ",
+            this.printExpression(expression.condition),
+            " then ",
+            this.printExpression(expression.whenTrue),
+            " else ",
+            this.printExpression(expression.whenFalse),
+        ]);
+    }
+
     public printOperator(kind: lua.Operator): SourceNode {
         return new SourceNode(null, null, this.relativeSourcePath, LuaPrinter.operatorMap[kind]);
     }
diff --git a/src/transformation/utils/scope.ts b/src/transformation/utils/scope.ts
@@ -25,6 +25,7 @@ interface FunctionDefinitionInfo {
 export enum LoopContinued {
     WithGoto,
     WithRepeatBreak,
+    WithContinue,
 }
 
 export interface Scope {
diff --git a/src/transformation/visitors/break-continue.ts b/src/transformation/visitors/break-continue.ts
@@ -11,12 +11,17 @@ export const transformBreakStatement: FunctionVisitor<ts.BreakStatement> = (brea
 
 export const transformContinueStatement: FunctionVisitor<ts.ContinueStatement> = (statement, context) => {
     const scope = findScope(context, ScopeType.Loop);
-    const continuedWith =
-        context.luaTarget === LuaTarget.Universal ||
-        context.luaTarget === LuaTarget.Lua50 ||
-        context.luaTarget === LuaTarget.Lua51
-            ? LoopContinued.WithRepeatBreak
-            : LoopContinued.WithGoto;
+
+    const continuedWith = {
+        [LuaTarget.Universal]: LoopContinued.WithRepeatBreak,
+        [LuaTarget.Lua50]: LoopContinued.WithRepeatBreak,
+        [LuaTarget.Lua51]: LoopContinued.WithRepeatBreak,
+        [LuaTarget.Lua52]: LoopContinued.WithGoto,
+        [LuaTarget.Lua53]: LoopContinued.WithGoto,
+        [LuaTarget.Lua54]: LoopContinued.WithGoto,
+        [LuaTarget.LuaJIT]: LoopContinued.WithGoto,
+        [LuaTarget.Luau]: LoopContinued.WithContinue,
+    }[context.luaTarget];
 
     if (scope) {
         scope.loopContinued = continuedWith;
@@ -28,6 +33,9 @@ export const transformContinueStatement: FunctionVisitor<ts.ContinueStatement> =
         case LoopContinued.WithGoto:
             return lua.createGotoStatement(label, statement);
 
+        case LoopContinued.WithContinue:
+            return lua.createContinueStatement(statement);
+
         case LoopContinued.WithRepeatBreak:
             return [
                 lua.createAssignmentStatement(lua.createIdentifier(label), lua.createBooleanLiteral(true), statement),
diff --git a/src/transformation/visitors/conditional.ts b/src/transformation/visitors/conditional.ts
@@ -6,6 +6,7 @@ import { performHoisting, ScopeType } from "../utils/scope";
 import { transformBlockOrStatement } from "./block";
 import { canBeFalsy } from "../utils/typescript";
 import { truthyOnlyConditionalValue } from "../utils/diagnostics";
+import { LuaTarget } from "../../CompilerOptions";
 
 function transformProtectedConditionalExpression(
     context: TransformationContext,
@@ -38,6 +39,16 @@ function transformProtectedConditionalExpression(
 }
 
 export const transformConditionalExpression: FunctionVisitor<ts.ConditionalExpression> = (expression, context) => {
+    if (context.luaTarget === LuaTarget.Luau) {
+        // Luau's ternary operator doesn't have these issues
+        return lua.createConditionalExpression(
+            context.transformExpression(expression.condition),
+            context.transformExpression(expression.whenTrue),
+            context.transformExpression(expression.whenFalse),
+            expression
+        );
+    }
+
     // Check if we need to add diagnostic about Lua truthiness
     checkOnlyTruthyCondition(expression.condition, context);
 
diff --git a/src/transformation/visitors/loops/utils.ts b/src/transformation/visitors/loops/utils.ts
@@ -21,6 +21,7 @@ export function transformLoopBody(
 
     switch (scope.loopContinued) {
         case undefined:
+        case LoopContinued.WithContinue:
             return body;
 
         case LoopContinued.WithGoto:
diff --git a/test/cli/parse.spec.ts b/test/cli/parse.spec.ts
@@ -248,6 +248,7 @@ describe("tsconfig", () => {
             ["luaTarget", "5.3", { luaTarget: tstl.LuaTarget.Lua53 }],
             ["luaTarget", "5.4", { luaTarget: tstl.LuaTarget.Lua54 }],
             ["luaTarget", "jit", { luaTarget: tstl.LuaTarget.LuaJIT }],
+            ["luaTarget", "luau", { luaTarget: tstl.LuaTarget.Luau }],
 
             ["luaBundle", "foo", { luaBundle: "foo" }],
             ["luaBundleEntry", "bar", { luaBundleEntry: "bar" }],
diff --git a/test/translation/__snapshots__/transformation.spec.ts.snap b/test/translation/__snapshots__/transformation.spec.ts.snap
@@ -1,5 +1,17 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`Luau Transformation (luauSpecificTransformations) 1`] = `
+"t = if true then "is true" else "is false"
+while false do
+    continue
+end
+repeat
+    do
+        continue
+    end
+until not false"
+`;
+
 exports[`Transformation (blockScopeVariables) 1`] = `
 "do
     local a = 1
diff --git a/test/translation/transformation.spec.ts b/test/translation/transformation.spec.ts
@@ -5,17 +5,27 @@ import { annotationDeprecated } from "../../src/transformation/utils/diagnostics
 import { couldNotResolveRequire } from "../../src/transpilation/diagnostics";
 import * as util from "../util";
 
-const fixturesPath = path.join(__dirname, "./transformation");
-const fixtures = fs
-    .readdirSync(fixturesPath)
-    .filter(f => path.extname(f) === ".ts")
-    .sort()
-    .map(f => [path.parse(f).name, fs.readFileSync(path.join(fixturesPath, f), "utf8")]);
+const targetSpecs: Array<[string, tstl.LuaTarget | undefined, string]> = [
+    ["", undefined, "./transformation"],
+    ["Luau ", tstl.LuaTarget.Luau, "./transformation/luau"],
+];
 
-test.each(fixtures)("Transformation (%s)", (_name, content) => {
-    util.testModule(content)
-        .setOptions({ luaLibImport: tstl.LuaLibImportKind.Require })
-        .ignoreDiagnostics([annotationDeprecated.code, couldNotResolveRequire.code])
-        .disableSemanticCheck()
-        .expectLuaToMatchSnapshot();
-});
+for (const [name, luaTarget, targetDir] of targetSpecs) {
+    const fixturesPath = path.join(__dirname, targetDir);
+    const fixtures = fs
+        .readdirSync(fixturesPath)
+        .filter(f => path.extname(f) === ".ts")
+        .sort()
+        .map(f => [path.parse(f).name, fs.readFileSync(path.join(fixturesPath, f), "utf8")]);
+
+    test.each(fixtures)(`${name}Transformation (%s)`, (_name, content) => {
+        util.testModule(content)
+            .setOptions({
+                luaLibImport: tstl.LuaLibImportKind.Require,
+                luaTarget,
+            })
+            .ignoreDiagnostics([annotationDeprecated.code, couldNotResolveRequire.code])
+            .disableSemanticCheck()
+            .expectLuaToMatchSnapshot();
+    });
+}
diff --git a/test/translation/transformation/luau/luauSpecificTransformations.ts b/test/translation/transformation/luau/luauSpecificTransformations.ts
@@ -0,0 +1,9 @@
+const t = true ? "is true" : "is false";
+
+while (false) {
+    continue;
+}
+
+do {
+    continue;
+} while (false);
diff --git a/test/unit/builtins/math.spec.ts b/test/unit/builtins/math.spec.ts
@@ -96,6 +96,7 @@ util.testEachVersion("Math.atan2", () => util.testExpression`Math.atan2(4, 5)`,
     [tstl.LuaTarget.Lua52]: builder => builder.tap(expectMathAtan2),
     [tstl.LuaTarget.Lua53]: builder => builder.tap(expectMathAtan),
     [tstl.LuaTarget.Lua54]: builder => builder.tap(expectMathAtan2),
+    [tstl.LuaTarget.Luau]: builder => builder.tap(expectMathAtan2),
 });
 
 util.testEachVersion(
diff --git a/test/unit/loops.spec.ts b/test/unit/loops.spec.ts
@@ -553,6 +553,7 @@ for (const testCase of [
         [tstl.LuaTarget.Lua53]: expectContinueGotoLabel,
         [tstl.LuaTarget.Lua54]: expectContinueGotoLabel,
         [tstl.LuaTarget.LuaJIT]: expectContinueGotoLabel,
+        [tstl.LuaTarget.Luau]: () => undefined, // TODO: This is N/A.
     });
 }
 
diff --git a/test/unit/spread.spec.ts b/test/unit/spread.spec.ts
@@ -81,6 +81,7 @@ describe("in function call", () => {
             [tstl.LuaTarget.Lua52]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
             [tstl.LuaTarget.Lua53]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
             [tstl.LuaTarget.Lua54]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
+            [tstl.LuaTarget.Luau]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
         }
     );
 });
@@ -94,6 +95,7 @@ describe("in array literal", () => {
         [tstl.LuaTarget.Lua52]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
         [tstl.LuaTarget.Lua53]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
         [tstl.LuaTarget.Lua54]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
+        [tstl.LuaTarget.Luau]: builder => builder.tap(expectTableUnpack).expectToMatchJsResult(),
     });
 
     test("of array literal /w OmittedExpression", () => {
diff --git a/test/util.ts b/test/util.ts
@@ -87,6 +87,7 @@ export function expectEachVersionExceptJit<T>(
         [tstl.LuaTarget.Lua53]: expectation,
         [tstl.LuaTarget.Lua54]: expectation,
         [tstl.LuaTarget.LuaJIT]: false, // Exclude JIT
+        [tstl.LuaTarget.Luau]: false,
     };
 }
 
diff --git a/tsconfig-schema.json b/tsconfig-schema.json
@@ -50,7 +50,7 @@
                     "description": "Specifies the Lua version you want to generate code for.",
                     "type": "string",
                     "default": "universal",
-                    "enum": ["5.0", "universal", "5.1", "5.2", "5.3", "5.4", "JIT"]
+                    "enum": ["5.0", "universal", "5.1", "5.2", "5.3", "5.4", "JIT", "Luau"]
                 },
                 "noImplicitGlobalVariables": {
                     "description": "Always declare all root-level variables as local, even if the file is not a module and they would be global in TypeScript.",

Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ export enum LuaTarget {`
`62`	`62`	`Lua53 = "5.3",`
`63`	`63`	`Lua54 = "5.4",`
`64`	`64`	`LuaJIT = "JIT",`
	`65`	`+ Luau = "Luau",`
`65`	`66`	`}`
`66`	`67`
`67`	`68`	`export enum BuildMode {`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ interface FunctionDefinitionInfo {`
`25`	`25`	`export enum LoopContinued {`
`26`	`26`	`WithGoto,`
`27`	`27`	`WithRepeatBreak,`
	`28`	`+ WithContinue,`
`28`	`29`	`}`
`29`	`30`
`30`	`31`	`export interface Scope {`