xray16 1.0.0 → 1.0.1

package/README.md

@@ -55,3 +55,32 @@ Separate transformer is needed to build luabind classes instead of table-based c
 - X-Ray C++ source code
 - LuaBind sources and docs
 - LuaJit sources and docs
+
+## 🧱 Plugins
+
+Package includes plugins for typescript-to-lua for easier work with xray16 typings. <br/>
+Following ones are available:
+
+- transform_luabind_class - transforms @LuaBind declared classes in a specific way
+- built_at_info - adds build information in resulting files
+- from_cast_utils - additional utils that should be removed in runtime
+- global_declarations_transform - transforms xray16 imports and removes them from runtime
+- inject_filename - adds $filename global variable to access current file name
+- strip_lua_logger - removes lua logger from runtime
+
+Plugins can be included in tsconfig file as following:
+
+```json
+{
+  "tstl": {
+    "luaPlugins": [
+      { "name": "xray16/plugins/transform_luabind_class/plugin.ts" },
+      { "name": "xray16/plugins/global_declarations_transform.ts" },
+      { "name": "xray16/plugins/built_at_info.ts" },
+      { "name": "xray16/plugins/strip_lua_logger.ts" },
+      { "name": "xray16/plugins/inject_filename.ts" },
+      { "name": "xray16/plugins/from_cast_utils.ts" }
+    ]
+  }
+}
+```

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "xray16",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "author": "Neloreck",
   "repository": "https://github.com/stalker-xrts/xray-16-types",
   "private": false,
-  "main": "src/index.d.ts",
-  "types": "src/index.d.ts",
+  "main": "types/index.d.ts",
+  "types": "types/index.d.ts",
   "scripts": {
+    "prepublish": "npm run build:plugins",
+    "build:plugins": "tsc -p ./src/tsconfig.json",
+    "build:types": "typedoc",
     "typecheck": "tsc --noEmit",
     "typedoc": "typedoc",
     "format": "prettier --write \"**/*.(js|ts|tsx|md)\" && eslint . --ext .ts,.tsx,.js --fix",
@@ -31,7 +34,7 @@
   },
   "files": [
     "plugins/**/*",
-    "src/**/*",
+    "types/**/*",
     "README.md",
     "LICENSE"
   ]

package/plugins/built_at_info.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comment = `-- Generated by xrf util at: ${new Date().toString()}\n\n`;
+const plugin = {
+    beforeEmit(program, options, emitHost, result) {
+        void program;
+        void options;
+        void emitHost;
+        for (const file of result) {
+            file.code = comment + file.code;
+        }
+    },
+};
+exports.default = plugin;

