typescript-to-lua 1.6.2 → 1.7.1

package/dist/transformation/builtins/index.js

@@ -22,10 +22,10 @@ const diagnostics_1 = require("../utils/diagnostics");
 function transformBuiltinPropertyAccessExpression(context, node) {
     const ownerType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
-        switch (node.expression.text) {
+        switch (ownerType.symbol.name) {
             case "Math":
                 return (0, math_1.transformMathProperty)(context, node);
-            case "Symbol":
+            case "SymbolConstructor":
                 (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Symbol);
         }
     }
@@ -40,102 +40,95 @@ function transformBuiltinPropertyAccessExpression(context, node) {
     }
 }
 exports.transformBuiltinPropertyAccessExpression = transformBuiltinPropertyAccessExpression;
-function transformBuiltinCallExpression(context, node, isOptionalCall) {
-    const unsupportedOptionalCall = () => {
-        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
-        return lua.createNilLiteral();
-    };
+function transformBuiltinCallExpression(context, node) {
     const expressionType = context.checker.getTypeAtLocation(node.expression);
     if (ts.isIdentifier(node.expression) && (0, typescript_1.isStandardLibraryType)(context, expressionType, undefined)) {
         checkForLuaLibType(context, expressionType);
-        const result = (0, global_1.transformGlobalCall)(context, node);
-        if (result) {
-            if (isOptionalCall)
-                return unsupportedOptionalCall();
+        const result = (0, global_1.tryTransformBuiltinGlobalCall)(context, node, expressionType);
+        if (result)
             return result;
-        }
     }
     const calledMethod = ts.getOriginalNode((0, call_1.getCalledExpression)(node));
-    if (!ts.isPropertyAccessExpression(calledMethod)) {
-        return;
+    if (ts.isPropertyAccessExpression(calledMethod)) {
+        const globalResult = tryTransformBuiltinGlobalMethodCall(context, node, calledMethod);
+        if (globalResult)
+            return globalResult;
+        const prototypeResult = tryTransformBuiltinPropertyCall(context, node, calledMethod);
+        if (prototypeResult)
+            return prototypeResult;
+        // object prototype call may work even without resolved signature/type (which the other builtin calls use)
+        // e.g. (foo as any).toString()
+        // prototype methods take precedence (e.g. number.toString(2))
+        const objectResult = (0, object_1.tryTransformObjectPrototypeCall)(context, node, calledMethod);
+        if (objectResult)
+            return objectResult;
     }
-    const isOptionalAccess = calledMethod.questionDotToken;
-    // If the function being called is of type owner.func, get the type of owner
+}
+exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
+function tryTransformBuiltinGlobalMethodCall(context, node, calledMethod) {
     const ownerType = context.checker.getTypeAtLocation(calledMethod.expression);
-    if ((0, typescript_1.isStandardLibraryType)(context, ownerType, undefined)) {
-        const symbol = ownerType.getSymbol();
-        switch (symbol === null || symbol === void 0 ? void 0 : symbol.name) {
-            case "ArrayConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, array_1.transformArrayConstructorCall)(context, node, calledMethod);
-            case "Console":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, console_1.transformConsoleCall)(context, node, calledMethod);
-            case "Math":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, math_1.transformMathCall)(context, node, calledMethod);
-            case "StringConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, string_1.transformStringConstructorCall)(context, node, calledMethod);
-            case "ObjectConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, object_1.transformObjectConstructorCall)(context, node, calledMethod);
-            case "SymbolConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, symbol_1.transformSymbolConstructorCall)(context, node, calledMethod);
-            case "NumberConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, number_1.transformNumberConstructorCall)(context, node, calledMethod);
-            case "PromiseConstructor":
-                if (isOptionalCall || isOptionalAccess)
-                    return unsupportedOptionalCall();
-                return (0, promise_1.transformPromiseConstructorCall)(context, node, calledMethod);
-        }
-    }
-    const isStringFunction = (0, typescript_1.isStringType)(context, ownerType) ||
-        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isStringType));
-    if (isStringFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return (0, string_1.transformStringPrototypeCall)(context, node, calledMethod);
-    }
-    const isNumberFunction = (0, typescript_1.isNumberType)(context, ownerType) ||
-        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isNumberType));
-    if (isNumberFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return (0, number_1.transformNumberPrototypeCall)(context, node, calledMethod);
-    }
-    const isArrayFunction = (0, typescript_1.isArrayType)(context, ownerType) ||
-        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, typescript_1.isArrayType));
-    if (isArrayFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return (0, array_1.transformArrayPrototypeCall)(context, node, calledMethod);
+    if (!(0, typescript_1.isStandardLibraryType)(context, ownerType, undefined))
+        return;
+    const ownerSymbol = ownerType.symbol;
+    if (!ownerSymbol || ownerSymbol.parent)
+        return;
+    let result;
+    switch (ownerSymbol.name) {
+        case "ArrayConstructor":
+            result = (0, array_1.transformArrayConstructorCall)(context, node, calledMethod);
+            break;
+        case "Console":
+            result = (0, console_1.transformConsoleCall)(context, node, calledMethod);
+            break;
+        case "Math":
+            result = (0, math_1.transformMathCall)(context, node, calledMethod);
+            break;
+        case "StringConstructor":
+            result = (0, string_1.transformStringConstructorCall)(context, node, calledMethod);
+            break;
+        case "ObjectConstructor":
+            result = (0, object_1.transformObjectConstructorCall)(context, node, calledMethod);
+            break;
+        case "SymbolConstructor":
+            result = (0, symbol_1.transformSymbolConstructorCall)(context, node, calledMethod);
+            break;
+        case "NumberConstructor":
+            result = (0, number_1.transformNumberConstructorCall)(context, node, calledMethod);
+            break;
+        case "PromiseConstructor":
+            result = (0, promise_1.transformPromiseConstructorCall)(context, node, calledMethod);
+            break;
     }
-    const isFunctionFunction = (0, typescript_1.isFunctionType)(ownerType) ||
-        (calledMethod.questionDotToken && (0, typescript_1.isNullableType)(context, ownerType, (_, t) => (0, typescript_1.isFunctionType)(t)));
-    if (isFunctionFunction && (0, typescript_1.hasStandardLibrarySignature)(context, node)) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return (0, function_1.transformFunctionPrototypeCall)(context, node, calledMethod);
+    if (result && calledMethod.questionDotToken) {
+        // e.g. console?.log()
+        context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(calledMethod));
     }
