xray16 1.0.0 → 1.0.1

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

@@ -0,0 +1,49 @@
+import { getDecorators } from "typescript";
+import * as lua from "typescript-to-lua";
+import { transformFunctionToExpression } from "typescript-to-lua/dist/transformation/visitors/function";
+import { transformPropertyName } from "typescript-to-lua/dist/transformation/visitors/literal";
+import { unsupportedMethodDecorator, unsupportedParameterDecorator, unsupportedStaticMethod } from "../errors";
+import { isStaticNode } from "../utils";
+export function transformMemberExpressionOwnerName(node, className) {
+    return lua.cloneIdentifier(className);
+}
+export function transformMethodName(context, node) {
+    const methodName = transformPropertyName(context, node.name);
+    if (lua.isStringLiteral(methodName) && methodName.value === "toString") {
+        return lua.createStringLiteral("__tostring", node.name);
+    }
+    return methodName;
+}
+export function transformMethodDeclaration(context, node, className) {
+    // Don't transform methods without body (overload declarations)
+    if (!node.body)
+        return;
+    // Don't transform static methods for luabind classes.
+    if (isStaticNode(node)) {
+        context.diagnostics.push(unsupportedStaticMethod(node));
+        return;
+    }
+    const methodTable = transformMemberExpressionOwnerName(node, className);
+    const methodName = transformMethodName(context, node);
+    const [functionExpression] = transformFunctionToExpression(context, node);
+    return lua.createAssignmentStatement(lua.createTableIndexExpression(methodTable, methodName), functionExpression, node);
+}
+/**
+ * Verify that method statement is not using decorators for methods/parameters.
+ */
+export function verifyMethodDecoratingExpression(context, node) {
+    node.parameters.flatMap((parameter, index) => {
+        const decorators = getDecorators(parameter);
+        if (decorators?.length) {
+            decorators.forEach((decorator) => {
+                context.diagnostics.push(unsupportedParameterDecorator(decorator));
+            });
+        }
+    });
+    const decorators = getDecorators(node);
+    if (decorators?.length) {
+        decorators.forEach((decorator) => {
+            context.diagnostics.push(unsupportedMethodDecorator(decorator));
+        });
+    }
+}

package/plugins/plugins/transform_luabind_class/transformation/new.js

@@ -0,0 +1,8 @@
+import * as tstl from "typescript-to-lua";
+import { transformArguments } from "typescript-to-lua/dist/transformation/visitors/call";
+/**
+ * Transform new call for luabind class as ClassConstructor() instead of TS_NEW from tstl.
+ */
+export function transformNewCallExpression(expression, context) {
+    return tstl.createCallExpression(context.transformExpression(expression.expression), transformArguments(context, expression.arguments ?? []));
+}

package/plugins/plugins/transform_luabind_class/transformation/setup.js

