typescript-to-lua 1.6.3 → 1.7.0

package/dist/transformation/utils/scope.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.addScopeVariableDeclaration = exports.popScope = exports.pushScope = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
+exports.performHoisting = exports.separateHoistedStatements = exports.isFunctionScopeWithDefinition = exports.hasReferencedSymbol = exports.hasReferencedUndefinedLocalFunction = exports.addScopeVariableDeclaration = exports.findScope = exports.peekScope = exports.markSymbolAsReferencedInCurrentScopes = exports.walkScopesUp = exports.ScopeType = void 0;
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const utils_1 = require("../../utils");
@@ -18,12 +18,8 @@ var ScopeType;
     ScopeType[ScopeType["Catch"] = 128] = "Catch";
     ScopeType[ScopeType["LoopInitializer"] = 256] = "LoopInitializer";
 })(ScopeType = exports.ScopeType || (exports.ScopeType = {}));
-const scopeStacks = new WeakMap();
-function getScopeStack(context) {
-    return (0, utils_1.getOrUpdate)(scopeStacks, context, () => []);
-}
 function* walkScopesUp(context) {
-    const scopeStack = getScopeStack(context);
+    const scopeStack = context.scopeStack;
     for (let i = scopeStack.length - 1; i >= 0; --i) {
         const scope = scopeStack[i];
         yield scope;
@@ -31,7 +27,7 @@ function* walkScopesUp(context) {
 }
 exports.walkScopesUp = walkScopesUp;
 function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
-    for (const scope of getScopeStack(context)) {
+    for (const scope of context.scopeStack) {
         if (!scope.referencedSymbols) {
             scope.referencedSymbols = new Map();
         }
@@ -41,34 +37,21 @@ function markSymbolAsReferencedInCurrentScopes(context, symbolId, identifier) {
 }
 exports.markSymbolAsReferencedInCurrentScopes = markSymbolAsReferencedInCurrentScopes;
 function peekScope(context) {
-    const scopeStack = getScopeStack(context);
+    const scopeStack = context.scopeStack;
     const scope = scopeStack[scopeStack.length - 1];
     (0, utils_1.assert)(scope);
     return scope;
 }
 exports.peekScope = peekScope;
 function findScope(context, scopeTypes) {
-    return [...getScopeStack(context)].reverse().find(s => scopeTypes & s.type);
+    for (let i = context.scopeStack.length - 1; i >= 0; --i) {
+        const scope = context.scopeStack[i];
+        if (scopeTypes & scope.type) {
+            return scope;
+        }
+    }
 }
 exports.findScope = findScope;
-const scopeIdCounters = new WeakMap();
-function pushScope(context, scopeType) {
-    var _a;
-    const nextScopeId = ((_a = scopeIdCounters.get(context)) !== null && _a !== void 0 ? _a : 0) + 1;
-    scopeIdCounters.set(context, nextScopeId);
-    const scopeStack = getScopeStack(context);
-    const scope = { type: scopeType, id: nextScopeId };
-    scopeStack.push(scope);
-    return scope;
-}
-exports.pushScope = pushScope;
-function popScope(context) {
-    const scopeStack = getScopeStack(context);
-    const scope = scopeStack.pop();
-    (0, utils_1.assert)(scope);
-    return scope;
-}
-exports.popScope = popScope;
 function addScopeVariableDeclaration(scope, declaration) {
     if (!scope.variableDeclarations) {
         scope.variableDeclarations = [];

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

@@ -8,4 +8,4 @@ export interface SymbolInfo {
 export declare function getSymbolInfo(context: TransformationContext, symbolId: lua.SymbolId): SymbolInfo | undefined;
 export declare function getSymbolIdOfSymbol(context: TransformationContext, symbol: ts.Symbol): lua.SymbolId | undefined;
 export declare function trackSymbolReference(context: TransformationContext, symbol: ts.Symbol, identifier: ts.Identifier): lua.SymbolId | undefined;
-export declare function getIdentifierSymbolId(context: TransformationContext, identifier: ts.Identifier): lua.SymbolId | undefined;
+export declare function getIdentifierSymbolId(context: TransformationContext, identifier: ts.Identifier, symbol: ts.Symbol | undefined): lua.SymbolId | undefined;

package/dist/transformation/utils/symbols.js

@@ -1,35 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIdentifierSymbolId = exports.trackSymbolReference = exports.getSymbolIdOfSymbol = exports.getSymbolInfo = void 0;
-const utils_1 = require("../../utils");
 const spread_1 = require("../visitors/spread");
 const scope_1 = require("./scope");
-const symbolIdCounters = new WeakMap();
-function nextSymbolId(context) {
-    var _a;
-    const symbolId = ((_a = symbolIdCounters.get(context)) !== null && _a !== void 0 ? _a : 0) + 1;
-    symbolIdCounters.set(context, symbolId);
-    return symbolId;
-}
-const symbolInfoMap = new WeakMap();
-const symbolIdMaps = new WeakMap();
 function getSymbolInfo(context, symbolId) {
-    return (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map()).get(symbolId);
+    return context.symbolInfoMap.get(symbolId);
 }
 exports.getSymbolInfo = getSymbolInfo;
 function getSymbolIdOfSymbol(context, symbol) {
-    return (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map()).get(symbol);
+    return context.symbolIdMaps.get(symbol);
 }
 exports.getSymbolIdOfSymbol = getSymbolIdOfSymbol;
 function trackSymbolReference(context, symbol, identifier) {
-    const symbolIds = (0, utils_1.getOrUpdate)(symbolIdMaps, context, () => new Map());
     // Track first time symbols are seen
-    let symbolId = symbolIds.get(symbol);
+    let symbolId = context.symbolIdMaps.get(symbol);
     if (symbolId === undefined) {
-        symbolId = nextSymbolId(context);
-        symbolIds.set(symbol, symbolId);
-        const symbolInfo = (0, utils_1.getOrUpdate)(symbolInfoMap, context, () => new Map());
-        symbolInfo.set(symbolId, { symbol, firstSeenAtPos: identifier.pos });
+        symbolId = context.nextSymbolId();
+        context.symbolIdMaps.set(symbol, symbolId);
+        context.symbolInfoMap.set(symbolId, { symbol, firstSeenAtPos: identifier.pos });
     }
     // If isOptimizedVarArgSpread returns true, the identifier will not appear in the resulting Lua.
     // Only the optimized ellipses (...) will be used.
@@ -39,8 +27,7 @@ function trackSymbolReference(context, symbol, identifier) {
     return symbolId;
 }
 exports.trackSymbolReference = trackSymbolReference;
-function getIdentifierSymbolId(context, identifier) {
-    const symbol = context.checker.getSymbolAtLocation(identifier);
+function getIdentifierSymbolId(context, identifier, symbol) {
     if (symbol) {
         return trackSymbolReference(context, symbol, identifier);
     }

package/dist/transformation/utils/typescript/index.d.ts

@@ -9,6 +9,7 @@ export declare function hasExportEquals(sourceFile: ts.SourceFile): boolean;
 export declare function findFirstNodeAbove<T extends ts.Node>(node: ts.Node, callback: (n: ts.Node) => n is T): T | undefined;
 export declare function findFirstNonOuterParent(node: ts.Node): ts.Node;
 export declare function getFirstDeclarationInFile(symbol: ts.Symbol, sourceFile: ts.SourceFile): ts.Declaration | undefined;
+export declare function isStandardLibraryDeclaration(context: TransformationContext, declaration: ts.Declaration): boolean;
 export declare function isStandardLibraryType(context: TransformationContext, type: ts.Type, name: string | undefined): boolean;
 export declare function hasStandardLibrarySignature(context: TransformationContext, callExpression: ts.CallExpression): boolean;
 export declare function inferAssignedType(context: TransformationContext, expression: ts.Expression): ts.Type;

package/dist/transformation/utils/typescript/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
+exports.isConstIdentifier = exports.getFunctionTypeForCall = exports.isExpressionWithEvaluationEffect = exports.getAllCallSignatures = exports.inferAssignedType = exports.hasStandardLibrarySignature = exports.isStandardLibraryType = exports.isStandardLibraryDeclaration = exports.getFirstDeclarationInFile = exports.findFirstNonOuterParent = exports.findFirstNodeAbove = exports.hasExportEquals = void 0;
 const ts = require("typescript");
 __exportStar(require("./nodes"), exports);
 __exportStar(require("./types"), exports);
@@ -62,6 +62,7 @@ function isStandardLibraryDeclaration(context, declaration) {
     }
     return context.program.isSourceFileDefaultLibrary(sourceFile);
 }
+exports.isStandardLibraryDeclaration = isStandardLibraryDeclaration;
 function isStandardLibraryType(context, type, name) {
     const symbol = type.getSymbol();
     if (!symbol || (name ? symbol.name !== name : symbol.name === "__type")) {

package/dist/transformation/utils/typescript/types.d.ts

@@ -1,12 +1,9 @@
 import * as ts from "typescript";
 import { TransformationContext } from "../../context";
-export declare function isTypeWithFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
-export declare function typeAlwaysSatisfies(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
-export declare function typeCanSatisfy(context: TransformationContext, type: ts.Type, predicate: (type: ts.Type) => boolean): boolean;
-export declare function isNullishType(context: TransformationContext, type: ts.Type): boolean;
+export declare function typeAlwaysHasSomeOfFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
+export declare function typeCanHaveSomeOfFlags(context: TransformationContext, type: ts.Type, flags: ts.TypeFlags): boolean;
 export declare function isStringType(context: TransformationContext, type: ts.Type): boolean;
 export declare function isNumberType(context: TransformationContext, type: ts.Type): boolean;
-export declare function isNullableType(context: TransformationContext, type: ts.Type, isType: (c: TransformationContext, t: ts.Type) => boolean): boolean;
 /**
  * Iterate over a type and its bases until the callback returns true.
  */

package/dist/transformation/utils/typescript/types.js

@@ -1,30 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNullableType = exports.isNumberType = exports.isStringType = exports.isNullishType = exports.typeCanSatisfy = exports.typeAlwaysSatisfies = exports.isTypeWithFlags = void 0;
+exports.canBeFalsyWhenNotNull = exports.canBeFalsy = exports.isFunctionType = exports.isArrayType = exports.forTypeOrAnySupertype = exports.isNumberType = exports.isStringType = exports.typeCanHaveSomeOfFlags = exports.typeAlwaysHasSomeOfFlags = void 0;
 const ts = require("typescript");
-function isTypeWithFlags(context, type, flags) {
-    const predicate = (type) => (type.flags & flags) !== 0;
-    return typeAlwaysSatisfies(context, type, predicate);
-}
-exports.isTypeWithFlags = isTypeWithFlags;
-function typeAlwaysSatisfies(context, type, predicate) {
+function typeAlwaysHasSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
     if (baseConstraint) {
         type = baseConstraint;
     }
-    if (predicate(type)) {
+    if (type.flags & flags) {
         return true;
     }
     if (type.isUnion()) {
-        return type.types.every(t => typeAlwaysSatisfies(context, t, predicate));
+        return type.types.every(t => typeAlwaysHasSomeOfFlags(context, t, flags));
     }
     if (type.isIntersection()) {
-        return type.types.some(t => typeAlwaysSatisfies(context, t, predicate));
+        return type.types.some(t => typeAlwaysHasSomeOfFlags(context, t, flags));
     }
     return false;
 }
-exports.typeAlwaysSatisfies = typeAlwaysSatisfies;
-function typeCanSatisfy(context, type, predicate) {
+exports.typeAlwaysHasSomeOfFlags = typeAlwaysHasSomeOfFlags;
+function typeCanHaveSomeOfFlags(context, type, flags) {
     const baseConstraint = context.checker.getBaseConstraintOfType(type);
     if (!baseConstraint) {
         // type parameter with no constraint can be anything, assume it might satisfy predicate
@@ -34,36 +29,29 @@ function typeCanSatisfy(context, type, predicate) {
     else {
         type = baseConstraint;
     }
-    if (predicate(type)) {
+    if (type.flags & flags) {
         return true;
     }
     if (type.isUnion()) {
-        return type.types.some(t => typeCanSatisfy(context, t, predicate));
+        return type.types.some(t => typeCanHaveSomeOfFlags(context, t, flags));
     }
     if (type.isIntersection()) {
-        return type.types.some(t => typeCanSatisfy(context, t, predicate));
+        return type.types.some(t => typeCanHaveSomeOfFlags(context, t, flags));
     }
     return false;
 }
-exports.typeCanSatisfy = typeCanSatisfy;
-function isNullishType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.VoidLike);
-}
-exports.isNullishType = isNullishType;
+exports.typeCanHaveSomeOfFlags = typeCanHaveSomeOfFlags;
 function isStringType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.String | ts.TypeFlags.StringLike | ts.TypeFlags.StringLiteral);
+    return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.StringLike);
 }
 exports.isStringType = isStringType;
 function isNumberType(context, type) {
-    return isTypeWithFlags(context, type, ts.TypeFlags.Number | ts.TypeFlags.NumberLike | ts.TypeFlags.NumberLiteral);
+    return typeAlwaysHasSomeOfFlags(context, type, ts.TypeFlags.NumberLike);
 }
 exports.isNumberType = isNumberType;
-function isNullableType(context, type, isType) {
-    return (typeCanSatisfy(context, type, t => isType(context, t)) &&
-        typeAlwaysSatisfies(context, type, t => isType(context, t) || isNullishType(context, t)));
-}
-exports.isNullableType = isNullableType;
 function isExplicitArrayType(context, type) {
+    if (context.checker.isArrayType(type) || context.checker.isTupleType(type))
+        return true;
     if (type.symbol) {
         const baseConstraint = context.checker.getBaseConstraintOfType(type);
         if (baseConstraint && baseConstraint !== type) {
@@ -73,25 +61,22 @@ function isExplicitArrayType(context, type) {
     if (type.isUnionOrIntersection()) {
         return type.types.some(t => isExplicitArrayType(context, t));
     }
-    const flags = ts.NodeBuilderFlags.InTypeAlias | ts.NodeBuilderFlags.AllowEmptyTuple;
-    let typeNode = context.checker.typeToTypeNode(type, undefined, flags);
-    if (typeNode && ts.isTypeOperatorNode(typeNode) && typeNode.operator === ts.SyntaxKind.ReadonlyKeyword) {
-        typeNode = typeNode.type;
-    }
-    return typeNode !== undefined && (ts.isArrayTypeNode(typeNode) || ts.isTupleTypeNode(typeNode));
+    return false;
 }
 /**
  * Iterate over a type and its bases until the callback returns true.
  */
 function forTypeOrAnySupertype(context, type, predicate) {
-    var _a;
     if (predicate(type)) {
         return true;
     }
     if (!type.isClassOrInterface() && type.symbol) {
         type = context.checker.getDeclaredTypeOfSymbol(type.symbol);
     }
-    return ((_a = type.getBaseTypes()) !== null && _a !== void 0 ? _a : []).some(superType => forTypeOrAnySupertype(context, superType, predicate));
+    const baseTypes = type.getBaseTypes();
+    if (!baseTypes)
+        return false;
+    return baseTypes.some(superType => forTypeOrAnySupertype(context, superType, predicate));
 }
 exports.forTypeOrAnySupertype = forTypeOrAnySupertype;
 function isArrayType(context, type) {
@@ -104,6 +89,8 @@ function isFunctionType(type) {
 exports.isFunctionType = isFunctionType;
 function canBeFalsy(context, type) {
     const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    if (!strictNullChecks && !type.isLiteral())
+        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
         ts.TypeFlags.Never |
@@ -112,17 +99,20 @@ function canBeFalsy(context, type) {
         ts.TypeFlags.Any |
         ts.TypeFlags.Undefined |
         ts.TypeFlags.Null;
-    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0 || (!strictNullChecks && !type.isLiteral()));
+    return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
 exports.canBeFalsy = canBeFalsy;
 function canBeFalsyWhenNotNull(context, type) {
+    const strictNullChecks = context.options.strict === true || context.options.strictNullChecks === true;
+    if (!strictNullChecks && !type.isLiteral())
+        return true;
     const falsyFlags = ts.TypeFlags.Boolean |
         ts.TypeFlags.BooleanLiteral |
         ts.TypeFlags.Never |
         ts.TypeFlags.Void |
         ts.TypeFlags.Unknown |
         ts.TypeFlags.Any;
-    return typeCanSatisfy(context, type, type => (type.flags & falsyFlags) !== 0);
+    return typeCanHaveSomeOfFlags(context, type, falsyFlags);
 }
 exports.canBeFalsyWhenNotNull = canBeFalsyWhenNotNull;
 //# sourceMappingURL=types.js.map

package/dist/transformation/visitors/access.js

@@ -76,10 +76,6 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
     const property = node.name.text;
     const type = context.checker.getTypeAtLocation(node.expression);
     const isOptionalLeft = (0, optional_chaining_1.isOptionalContinuation)(node.expression);
-    const annotations = (0, annotations_1.getTypeAnnotations)(type);
-    if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
-    }
     const constEnumValue = (0, enum_1.tryGetConstEnumValue)(context, node);
     if (constEnumValue) {
         return { expression: constEnumValue };
@@ -91,6 +87,7 @@ function transformPropertyAccessExpressionWithCapture(context, node, thisValueCa
         return (0, optional_chaining_1.transformOptionalChainWithCapture)(context, node, thisValueCapture);
     }
     // Do not output path for member only enums
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     if (annotations.has(annotations_1.AnnotationKind.CompileMembersOnly)) {
         if (isOptionalLeft) {
             context.diagnostics.push((0, diagnostics_1.unsupportedOptionalCompileMembersOnly)(node));

package/dist/transformation/visitors/block.js

@@ -9,16 +9,16 @@ function transformBlockOrStatement(context, statement) {
 }
 exports.transformBlockOrStatement = transformBlockOrStatement;
 function transformScopeBlock(context, node, scopeType) {
-    (0, scope_1.pushScope)(context, scopeType);
+    context.pushScope(scopeType);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
-    const scope = (0, scope_1.popScope)(context);
+    const scope = context.popScope();
     return [lua.createBlock(statements, node), scope];
 }
 exports.transformScopeBlock = transformScopeBlock;
 const transformBlock = (node, context) => {
-    (0, scope_1.pushScope)(context, scope_1.ScopeType.Block);
+    context.pushScope(scope_1.ScopeType.Block);
     const statements = (0, scope_1.performHoisting)(context, context.transformStatements(node.statements));
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return lua.createDoStatement(statements, node);
 };
 exports.transformBlock = transformBlock;

package/dist/transformation/visitors/call.js

@@ -4,7 +4,6 @@ exports.getCalledExpression = exports.transformCallExpression = exports.transfor
 const ts = require("typescript");
 const lua = require("../../LuaAST");
 const builtins_1 = require("../builtins");
-const annotations_1 = require("../utils/annotations");
 const assignment_validation_1 = require("../utils/assignment-validation");
 const function_context_1 = require("../utils/function-context");
 const lua_ast_1 = require("../utils/lua-ast");
@@ -16,17 +15,17 @@ const diagnostics_1 = require("../utils/diagnostics");
 const expression_list_1 = require("./expression-list");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const optional_chaining_1 = require("./optional-chaining");
-const language_extensions_1 = require("./language-extensions");
 const import_1 = require("./modules/import");
+const call_extension_1 = require("./language-extensions/call-extension");
 function validateArguments(context, params, signature) {
     if (!signature || signature.parameters.length < params.length) {
         return;
     }
     for (const [index, param] of params.entries()) {
         const signatureParameter = signature.parameters[index];
-        const paramType = context.checker.getTypeAtLocation(param);
         if (signatureParameter.valueDeclaration !== undefined) {
             const signatureType = context.checker.getTypeAtLocation(signatureParameter.valueDeclaration);
+            const paramType = context.checker.getTypeAtLocation(param);
             (0, assignment_validation_1.validateAssignment)(context, param, paramType, signatureType, signatureParameter.name);
         }
     }
@@ -157,20 +156,14 @@ const transformCallExpression = (node, context) => {
         ? (0, optional_chaining_1.getOptionalContinuationData)(calledExpression)
         : undefined;
     const wrapResultInTable = (0, multi_1.isMultiReturnCall)(context, node) && (0, multi_1.shouldMultiReturnCallBeWrapped)(context, node);
-    if ((0, annotations_1.isTupleReturnCall)(context, node)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.TupleReturn));
-    }
-    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node, optionalContinuation !== undefined)) !== null && _a !== void 0 ? _a : (0, language_extensions_1.transformLanguageExtensionCallExpression)(context, node, optionalContinuation !== undefined);
+    const builtinOrExtensionResult = (_a = (0, builtins_1.transformBuiltinCallExpression)(context, node)) !== null && _a !== void 0 ? _a : (0, call_extension_1.transformLanguageExtensionCallExpression)(context, node);
     if (builtinOrExtensionResult) {
-        // unsupportedOptionalCall diagnostic already present
+        if (optionalContinuation !== undefined) {
+            context.diagnostics.push((0, diagnostics_1.unsupportedBuiltinOptionalCall)(node));
+        }
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(builtinOrExtensionResult) : builtinOrExtensionResult;
     }
     if (ts.isPropertyAccessExpression(calledExpression)) {
-        const ownerType = context.checker.getTypeAtLocation(calledExpression.expression);
-        const annotations = (0, annotations_1.getTypeAnnotations)(ownerType);
-        if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-            context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
-        }
         const result = transformPropertyCall(context, node, calledExpression);
         return wrapResultInTable ? (0, lua_ast_1.wrapInTable)(result) : result;
     }
@@ -211,11 +204,7 @@ function isContextualCallExpression(context, signature) {
     return (0, function_context_1.getDeclarationContextType)(context, declaration) !== function_context_1.ContextType.Void;
 }
 function getCalledExpression(node) {
-    function unwrapExpression(expression) {
-        expression = ts.skipOuterExpressions(expression);
-        return ts.isNonNullExpression(expression) ? unwrapExpression(expression.expression) : expression;
-    }
-    return unwrapExpression(node.expression);
+    return ts.skipOuterExpressions(node.expression);
 }
 exports.getCalledExpression = getCalledExpression;
 //# sourceMappingURL=call.js.map

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

@@ -3,9 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformSuperExpression = exports.transformClassAsExpression = exports.transformThisExpression = exports.transformClassDeclaration = void 0;
 const ts = require("typescript");
 const lua = require("../../../LuaAST");
-const utils_1 = require("../../../utils");
-const annotations_1 = require("../../utils/annotations");
-const diagnostics_1 = require("../../utils/diagnostics");
 const export_1 = require("../../utils/export");
 const lua_ast_1 = require("../../utils/lua-ast");
 const safe_names_1 = require("../../utils/safe-names");
@@ -15,7 +12,7 @@ const accessors_1 = require("./members/accessors");
 const constructor_1 = require("./members/constructor");
 const fields_1 = require("./members/fields");
 const method_1 = require("./members/method");
-const utils_2 = require("./utils");
+const utils_1 = require("./utils");
 const setup_1 = require("./setup");
 const transformClassDeclaration = (declaration, context) => {
     // If declaration is a default export, transform to export variable assignment instead
@@ -36,7 +33,6 @@ function transformClassAsExpression(expression, context) {
     return name;
 }
 exports.transformClassAsExpression = transformClassAsExpression;
-const classSuperInfos = new WeakMap();
 function transformClassLikeDeclaration(classDeclaration, context, nameOverride) {
     let className;
     if (nameOverride !== undefined) {
@@ -48,22 +44,14 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
     else {
         className = lua.createIdentifier(context.createTempName("class"), classDeclaration);
     }
-    const annotations = (0, annotations_1.getTypeAnnotations)(context.checker.getTypeAtLocation(classDeclaration));
-    if (annotations.has(annotations_1.AnnotationKind.Extension)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.Extension));
-    }
-    if (annotations.has(annotations_1.AnnotationKind.MetaExtension)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(classDeclaration, annotations_1.AnnotationKind.MetaExtension));
-    }
     // Get type that is extended
-    const extendedTypeNode = (0, utils_2.getExtendedNode)(context, classDeclaration);
-    const extendedType = (0, utils_2.getExtendedType)(context, classDeclaration);
-    const superInfo = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
-    superInfo.push({ className, extendedTypeNode });
+    const extendedTypeNode = (0, utils_1.getExtendedNode)(classDeclaration);
+    const extendedType = (0, utils_1.getExtendedType)(context, classDeclaration);
+    context.classSuperInfos.push({ className, extendedTypeNode });
     // Get all properties with value
     const properties = classDeclaration.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);
     // Divide properties into static and non-static
-    const instanceFields = properties.filter(prop => !(0, utils_2.isStaticNode)(prop));
+    const instanceFields = properties.filter(prop => !(0, utils_1.isStaticNode)(prop));
     const result = [];
     let localClassName;
     if ((0, safe_names_1.isUnsafeName)(className.text, context.options)) {
@@ -129,7 +117,7 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
             }
         }
         else if (ts.isPropertyDeclaration(member)) {
-            if ((0, utils_2.isStaticNode)(member)) {
+            if ((0, utils_1.isStaticNode)(member)) {
                 const statement = (0, fields_1.transformStaticPropertyDeclaration)(context, member, localClassName);
                 if (statement)
                     decorationStatements.push(statement);
@@ -153,11 +141,11 @@ function transformClassLikeDeclaration(classDeclaration, context, nameOverride)
             result.push(classAssignment);
         }
     }
-    superInfo.pop();
+    context.classSuperInfos.pop();
     return { statements: result, name: className };
 }
 const transformSuperExpression = (expression, context) => {
-    const superInfos = (0, utils_1.getOrUpdate)(classSuperInfos, context, () => []);
+    const superInfos = context.classSuperInfos;
     const superInfo = superInfos[superInfos.length - 1];
     if (!superInfo)
         return lua.createAnonymousIdentifier(expression);

package/dist/transformation/visitors/class/members/constructor.js

@@ -22,7 +22,7 @@ function transformConstructorDeclaration(context, statement, className, instance
         return undefined;
     }
     // Transform body
-    const scope = (0, scope_1.pushScope)(context, scope_1.ScopeType.Function);
+    const scope = context.pushScope(scope_1.ScopeType.Function);
     const body = (0, function_1.transformFunctionBodyContent)(context, statement.body);
     const [params, dotsLiteral, restParamName] = (0, function_1.transformParameters)(context, statement.parameters, (0, lua_ast_1.createSelfIdentifier)());
     // Make sure default parameters are assigned before fields are initialized
@@ -58,7 +58,7 @@ function transformConstructorDeclaration(context, statement, className, instance
     bodyWithFieldInitializers.push(...body);
     const block = lua.createBlock(bodyWithFieldInitializers);
     const constructorWasGenerated = statement.pos === -1;
-    (0, scope_1.popScope)(context);
+    context.popScope();
     return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.NodeFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
 }
 exports.transformConstructorDeclaration = transformConstructorDeclaration;

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

@@ -10,16 +10,13 @@ const call_1 = require("../call");
 const table_1 = require("../language-extensions/table");
 const transformNewExpression = (node, context) => {
     var _a, _b;
-    const type = context.checker.getTypeAtLocation(node);
-    const annotations = (0, annotations_1.getTypeAnnotations)(type);
-    if (annotations.has(annotations_1.AnnotationKind.LuaTable)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(node, annotations_1.AnnotationKind.LuaTable));
-    }
     if ((0, table_1.isTableNewCall)(context, node)) {
         return lua.createTableExpression(undefined, node);
     }
     const signature = context.checker.getResolvedSignature(node);
     const [name, params] = (0, call_1.transformCallAndArguments)(context, node.expression, (_a = node.arguments) !== null && _a !== void 0 ? _a : [ts.factory.createTrue()], signature);
+    const type = context.checker.getTypeAtLocation(node);
+    const annotations = (0, annotations_1.getTypeAnnotations)(type);
     const customConstructorAnnotation = annotations.get(annotations_1.AnnotationKind.CustomConstructor);
     if (customConstructorAnnotation) {
         if (customConstructorAnnotation.args.length === 1) {

package/dist/transformation/visitors/class/setup.d.ts

@@ -2,4 +2,4 @@ import * as ts from "typescript";
 import * as lua from "../../../LuaAST";
 import { TransformationContext } from "../../context";
 export declare function createClassSetup(context: TransformationContext, statement: ts.ClassLikeDeclarationBase, className: lua.Identifier, localClassName: lua.Identifier, extendsType?: ts.Type): lua.Statement[];
-export declare function getReflectionClassName(context: TransformationContext, declaration: ts.ClassLikeDeclarationBase, className: lua.Identifier): lua.Expression;
+export declare function getReflectionClassName(declaration: ts.ClassLikeDeclarationBase, className: lua.Identifier): lua.Expression;

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

@@ -34,16 +34,16 @@ function createClassSetup(context, statement, className, localClassName, extends
         }
     }
     // localClassName.name = className
-    result.push(lua.createAssignmentStatement(lua.createTableIndexExpression(lua.cloneIdentifier(localClassName), lua.createStringLiteral("name")), getReflectionClassName(context, statement, className), statement));
+    result.push(lua.createAssignmentStatement(lua.createTableIndexExpression(lua.cloneIdentifier(localClassName), lua.createStringLiteral("name")), getReflectionClassName(statement, className), statement));
     if (extendsType) {
-        const extendedNode = (0, utils_2.getExtendedNode)(context, statement);
+        const extendedNode = (0, utils_2.getExtendedNode)(statement);
         (0, utils_1.assert)(extendedNode);
         result.push(lua.createExpressionStatement((0, lualib_1.transformLuaLibFunction)(context, lualib_1.LuaLibFeature.ClassExtends, (0, utils_2.getExtendsClause)(statement), lua.cloneIdentifier(localClassName), context.transformExpression(extendedNode.expression))));
     }
     return result;
 }
 exports.createClassSetup = createClassSetup;
-function getReflectionClassName(context, declaration, className) {
+function getReflectionClassName(declaration, className) {
     if (declaration.name) {
         return lua.createStringLiteral(declaration.name.text);
     }
@@ -53,7 +53,7 @@ function getReflectionClassName(context, declaration, className) {
     else if ((0, export_1.hasDefaultExportModifier)(declaration)) {
         return lua.createStringLiteral("default");
     }
-    if ((0, utils_2.getExtendedNode)(context, declaration)) {
+    if ((0, utils_2.getExtendedNode)(declaration)) {
         return lua.createTableIndexExpression(className, lua.createStringLiteral("name"));
     }
     return lua.createStringLiteral("");

package/dist/transformation/visitors/class/utils.d.ts

@@ -2,5 +2,5 @@ import * as ts from "typescript";
 import { TransformationContext } from "../../context";
 export declare function isStaticNode(node: ts.Node): boolean;
 export declare function getExtendsClause(node: ts.ClassLikeDeclarationBase): ts.HeritageClause | undefined;
-export declare function getExtendedNode(context: TransformationContext, node: ts.ClassLikeDeclarationBase): ts.ExpressionWithTypeArguments | undefined;
+export declare function getExtendedNode(node: ts.ClassLikeDeclarationBase): ts.ExpressionWithTypeArguments | undefined;
 export declare function getExtendedType(context: TransformationContext, node: ts.ClassLikeDeclarationBase): ts.Type | undefined;

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

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getExtendedType = exports.getExtendedNode = exports.getExtendsClause = exports.isStaticNode = void 0;
 const ts = require("typescript");
-const annotations_1 = require("../../utils/annotations");
-const diagnostics_1 = require("../../utils/diagnostics");
 function isStaticNode(node) {
     var _a;
     return ((_a = node.modifiers) !== null && _a !== void 0 ? _a : []).some(m => m.kind === ts.SyntaxKind.StaticKeyword);
@@ -14,20 +12,15 @@ function getExtendsClause(node) {
     return ((_a = node.heritageClauses) !== null && _a !== void 0 ? _a : []).find(clause => clause.token === ts.SyntaxKind.ExtendsKeyword);
 }
 exports.getExtendsClause = getExtendsClause;
-function getExtendedNode(context, node) {
+function getExtendedNode(node) {
     const extendsClause = getExtendsClause(node);
     if (!extendsClause)
         return;
-    const superType = context.checker.getTypeAtLocation(extendsClause.types[0]);
-    const annotations = (0, annotations_1.getTypeAnnotations)(superType);
-    if (annotations.has(annotations_1.AnnotationKind.PureAbstract)) {
-        context.diagnostics.push((0, diagnostics_1.annotationRemoved)(extendsClause, annotations_1.AnnotationKind.PureAbstract));
-    }
     return extendsClause.types[0];
 }
 exports.getExtendedNode = getExtendedNode;
 function getExtendedType(context, node) {
-    const extendedNode = getExtendedNode(context, node);
+    const extendedNode = getExtendedNode(node);
     return extendedNode && context.checker.getTypeAtLocation(extendedNode);
 }
 exports.getExtendedType = getExtendedType;