-    const objectResult = (0, object_1.transformObjectPrototypeCall)(context, node, calledMethod);
-    if (objectResult) {
-        if (isOptionalCall)
-            return unsupportedOptionalCall();
-        return objectResult;
+    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))
+        return;
+    const callSymbol = context.checker.getTypeAtLocation(signatureDeclaration).symbol;
+    const ownerSymbol = callSymbol.parent;
+    if (!ownerSymbol || ownerSymbol.parent)
+        return;
+    switch (ownerSymbol.name) {
+        case "String":
+            return (0, string_1.transformStringPrototypeCall)(context, node, calledMethod);
+        case "Number":
+            return (0, number_1.transformNumberPrototypeCall)(context, node, calledMethod);
+        case "Array":
+        case "ReadonlyArray":
+            return (0, array_1.transformArrayPrototypeCall)(context, node, calledMethod);
+        case "Function":
+        case "CallableFunction":
+        case "NewableFunction":
+            return (0, function_1.transformFunctionPrototypeCall)(context, node, calledMethod);
     }
 }
-exports.transformBuiltinCallExpression = transformBuiltinCallExpression;
-function transformBuiltinIdentifierExpression(context, node) {
+function transformBuiltinIdentifierExpression(context, node, symbol) {
     switch (node.text) {
         case "NaN":
             return (0, lua_ast_1.createNaN)(node);
@@ -144,7 +137,7 @@ function transformBuiltinIdentifierExpression(context, node) {
             const huge = lua.createStringLiteral("huge");
             return lua.createTableIndexExpression(math, huge, node);
         case "globalThis":
-            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node), "globalThis");
+            return lua.createIdentifier("_G", node, (0, symbols_1.getIdentifierSymbolId)(context, node, symbol), "globalThis");
     }
 }
 exports.transformBuiltinIdentifierExpression = transformBuiltinIdentifierExpression;
@@ -163,9 +156,10 @@ const builtinErrorTypeNames = new Set([
     "URIErrorConstructor",
 ]);
 function checkForLuaLibType(context, type) {
-    if (!type.symbol)
+    const symbol = type.symbol;
+    if (!symbol || symbol.parent)
         return;
-    const name = context.checker.getFullyQualifiedName(type.symbol);
+    const name = symbol.name;
     switch (name) {
         case "Map":
         case "MapConstructor":
@@ -183,6 +177,10 @@ function checkForLuaLibType(context, type) {
         case "WeakSetConstructor":
             (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.WeakSet);
             return;
+        case "Promise":
+        case "PromiseConstructor":
+            (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Promise);
+            return;
     }
     if (builtinErrorTypeNames.has(name)) {
         (0, lualib_1.importLuaLibFeature)(context, lualib_1.LuaLibFeature.Error);

package/dist/transformation/builtins/object.d.ts

@@ -2,4 +2,4 @@ import * as lua from "../../LuaAST";
 import * as ts from "typescript";
 import { TransformationContext } from "../context";
 export declare function transformObjectConstructorCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
-export declare function transformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;
+export declare function tryTransformObjectPrototypeCall(context: TransformationContext, node: ts.CallExpression, calledMethod: ts.PropertyAccessExpression): lua.Expression | undefined;

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[];