@@ -0,0 +1,76 @@
+import { isIdentifier, isVariableDeclaration } from "typescript";
+import * as tstl from "typescript-to-lua";
+import { createDefaultExportStringLiteral, createExportedIdentifier, getIdentifierExportScope, hasDefaultExportModifier, } from "typescript-to-lua/dist/transformation/utils/export";
+import { createExportsIdentifier, createLocalOrExportedOrGlobalDeclaration, } from "typescript-to-lua/dist/transformation/utils/lua-ast";
+import { LUABIND_NAME_FIELD } from "./constants";
+import { getExtendedNode } from "./utils";
+/**
+ * Create full class setup statement with name/super calls/methods/declaration/fields etc.
+ */
+export function createClassSetup(context, statement, className, localClassName) {
+    const result = [];
+    // class("name")(base)
+    const classInitializer = createLuabindClassStatement(statement, context, localClassName);
+    result.push(tstl.createExpressionStatement(classInitializer));
+    const classReference = createLuabindClassGlobalClassRef(statement, context, localClassName);
+    const defaultExportLeftHandSide = hasDefaultExportModifier(statement)
+        ? tstl.createTableIndexExpression(createExportsIdentifier(), createDefaultExportStringLiteral(statement))
+        : undefined;
+    // [____exports.]className = class()
+    if (defaultExportLeftHandSide) {
+        result.push(tstl.createAssignmentStatement(defaultExportLeftHandSide, classReference, statement));
+    }
+    else {
+        result.push(...createLocalOrExportedOrGlobalDeclaration(context, className, classReference, statement));
+    }
+    if (defaultExportLeftHandSide) {
+        // local localClassName = ____exports.default
+        result.push(tstl.createVariableDeclarationStatement(localClassName, defaultExportLeftHandSide));
+    }
+    else {
+        const exportScope = getIdentifierExportScope(context, className);
+        if (exportScope) {
+            // local localClassName = ____exports.className
+            result.push(tstl.createVariableDeclarationStatement(localClassName, createExportedIdentifier(context, tstl.cloneIdentifier(className), exportScope)));
+        }
+    }
+    // localClassName.__name = className
+    result.push(tstl.createAssignmentStatement(tstl.createTableIndexExpression(tstl.cloneIdentifier(localClassName), tstl.createStringLiteral(LUABIND_NAME_FIELD)), getReflectionClassName(statement, className), statement));
+    return result;
+}
+export function getReflectionClassName(declaration, className) {
+    if (declaration.name) {
+        return tstl.createStringLiteral(declaration.name.text);
+    }
+    else if (isVariableDeclaration(declaration.parent) && isIdentifier(declaration.parent.name)) {
+        return tstl.createStringLiteral(declaration.parent.name.text);
+    }
+    else if (hasDefaultExportModifier(declaration)) {
+        return tstl.createStringLiteral("default");
+    }
+    if (getExtendedNode(declaration)) {
+        return tstl.createTableIndexExpression(className, tstl.createStringLiteral("name"));
+    }
+    return tstl.createStringLiteral("");
+}
+/**
+ * Creates class("Name")(base) expression for luabind classes.
+ */
+function createLuabindClassStatement(declaration, context, className) {
+    const extendedNode = getExtendedNode(declaration);
+    let classDeclaration = tstl.createCallExpression(tstl.createIdentifier("class"), [
+        getReflectionClassName(declaration, className),
+    ]);
+    if (extendedNode) {
+        classDeclaration = tstl.createCallExpression(classDeclaration, [
+            context.transformExpression(extendedNode.expression),
+        ]);
+    }
+    return classDeclaration;
+}
+/**
+ * Creates name expression for luabind classes.
+ */
+function createLuabindClassGlobalClassRef(declaration, context, className) {
+    return className;
+}

package/plugins/plugins/transform_luabind_class/transformation/super.js

@@ -0,0 +1,65 @@
+import { factory, isIdentifier, SyntaxKind } from "typescript";
+import * as tstl from "typescript-to-lua";
+import { isSymbolExported } from "typescript-to-lua/dist/transformation/utils/export";
+import { getCalledExpression, transformArguments } from "typescript-to-lua/dist/transformation/visitors/call";
+import { transformIdentifier } from "typescript-to-lua/dist/transformation/visitors/identifier";
+import { LUABIND_CONSTRUCTOR_METHOD } from "./constants";
+import { isLuabindClassType } from "./utils";
+/**
+ * Transform generic methods super calls.
+ * Example: super.parentMethod(first, second).
+ */
+export function transformClassSuperMethodExpression(expression, context) {
+    const superInfos = context.classSuperInfos;
+    const superInfo = superInfos[superInfos.length - 1];
+    if (!superInfo.classDeclaration || !isLuabindClassType(superInfo.classDeclaration, context)) {
+        return context.superTransformExpression(expression);
+    }
+    const { extendedTypeNode } = superInfo;
+    // Using `super` without extended type node is a TypeScript error
+    const extendsExpression = extendedTypeNode?.expression;
+    let baseClassName;
+    if (extendsExpression && isIdentifier(extendsExpression)) {
+        const symbol = context.checker.getSymbolAtLocation(extendsExpression);
+        if (symbol && !isSymbolExported(context, symbol)) {
+            // Use "baseClassName" if base is a simple identifier
+            baseClassName = transformIdentifier(context, extendsExpression);
+        }
+    }
+    if (!baseClassName) {
+        throw new Error("Super without identifier - not supported with luabind.");
+    }
+    return baseClassName;
+}
+/**
+ * Check if super() call is in luabind class target.
+ */
+export function isLuabindClassSuperCall(expression, context) {
+    const calledExpression = getCalledExpression(expression);
+    if (calledExpression.kind !== SyntaxKind.SuperKeyword) {
+        return false;
+    }
+    else {
+        const superInfos = context.classSuperInfos;
+        const superInfo = superInfos[superInfos.length - 1];
+        // Handle super calls properly for luabind classes.
+        return superInfo?.classDeclaration ? isLuabindClassType(superInfo.classDeclaration, context) : false;
+    }
+}
+/**
+ * Check if super.method() call is in luabind class target.
+ */
+export function isLuabindClassSuperMethodCall(expression, context) {
+    const superInfos = context.classSuperInfos;
+    const superInfo = superInfos[superInfos.length - 1];
+    // Handle super calls properly for luabind classes.
+    return superInfo?.classDeclaration ? isLuabindClassType(superInfo.classDeclaration, context) : false;
+}
+/**
+ * Transform super() call in luabind classes to base_class.__init(self, param).
+ */
+export function transformLuabindConstructorSuperCall(expression, context) {
+    const signature = context.checker.getResolvedSignature(expression);
+    const parameters = transformArguments(context, expression.arguments, signature, factory.createThis());
+    return tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(factory.createSuper()), tstl.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD)), parameters, expression);
+}

