typescript-to-lua 1.31.0 → 1.31.2

package/dist/transformation/pre-transformers/using-transformer.js

@@ -6,11 +6,13 @@ const lualib_1 = require("../utils/lualib");
 function usingTransformer(context) {
     return ctx => sourceFile => {
         function visit(node) {
-            if (ts.isBlock(node)) {
+            if (ts.isBlock(node) || ts.isSourceFile(node)) {
                 const [hasUsings, newStatements] = transformBlockWithUsing(context, node.statements, node);
                 if (hasUsings) {
                     // Recurse visitor into updated block to find further usings
-                    const updatedBlock = ts.factory.updateBlock(node, newStatements);
+                    const updatedBlock = ts.isBlock(node)
+                        ? ts.factory.updateBlock(node, newStatements)
+                        : ts.factory.updateSourceFile(node, newStatements);
                     const result = ts.visitEachChild(updatedBlock, visit, ctx);
                     // Set all the synthetic node parents to something that makes sense
                     const parent = [updatedBlock];
@@ -28,7 +30,8 @@ function usingTransformer(context) {
             }
             return ts.visitEachChild(node, visit, ctx);
         }
-        return ts.visitEachChild(sourceFile, visit, ctx);
+        const transformedSourceFile = ts.visitEachChild(sourceFile, visit, ctx);
+        return visit(transformedSourceFile);
     };
 }
 function isUsingDeclarationList(node) {
@@ -68,7 +71,13 @@ function transformBlockWithUsing(context, statements, block) {
             if (isAwaitUsing) {
                 call = ts.factory.createAwaitExpression(call);
             }
-            if (ts.isBlock(block.parent) && block.parent.statements[block.parent.statements.length - 1] !== block) {
+            if (ts.isSourceFile(block)) {
+                // If block is a sourcefile, don't insert a return statement into root code
+                newStatements.push(ts.factory.createExpressionStatement(call));
+            }
+            else if (block.parent &&
+                ts.isBlock(block.parent) &&
+                block.parent.statements[block.parent.statements.length - 1] !== block) {
                 // If this is a free-standing block in a function (not the last statement), dont return the value
                 newStatements.push(ts.factory.createExpressionStatement(call));
             }

package/dist/transformation/utils/export.d.ts

@@ -3,6 +3,7 @@ import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
 export declare function hasDefaultExportModifier(node: ts.Node): boolean;
 export declare function hasExportModifier(node: ts.Node): boolean;
+export declare function shouldBeExported(node: ts.Node): boolean;
 export declare const createDefaultExportStringLiteral: (original?: ts.Node) => lua.StringLiteral;
 export declare function getExportedSymbolDeclaration(symbol: ts.Symbol): ts.Declaration | undefined;
 export declare function getSymbolFromIdentifier(context: TransformationContext, identifier: lua.Identifier): ts.Symbol | undefined;

package/dist/transformation/utils/export.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDefaultExportStringLiteral = void 0;
 exports.hasDefaultExportModifier = hasDefaultExportModifier;
 exports.hasExportModifier = hasExportModifier;
+exports.shouldBeExported = shouldBeExported;
 exports.getExportedSymbolDeclaration = getExportedSymbolDeclaration;
 exports.getSymbolFromIdentifier = getSymbolFromIdentifier;
 exports.getIdentifierExportScope = getIdentifierExportScope;
@@ -30,6 +31,13 @@ function hasExportModifier(node) {
     return (ts.canHaveModifiers(node) &&
         ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)) === true);
 }
+function shouldBeExported(node) {
+    if (hasExportModifier(node)) {
+        // Don't export if we're inside a namespace (module declaration)
+        return ts.findAncestor(node, ts.isModuleDeclaration) === undefined;
+    }
+    return false;
+}
 const createDefaultExportStringLiteral = (original) => lua.createStringLiteral("default", original);
 exports.createDefaultExportStringLiteral = createDefaultExportStringLiteral;
 function getExportedSymbolDeclaration(symbol) {

package/dist/transformation/visitors/call.js

@@ -110,7 +110,7 @@ function transformContextualCallExpression(context, node, args) {
             return lua.createCallExpression(expression, transformedArguments, node);
         }
     }
-    else if (ts.isIdentifier(left)) {
+    else if (ts.isIdentifier(left) || ts.isCallExpression(left)) {
         const callContext = context.isStrict ? ts.factory.createNull() : ts.factory.createIdentifier("_G");
         let expression;
         [expression, transformedArguments] = transformCallWithArguments(context, left, transformedArguments, argPrecedingStatements, callContext);

package/dist/transformation/visitors/class/index.js

@@ -153,7 +153,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
         const decoratingExpression = (0, decorators_1.createClassDecoratingExpression)(context, classDeclaration, localClassName);
         const decoratingStatement = lua.createAssignmentStatement(localClassName, decoratingExpression);
         result.push(decoratingStatement);
-        if ((0, export_1.hasExportModifier)(classDeclaration)) {
+        if ((0, export_1.shouldBeExported)(classDeclaration)) {
             const exportExpression = (0, export_1.hasDefaultExportModifier)(classDeclaration)
                 ? (0, export_1.createDefaultExportExpression)(classDeclaration)
                 : (0, export_1.createExportedIdentifier)(context, className);

package/dist/transformation/visitors/loops/for.js

@@ -6,8 +6,10 @@ const lua = require("../../../LuaAST");
 const preceding_statements_1 = require("../../utils/preceding-statements");
 const variable_declaration_1 = require("../variable-declaration");
 const utils_1 = require("./utils");
+const scope_1 = require("../../utils/scope");
 const transformForStatement = (statement, context) => {
     const result = [];
+    context.pushScope(scope_1.ScopeType.Loop);
     if (statement.initializer) {
         if (ts.isVariableDeclarationList(statement.initializer)) {
             (0, variable_declaration_1.checkVariableDeclarationList)(context, statement.initializer);
@@ -47,6 +49,7 @@ const transformForStatement = (statement, context) => {
     }
     // while (condition) do ... end
     result.push(lua.createWhileStatement(lua.createBlock(body), condition, statement));
+    context.popScope();
     return lua.createDoStatement(result, statement);
 };
 exports.transformForStatement = transformForStatement;

package/dist/transformation/visitors/loops/utils.js

@@ -28,10 +28,24 @@ function transformLoopBody(context, loop) {
         case scope_1.LoopContinued.WithRepeatBreak:
             const identifier = lua.createIdentifier(`__continue${scopeId}`);
             const literalTrue = lua.createBooleanLiteral(true);
+            // If there is a break in the body statements, do not include any code afterwards
+            const transformedBodyStatements = [];
+            let bodyBroken = false;
+            for (const statement of body) {
+                transformedBodyStatements.push(statement);
+                if (lua.isBreakStatement(statement)) {
+                    bodyBroken = true;
+                    break;
+                }
+            }
+            if (!bodyBroken) {
+                // Tell loop to continue if not broken
+                transformedBodyStatements.push(lua.createAssignmentStatement(identifier, literalTrue));
+            }
             return [
                 lua.createDoStatement([
                     lua.createVariableDeclarationStatement(identifier),
-                    lua.createRepeatStatement(lua.createBlock([...body, lua.createAssignmentStatement(identifier, literalTrue)]), literalTrue),
+                    lua.createRepeatStatement(lua.createBlock(transformedBodyStatements), literalTrue),
                     lua.createIfStatement(lua.createUnaryExpression(identifier, lua.SyntaxKind.NotOperator), lua.createBlock([lua.createBreakStatement()])),
                 ]),
             ];

package/dist/transformation/visitors/unary-expression.js

@@ -7,6 +7,8 @@ const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
 const bit_1 = require("./binary-expression/bit");
 const compound_1 = require("./binary-expression/compound");
+const typescript_1 = require("../utils/typescript");
+const lualib_1 = require("../utils/lualib");
 function transformUnaryExpressionStatement(context, node) {
     const expression = ts.isExpressionStatement(node) ? node.expression : node;
     if (ts.isPrefixUnaryExpression(expression) &&
@@ -38,11 +40,26 @@ const transformPrefixUnaryExpression = (expression, context) => {
             return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.PlusToken, false);
         case ts.SyntaxKind.MinusMinusToken:
             return (0, compound_1.transformCompoundAssignmentExpression)(context, expression, expression.operand, ts.factory.createNumericLiteral(1), ts.SyntaxKind.MinusToken, false);
-        case ts.SyntaxKind.PlusToken:
-            // TODO: Wrap with `Number`
-            return context.transformExpression(expression.operand);
-        case ts.SyntaxKind.MinusToken:
-            return lua.createUnaryExpression(context.transformExpression(expression.operand), lua.SyntaxKind.NegationOperator);
+        case ts.SyntaxKind.PlusToken: {
+            const operand = context.transformExpression(expression.operand);
+            const type = context.checker.getTypeAtLocation(expression.operand);
+            if ((0, typescript_1.isNumberType)(context, type)) {
+                return operand;
+            }
+            else {
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, expression, operand);
+            }
+        }
+        case ts.SyntaxKind.MinusToken: {
+            const operand = context.transformExpression(expression.operand);
+            const type = context.checker.getTypeAtLocation(expression.operand);
+            if ((0, typescript_1.isNumberType)(context, type)) {
+                return lua.createUnaryExpression(operand, lua.SyntaxKind.NegationOperator);
+            }
+            else {
+                return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.Number, expression, lua.createUnaryExpression(operand, lua.SyntaxKind.NegationOperator));
+            }
+        }
         case ts.SyntaxKind.ExclamationToken:
             return lua.createUnaryExpression(context.transformExpression(expression.operand), lua.SyntaxKind.NotOperator);
         case ts.SyntaxKind.TildeToken:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.31.0",
+    "version": "1.31.2",
     "description": "A generic TypeScript to Lua transpiler. Write your code in TypeScript and publish Lua!",
     "repository": "https://github.com/TypeScriptToLua/TypeScriptToLua",
     "homepage": "https://typescripttolua.github.io/",