xray16 1.0.0 → 1.0.1

package/plugins/strip_lua_logger.ts

@@ -1,73 +0,0 @@
-import {
-  CallExpression,
-  factory,
-  Identifier,
-  PropertyAccessExpression,
-  SyntaxKind,
-  Type,
-  TypeChecker,
-  VariableDeclaration,
-  VariableDeclarationList,
-} from "typescript";
-import { Plugin } from "typescript-to-lua";
-
-const LUA_LOGGER_STRIP_TARGET: string = "LuaLogger";
-const IS_LUA_LOGGER_DISABLED: boolean = process.argv.includes("--no-lua-logs");
-
-/**
- * Plugin that removes all LuaLogger instance creations and calls when possible.
- */
-const plugin: Plugin = {
-  visitors: {
-    [SyntaxKind.VariableStatement]: (statement, context) => {
-      if (IS_LUA_LOGGER_DISABLED) {
-        let elementsCount: number = 0;
-        const list = statement.declarationList as VariableDeclarationList;
-        const nodes: Array<VariableDeclaration> = [];
-
-        list.forEachChild((it: VariableDeclaration) => {
-          const checker: TypeChecker = context.program.getTypeChecker();
-          const typeSymbol: Type = 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: CallExpression = statement.expression as CallExpression;
-        const propertyAccess: PropertyAccessExpression = expression.expression as PropertyAccessExpression;
-
-        if (propertyAccess.expression?.kind === SyntaxKind.Identifier) {
-          const checker: TypeChecker = context.program.getTypeChecker();
-          const identifier: Identifier = propertyAccess.expression as Identifier;
-          const typeSymbol: Type = checker.getTypeAtLocation(identifier);
-
-          if (typeSymbol.symbol?.name === LUA_LOGGER_STRIP_TARGET) {
-            return undefined;
-          }
-        }
-      }
-
-      return context.superTransformStatements(statement);
-    },
-  },
-};
-
-export default plugin;

package/plugins/transform_luabind_class/plugin.ts

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

package/plugins/transform_luabind_class/transformation/class_declaration.ts

@@ -1,226 +0,0 @@
-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 { verifyPropertyDecoratingExpression, transformClassInstanceFields } from "./members/fields";
-import { verifyMethodDecoratingExpression, transformMethodDeclaration } from "./members/method";
-import { createClassSetup } from "./setup";
-import { getExtendedNode, getExtendedType, isStaticNode, markTypeAsLuabind } from "./utils";
-import {
-  canHaveDecorators,
-  ClassLikeDeclaration,
-  ConstructorDeclaration,
-  ExpressionWithTypeArguments,
-  factory,
-  getDecorators,
-  isAccessor,
-  isConstructorDeclaration,
-  isMethodDeclaration,
-  isPropertyDeclaration,
-} from "typescript";
-import * as tstl from "typescript-to-lua";
-import { LuaTarget, TransformationContext } 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";
-
-export interface ITransformationContext extends TransformationContext {
-  classSuperInfos: Array<ClassSuperInfo>;
-}
-
-export const transformLuabindClassDeclaration = (declaration, context: TransformationContext) => {
-  // 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 as ITransformationContext);
-      return [];
-    });
-    return precedingStatements;
-  }
-
-  const { statements } = transformClassLikeDeclaration(declaration, context as ITransformationContext);
-  return statements;
-};
-
-export function transformClassAsExpression(
-  expression: ClassLikeDeclaration,
-  context: ITransformationContext
-): tstl.Expression {
-  const { statements, name } = transformClassLikeDeclaration(expression, context);
-  context.addPrecedingStatements(statements);
-  return name;
-}
-
-/** @internal */
-export interface ClassSuperInfo {
-  className: tstl.Identifier;
-  classDeclaration: ClassLikeDeclaration;
-  extendedTypeNode?: ExpressionWithTypeArguments;
-}
-
-export function transformClassLikeDeclaration(
-  classDeclaration: ClassLikeDeclaration,
-  context: ITransformationContext,
-  nameOverride?: tstl.Identifier
-): { statements: tstl.Statement[]; name: tstl.Identifier } {
-  let className: tstl.Identifier;
-
-  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: tstl.Statement[] = [];
-
-  let localClassName: tstl.Identifier;
-  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): n is ConstructorDeclaration => 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: tstl.Statement[] = [];
-
-  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/transform_luabind_class/transformation/constants.ts

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

package/plugins/transform_luabind_class/transformation/decorators.ts

