typescript-to-lua 1.8.1 → 1.8.2

package/dist/transformation/builtins/index.js

@@ -67,9 +67,7 @@ function transformBuiltinCallExpression(context, node) {
 exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
 function tryTransformBuiltinGlobalMethodCall(context, node, calledMethod) {
     const ownerType = context.checker.getTypeAtLocation(calledMethod.expression);
-    if (!(0, typescript_1.isStandardLibraryType)(context, ownerType, undefined))
-        return;
-    const ownerSymbol = ownerType.symbol;
+    const ownerSymbol = tryGetStandardLibrarySymbolOfType(context, ownerType);
     if (!ownerSymbol || ownerSymbol.parent)
         return;
     let result;
@@ -106,11 +104,10 @@ function tryTransformBuiltinGlobalMethodCall(context, node, calledMethod) {
     return result;
 }
 function tryTransformBuiltinPropertyCall(context, node, calledMethod) {
-    var _a;
-    const signatureDeclaration = (_a = context.checker.getResolvedSignature(node)) === null || _a === void 0 ? void 0 : _a.declaration;
-    if (!signatureDeclaration || !(0, typescript_1.isStandardLibraryDeclaration)(context, signatureDeclaration))
+    const functionType = context.checker.getTypeAtLocation(node.expression);
+    const callSymbol = tryGetStandardLibrarySymbolOfType(context, functionType);
+    if (!callSymbol)
         return;
-    const callSymbol = context.checker.getTypeAtLocation(signatureDeclaration).symbol;
     const ownerSymbol = callSymbol.parent;
     if (!ownerSymbol || ownerSymbol.parent)
         return;
@@ -187,4 +184,17 @@ function checkForLuaLibType(context, type) {
     }
 }
 exports.checkForLuaLibType = checkForLuaLibType;
+function tryGetStandardLibrarySymbolOfType(context, type) {
+    if (type.isUnionOrIntersection()) {
+        for (const subType of type.types) {
+            const symbol = tryGetStandardLibrarySymbolOfType(context, subType);
+            if (symbol)
+                return symbol;
+        }
+    }
+    else if ((0, typescript_1.isStandardLibraryType)(context, type, undefined)) {
+        return type.symbol;
+    }
+    return undefined;
+}
 //# sourceMappingURL=index.js.map

package/dist/transformation/visitors/language-extensions/multi.js

@@ -11,7 +11,9 @@ function isMultiReturnType(type) {
 }
 exports.isMultiReturnType = isMultiReturnType;
 function canBeMultiReturnType(type) {
-    return isMultiReturnType(type) || (type.isUnion() && type.types.some(t => canBeMultiReturnType(t)));
+    return ((type.flags & ts.TypeFlags.Any) !== 0 ||
+        isMultiReturnType(type) ||
+        (type.isUnion() && type.types.some(t => canBeMultiReturnType(t))));
 }
 exports.canBeMultiReturnType = canBeMultiReturnType;
 function isMultiFunctionCall(context, expression) {

package/dist/transformation/visitors/return.js

@@ -12,28 +12,33 @@ const diagnostics_1 = require("../utils/diagnostics");
 const typescript_1 = require("../utils/typescript");
 function transformExpressionsInReturn(context, node, insideTryCatch) {
     const expressionType = context.checker.getTypeAtLocation(node);
-    if (ts.isCallExpression(node)) {
+    // skip type assertions
+    // don't skip parenthesis as it may arise confusion with lua behavior (where parenthesis are significant)
+    const innerNode = ts.skipOuterExpressions(node, ts.OuterExpressionKinds.Assertions);
+    if (ts.isCallExpression(innerNode)) {
         // $multi(...)
-        if ((0, multi_1.isMultiFunctionCall)(context, node)) {
+        if ((0, multi_1.isMultiFunctionCall)(context, innerNode)) {
             // Don't allow $multi to be implicitly cast to something other than LuaMultiReturn
             const type = context.checker.getContextualType(node);
             if (type && !(0, multi_1.canBeMultiReturnType)(type)) {
-                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionReturnType)(node));
+                context.diagnostics.push((0, diagnostics_1.invalidMultiFunctionReturnType)(innerNode));
             }
-            let returnValues = (0, call_1.transformArguments)(context, node.arguments);
+            let returnValues = (0, call_1.transformArguments)(context, innerNode.arguments);
             if (insideTryCatch) {
                 returnValues = [(0, lua_ast_1.wrapInTable)(...returnValues)]; // Wrap results when returning inside try/catch
             }
             return returnValues;
         }
         // Force-wrap LuaMultiReturn when returning inside try/catch
-        if (insideTryCatch && (0, multi_1.returnsMultiType)(context, node) && !(0, multi_1.shouldMultiReturnCallBeWrapped)(context, node)) {
+        if (insideTryCatch &&
+            (0, multi_1.returnsMultiType)(context, innerNode) &&
+            !(0, multi_1.shouldMultiReturnCallBeWrapped)(context, innerNode)) {
             return [(0, lua_ast_1.wrapInTable)(context.transformExpression(node))];
         }
     }
-    else if ((0, multi_1.isInMultiReturnFunction)(context, node) && (0, multi_1.isMultiReturnType)(expressionType)) {
+    else if ((0, multi_1.isInMultiReturnFunction)(context, innerNode) && (0, multi_1.isMultiReturnType)(expressionType)) {
         // Unpack objects typed as LuaMultiReturn
-        return [(0, lua_ast_1.createUnpackCall)(context, context.transformExpression(node), node)];
+        return [(0, lua_ast_1.createUnpackCall)(context, context.transformExpression(innerNode), innerNode)];
     }
     return [context.transformExpression(node)];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "typescript-to-lua",
-    "version": "1.8.1",
+    "version": "1.8.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/",