diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts index 5f740123b..35004d25d 100644 --- 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 index 994755617..ad4a7e06b 100644 --- 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 index 1f89dd4ec..26ea7cc06 100644 --- 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 index 87f431162..2b0351e4f 100644 --- 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 index cfc411439..87487475d 100644 --- a/src/transformation/visitors/break-continue.ts +++ b/src/transformation/visitors/break-continue.ts @@ -11,12 +11,17 @@ export const transformBreakStatement: FunctionVisitor = (brea export const transformContinueStatement: FunctionVisitor = (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 = 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 index 178f6ac2d..b90c7e2db 100644 --- 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 = (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 index f34b35245..01466b450 100644 --- 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 index 283b4095e..e06a8fafd 100644 --- 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 index b0c7eea52..555092795 100644 --- 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 index 42a4b4355..fc7d66e49 100644 --- 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 new file mode 100644 index 000000000..b4c9fdec4 --- /dev/null +++ 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 index aebaead4c..b8f6b2cc3 100644 --- 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 index f2225c7f5..7e13c6db4 100644 --- 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 index 04b1bd726..3a1add475 100644 --- 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 index 73942a473..7ebe1ccd3 100644 --- a/test/util.ts +++ b/test/util.ts @@ -87,6 +87,7 @@ export function expectEachVersionExceptJit( [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 index 5af971b49..87366ea76 100644 --- 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.",