@@ -1,16 +0,0 @@
-import { unsupportedClassDecorator } from "./errors";
-import { LUABIND_DECORATOR } from "./constants";
-import { CallExpression, Decorator, Identifier } from "typescript";
-import { TransformationContext } from "typescript-to-lua";
-
-/**
- * Transform decorator call expressions for luabind class.
- */
-export function checkLuabindClassDecoratorExpression(context: TransformationContext, decorator: Decorator) {
-  const expression = decorator.expression;
-
-  // Do not transform luabind decorator.
-  if (((expression as CallExpression).expression as Identifier).text !== LUABIND_DECORATOR) {
-    context.diagnostics.push(unsupportedClassDecorator(expression));
-  }
-}

package/plugins/transform_luabind_class/transformation/errors.ts

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

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

@@ -1,48 +0,0 @@
-import { unsupportedStaticAccessor } from "../errors";
-import { AccessorDeclaration } from "typescript";
-import { AllAccessorDeclarations, LuaLibFeature, TransformationContext } 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 { isStaticNode } from "../utils";
-
-function transformAccessor(context: TransformationContext, node: AccessorDeclaration): lua.FunctionExpression {
-  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: TransformationContext,
-  { firstAccessor, getAccessor, setAccessor }: AllAccessorDeclarations,
-  className: lua.Identifier
-): lua.Statement | undefined {
-  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: lua.Expression[] = [target, propertyName, descriptor];
-
-  const call = transformLuaLibFunction(context, feature, undefined, ...parameters);
-  return lua.createExpressionStatement(call);
-}

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

@@ -1,107 +0,0 @@
-import { LUABIND_CONSTRUCTOR_METHOD } from "../constants";
-import {
-  ClassLikeDeclaration,
-  ConstructorDeclaration,
-  isCallExpression,
-  isExpressionStatement,
-  isIdentifier,
-  PropertyDeclaration,
-  SyntaxKind,
-} from "typescript";
-import { TransformationContext } from "typescript-to-lua";
-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 { transformClassInstanceFields } from "./fields";
-
-export function createConstructorName(className: lua.Identifier): lua.TableIndexExpression {
-  return lua.createTableIndexExpression(
-    lua.cloneIdentifier(className),
-    lua.createStringLiteral(LUABIND_CONSTRUCTOR_METHOD)
-  );
-}
-
-export function transformConstructorDeclaration(
-  context: TransformationContext,
-  statement: ConstructorDeclaration,
-  className: lua.Identifier,
-  instanceFields: Array<PropertyDeclaration>,
-  classDeclaration: ClassLikeDeclaration
-): lua.Statement | undefined {
-  // 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/transform_luabind_class/transformation/members/fields.ts

@@ -1,53 +0,0 @@
-import { unsupportedPropertyDecorator } from "../errors";
-import { AccessorDeclaration, canHaveDecorators, getDecorators, PropertyDeclaration } from "typescript";
-import { TransformationContext } from "typescript-to-lua";
-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";
-
-/**
- * Verify whether decorators provided for luabind class.
- */
-export function verifyPropertyDecoratingExpression(
-  context: TransformationContext,
-  node: PropertyDeclaration | AccessorDeclaration
-): void {
-  if (!canHaveDecorators(node)) return;
-
-  const decorators = getDecorators(node);
-
-  if (!decorators) return;
-
-  decorators.forEach((decorator) => {
-    context.diagnostics.push(unsupportedPropertyDecorator(decorator));
-  });
-}
-
-export function transformClassInstanceFields(
-  context: TransformationContext,
-  instanceFields: Array<PropertyDeclaration>
-): Array<tstl.Statement> {
-  const statements: Array<tstl.Statement> = [];
-
-  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;
-}

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

@@ -1,70 +0,0 @@
-import { isStaticNode } from "../utils";
-import { unsupportedMethodDecorator, unsupportedParameterDecorator, unsupportedStaticMethod } from "../errors";
-import { AccessorDeclaration, getDecorators, MethodDeclaration, PropertyDeclaration } from "typescript";
-import { TransformationContext } from "typescript-to-lua";
-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";
-
-export function transformMemberExpressionOwnerName(
-  node: PropertyDeclaration | MethodDeclaration | AccessorDeclaration,
-  className: lua.Identifier
-): lua.Expression {
-  return lua.cloneIdentifier(className);
-}
-
-export function transformMethodName(context: TransformationContext, node: MethodDeclaration): lua.Expression {
-  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: TransformationContext,
-  node: MethodDeclaration,
-  className: lua.Identifier
-): lua.Statement | undefined {
-  // 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: TransformationContext, node: MethodDeclaration): void {
-  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));
-    });
-  }
-}