xray16 1.0.0 → 1.0.3

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));
-    });
-  }
-}

package/plugins/transform_luabind_class/transformation/new.ts

@@ -1,14 +0,0 @@
-import { ITransformationContext } from "./index";
-import { NewExpression } from "typescript";
-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: NewExpression, context: ITransformationContext) {
-  return tstl.createCallExpression(
-    context.transformExpression(expression.expression),
-    transformArguments(context, expression.arguments ?? [])
-  );
-}

package/plugins/transform_luabind_class/transformation/setup.ts

@@ -1,128 +0,0 @@
-import { LUABIND_NAME_FIELD } from "./constants";
-import { ClassLikeDeclarationBase, isIdentifier, isVariableDeclaration } from "typescript";
-import * as tstl from "typescript-to-lua";
-import { TransformationContext } 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 { getExtendedNode } from "./utils";
-
-/**
- * Create full class setup statement with name/super calls/methods/declaration/fields etc.
- */
-export function createClassSetup(
-  context: TransformationContext,
-  statement: ClassLikeDeclarationBase,
-  className: tstl.Identifier,
-  localClassName: tstl.Identifier
-) {
-  const result: tstl.Statement[] = [];
-
-  // 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: ClassLikeDeclarationBase,
-  className: tstl.Identifier
-): tstl.Expression {
-  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: ClassLikeDeclarationBase,
-  context: TransformationContext,
-  className: tstl.Identifier
-) {
-  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: ClassLikeDeclarationBase,
-  context: TransformationContext,
-  className: tstl.Identifier
-) {
-  return className;
-}

package/plugins/transform_luabind_class/transformation/super.ts

@@ -1,92 +0,0 @@
-import { CallExpression, Expression, factory, isIdentifier, SuperExpression, 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 { ITransformationContext } from "./class_declaration";
-import { LUABIND_CONSTRUCTOR_METHOD } from "./constants";
-import { isLuabindClassType } from "./utils";
-
-/**
- * Transform generic methods super calls.
- * Example: super.parentMethod(first, second).
- */
-export function transformClassSuperMethodExpression(expression: Expression, context: ITransformationContext) {
-  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: tstl.AssignmentLeftHandSideExpression | undefined;
-
-  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: CallExpression | SuperExpression,
-  context: ITransformationContext
-): boolean {
-  const calledExpression: Expression = getCalledExpression(expression as CallExpression);
-
-  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: CallExpression | SuperExpression,
-  context: ITransformationContext
-): boolean {
-  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: CallExpression, context: ITransformationContext) {
-  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/transform_luabind_class/transformation/utils.ts

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

package/plugins/utils/diagnostics.ts

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