package/plugins/plugins/transform_luabind_class/transformation/utils.js

@@ -0,0 +1,67 @@
+import { getDecorators, SyntaxKind, } from "typescript";
+import { LUABIND_DECORATOR, LUABIND_SYMBOL } from "./constants";
+/**
+ * Whether method / field is static.
+ */
+export function isStaticNode(node) {
+    return node.modifiers?.some((m) => m.kind === SyntaxKind.StaticKeyword) === true;
+}
+/**
+ * Get class extends node.
+ */
+export function getExtendsClause(node) {
+    return node.heritageClauses?.find((clause) => clause.token === SyntaxKind.ExtendsKeyword);
+}
+/**
+ * Get class extended node.
+ */
+export function getExtendedNode(node) {
+    const extendsClause = getExtendsClause(node);
+    if (!extendsClause)
+        return;
+    return extendsClause.types[0];
+}
+/**
+ * Get class extended node.
+ */
+export function getExtendedType(context, node) {
+    const extendedNode = getExtendedNode(node);
+    return extendedNode && context.checker.getTypeAtLocation(extendedNode);
+}
+/**
+ * Check if class is decorated with provided decorator name.
+ */
+export function isLuabindDecoratedClass(declaration) {
+    const decorators = getDecorators(declaration);
+    if (!decorators) {
+        return false;
+    }
+    return decorators.some((it) => it.expression.expression?.escapedText === LUABIND_DECORATOR);
+}
+/**
+ * Mark provided class as Luabind target.
+ */
+export function markTypeAsLuabind(declaration, context) {
+    const typeAtLocation = context.checker.getTypeAtLocation(declaration);
+    const typeSymbol = typeAtLocation.symbol || typeAtLocation.aliasSymbol;
+    typeSymbol[LUABIND_SYMBOL] = true;
+}
+/**
+ * Check if provided class is specified as LuaBind.
+ */
+export function isLuabindClassType(declaration, context) {
+    const typeAtLocation = context.checker.getTypeAtLocation(declaration);
+    const typeSymbol = typeAtLocation.symbol || typeAtLocation.aliasSymbol;
+    if (typeSymbol) {
+        const isMarked = typeSymbol[LUABIND_SYMBOL] === true;
+        if (isMarked) {
+            return true;
+        }
+        else {
+            return isLuabindDecoratedClass(typeSymbol.declarations[0]);
+        }
+    }
+    else {
+        return false;
+    }
+}

package/plugins/plugins/utils/diagnostics.js

@@ -0,0 +1,17 @@
+import { DiagnosticCategory, getOriginalNode } from "typescript";
+import { createSerialDiagnosticFactory } from "typescript-to-lua/dist/utils";
+/**
+ * Create diagnostics factory to push errors when transpile lua to typescript.
+ */
+export function createDiagnosticFactory(category, message) {
+    return createSerialDiagnosticFactory((node, ...args) => ({
+        file: getOriginalNode(node).getSourceFile(),
+        start: getOriginalNode(node).getStart(),
+        length: getOriginalNode(node).getWidth(),
+        messageText: typeof message === "string" ? message : message(...args),
+        category,
+    }));
+}
+export function createErrorDiagnosticFactory(message) {
+    return createDiagnosticFactory(DiagnosticCategory.Error, message);
+}