package/plugins/from_cast_utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = require("typescript");
+const diagnostics_1 = require("./utils/diagnostics");
+const FROM_CAST_METHODS = ["$fromObject", "$fromArray", "$fromLuaArray", "$fromLuaTable"];
+/**
+ * Push generic error to notify about usage issue.
+ */
+const createInvalidFunctionCallError = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    return `Invalid transformer call, expected function to have exactly 1 argument.`;
+});
+/**
+ * Plugin for transformation of casting methods.
+ * Simplifies TS/Lua testing and interoperation.
+ */
+const plugin = {
+    visitors: {
+        [typescript_1.SyntaxKind.CallExpression]: (node, context) => {
+            if ((0, typescript_1.isIdentifier)(node.expression) && FROM_CAST_METHODS.includes(node.expression.text)) {
+                if (node.arguments.length !== 1) {
+                    context.diagnostics.push(createInvalidFunctionCallError(node));
+                }
+                return context.transformExpression(node.arguments[0]);
+            }
+            return context.superTransformExpression(node);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/global_declarations_transform.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = require("typescript");
+const XRF_GLOBALS = ["xray16"];
+/**
+ * Plugin that removes imports from 'global' libraries like engine typedefs.
+ */
+const plugin = {
+    visitors: {
+        [typescript_1.SyntaxKind.ImportDeclaration]: (node, context) => {
+            const module = node.moduleSpecifier.getText().slice(1, -1);
+            const shouldNotBeTransformed = XRF_GLOBALS.includes(module);
+            if (shouldNotBeTransformed) {
+                return undefined;
+            }
+            return context.superTransformStatements(node);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/inject_filename.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const typescript_1 = require("typescript");
+const typescript_to_lua_1 = require("typescript-to-lua");
+const FILENAME_IDENTIFIER = "$filename";
+/**
+ * Plugin that injects FILE_NAME in compile-time.
+ */
+const plugin = {
+    visitors: {
+        [typescript_1.SyntaxKind.Identifier]: (node, context) => {
+            if (node.text === FILENAME_IDENTIFIER) {
+                return (0, typescript_to_lua_1.createStringLiteral)(path.parse(context.sourceFile.fileName).name);
+            }
+            return context.superTransformExpression(node);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/plugins/built_at_info.js

@@ -0,0 +1,12 @@
+const comment = `-- Generated by xrf util at: ${new Date().toString()}\n\n`;
+const plugin = {
+    beforeEmit(program, options, emitHost, result) {
+        void program;
+        void options;
+        void emitHost;
+        for (const file of result) {
+            file.code = comment + file.code;
+        }
+    },
+};
+export default plugin;

package/plugins/plugins/from_cast_utils.js

@@ -0,0 +1,27 @@
+import { isIdentifier, SyntaxKind } from "typescript";
+import { createErrorDiagnosticFactory } from "./utils/diagnostics";
+const FROM_CAST_METHODS = ["$fromObject", "$fromArray", "$fromLuaArray", "$fromLuaTable"];
+/**
+ * Push generic error to notify about usage issue.
+ */
+const createInvalidFunctionCallError = createErrorDiagnosticFactory((name) => {
+    return `Invalid transformer call, expected function to have exactly 1 argument.`;
+});
+/**
+ * Plugin for transformation of casting methods.
+ * Simplifies TS/Lua testing and interoperation.
+ */
+const plugin = {
+    visitors: {
+        [SyntaxKind.CallExpression]: (node, context) => {
+            if (isIdentifier(node.expression) && FROM_CAST_METHODS.includes(node.expression.text)) {
+                if (node.arguments.length !== 1) {
+                    context.diagnostics.push(createInvalidFunctionCallError(node));
+                }
+                return context.transformExpression(node.arguments[0]);
+            }
+            return context.superTransformExpression(node);
+        },
+    },
+};
+export default plugin;

package/plugins/plugins/global_declarations_transform.js

@@ -0,0 +1,18 @@
+import { SyntaxKind } from "typescript";
+const XRF_GLOBALS = ["xray16"];
+/**
+ * Plugin that removes imports from 'global' libraries like engine typedefs.
+ */
+const plugin = {
+    visitors: {
+        [SyntaxKind.ImportDeclaration]: (node, context) => {
+            const module = node.moduleSpecifier.getText().slice(1, -1);
+            const shouldNotBeTransformed = XRF_GLOBALS.includes(module);
+            if (shouldNotBeTransformed) {
+                return undefined;
+            }
+            return context.superTransformStatements(node);
+        },
+    },
+};
+export default plugin;

package/plugins/plugins/inject_filename.js

@@ -0,0 +1,18 @@
+import * as path from "path";
+import { SyntaxKind } from "typescript";
+import { createStringLiteral } from "typescript-to-lua";
+const FILENAME_IDENTIFIER = "$filename";
+/**
+ * Plugin that injects FILE_NAME in compile-time.
+ */
+const plugin = {
+    visitors: {
+        [SyntaxKind.Identifier]: (node, context) => {
+            if (node.text === FILENAME_IDENTIFIER) {
+                return createStringLiteral(path.parse(context.sourceFile.fileName).name);
+            }
+            return context.superTransformExpression(node);
+        },
+    },
+};
+export default plugin;

package/plugins/plugins/strip_lua_logger.js

@@ -0,0 +1,51 @@
+import { factory, SyntaxKind, } from "typescript";
+const LUA_LOGGER_STRIP_TARGET = "LuaLogger";
+const IS_LUA_LOGGER_DISABLED = process.argv.includes("--no-lua-logs");
+/**
+ * Plugin that removes all LuaLogger instance creations and calls when possible.
+ */
+const plugin = {
+    visitors: {
+        [SyntaxKind.VariableStatement]: (statement, context) => {
+            if (IS_LUA_LOGGER_DISABLED) {
+                let elementsCount = 0;
+                const list = statement.declarationList;
+                const nodes = [];
+                list.forEachChild((it) => {
+                    const checker = context.program.getTypeChecker();
+                    const typeSymbol = checker.getTypeAtLocation(it);
+                    if (typeSymbol.symbol?.name === LUA_LOGGER_STRIP_TARGET) {
+                        // nothing
+                    }
+                    else {
+                        nodes.push(it);
+                    }
+                    elementsCount += 1;
+                });
+                if (nodes.length === 0) {
+                    return undefined;
+                }
+                else if (nodes.length !== elementsCount) {
+                    return context.superTransformStatements(factory.createVariableStatement(statement.modifiers, factory.updateVariableDeclarationList(list, nodes)));
+                }
+            }
+            return context.superTransformStatements(statement);
+        },
+        [SyntaxKind.ExpressionStatement]: (statement, context) => {
+            if (IS_LUA_LOGGER_DISABLED && statement.expression?.kind === SyntaxKind.CallExpression) {
+                const expression = statement.expression;
+                const propertyAccess = expression.expression;
+                if (propertyAccess.expression?.kind === SyntaxKind.Identifier) {
+                    const checker = context.program.getTypeChecker();
+                    const identifier = propertyAccess.expression;
+                    const typeSymbol = checker.getTypeAtLocation(identifier);
+                    if (typeSymbol.symbol?.name === LUA_LOGGER_STRIP_TARGET) {
+                        return undefined;
+                    }
+                }
+            }
+            return context.superTransformStatements(statement);
+        },
+    },
+};
+export default plugin;

package/plugins/plugins/transform_luabind_class/plugin.js

@@ -0,0 +1,34 @@
+import { SyntaxKind } from "typescript";
+import { isLuabindClassSuperCall, isLuabindClassSuperMethodCall, isLuabindClassType, isLuabindDecoratedClass, transformClassSuperMethodExpression, transformLuabindClassDeclaration, transformLuabindConstructorSuperCall, transformNewCallExpression, } from "./transformation";
+/**
+ * Plugin that transform TS classes marked with decorator to luabind class declaration.
+ */
+const plugin = {
+    visitors: {
+        [SyntaxKind.CallExpression]: (expression, context) => {
+            if (isLuabindClassSuperCall(expression, context)) {
+                return transformLuabindConstructorSuperCall(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+        [SyntaxKind.ClassDeclaration]: (declaration, context) => {
+            if (isLuabindDecoratedClass(declaration)) {
+                return transformLuabindClassDeclaration(declaration, context);
+            }
+            return context.superTransformStatements(declaration);
+        },
+        [SyntaxKind.NewExpression]: (expression, context) => {
+            if (isLuabindClassType(expression, context)) {
+                return transformNewCallExpression(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+        [SyntaxKind.SuperKeyword]: (expression, context) => {
+            if (isLuabindClassSuperMethodCall(expression, context)) {
+                return transformClassSuperMethodExpression(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+    },
+};
+export default plugin;

package/plugins/plugins/transform_luabind_class/transformation/class_declaration.js

@@ -0,0 +1,141 @@
+import { canHaveDecorators, factory, getDecorators, isAccessor, isConstructorDeclaration, isMethodDeclaration, isPropertyDeclaration, } from "typescript";
+import * as tstl from "typescript-to-lua";
+import { LuaTarget } from "typescript-to-lua";
+import { createDefaultExportExpression, createExportedIdentifier, hasDefaultExportModifier, hasExportModifier, } from "typescript-to-lua/dist/transformation/utils/export";
+import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
+import { transformInPrecedingStatementScope } from "typescript-to-lua/dist/transformation/utils/preceding-statements";
+import { createSafeName, isUnsafeName } from "typescript-to-lua/dist/transformation/utils/safe-names";
+import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
+import { LUABIND_CONSTRUCTOR_METHOD } from "./constants";
+import { checkLuabindClassDecoratorExpression } from "./decorators";
+import { unsupportedStaticMethod } from "./errors";
+import { transformAccessorDeclarations } from "./members/accessors";
+import { createConstructorName, transformConstructorDeclaration } from "./members/constructor";
+import { transformClassInstanceFields, verifyPropertyDecoratingExpression } from "./members/fields";
+import { transformMethodDeclaration, verifyMethodDecoratingExpression } from "./members/method";
+import { createClassSetup } from "./setup";
+import { getExtendedNode, getExtendedType, isStaticNode, markTypeAsLuabind } from "./utils";
+export const transformLuabindClassDeclaration = (declaration, context) => {
+    // If declaration is a default export, transform to export variable assignment instead
+    if (hasDefaultExportModifier(declaration)) {
+        // Class declaration including assignment to ____exports.default are in preceding statements
+        const { precedingStatements } = transformInPrecedingStatementScope(context, () => {
+            transformClassAsExpression(declaration, context);
+            return [];
+        });
+        return precedingStatements;
+    }
+    const { statements } = transformClassLikeDeclaration(declaration, context);
+    return statements;
+};
+export function transformClassAsExpression(expression, context) {
+    const { statements, name } = transformClassLikeDeclaration(expression, context);
+    context.addPrecedingStatements(statements);
+    return name;
+}
+export function transformClassLikeDeclaration(classDeclaration, context, nameOverride) {
+    let className;
+    if (nameOverride !== undefined) {
+        className = nameOverride;
+    }
+    else if (classDeclaration.name !== undefined) {
+        className = transformIdentifier(context, classDeclaration.name);
+    }
+    else {
+        className = tstl.createIdentifier(context.createTempName("class"), classDeclaration);
+    }
+    markTypeAsLuabind(classDeclaration, context);
+    // Get type that is extended
+    const extendedTypeNode = getExtendedNode(classDeclaration);
+    const extendedType = getExtendedType(context, classDeclaration);
+    context.classSuperInfos.push({ className, classDeclaration: classDeclaration, extendedTypeNode });
+    // Get all properties with value
+    const properties = classDeclaration.members.filter(isPropertyDeclaration).filter((member) => member.initializer);
+    // Divide properties into static and non-static
+    const instanceFields = properties.filter((prop) => !isStaticNode(prop));
+    const result = [];
+    let localClassName;
+    if (isUnsafeName(className.text, context.options)) {
+        localClassName = tstl.createIdentifier(createSafeName(className.text), undefined, className.symbolId, className.text);
+        tstl.setNodePosition(localClassName, className);
+    }
+    else {
+        localClassName = className;
+    }
+    result.push(...createClassSetup(context, classDeclaration, className, localClassName));
+    // Find first constructor with body
+    const constructor = classDeclaration.members.find((n) => isConstructorDeclaration(n) && n.body !== undefined);
+    if (constructor) {
+        // Add constructor plus initialization of instance fields
+        const constructorResult = transformConstructorDeclaration(context, constructor, localClassName, instanceFields, classDeclaration);
+        if (constructorResult)
+            result.push(constructorResult);
+    }
+    else if (!extendedType) {
+        // Generate a constructor if none was defined in a base class
+        const constructorResult = transformConstructorDeclaration(context, factory.createConstructorDeclaration([], [], factory.createBlock([], true)), localClassName, instanceFields, classDeclaration);
+        if (constructorResult)
+            result.push(constructorResult);
+    }
+    else {
+        // Generate a constructor if none was defined in a class with instance fields that need initialization
+        // localClassName.__init = function(self, ...)
+        //     baseClassName.__init(self, ...)  // or unpack(arg) for Lua 5.0
+        //     ...
+        // Also luabind always needs definition of call expression to use table as class.
+        const constructorBody = transformClassInstanceFields(context, instanceFields);
+        const argsExpression = context.luaTarget === LuaTarget.Lua50
+            ? tstl.createCallExpression(tstl.createIdentifier("unpack"), [tstl.createArgLiteral()])
+            : tstl.createDotsLiteral();
+        const superCall = tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(factory.createSuper()), tstl.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD)), [createSelfIdentifier(), argsExpression]));
+        constructorBody.unshift(superCall);
+        const constructorFunction = tstl.createFunctionExpression(tstl.createBlock(constructorBody), [createSelfIdentifier()], tstl.createDotsLiteral(), tstl.NodeFlags.Declaration);
+        result.push(tstl.createAssignmentStatement(createConstructorName(localClassName), constructorFunction, classDeclaration));
+    }
+    // Transform accessors
+    for (const member of classDeclaration.members) {
+        if (!isAccessor(member))
+            continue;
+        const accessors = context.resolver.getAllAccessorDeclarations(member);
+        if (accessors.firstAccessor !== member)
+            continue;
+        const accessorsResult = transformAccessorDeclarations(context, accessors, localClassName);
+        if (accessorsResult) {
+            result.push(accessorsResult);
+        }
+    }
+    const decorationStatements = [];
+    for (const member of classDeclaration.members) {
+        if (isAccessor(member)) {
+            verifyPropertyDecoratingExpression(context, member);
+        }
+        else if (isMethodDeclaration(member)) {
+            const statement = transformMethodDeclaration(context, member, localClassName);
+            if (statement)
+                result.push(statement);
+            if (member.body) {
+                verifyMethodDecoratingExpression(context, member);
+            }
+        }
+        else if (isPropertyDeclaration(member)) {
+            if (isStaticNode(member)) {
+                context.diagnostics.push(unsupportedStaticMethod(member));
+            }
+            verifyPropertyDecoratingExpression(context, member);
+        }
+    }
+    result.push(...decorationStatements);
+    // Decorate the class
+    if (canHaveDecorators(classDeclaration) && getDecorators(classDeclaration)) {
+        getDecorators(classDeclaration)?.forEach((d) => checkLuabindClassDecoratorExpression(context, d));
+        if (hasExportModifier(classDeclaration)) {
+            const exportExpression = hasDefaultExportModifier(classDeclaration)
+                ? createDefaultExportExpression(classDeclaration)
+                : createExportedIdentifier(context, className);
+            const classAssignment = tstl.createAssignmentStatement(exportExpression, localClassName);
+            result.push(classAssignment);
+        }
+    }
+    context.classSuperInfos.pop();
+    return { statements: result, name: className };
+}

package/plugins/plugins/transform_luabind_class/transformation/constants.js

@@ -0,0 +1,4 @@
+export const LUABIND_NAME_FIELD = "__name";
+export const LUABIND_DECORATOR = "LuabindClass";
+export const LUABIND_CONSTRUCTOR_METHOD = "__init";
+export const LUABIND_SYMBOL = Symbol("IS_LUABIND_CLASS");

package/plugins/plugins/transform_luabind_class/transformation/decorators.js

@@ -0,0 +1,12 @@
+import { LUABIND_DECORATOR } from "./constants";
+import { unsupportedClassDecorator } from "./errors";
+/**
+ * Transform decorator call expressions for luabind class.
+ */
+export function checkLuabindClassDecoratorExpression(context, decorator) {
+    const expression = decorator.expression;
+    // Do not transform luabind decorator.
+    if (expression.expression.text !== LUABIND_DECORATOR) {
+        context.diagnostics.push(unsupportedClassDecorator(expression));
+    }
+}

package/plugins/plugins/transform_luabind_class/transformation/errors.js

@@ -0,0 +1,25 @@
+import { createErrorDiagnosticFactory } from "../../utils/diagnostics";
+export const unsupportedStaticMethod = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform static properties for luabind classes${nameReference}.`;
+});
+export const unsupportedClassDecorator = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform class decorators for luabind classes${nameReference}.`;
+});
+export const unsupportedPropertyDecorator = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform property decorator for luabind classes${nameReference}.`;
+});
+export const unsupportedParameterDecorator = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform parameter decorator for luabind classes${nameReference}.`;
+});
+export const unsupportedMethodDecorator = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform method decorator for luabind classes${nameReference}.`;
+});
+export const unsupportedStaticAccessor = createErrorDiagnosticFactory((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform static accessors for luabind classes${nameReference}.`;
+});

package/plugins/{transform_luabind_class/transformation/index.ts → plugins/transform_luabind_class/transformation/index.js}

@@ -1,5 +1,5 @@
-export * from "./constants";
-export * from "./utils";
-export * from "./class_declaration";
-export * from "./super";
-export * from "./new";
+export * from "./constants";
+export * from "./utils";
+export * from "./class_declaration";
+export * from "./super";
+export * from "./new";

package/plugins/plugins/transform_luabind_class/transformation/members/accessors.js

@@ -0,0 +1,35 @@
+import { LuaLibFeature } from "typescript-to-lua";
+import * as lua from "typescript-to-lua";
+import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
+import { transformLuaLibFunction } from "typescript-to-lua/dist/transformation/utils/lualib";
+import { transformFunctionBody, transformParameters } from "typescript-to-lua/dist/transformation/visitors/function";
+import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
+import { unsupportedStaticAccessor } from "../errors";
+import { isStaticNode } from "../utils";
+function transformAccessor(context, node) {
+    const [params, dot, restParam] = transformParameters(context, node.parameters, createSelfIdentifier());
+    const body = node.body ? transformFunctionBody(context, node.parameters, node.body, restParam)[0] : [];
+    return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.NodeFlags.Declaration);
+}
+export function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
+    const propertyName = transformPropertyName(context, firstAccessor.name);
+    const descriptor = lua.createTableExpression([]);
+    if (getAccessor) {
+        const getterFunction = transformAccessor(context, getAccessor);
+        descriptor.fields.push(lua.createTableFieldExpression(getterFunction, lua.createStringLiteral("get")));
+    }
+    if (setAccessor) {
+        const setterFunction = transformAccessor(context, setAccessor);
+        descriptor.fields.push(lua.createTableFieldExpression(setterFunction, lua.createStringLiteral("set")));
+    }
+    const isStatic = isStaticNode(firstAccessor);
+    if (isStatic) {
+        context.diagnostics.push(unsupportedStaticAccessor(firstAccessor));
+        return;
+    }
+    const target = lua.cloneIdentifier(className);
+    const feature = LuaLibFeature.ObjectDefineProperty;
+    const parameters = [target, propertyName, descriptor];
+    const call = transformLuaLibFunction(context, feature, undefined, ...parameters);
+    return lua.createExpressionStatement(call);
+}

package/plugins/plugins/transform_luabind_class/transformation/members/constructor.js

@@ -0,0 +1,56 @@
+import { isCallExpression, isExpressionStatement, isIdentifier, SyntaxKind, } from "typescript";
+import * as lua from "typescript-to-lua";
+import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
+import { ScopeType } from "typescript-to-lua/dist/transformation/utils/scope";
+import { transformFunctionBodyContent, transformFunctionBodyHeader, transformParameters, } from "typescript-to-lua/dist/transformation/visitors/function";
+import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
+import { LUABIND_CONSTRUCTOR_METHOD } from "../constants";
+import { transformClassInstanceFields } from "./fields";
+export function createConstructorName(className) {
+    return lua.createTableIndexExpression(lua.cloneIdentifier(className), lua.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD));
+}
+export function transformConstructorDeclaration(context, statement, className, instanceFields, classDeclaration) {
+    // Don't transform methods without body (overload declarations)
+    if (!statement.body) {
+        return undefined;
+    }
+    // Transform body
+    const scope = context.pushScope(ScopeType.Function);
+    const body = transformFunctionBodyContent(context, statement.body);
+    const [params, dotsLiteral, restParamName] = transformParameters(context, statement.parameters, createSelfIdentifier());
+    // Make sure default parameters are assigned before fields are initialized
+    const bodyWithFieldInitializers = transformFunctionBodyHeader(context, scope, statement.parameters, restParamName);
+    // Check for field declarations in constructor
+    const constructorFieldsDeclarations = statement.parameters.filter((p) => p.modifiers !== undefined);
+    const classInstanceFields = transformClassInstanceFields(context, instanceFields);
+    // If there are field initializers and the first statement is a super call,
+    // move super call between default assignments and initializers
+    if ((constructorFieldsDeclarations.length > 0 || classInstanceFields.length > 0) &&
+        statement.body &&
+        statement.body.statements.length > 0) {
+        const firstStatement = statement.body.statements[0];
+        if (isExpressionStatement(firstStatement) &&
+            isCallExpression(firstStatement.expression) &&
+            firstStatement.expression.expression.kind === SyntaxKind.SuperKeyword) {
+            const superCall = body.shift();
+            if (superCall) {
+                bodyWithFieldInitializers.push(superCall);
+            }
+        }
+    }
+    // Add in instance field declarations
+    for (const declaration of constructorFieldsDeclarations) {
+        if (isIdentifier(declaration.name)) {
+            // self.declarationName = declarationName
+            const assignment = lua.createAssignmentStatement(lua.createTableIndexExpression(createSelfIdentifier(), lua.createStringLiteral(declaration.name.text)), transformIdentifier(context, declaration.name));
+            bodyWithFieldInitializers.push(assignment);
+        }
+        // else { TypeScript error: A parameter property may not be declared using a binding pattern }
+    }
+    bodyWithFieldInitializers.push(...classInstanceFields);
+    bodyWithFieldInitializers.push(...body);
+    const block = lua.createBlock(bodyWithFieldInitializers);
+    const constructorWasGenerated = statement.pos === -1;
+    context.popScope();
+    return lua.createAssignmentStatement(createConstructorName(className), lua.createFunctionExpression(block, params, dotsLiteral, lua.NodeFlags.Declaration), constructorWasGenerated ? classDeclaration : statement);
+}

package/plugins/plugins/transform_luabind_class/transformation/members/fields.js

@@ -0,0 +1,36 @@
+import { canHaveDecorators, getDecorators } from "typescript";
+import * as tstl from "typescript-to-lua";
+import { createSelfIdentifier } from "typescript-to-lua/dist/transformation/utils/lua-ast";
+import { transformInPrecedingStatementScope } from "typescript-to-lua/dist/transformation/utils/preceding-statements";
+import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
+import { unsupportedPropertyDecorator } from "../errors";
+/**
+ * Verify whether decorators provided for luabind class.
+ */
+export function verifyPropertyDecoratingExpression(context, node) {
+    if (!canHaveDecorators(node))
+        return;
+    const decorators = getDecorators(node);
+    if (!decorators)
+        return;
+    decorators.forEach((decorator) => {
+        context.diagnostics.push(unsupportedPropertyDecorator(decorator));
+    });
+}
+export function transformClassInstanceFields(context, instanceFields) {
+    const statements = [];
+    for (const f of instanceFields) {
+        const { precedingStatements, result: statement } = transformInPrecedingStatementScope(context, () => {
+            // Get identifier
+            const fieldName = transformPropertyName(context, f.name);
+            const value = f.initializer ? context.transformExpression(f.initializer) : undefined;
+            // self[fieldName]
+            const selfIndex = tstl.createTableIndexExpression(createSelfIdentifier(), fieldName);
+            // self[fieldName] = value
+            const assignClassField = tstl.createAssignmentStatement(selfIndex, value, f);
+            return assignClassField;
+        });
+        statements.push(...precedingStatements, statement);
+    }
+    return statements;
+}