typescript-to-lua 1.6.3 → 1.7.0

package/dist/transformation/builtins/object.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformObjectPrototypeCall = exports.transformObjectConstructorCall = void 0;
+exports.tryTransformObjectPrototypeCall = exports.transformObjectConstructorCall = void 0;
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
@@ -30,8 +30,7 @@ function transformObjectConstructorCall(context, node, calledMethod) {
     }
 }
 exports.transformObjectConstructorCall = transformObjectConstructorCall;
-function transformObjectPrototypeCall(context, node, calledMethod) {
-    const signature = context.checker.getResolvedSignature(node);
+function tryTransformObjectPrototypeCall(context, node, calledMethod) {
     const name = calledMethod.name.text;
     switch (name) {
         case "toString":
@@ -39,11 +38,12 @@ function transformObjectPrototypeCall(context, node, calledMethod) {
             return lua.createCallExpression(toStringIdentifier, [context.transformExpression(calledMethod.expression)], node);
         case "hasOwnProperty":
             const expr = context.transformExpression(calledMethod.expression);
+            const signature = context.checker.getResolvedSignature(node);
             const parameters = (0, call_1.transformArguments)(context, node.arguments, signature);
             const rawGetIdentifier = lua.createIdentifier("rawget");
             const rawGetCall = lua.createCallExpression(rawGetIdentifier, [expr, ...parameters]);
             return lua.createBinaryExpression(rawGetCall, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
     }
 }
-exports.transformObjectPrototypeCall = transformObjectPrototypeCall;
+exports.tryTransformObjectPrototypeCall = tryTransformObjectPrototypeCall;
 //# sourceMappingURL=object.js.map

package/dist/transformation/builtins/promise.js

@@ -4,11 +4,13 @@ exports.createStaticPromiseFunctionAccessor = exports.transformPromiseConstructo
 const lua = require("../../LuaAST");
 const diagnostics_1 = require("../utils/diagnostics");
 const lualib_1 = require("../utils/lualib");
-const typescript_1 = require("../utils/typescript");
 const call_1 = require("../visitors/call");
+const typescript_1 = require("../utils/typescript");
 function isPromiseClass(context, node) {
+    if (node.text !== "Promise")
+        return false;
     const type = context.checker.getTypeAtLocation(node);
-    return (0, typescript_1.isStandardLibraryType)(context, type, undefined) && node.text === "Promise";
+    return (0, typescript_1.isStandardLibraryType)(context, type, undefined);
 }
 exports.isPromiseClass = isPromiseClass;
 function createPromiseIdentifier(original) {

package/dist/transformation/builtins/string.js

@@ -100,6 +100,8 @@ function transformStringPrototypeCall(context, node, calledMethod) {
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadStart, node, caller, ...params);
         case "padEnd":
             return (0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.StringPadEnd, node, caller, ...params);
+        case "toString":
+            return; // will be handled by transformObjectPrototypeCall
         default:
             context.diagnostics.push((0, diagnostics_1.unsupportedProperty)(calledMethod.name, "string", expressionName));
     }

package/dist/transformation/context/context.d.ts

@@ -2,6 +2,9 @@ import * as ts from "typescript";
 import { CompilerOptions, LuaTarget } from "../../CompilerOptions";
 import * as lua from "../../LuaAST";
 import { ExpressionLikeNode, StatementLikeNode, VisitorMap } from "./visitors";
+import { SymbolInfo } from "../utils/symbols";
+import { LuaLibFeature } from "../../LuaLib";
+import { Scope, ScopeType } from "../utils/scope";
 export declare const tempSymbolId: lua.SymbolId;
 export interface AllAccessorDeclarations {
     firstAccessor: ts.AccessorDeclaration;
@@ -33,10 +36,13 @@ export declare class TransformationContext {
     readonly isStrict: boolean;
     constructor(program: ts.Program, sourceFile: ts.SourceFile, visitorMap: VisitorMap);
     private currentNodeVisitors;
+    private currentNodeVisitorsIndex;
     private nextTempId;
     transformNode(node: ts.Node): lua.Node[];
     superTransformNode(node: ts.Node): lua.Node[];
+    private doSuperTransformNode;
     transformExpression(node: ExpressionLikeNode): lua.Expression;
+    private assertIsExpression;
     superTransformExpression(node: ExpressionLikeNode): lua.Expression;
     transformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
     superTransformStatements(node: StatementLikeNode | readonly StatementLikeNode[]): lua.Statement[];
@@ -49,4 +55,13 @@ export declare class TransformationContext {
     createTempNameForLuaExpression(expression: lua.Expression): lua.Identifier;
     private getTempNameForNode;
     createTempNameForNode(node: ts.Node): lua.Identifier;
+    private lastSymbolId;
+    readonly symbolInfoMap: Map<lua.SymbolId, SymbolInfo>;
+    readonly symbolIdMaps: Map<ts.Symbol, lua.SymbolId>;
+    nextSymbolId(): lua.SymbolId;
+    readonly usedLuaLibFeatures: Set<LuaLibFeature>;
+    readonly scopeStack: Scope[];
+    private lastScopeId;
+    pushScope(type: ScopeType): Scope;
+    popScope(): Scope;
 }

package/dist/transformation/context/context.js

@@ -24,66 +24,91 @@ class TransformationContext {
         this.isStrict = ((_b = this.options.alwaysStrict) !== null && _b !== void 0 ? _b : this.options.strict) ||
             (this.isModule && this.options.target !== undefined && this.options.target >= ts.ScriptTarget.ES2015);
         this.currentNodeVisitors = [];
+        this.currentNodeVisitorsIndex = 0;
         this.nextTempId = 0;
+        // other utils
+        this.lastSymbolId = 0;
+        this.symbolInfoMap = new Map();
+        this.symbolIdMaps = new Map();
+        this.usedLuaLibFeatures = new Set();
+        this.scopeStack = [];
+        this.lastScopeId = 0;
+        /** @internal */
+        this.classSuperInfos = [];
         // Use `getParseTreeNode` to get original SourceFile node, before it was substituted by custom transformers.
         // It's required because otherwise `getEmitResolver` won't use cached diagnostics, produced in `emitWorker`
         // and would try to re-analyze the file, which would fail because of replaced nodes.
         const originalSourceFile = (_c = ts.getParseTreeNode(sourceFile, ts.isSourceFile)) !== null && _c !== void 0 ? _c : sourceFile;
         this.resolver = this.checker.getEmitResolver(originalSourceFile);
     }
-    transformNode(node, isExpression) {
+    transformNode(node) {
+        return (0, lua_ast_1.unwrapVisitorResult)(this.transformNodeRaw(node));
+    }
+    /** @internal */
+    transformNodeRaw(node, isExpression) {
         var _a;
         // TODO: Move to visitors?
         if ((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword)) {
             return [];
         }
         const nodeVisitors = this.visitorMap.get(node.kind);
-        if (!nodeVisitors || nodeVisitors.length === 0) {
+        if (!nodeVisitors) {
             this.diagnostics.push((0, diagnostics_1.unsupportedNodeKind)(node, node.kind));
             return isExpression ? [lua.createNilLiteral()] : [];
         }
         const previousNodeVisitors = this.currentNodeVisitors;
-        this.currentNodeVisitors = [...nodeVisitors];
-        const visitor = this.currentNodeVisitors.pop();
-        const result = (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
+        const previousNodeVisitorsIndex = this.currentNodeVisitorsIndex;
+        this.currentNodeVisitors = nodeVisitors;
+        this.currentNodeVisitorsIndex = nodeVisitors.length - 1;
+        const visitor = this.currentNodeVisitors[this.currentNodeVisitorsIndex];
+        const result = visitor(node, this);
         this.currentNodeVisitors = previousNodeVisitors;
+        this.currentNodeVisitorsIndex = previousNodeVisitorsIndex;
         return result;
     }
     superTransformNode(node) {
-        if (this.currentNodeVisitors.length === 0) {
+        return (0, lua_ast_1.unwrapVisitorResult)(this.doSuperTransformNode(node));
+    }
+    doSuperTransformNode(node) {
+        if (--this.currentNodeVisitorsIndex < 0) {
             throw new Error(`There is no super transform for ${ts.SyntaxKind[node.kind]} visitor`);
         }
-        const visitor = this.currentNodeVisitors.pop();
-        return (0, lua_ast_1.unwrapVisitorResult)(visitor.transform(node, this));
+        const visitor = this.currentNodeVisitors[this.currentNodeVisitorsIndex];
+        return (0, lua_ast_1.unwrapVisitorResult)(visitor(node, this));
     }
     transformExpression(node) {
-        const [result] = this.transformNode(node, true);
+        const result = this.transformNodeRaw(node, true);
+        return this.assertIsExpression(node, result);
+    }
+    assertIsExpression(node, result) {
         if (result === undefined) {
             throw new Error(`Expression visitor for node type ${ts.SyntaxKind[node.kind]} did not return any result.`);
         }
+        if (Array.isArray(result)) {
+            return result[0];
+        }
         return result;
     }
     superTransformExpression(node) {
-        const [result] = this.superTransformNode(node);
-        if (result === undefined) {
-            throw new Error(`Expression visitor for node type ${ts.SyntaxKind[node.kind]} did not return any result.`);
-        }
-        return result;
+        const result = this.doSuperTransformNode(node);
+        return this.assertIsExpression(node, result);
     }
     transformStatements(node) {
         return (0, utils_1.castArray)(node).flatMap(n => {
             this.pushPrecedingStatements();
             const statements = this.transformNode(n);
-            statements.unshift(...this.popPrecedingStatements());
-            return statements;
+            const result = this.popPrecedingStatements();
+            result.push(...statements);
+            return result;
         });
     }
     superTransformStatements(node) {
         return (0, utils_1.castArray)(node).flatMap(n => {
             this.pushPrecedingStatements();
             const statements = this.superTransformNode(n);
-            statements.unshift(...this.popPrecedingStatements());
-            return statements;
+            const result = this.popPrecedingStatements();
+            result.push(...statements);
+            return result;
         });
     }
     pushPrecedingStatements() {
@@ -97,18 +122,22 @@ class TransformationContext {
     addPrecedingStatements(statements) {
         const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
         (0, utils_1.assert)(precedingStatements);
-        if (!Array.isArray(statements)) {
-            statements = [statements];
+        if (Array.isArray(statements)) {
+            precedingStatements.push(...statements);
+        }
+        else {
+            precedingStatements.push(statements);
         }
-        precedingStatements.push(...statements);
     }
     prependPrecedingStatements(statements) {
         const precedingStatements = this.precedingStatementsStack[this.precedingStatementsStack.length - 1];
         (0, utils_1.assert)(precedingStatements);
-        if (!Array.isArray(statements)) {
-            statements = [statements];
+        if (Array.isArray(statements)) {
+            precedingStatements.unshift(...statements);
+        }
+        else {
+            precedingStatements.unshift(statements);
         }
-        precedingStatements.unshift(...statements);
     }
     createTempName(prefix = "temp") {
         prefix = prefix.replace(/^_*/, ""); // Strip leading underscores because createSafeName will add them again
@@ -171,6 +200,19 @@ class TransformationContext {
         const name = this.getTempNameForNode(node);
         return lua.createIdentifier(this.createTempName(name), node, exports.tempSymbolId);
     }
+    nextSymbolId() {
+        return ++this.lastSymbolId;
+    }
+    pushScope(type) {
+        const scope = { type, id: ++this.lastScopeId };
+        this.scopeStack.push(scope);
+        return scope;
+    }
+    popScope() {
+        const scope = this.scopeStack.pop();
+        (0, utils_1.assert)(scope);
+        return scope;
+    }
 }
 exports.TransformationContext = TransformationContext;
 //# sourceMappingURL=context.js.map

package/dist/transformation/context/visitors.d.ts

@@ -149,5 +149,5 @@ export interface ObjectVisitor<T extends ts.Node> {
 export declare type Visitors = {
     [P in keyof NodesBySyntaxKind]?: Visitor<NodesBySyntaxKind[P]>;
 };
-export declare type VisitorMap = Map<ts.SyntaxKind, Array<ObjectVisitor<ts.Node>>>;
+export declare type VisitorMap = Map<ts.SyntaxKind, Array<FunctionVisitor<ts.Node>>>;
 export {};

package/dist/transformation/index.js

@@ -5,22 +5,23 @@ const utils_1 = require("../utils");
 const context_1 = require("./context");
 const visitors_1 = require("./visitors");
 function createVisitorMap(customVisitors) {
-    const visitorMap = new Map();
+    const objectVisitorMap = new Map();
     for (const visitors of [visitors_1.standardVisitors, ...customVisitors]) {
         const priority = visitors === visitors_1.standardVisitors ? -Infinity : 0;
         for (const [syntaxKindKey, visitor] of Object.entries(visitors)) {
             if (!visitor)
                 continue;
             const syntaxKind = Number(syntaxKindKey);
-            const nodeVisitors = (0, utils_1.getOrUpdate)(visitorMap, syntaxKind, () => []);
+            const nodeVisitors = (0, utils_1.getOrUpdate)(objectVisitorMap, syntaxKind, () => []);
             const objectVisitor = typeof visitor === "function" ? { transform: visitor, priority } : visitor;
             nodeVisitors.push(objectVisitor);
         }
     }
-    for (const nodeVisitors of visitorMap.values()) {
-        nodeVisitors.sort((a, b) => { var _a, _b; return ((_a = a.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = b.priority) !== null && _b !== void 0 ? _b : 0); });
+    const result = new Map();
+    for (const [kind, nodeVisitors] of objectVisitorMap) {
+        result.set(kind, nodeVisitors.sort((a, b) => { var _a, _b; return ((_a = a.priority) !== null && _a !== void 0 ? _a : 0) - ((_b = b.priority) !== null && _b !== void 0 ? _b : 0); }).map(visitor => visitor.transform));
     }
-    return visitorMap;
+    return result;
 }
 exports.createVisitorMap = createVisitorMap;
 function transformSourceFile(program, sourceFile, visitorMap) {

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

@@ -1,20 +1,10 @@
 import * as ts from "typescript";
-import { TransformationContext } from "../context";
 export declare enum AnnotationKind {
-    Extension = "extension",
-    MetaExtension = "metaExtension",
     CustomConstructor = "customConstructor",
     CompileMembersOnly = "compileMembersOnly",
     NoResolution = "noResolution",
-    PureAbstract = "pureAbstract",
-    Phantom = "phantom",
-    TupleReturn = "tupleReturn",
-    LuaIterator = "luaIterator",
-    LuaTable = "luaTable",
     NoSelf = "noSelf",
-    NoSelfInFile = "noSelfInFile",
-    Vararg = "vararg",
-    ForRange = "forRange"
+    NoSelfInFile = "noSelfInFile"
 }
 export interface Annotation {
     kind: AnnotationKind;
@@ -25,9 +15,3 @@ export declare function getSymbolAnnotations(symbol: ts.Symbol): AnnotationsMap;
 export declare function getTypeAnnotations(type: ts.Type): AnnotationsMap;
 export declare function getNodeAnnotations(node: ts.Node): AnnotationsMap;
 export declare function getFileAnnotations(sourceFile: ts.SourceFile): AnnotationsMap;
-export declare function getSignatureAnnotations(context: TransformationContext, signature: ts.Signature): AnnotationsMap;
-export declare function isTupleReturnCall(context: TransformationContext, node: ts.Node): boolean;
-export declare function isLuaIteratorType(context: TransformationContext, node: ts.Node): boolean;
-export declare function isVarargType(context: TransformationContext, node: ts.Node): boolean;
-export declare function isForRangeType(context: TransformationContext, node: ts.Node): boolean;
-export declare function getTagArgsFromComment(tag: ts.JSDocTag): string[];

package/dist/transformation/utils/annotations.js

@@ -1,135 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTagArgsFromComment = exports.isForRangeType = exports.isVarargType = exports.isLuaIteratorType = exports.isTupleReturnCall = exports.getSignatureAnnotations = exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
+exports.getFileAnnotations = exports.getNodeAnnotations = exports.getTypeAnnotations = exports.getSymbolAnnotations = exports.AnnotationKind = void 0;
 const ts = require("typescript");
 var AnnotationKind;
 (function (AnnotationKind) {
-    AnnotationKind["Extension"] = "extension";
-    AnnotationKind["MetaExtension"] = "metaExtension";
     AnnotationKind["CustomConstructor"] = "customConstructor";
     AnnotationKind["CompileMembersOnly"] = "compileMembersOnly";
     AnnotationKind["NoResolution"] = "noResolution";
-    AnnotationKind["PureAbstract"] = "pureAbstract";
-    AnnotationKind["Phantom"] = "phantom";
-    AnnotationKind["TupleReturn"] = "tupleReturn";
-    AnnotationKind["LuaIterator"] = "luaIterator";
-    AnnotationKind["LuaTable"] = "luaTable";
     AnnotationKind["NoSelf"] = "noSelf";
     AnnotationKind["NoSelfInFile"] = "noSelfInFile";
-    AnnotationKind["Vararg"] = "vararg";
-    AnnotationKind["ForRange"] = "forRange";
 })(AnnotationKind = exports.AnnotationKind || (exports.AnnotationKind = {}));
-function createAnnotation(name, args) {
-    const kind = Object.values(AnnotationKind).find(k => k.toLowerCase() === name.toLowerCase());
-    if (kind !== undefined) {
-        return { kind, args };
-    }
-}
+const annotationValues = new Map(Object.values(AnnotationKind).map(k => [k.toLowerCase(), k]));
 function collectAnnotations(source, annotationsMap) {
     var _a, _b;
     for (const tag of source.getJsDocTags()) {
-        const annotation = createAnnotation(tag.name, (_b = (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(p => p.text)) !== null && _b !== void 0 ? _b : []);
-        if (annotation) {
-            annotationsMap.set(annotation.kind, annotation);
-        }
+        const tagName = annotationValues.get(tag.name.toLowerCase());
+        if (!tagName)
+            continue;
+        const annotation = {
+            kind: tag.name,
+            args: (_b = (_a = tag.text) === null || _a === void 0 ? void 0 : _a.map(p => p.text)) !== null && _b !== void 0 ? _b : [],
+        };
+        annotationsMap.set(tagName, annotation);
     }
 }
+const symbolAnnotations = new WeakMap();
 function getSymbolAnnotations(symbol) {
+    const known = symbolAnnotations.get(symbol);
+    if (known)
+        return known;
     const annotationsMap = new Map();
     collectAnnotations(symbol, annotationsMap);
+    symbolAnnotations.set(symbol, annotationsMap);
     return annotationsMap;
 }
 exports.getSymbolAnnotations = getSymbolAnnotations;
 function getTypeAnnotations(type) {
+    // types are not frequently repeatedly polled for annotations, so it's not worth caching them
     const annotationsMap = new Map();
-    if (type.symbol)
-        collectAnnotations(type.symbol, annotationsMap);
-    if (type.aliasSymbol)
-        collectAnnotations(type.aliasSymbol, annotationsMap);
+    if (type.symbol) {
+        getSymbolAnnotations(type.symbol).forEach((value, key) => {
+            annotationsMap.set(key, value);
+        });
+    }
+    if (type.aliasSymbol) {
+        getSymbolAnnotations(type.aliasSymbol).forEach((value, key) => {
+            annotationsMap.set(key, value);
+        });
+    }
     return annotationsMap;
 }
 exports.getTypeAnnotations = getTypeAnnotations;
+const nodeAnnotations = new WeakMap();
 function getNodeAnnotations(node) {
+    const known = nodeAnnotations.get(node);
+    if (known)
+        return known;
     const annotationsMap = new Map();
-    for (const tag of ts.getJSDocTags(node)) {
-        const tagName = tag.tagName.text;
-        const annotation = createAnnotation(tagName, getTagArgsFromComment(tag));
-        if (annotation) {
-            annotationsMap.set(annotation.kind, annotation);
-        }
-    }
+    collectAnnotationsFromTags(annotationsMap, ts.getAllJSDocTags(node, ts.isJSDocUnknownTag));
+    nodeAnnotations.set(node, annotationsMap);
     return annotationsMap;
 }
 exports.getNodeAnnotations = getNodeAnnotations;
+function collectAnnotationsFromTags(annotationsMap, tags) {
+    for (const tag of tags) {
+        const tagName = annotationValues.get(tag.tagName.text.toLowerCase());
+        if (!tagName)
+            continue;
+        annotationsMap.set(tagName, { kind: tagName, args: getTagArgsFromComment(tag) });
+    }
+}
+const fileAnnotations = new WeakMap();
 function getFileAnnotations(sourceFile) {
+    const known = fileAnnotations.get(sourceFile);
+    if (known)
+        return known;
     const annotationsMap = new Map();
     if (sourceFile.statements.length > 0) {
         // Manually collect jsDoc because `getJSDocTags` includes tags only from closest comment
         const jsDoc = sourceFile.statements[0].jsDoc;
         if (jsDoc) {
-            for (const tag of jsDoc.flatMap(x => { var _a; return (_a = x.tags) !== null && _a !== void 0 ? _a : []; })) {
-                const tagName = tag.tagName.text;
-                const annotation = createAnnotation(tagName, getTagArgsFromComment(tag));
-                if (annotation) {
-                    annotationsMap.set(annotation.kind, annotation);
+            for (const jsDocElement of jsDoc) {
+                if (jsDocElement.tags) {
+                    collectAnnotationsFromTags(annotationsMap, jsDocElement.tags);
                 }
             }
         }
     }
+    fileAnnotations.set(sourceFile, annotationsMap);
     return annotationsMap;
 }
 exports.getFileAnnotations = getFileAnnotations;
-function getSignatureAnnotations(context, signature) {
-    const annotationsMap = new Map();
-    collectAnnotations(signature, annotationsMap);
-    // Function properties on interfaces have the JSDoc tags on the parent PropertySignature
-    const declaration = signature.getDeclaration();
-    if ((declaration === null || declaration === void 0 ? void 0 : declaration.parent) && ts.isPropertySignature(declaration.parent)) {
-        const symbol = context.checker.getSymbolAtLocation(declaration.parent.name);
-        if (symbol) {
-            collectAnnotations(symbol, annotationsMap);
-        }
-    }
-    return annotationsMap;
-}
-exports.getSignatureAnnotations = getSignatureAnnotations;
-function isTupleReturnCall(context, node) {
-    if (!ts.isCallExpression(node)) {
-        return false;
-    }
-    const signature = context.checker.getResolvedSignature(node);
-    if (signature) {
-        if (getSignatureAnnotations(context, signature).has(AnnotationKind.TupleReturn)) {
-            return true;
-        }
-        // Only check function type for directive if it is declared as an interface or type alias
-        const declaration = signature.getDeclaration();
-        const isInterfaceOrAlias = (declaration === null || declaration === void 0 ? void 0 : declaration.parent) &&
-            ((ts.isInterfaceDeclaration(declaration.parent) && ts.isCallSignatureDeclaration(declaration)) ||
-                ts.isTypeAliasDeclaration(declaration.parent));
-        if (!isInterfaceOrAlias) {
-            return false;
-        }
-    }
-    const type = context.checker.getTypeAtLocation(node.expression);
-    return getTypeAnnotations(type).has(AnnotationKind.TupleReturn);
-}
-exports.isTupleReturnCall = isTupleReturnCall;
-function isLuaIteratorType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.LuaIterator);
-}
-exports.isLuaIteratorType = isLuaIteratorType;
-function isVarargType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.Vararg);
-}
-exports.isVarargType = isVarargType;
-function isForRangeType(context, node) {
-    const type = context.checker.getTypeAtLocation(node);
-    return getTypeAnnotations(type).has(AnnotationKind.ForRange);
-}
-exports.isForRangeType = isForRangeType;
 function getTagArgsFromComment(tag) {
     if (tag.comment) {
         if (typeof tag.comment === "string") {
@@ -141,5 +102,4 @@ function getTagArgsFromComment(tag) {
     }
     return [];
 }
-exports.getTagArgsFromComment = getTagArgsFromComment;
 //# sourceMappingURL=annotations.js.map

package/dist/transformation/utils/assignment-validation.js

@@ -8,6 +8,7 @@ const function_context_1 = require("./function-context");
 // TODO: Clear if types are reused between compilations
 const typeValidationCache = new WeakMap();
 function validateAssignment(context, node, fromType, toType, toName) {
+    var _a, _b;
     if (toType === fromType) {
         return;
     }
@@ -21,13 +22,9 @@ function validateAssignment(context, node, fromType, toType, toName) {
         return;
     fromTypeCache.add(toType);
     validateFunctionAssignment(context, node, fromType, toType, toName);
-    const fromTypeNode = context.checker.typeToTypeNode(fromType, undefined, undefined);
-    const toTypeNode = context.checker.typeToTypeNode(toType, undefined, undefined);
-    if (!fromTypeNode || !toTypeNode) {
-        return;
-    }
-    if ((ts.isArrayTypeNode(toTypeNode) || ts.isTupleTypeNode(toTypeNode)) &&
-        (ts.isArrayTypeNode(fromTypeNode) || ts.isTupleTypeNode(fromTypeNode))) {
+    const checker = context.checker;
+    if ((checker.isTupleType(toType) || checker.isArrayType(toType)) &&
+        (checker.isTupleType(fromType) || checker.isArrayType(fromType))) {
         // Recurse into arrays/tuples
         const fromTypeArguments = fromType.typeArguments;
         const toTypeArguments = toType.typeArguments;
@@ -39,25 +36,32 @@ function validateAssignment(context, node, fromType, toType, toName) {
             validateAssignment(context, node, fromTypeArguments[i], toTypeArguments[i], toName);
         }
     }
-    if ((toType.flags & ts.TypeFlags.Object) !== 0 &&
-        (ts.isTypeLiteralNode(toTypeNode) ||
-            (toType.objectFlags & ts.ObjectFlags.ClassOrInterface) !== 0) &&
-        toType.symbol &&
-        toType.symbol.members &&
-        fromType.symbol &&
-        fromType.symbol.members) {
+    const fromMembers = (_a = fromType.symbol) === null || _a === void 0 ? void 0 : _a.members;
+    const toMembers = (_b = toType.symbol) === null || _b === void 0 ? void 0 : _b.members;
+    if (fromMembers && toMembers) {
         // Recurse into interfaces
-        toType.symbol.members.forEach((toMember, escapedMemberName) => {
-            if (fromType.symbol.members) {
-                const fromMember = fromType.symbol.members.get(escapedMemberName);
+        if (toMembers.size < fromMembers.size) {
+            toMembers.forEach((toMember, escapedMemberName) => {
+                const fromMember = fromMembers.get(escapedMemberName);
                 if (fromMember) {
-                    const toMemberType = context.checker.getTypeOfSymbolAtLocation(toMember, node);
-                    const fromMemberType = context.checker.getTypeOfSymbolAtLocation(fromMember, node);
-                    const memberName = ts.unescapeLeadingUnderscores(escapedMemberName);
-                    validateAssignment(context, node, fromMemberType, toMemberType, toName ? `${toName}.${memberName}` : memberName);
+                    validateMember(toMember, fromMember, escapedMemberName);
+                }
+            });
+        }
+        else {
+            fromMembers.forEach((fromMember, escapedMemberName) => {
+                const toMember = toMembers.get(escapedMemberName);
+                if (toMember) {
+                    validateMember(toMember, fromMember, escapedMemberName);
                 }
-            }
-        });
+            });
+        }
+    }
+    function validateMember(toMember, fromMember, escapedMemberName) {
+        const toMemberType = context.checker.getTypeOfSymbolAtLocation(toMember, node);
+        const fromMemberType = context.checker.getTypeOfSymbolAtLocation(fromMember, node);
+        const memberName = ts.unescapeLeadingUnderscores(escapedMemberName);
+        validateAssignment(context, node, fromMemberType, toMemberType, toName ? `${toName}.${memberName}` : memberName);
     }
 }
 exports.validateAssignment = validateAssignment;

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

@@ -74,10 +74,7 @@ export declare const invalidMultiTypeToEmptyPatternOrArrayLiteral: ((node: ts.No
 export declare const invalidMultiReturnAccess: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
-export declare const invalidOperatorMappingUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
-    code: number;
-};
-export declare const invalidTableExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
+export declare const invalidCallExtensionUse: ((node: ts.Node, ...args: any[]) => ts.Diagnostic) & {
     code: number;
 };
 export declare const annotationRemoved: ((node: ts.Node, kind: AnnotationKind) => ts.Diagnostic) & {

package/dist/transformation/utils/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidTableExtensionUse = exports.invalidOperatorMappingUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
+exports.undefinedInArrayLiteral = exports.unsupportedOptionalCompileMembersOnly = exports.unsupportedBuiltinOptionalCall = exports.awaitMustBeInAsyncFunction = exports.notAllowedOptionalAssignment = exports.annotationDeprecated = exports.annotationRemoved = exports.invalidCallExtensionUse = exports.invalidMultiReturnAccess = exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = exports.invalidMultiTypeToNonArrayLiteral = exports.invalidMultiFunctionReturnType = exports.invalidMultiFunctionUse = exports.unsupportedVarDeclaration = exports.invalidAmbientIdentifierName = exports.unsupportedProperty = exports.unsupportedForTargetButOverrideAvailable = exports.unsupportedForTarget = exports.unsupportedRightShiftOperator = exports.unsupportedAccessorInObjectLiteral = exports.invalidPairsIterableWithoutDestructuring = exports.invalidMultiIterableWithoutDestructuring = exports.invalidRangeControlVariable = exports.invalidVarargUse = exports.invalidRangeUse = exports.annotationInvalidArgumentCount = exports.decoratorInvalidContext = exports.unsupportedOverloadAssignment = exports.unsupportedSelfFunctionConversion = exports.unsupportedNoSelfFunctionConversion = exports.forbiddenForIn = exports.unsupportedNodeKind = void 0;
 const ts = require("typescript");
 const CompilerOptions_1 = require("../../CompilerOptions");
 const utils_1 = require("../../utils");
@@ -52,8 +52,7 @@ exports.invalidMultiFunctionReturnType = createErrorDiagnosticFactory("The $mult
 exports.invalidMultiTypeToNonArrayLiteral = createErrorDiagnosticFactory("Expected an array literal.");
 exports.invalidMultiTypeToEmptyPatternOrArrayLiteral = createErrorDiagnosticFactory("There must be one or more elements specified here.");
 exports.invalidMultiReturnAccess = createErrorDiagnosticFactory("The LuaMultiReturn type can only be accessed via an element access expression of a numeric type.");
-exports.invalidOperatorMappingUse = createErrorDiagnosticFactory("This function must always be directly called and cannot be referred to.");
-exports.invalidTableExtensionUse = createErrorDiagnosticFactory("This function must be called directly and cannot be referred to.");
+exports.invalidCallExtensionUse = createErrorDiagnosticFactory("This function must be called directly and cannot be referred to.");
 exports.annotationRemoved = createErrorDiagnosticFactory((kind) => `'@${kind}' has been removed and will no longer have any effect.` +
     `See https://typescripttolua.github.io/docs/advanced/compiler-annotations#${kind.toLowerCase()} for more information.`);
 exports.annotationDeprecated = createWarningDiagnosticFactory((kind) => `'@${kind}' is deprecated and will be removed in a future update. Please update your code before upgrading to the next release, otherwise your project will no longer compile. ` +

package/dist/transformation/utils/function-context.d.ts

@@ -6,5 +6,5 @@ export declare enum ContextType {
     NonVoid = 2,
     Mixed = 3
 }
-export declare function getDeclarationContextType({ program }: TransformationContext, signatureDeclaration: ts.SignatureDeclaration): ContextType;
+export declare function getDeclarationContextType(context: TransformationContext, signatureDeclaration: ts.SignatureDeclaration): ContextType;
 export declare function getFunctionContextType(context: TransformationContext, type: ts.Type): ContextType;