package/plugins/strip_lua_logger.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = require("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: {
+        [typescript_1.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(typescript_1.factory.createVariableStatement(statement.modifiers, typescript_1.factory.updateVariableDeclarationList(list, nodes)));
+                }
+            }
+            return context.superTransformStatements(statement);
+        },
+        [typescript_1.SyntaxKind.ExpressionStatement]: (statement, context) => {
+            if (IS_LUA_LOGGER_DISABLED && statement.expression?.kind === typescript_1.SyntaxKind.CallExpression) {
+                const expression = statement.expression;
+                const propertyAccess = expression.expression;
+                if (propertyAccess.expression?.kind === typescript_1.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);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/transform_luabind_class/plugin.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = require("typescript");
+const transformation_1 = require("./transformation");
+/**
+ * Plugin that transform TS classes marked with decorator to luabind class declaration.
+ */
+const plugin = {
+    visitors: {
+        [typescript_1.SyntaxKind.CallExpression]: (expression, context) => {
+            if ((0, transformation_1.isLuabindClassSuperCall)(expression, context)) {
+                return (0, transformation_1.transformLuabindConstructorSuperCall)(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+        [typescript_1.SyntaxKind.ClassDeclaration]: (declaration, context) => {
+            if ((0, transformation_1.isLuabindDecoratedClass)(declaration)) {
+                return (0, transformation_1.transformLuabindClassDeclaration)(declaration, context);
+            }
+            return context.superTransformStatements(declaration);
+        },
+        [typescript_1.SyntaxKind.NewExpression]: (expression, context) => {
+            if ((0, transformation_1.isLuabindClassType)(expression, context)) {
+                return (0, transformation_1.transformNewCallExpression)(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+        [typescript_1.SyntaxKind.SuperKeyword]: (expression, context) => {
+            if ((0, transformation_1.isLuabindClassSuperMethodCall)(expression, context)) {
+                return (0, transformation_1.transformClassSuperMethodExpression)(expression, context);
+            }
+            return context.superTransformExpression(expression);
+        },
+    },
+};
+exports.default = plugin;

package/plugins/transform_luabind_class/transformation/class_declaration.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassLikeDeclaration = exports.transformClassAsExpression = exports.transformLuabindClassDeclaration = void 0;
+const typescript_1 = require("typescript");
+const tstl = require("typescript-to-lua");
+const typescript_to_lua_1 = require("typescript-to-lua");
+const export_1 = require("typescript-to-lua/dist/transformation/utils/export");
+const lua_ast_1 = require("typescript-to-lua/dist/transformation/utils/lua-ast");
+const preceding_statements_1 = require("typescript-to-lua/dist/transformation/utils/preceding-statements");
+const safe_names_1 = require("typescript-to-lua/dist/transformation/utils/safe-names");
+const identifier_1 = require("typescript-to-lua/dist/transformation/visitors/identifier");
+const constants_1 = require("./constants");
+const decorators_1 = require("./decorators");
+const errors_1 = require("./errors");
+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 setup_1 = require("./setup");
+const utils_1 = require("./utils");
+const transformLuabindClassDeclaration = (declaration, context) => {
+    // If declaration is a default export, transform to export variable assignment instead
+    if ((0, export_1.hasDefaultExportModifier)(declaration)) {
+        // Class declaration including assignment to ____exports.default are in preceding statements
+        const { precedingStatements } = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+            transformClassAsExpression(declaration, context);
+            return [];
+        });
+        return precedingStatements;
+    }
+    const { statements } = transformClassLikeDeclaration(declaration, context);
+    return statements;
+};
+exports.transformLuabindClassDeclaration = transformLuabindClassDeclaration;
+function transformClassAsExpression(expression, context) {
+    const { statements, name } = transformClassLikeDeclaration(expression, context);
+    context.addPrecedingStatements(statements);
+    return name;
+}
+exports.transformClassAsExpression = transformClassAsExpression;
+function transformClassLikeDeclaration(classDeclaration, context, nameOverride) {
+    let className;
+    if (nameOverride !== undefined) {
+        className = nameOverride;
+    }
+    else if (classDeclaration.name !== undefined) {
+        className = (0, identifier_1.transformIdentifier)(context, classDeclaration.name);
+    }
+    else {
+        className = tstl.createIdentifier(context.createTempName("class"), classDeclaration);
+    }
+    (0, utils_1.markTypeAsLuabind)(classDeclaration, context);
+    // Get type that is extended
+    const extendedTypeNode = (0, utils_1.getExtendedNode)(classDeclaration);
+    const extendedType = (0, utils_1.getExtendedType)(context, classDeclaration);
+    context.classSuperInfos.push({ className, classDeclaration: classDeclaration, extendedTypeNode });
+    // Get all properties with value
+    const properties = classDeclaration.members.filter(typescript_1.isPropertyDeclaration).filter((member) => member.initializer);
+    // Divide properties into static and non-static
+    const instanceFields = properties.filter((prop) => !(0, utils_1.isStaticNode)(prop));
+    const result = [];
+    let localClassName;
+    if ((0, safe_names_1.isUnsafeName)(className.text, context.options)) {
+        localClassName = tstl.createIdentifier((0, safe_names_1.createSafeName)(className.text), undefined, className.symbolId, className.text);
+        tstl.setNodePosition(localClassName, className);
+    }
+    else {
+        localClassName = className;
+    }
+    result.push(...(0, setup_1.createClassSetup)(context, classDeclaration, className, localClassName));
+    // Find first constructor with body
+    const constructor = classDeclaration.members.find((n) => (0, typescript_1.isConstructorDeclaration)(n) && n.body !== undefined);
+    if (constructor) {
+        // Add constructor plus initialization of instance fields
+        const constructorResult = (0, constructor_1.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 = (0, constructor_1.transformConstructorDeclaration)(context, typescript_1.factory.createConstructorDeclaration([], [], typescript_1.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 = (0, fields_1.transformClassInstanceFields)(context, instanceFields);
+        const argsExpression = context.luaTarget === typescript_to_lua_1.LuaTarget.Lua50
+            ? tstl.createCallExpression(tstl.createIdentifier("unpack"), [tstl.createArgLiteral()])
+            : tstl.createDotsLiteral();
+        const superCall = tstl.createExpressionStatement(tstl.createCallExpression(tstl.createTableIndexExpression(context.transformExpression(typescript_1.factory.createSuper()), tstl.createStringLiteral(constants_1.LUABIND_CONSTRUCTOR_METHOD)), [(0, lua_ast_1.createSelfIdentifier)(), argsExpression]));
+        constructorBody.unshift(superCall);
+        const constructorFunction = tstl.createFunctionExpression(tstl.createBlock(constructorBody), [(0, lua_ast_1.createSelfIdentifier)()], tstl.createDotsLiteral(), tstl.NodeFlags.Declaration);
+        result.push(tstl.createAssignmentStatement((0, constructor_1.createConstructorName)(localClassName), constructorFunction, classDeclaration));
+    }
+    // Transform accessors
+    for (const member of classDeclaration.members) {
+        if (!(0, typescript_1.isAccessor)(member))
+            continue;
+        const accessors = context.resolver.getAllAccessorDeclarations(member);
+        if (accessors.firstAccessor !== member)
+            continue;
+        const accessorsResult = (0, accessors_1.transformAccessorDeclarations)(context, accessors, localClassName);
+        if (accessorsResult) {
+            result.push(accessorsResult);
+        }
+    }
+    const decorationStatements = [];
+    for (const member of classDeclaration.members) {
+        if ((0, typescript_1.isAccessor)(member)) {
+            (0, fields_1.verifyPropertyDecoratingExpression)(context, member);
+        }
+        else if ((0, typescript_1.isMethodDeclaration)(member)) {
+            const statement = (0, method_1.transformMethodDeclaration)(context, member, localClassName);
+            if (statement)
+                result.push(statement);
+            if (member.body) {
+                (0, method_1.verifyMethodDecoratingExpression)(context, member);
+            }
+        }
+        else if ((0, typescript_1.isPropertyDeclaration)(member)) {
+            if ((0, utils_1.isStaticNode)(member)) {
+                context.diagnostics.push((0, errors_1.unsupportedStaticMethod)(member));
+            }
+            (0, fields_1.verifyPropertyDecoratingExpression)(context, member);
+        }
+    }
+    result.push(...decorationStatements);
+    // Decorate the class
+    if ((0, typescript_1.canHaveDecorators)(classDeclaration) && (0, typescript_1.getDecorators)(classDeclaration)) {
+        (0, typescript_1.getDecorators)(classDeclaration)?.forEach((d) => (0, decorators_1.checkLuabindClassDecoratorExpression)(context, d));
+        if ((0, export_1.hasExportModifier)(classDeclaration)) {
+            const exportExpression = (0, export_1.hasDefaultExportModifier)(classDeclaration)
+                ? (0, export_1.createDefaultExportExpression)(classDeclaration)
+                : (0, export_1.createExportedIdentifier)(context, className);
+            const classAssignment = tstl.createAssignmentStatement(exportExpression, localClassName);
+            result.push(classAssignment);
+        }
+    }
+    context.classSuperInfos.pop();
+    return { statements: result, name: className };
+}
+exports.transformClassLikeDeclaration = transformClassLikeDeclaration;

package/plugins/transform_luabind_class/transformation/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LUABIND_SYMBOL = exports.LUABIND_CONSTRUCTOR_METHOD = exports.LUABIND_DECORATOR = exports.LUABIND_NAME_FIELD = void 0;
+exports.LUABIND_NAME_FIELD = "__name";
+exports.LUABIND_DECORATOR = "LuabindClass";
+exports.LUABIND_CONSTRUCTOR_METHOD = "__init";
+exports.LUABIND_SYMBOL = Symbol("IS_LUABIND_CLASS");

package/plugins/transform_luabind_class/transformation/decorators.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLuabindClassDecoratorExpression = void 0;
+const constants_1 = require("./constants");
+const errors_1 = require("./errors");
+/**
+ * Transform decorator call expressions for luabind class.
+ */
+function checkLuabindClassDecoratorExpression(context, decorator) {
+    const expression = decorator.expression;
+    // Do not transform luabind decorator.
+    if (expression.expression.text !== constants_1.LUABIND_DECORATOR) {
+        context.diagnostics.push((0, errors_1.unsupportedClassDecorator)(expression));
+    }
+}
+exports.checkLuabindClassDecoratorExpression = checkLuabindClassDecoratorExpression;

package/plugins/transform_luabind_class/transformation/errors.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsupportedStaticAccessor = exports.unsupportedMethodDecorator = exports.unsupportedParameterDecorator = exports.unsupportedPropertyDecorator = exports.unsupportedClassDecorator = exports.unsupportedStaticMethod = void 0;
+const diagnostics_1 = require("../../utils/diagnostics");
+exports.unsupportedStaticMethod = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform static properties for luabind classes${nameReference}.`;
+});
+exports.unsupportedClassDecorator = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform class decorators for luabind classes${nameReference}.`;
+});
+exports.unsupportedPropertyDecorator = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform property decorator for luabind classes${nameReference}.`;
+});
+exports.unsupportedParameterDecorator = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform parameter decorator for luabind classes${nameReference}.`;
+});
+exports.unsupportedMethodDecorator = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform method decorator for luabind classes${nameReference}.`;
+});
+exports.unsupportedStaticAccessor = (0, diagnostics_1.createErrorDiagnosticFactory)((name) => {
+    const nameReference = name ? ` '${name}'` : "";
+    return `Unable transform static accessors for luabind classes${nameReference}.`;
+});

package/plugins/transform_luabind_class/transformation/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./class_declaration"), exports);
+__exportStar(require("./super"), exports);
+__exportStar(require("./new"), exports);

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAccessorDeclarations = void 0;
+const typescript_to_lua_1 = require("typescript-to-lua");
+const lua = require("typescript-to-lua");
+const lua_ast_1 = require("typescript-to-lua/dist/transformation/utils/lua-ast");
+const lualib_1 = require("typescript-to-lua/dist/transformation/utils/lualib");
+const function_1 = require("typescript-to-lua/dist/transformation/visitors/function");
+const literal_1 = require("typescript-to-lua/dist/transformation/visitors/literal");
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+function transformAccessor(context, node) {
+    const [params, dot, restParam] = (0, function_1.transformParameters)(context, node.parameters, (0, lua_ast_1.createSelfIdentifier)());
+    const body = node.body ? (0, function_1.transformFunctionBody)(context, node.parameters, node.body, restParam)[0] : [];
+    return lua.createFunctionExpression(lua.createBlock(body), params, dot, lua.NodeFlags.Declaration);
+}
+function transformAccessorDeclarations(context, { firstAccessor, getAccessor, setAccessor }, className) {
+    const propertyName = (0, literal_1.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 = (0, utils_1.isStaticNode)(firstAccessor);
+    if (isStatic) {
+        context.diagnostics.push((0, errors_1.unsupportedStaticAccessor)(firstAccessor));
+        return;
+    }
+    const target = lua.cloneIdentifier(className);
+    const feature = typescript_to_lua_1.LuaLibFeature.ObjectDefineProperty;
+    const parameters = [target, propertyName, descriptor];
+    const call = (0, lualib_1.transformLuaLibFunction)(context, feature, undefined, ...parameters);
+    return lua.createExpressionStatement(call);
+}
+exports.transformAccessorDeclarations = transformAccessorDeclarations;