import * as path from "path";

import * as ts from "typescript";

import { CompilerOptions, LuaTarget } from "./CompilerOptions";

import { DecoratorKind } from "./Decorator";

import * as tstl from "./LuaAST";

import { LuaLibFeature } from "./LuaLib";

import * as tsHelper from "./TSHelper";

import * as TSTLErrors from "./TSTLErrors";

import { luaKeywords, luaBuiltins } from "./LuaKeywords";

export type StatementVisitResult = tstl.Statement | tstl.Statement[] | undefined;

export type ExpressionVisitResult = tstl.Expression;

export enum ScopeType {

File = 0x1,

Function = 0x2,

Switch = 0x4,

Loop = 0x8,

Conditional = 0x10,

Block = 0x20,

Try = 0x40,

Catch = 0x80,

}

interface SymbolInfo {

symbol: ts.Symbol;

firstSeenAtPos: number;

}

interface FunctionDefinitionInfo {

referencedSymbols: Map<tstl.SymbolId, ts.Node[]>;

definition?: tstl.VariableDeclarationStatement | tstl.AssignmentStatement;

}

interface Scope {

type: ScopeType;

id: number;

referencedSymbols?: Map<tstl.SymbolId, ts.Node[]>;

variableDeclarations?: tstl.VariableDeclarationStatement[];

functionDefinitions?: Map<tstl.SymbolId, FunctionDefinitionInfo>;

importStatements?: tstl.Statement[];

loopContinued?: boolean;

functionReturned?: boolean;

}

export interface EmitResolver {

isValueAliasDeclaration(node: ts.Node): boolean;

isReferencedAliasDeclaration(node: ts.Node, checkChildren?: boolean): boolean;

isTopLevelValueImportEqualsWithEntityName(node: ts.ImportEqualsDeclaration): boolean;

moduleExportsSomeValue(moduleReferenceExpression: ts.Expression): boolean;

}

export interface DiagnosticsProducingTypeChecker extends ts.TypeChecker {

getEmitResolver(sourceFile?: ts.SourceFile, cancellationToken?: ts.CancellationToken): EmitResolver;

}

export class LuaTransformer {

protected readonly typeValidationCache = new Map<ts.Type, Set<ts.Type>>();

protected currentNamespace?: ts.ModuleDeclaration;

protected checker: DiagnosticsProducingTypeChecker;

protected options: CompilerOptions;

protected luaTarget: LuaTarget;

protected isStrict: boolean;

public constructor(protected program: ts.Program) {

this.checker = (program as any).getDiagnosticsProducingTypeChecker();

this.options = program.getCompilerOptions();

this.luaTarget = this.options.luaTarget || LuaTarget.LuaJIT;

this.isStrict =

this.options.alwaysStrict !== undefined ||

(this.options.strict !== undefined && this.options.alwaysStrict !== false) ||

(this.isModule && this.options.target !== undefined && this.options.target >= ts.ScriptTarget.ES2015);

this.setupState();

}

protected genVarCounter!: number;

protected luaLibFeatureSet!: Set<LuaLibFeature>;

protected visitedExportEquals!: boolean;

protected scopeStack!: Scope[];

protected classStack!: ts.ClassLikeDeclaration[];

protected symbolInfo!: Map<tstl.SymbolId, SymbolInfo>;

protected symbolIds!: Map<ts.Symbol, tstl.SymbolId>;

protected genSymbolIdCounter!: number;

private setupState(): void {

this.genVarCounter = 0;

this.luaLibFeatureSet = new Set<LuaLibFeature>();

this.visitedExportEquals = false;

this.scopeStack = [];

this.classStack = [];

this.symbolInfo = new Map();

this.symbolIds = new Map();

this.genSymbolIdCounter = 1;

}

protected currentSourceFile!: ts.SourceFile;

protected isModule!: boolean;

protected resolver!: EmitResolver;

/** @internal */

public transform(sourceFile: ts.SourceFile): [tstl.Block, Set<LuaLibFeature>] {

this.setupState();

this.currentSourceFile = sourceFile;

this.isModule = tsHelper.isFileModule(sourceFile);

// Use `getParseTreeNode` to get original SourceFile node, before it was substituted by custom transformers.

// It's required because otherwise `getEmitResolver` won't use cached diagnostics, produced in `emitWorker`

// and would try to re-analyze the file, which would fail because of replaced nodes.

const originalSourceFile = ts.getParseTreeNode(sourceFile, ts.isSourceFile) || sourceFile;

this.resolver = this.checker.getEmitResolver(originalSourceFile);

return [this.transformSourceFile(sourceFile), this.luaLibFeatureSet];

}

public transformSourceFile(sourceFile: ts.SourceFile): tstl.Block {

let statements: tstl.Statement[] = [];

if (sourceFile.flags & ts.NodeFlags.JsonFile) {

const statement = sourceFile.statements[0];

if (!statement || !ts.isExpressionStatement(statement)) {

throw TSTLErrors.InvalidJsonFileContent(sourceFile);

}

statements.push(tstl.createReturnStatement([this.transformExpression(statement.expression)]));

} else {

this.pushScope(ScopeType.File);

statements = this.performHoisting(this.transformStatements(sourceFile.statements));

this.popScope();

if (this.isModule) {

// If export equals was not used. Create the exports table.

// local exports = {}

if (!this.visitedExportEquals) {

statements.unshift(

tstl.createVariableDeclarationStatement(

this.createExportsIdentifier(),

tstl.createTableExpression()

)

);

}

// return exports

statements.push(tstl.createReturnStatement([this.createExportsIdentifier()]));

}

}

return tstl.createBlock(statements, sourceFile);

}

public transformStatement(node: ts.Statement): StatementVisitResult {

// Ignore declarations

if (node.modifiers && node.modifiers.some(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword)) {

return undefined;

}

switch (node.kind) {

// Block

case ts.SyntaxKind.Block:

return this.transformBlockAsDoStatement(node as ts.Block);

// Declaration Statements

case ts.SyntaxKind.ExportAssignment:

return this.transformExportAssignment(node as ts.ExportAssignment);

case ts.SyntaxKind.ExportDeclaration:

return this.transformExportDeclaration(node as ts.ExportDeclaration);

case ts.SyntaxKind.ImportDeclaration:

return this.transformImportDeclaration(node as ts.ImportDeclaration);

case ts.SyntaxKind.ImportEqualsDeclaration:

return this.transformImportEqualsDeclaration(node as ts.ImportEqualsDeclaration);

case ts.SyntaxKind.ClassDeclaration:

return this.transformClassDeclaration(node as ts.ClassDeclaration);

case ts.SyntaxKind.ModuleDeclaration:

return this.transformModuleDeclaration(node as ts.ModuleDeclaration);

case ts.SyntaxKind.EnumDeclaration:

return this.transformEnumDeclaration(node as ts.EnumDeclaration);

case ts.SyntaxKind.FunctionDeclaration:

return this.transformFunctionDeclaration(node as ts.FunctionDeclaration);

case ts.SyntaxKind.TypeAliasDeclaration:

return this.transformTypeAliasDeclaration(node as ts.TypeAliasDeclaration);

case ts.SyntaxKind.InterfaceDeclaration:

return this.transformInterfaceDeclaration(node as ts.InterfaceDeclaration);

// Statements

case ts.SyntaxKind.VariableStatement:

return this.transformVariableStatement(node as ts.VariableStatement);

case ts.SyntaxKind.ExpressionStatement:

return this.transformExpressionStatement(node as ts.ExpressionStatement);

case ts.SyntaxKind.ReturnStatement:

return this.transformReturnStatement(node as ts.ReturnStatement);

case ts.SyntaxKind.IfStatement:

return this.transformIfStatement(node as ts.IfStatement);

case ts.SyntaxKind.WhileStatement:

return this.transformWhileStatement(node as ts.WhileStatement);

case ts.SyntaxKind.DoStatement:

return this.transformDoStatement(node as ts.DoStatement);

case ts.SyntaxKind.ForStatement:

return this.transformForStatement(node as ts.ForStatement);

case ts.SyntaxKind.ForOfStatement:

return this.transformForOfStatement(node as ts.ForOfStatement);

case ts.SyntaxKind.ForInStatement:

return this.transformForInStatement(node as ts.ForInStatement);

case ts.SyntaxKind.SwitchStatement:

return this.transformSwitchStatement(node as ts.SwitchStatement);

case ts.SyntaxKind.BreakStatement:

return this.transformBreakStatement(node as ts.BreakStatement);

case ts.SyntaxKind.TryStatement:

return this.transformTryStatement(node as ts.TryStatement);

case ts.SyntaxKind.ThrowStatement:

return this.transformThrowStatement(node as ts.ThrowStatement);

case ts.SyntaxKind.ContinueStatement:

return this.transformContinueStatement(node as ts.ContinueStatement);

case ts.SyntaxKind.EmptyStatement:

return this.transformEmptyStatement(node as ts.EmptyStatement);

case ts.SyntaxKind.NotEmittedStatement:

return undefined;

default:

throw TSTLErrors.UnsupportedKind("Statement", node.kind, node);

}

}

/** Converts an array of ts.Statements into an array of tstl.Statements */

protected transformStatements(statements: readonly ts.Statement[]): tstl.Statement[] {

const tstlStatements: tstl.Statement[] = [];

(statements as ts.Statement[]).forEach(statement => {

tstlStatements.push(...this.statementVisitResultToArray(this.transformStatement(statement)));

});

return tstlStatements;

}

public transformBlock(block: ts.Block): tstl.Block {

this.pushScope(ScopeType.Block);

const statements = this.performHoisting(this.transformStatements(block.statements));

this.popScope();

return tstl.createBlock(statements, block);

}

public transformBlockAsDoStatement(block: ts.Block): StatementVisitResult {

this.pushScope(ScopeType.Block);

const statements = this.performHoisting(this.transformStatements(block.statements));

this.popScope();

return tstl.createDoStatement(statements, block);

}

public transformExportAssignment(statement: ts.ExportAssignment): StatementVisitResult {

if (!this.resolver.isValueAliasDeclaration(statement)) {

return undefined;

}

// export = [expression];

// ____exports = [expression];

if (statement.isExportEquals) {

// Stop the creation of the exports table.

// This should be the only export of the module.

this.visitedExportEquals = true;

return tstl.createVariableDeclarationStatement(

this.createExportsIdentifier(),

this.transformExpression(statement.expression),

statement

);

}

// export default [expression];

// ____exports.default = [expression];

const defaultIdentifier = this.createDefaultExportStringLiteral(statement);

return tstl.createAssignmentStatement(

tstl.createTableIndexExpression(this.createExportsIdentifier(), defaultIdentifier),

this.transformExpression(statement.expression),

statement

);

}

public transformExportDeclaration(statement: ts.ExportDeclaration): StatementVisitResult {

if (statement.exportClause) {

if (!this.resolver.isValueAliasDeclaration(statement)) {

return undefined;

}

const exportSpecifiers = tsHelper.getExportable(statement.exportClause, this.resolver);

// export { ... };

if (statement.moduleSpecifier === undefined) {

return exportSpecifiers.map(exportSpecifier => this.transformExportSpecifier(exportSpecifier));

}

// export { ... } from "...";

return this.transformExportSpecifiersFrom(statement, statement.moduleSpecifier, exportSpecifiers);

} else {

// export * from "...";

return this.transformExportAllFrom(statement);

}

}

protected transformExportSpecifier(node: ts.ExportSpecifier): tstl.AssignmentStatement {

const exportedSymbol = this.checker.getExportSpecifierLocalTargetSymbol(node);

const exportedIdentifier = node.propertyName ? node.propertyName : node.name;

const exportedExpression = this.createShorthandIdentifier(exportedSymbol, exportedIdentifier);

const isDefault = tsHelper.isDefaultExportSpecifier(node);

const identifierToExport = isDefault

? this.createDefaultExportIdentifier(node)

: this.transformIdentifier(node.name);

const exportAssignmentLeftHandSide = this.createExportedIdentifier(identifierToExport);

return tstl.createAssignmentStatement(exportAssignmentLeftHandSide, exportedExpression, node);

}

protected transformExportSpecifiersFrom(

statement: ts.ExportDeclaration,

moduleSpecifier: ts.Expression,

exportSpecifiers: ts.ExportSpecifier[]

): tstl.Statement {

// First transpile as import clause

const importClause = ts.createImportClause(

undefined,

ts.createNamedImports(exportSpecifiers.map(s => ts.createImportSpecifier(s.propertyName, s.name)))

);

const importDeclaration = ts.createImportDeclaration(

statement.decorators,

statement.modifiers,

importClause,

moduleSpecifier

);

// Wrap in block to prevent imports from hoisting out of `do` statement

const block = ts.createBlock([importDeclaration]);

const result = this.transformBlock(block).statements;

// Now the module is imported, add the imports to the export table

for (const specifier of exportSpecifiers) {

result.push(

tstl.createAssignmentStatement(

this.createExportedIdentifier(this.transformIdentifier(specifier.name)),

this.transformIdentifier(specifier.name)

)

);

}

// Wrap this in a DoStatement to prevent polluting the scope.

return tstl.createDoStatement(this.filterUndefined(result), statement);

}

protected transformExportAllFrom(statement: ts.ExportDeclaration): tstl.Statement | undefined {

if (statement.moduleSpecifier === undefined) {

throw TSTLErrors.InvalidExportDeclaration(statement);

}

if (!this.resolver.moduleExportsSomeValue(statement.moduleSpecifier)) {

return undefined;

}

const moduleRequire = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral);

const tempModuleIdentifier = tstl.createIdentifier("____export");

const declaration = tstl.createVariableDeclarationStatement(tempModuleIdentifier, moduleRequire);

const forKey = tstl.createIdentifier("____exportKey");

const forValue = tstl.createIdentifier("____exportValue");

const body = tstl.createBlock([

tstl.createAssignmentStatement(

tstl.createTableIndexExpression(this.createExportsIdentifier(), forKey),

forValue

),

]);

const pairsIdentifier = tstl.createIdentifier("pairs");

const forIn = tstl.createForInStatement(

body,

[tstl.cloneIdentifier(forKey), tstl.cloneIdentifier(forValue)],

[tstl.createCallExpression(pairsIdentifier, [tstl.cloneIdentifier(tempModuleIdentifier)])]

);

// Wrap this in a DoStatement to prevent polluting the scope.

return tstl.createDoStatement([declaration, forIn], statement);

}

public transformImportDeclaration(statement: ts.ImportDeclaration): StatementVisitResult {

const scope = this.peekScope();

if (scope === undefined) {

throw TSTLErrors.UndefinedScope();

}

if (!this.options.noHoisting && !scope.importStatements) {

scope.importStatements = [];

}

const shouldResolve = tsHelper.shouldResolveModulePath(statement.moduleSpecifier, this.checker);

const moduleSpecifier = statement.moduleSpecifier as ts.StringLiteral;

const importPath = moduleSpecifier.text.replace(new RegExp('"', "g"), "");

const requireCall = this.createModuleRequire(statement.moduleSpecifier as ts.StringLiteral, shouldResolve);

const result: tstl.Statement[] = [];

// import "./module";

// require("module")

if (statement.importClause === undefined) {

result.push(tstl.createExpressionStatement(requireCall));

if (scope.importStatements) {

scope.importStatements.push(...result);

return undefined;

} else {

return result;

}

}

// Create the require statement to extract values.

// local ____module = require("module")

const tstlIdentifier = (name: string) => "____" + tsHelper.fixInvalidLuaIdentifier(name);

const importUniqueName = tstl.createIdentifier(tstlIdentifier(path.basename(importPath)));

const requireStatement = tstl.createVariableDeclarationStatement(

tstl.createIdentifier(tstlIdentifier(path.basename(importPath))),

requireCall,

statement

);

let usingRequireStatement = false;

// import defaultValue from "./module";

// local defaultValue = __module.default

if (statement.importClause.name) {

if (tsHelper.shouldBeImported(statement.importClause, this.checker, this.resolver)) {

const propertyName = this.createDefaultExportStringLiteral(statement.importClause.name);

const defaultImportAssignmentStatement = tstl.createVariableDeclarationStatement(

this.transformIdentifier(statement.importClause.name),

tstl.createTableIndexExpression(importUniqueName, propertyName),

statement.importClause.name

);

result.push(defaultImportAssignmentStatement);

usingRequireStatement = true;

}

}

// import * as module from "./module";

// local module = require("module")

if (statement.importClause.namedBindings && ts.isNamespaceImport(statement.importClause.namedBindings)) {

if (this.resolver.isReferencedAliasDeclaration(statement.importClause.namedBindings)) {

const requireStatement = tstl.createVariableDeclarationStatement(

this.transformIdentifier(statement.importClause.namedBindings.name),

requireCall,

statement

);

result.push(requireStatement);

}

}

// import { a, b, c } from "./module";

// local a = __module.a

// local b = __module.b

// local c = __module.c

if (statement.importClause.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {

const assignmentStatements = statement.importClause.namedBindings.elements

.filter(importSpecifier => tsHelper.shouldBeImported(importSpecifier, this.checker, this.resolver))

.map(importSpecifier => this.transformImportSpecifier(importSpecifier, importUniqueName));

if (assignmentStatements.length > 0) {

usingRequireStatement = true;

}

result.push(...assignmentStatements);

}

if (result.length === 0) {

return undefined;

}

if (usingRequireStatement) {

result.unshift(requireStatement);

}

if (scope.importStatements) {

scope.importStatements.push(...result);

return undefined;

} else {

return result;

}

}

protected transformImportSpecifier(

importSpecifier: ts.ImportSpecifier,

moduleTableName: tstl.Identifier

): tstl.VariableDeclarationStatement {

const leftIdentifier = this.transformIdentifier(importSpecifier.name);

const propertyName = this.transformPropertyName(

importSpecifier.propertyName ? importSpecifier.propertyName : importSpecifier.name

);

return tstl.createVariableDeclarationStatement(

leftIdentifier,

tstl.createTableIndexExpression(moduleTableName, propertyName),

importSpecifier

);

}

protected createModuleRequire(moduleSpecifier: ts.StringLiteral, resolveModule = true): tstl.CallExpression {

const modulePathString = resolveModule

? tsHelper.getImportPath(

this.currentSourceFile.fileName,

moduleSpecifier.text.replace(new RegExp('"', "g"), ""),

moduleSpecifier,

this.options

)

: moduleSpecifier.text;

const modulePath = tstl.createStringLiteral(modulePathString);

return tstl.createCallExpression(tstl.createIdentifier("require"), [modulePath], moduleSpecifier);

}

protected validateClassElement(element: ts.ClassElement): void {

if (element.name && (ts.isStringLiteral(element.name) || ts.isIdentifier(element.name))) {

if (tsHelper.isStaticNode(element) && element.name.text === "new") {

throw TSTLErrors.ForbiddenStaticClassPropertyName(element, element.name.text);

}

}

}

public transformImportEqualsDeclaration(declaration: ts.ImportEqualsDeclaration): StatementVisitResult {

const name = this.transformIdentifier(declaration.name);

let expression: tstl.Expression;

if (ts.isExternalModuleReference(declaration.moduleReference)) {

if (!this.resolver.isReferencedAliasDeclaration(declaration)) {

return undefined;

}

expression = this.transformExternalModuleReference(declaration.moduleReference);

} else {

const shouldEmit =

this.resolver.isReferencedAliasDeclaration(declaration) ||

(!ts.isExternalModule(this.currentSourceFile) &&

this.resolver.isTopLevelValueImportEqualsWithEntityName(declaration));

if (!shouldEmit) {

return undefined;

}

expression = this.transformEntityName(declaration.moduleReference);

}

return this.createHoistableVariableDeclarationStatement(name, expression, declaration);

}

public transformExternalModuleReference(

externalModuleReference: ts.ExternalModuleReference

): ExpressionVisitResult {

// TODO: Should `externalModuleReference` be original node?

return this.createModuleRequire(externalModuleReference.expression as ts.StringLiteral);

}

protected transformEntityName(entityName: ts.EntityName): ExpressionVisitResult {

return ts.isQualifiedName(entityName)

? this.transformQualifiedName(entityName)

: this.transformIdentifierExpression(entityName);

}

public transformQualifiedName(qualifiedName: ts.QualifiedName): ExpressionVisitResult {

const right = tstl.createStringLiteral(qualifiedName.right.text, qualifiedName.right);

const left = this.transformEntityName(qualifiedName.left);

return tstl.createTableIndexExpression(left, right, qualifiedName);

}

public transformClassDeclaration(

statement: ts.ClassLikeDeclaration,

nameOverride?: tstl.Identifier

): StatementVisitResult {

this.classStack.push(statement);

let className: tstl.Identifier;

let classNameText: string;

if (nameOverride !== undefined) {

className = nameOverride;

classNameText = nameOverride.text;

} else if (statement.name !== undefined) {

className = this.transformIdentifier(statement.name);

classNameText = statement.name.text;

} else {

const isDefaultExport = tsHelper.hasDefaultExportModifier(statement.modifiers);

if (isDefaultExport) {

const left = this.createExportedIdentifier(this.createDefaultExportIdentifier(statement));

const right = this.transformClassExpression(statement);

return tstl.createAssignmentStatement(left, right, statement);

} else {

throw TSTLErrors.MissingClassName(statement);

}

}

const decorators = tsHelper.getCustomDecorators(this.checker.getTypeAtLocation(statement), this.checker);

// Find out if this class is extension of existing class

const extensionDirective = decorators.get(DecoratorKind.Extension);

const isExtension = extensionDirective !== undefined;

const isMetaExtension = decorators.has(DecoratorKind.MetaExtension);

if (isExtension && isMetaExtension) {

throw TSTLErrors.InvalidExtensionMetaExtension(statement);

}

if ((isExtension || isMetaExtension) && this.getIdentifierExportScope(className) !== undefined) {

// Cannot export extension classes

throw TSTLErrors.InvalidExportsExtension(statement);

}

// Get type that is extended

const extendsType = tsHelper.getExtendedType(statement, this.checker);

if (!(isExtension || isMetaExtension) && extendsType) {

// Non-extensions cannot extend extension classes

const extendsDecorators = tsHelper.getCustomDecorators(extendsType, this.checker);

if (extendsDecorators.has(DecoratorKind.Extension) || extendsDecorators.has(DecoratorKind.MetaExtension)) {

throw TSTLErrors.InvalidExtendsExtension(statement);

}

}

// You cannot extend LuaTable classes

if (extendsType) {

const decorators = tsHelper.getCustomDecorators(extendsType, this.checker);

if (decorators.has(DecoratorKind.LuaTable)) {

throw TSTLErrors.InvalidExtendsLuaTable(statement);

}

}

// LuaTable classes must be ambient

if (decorators.has(DecoratorKind.LuaTable) && !tsHelper.isAmbientNode(statement)) {

throw TSTLErrors.ForbiddenLuaTableNonDeclaration(statement);

}

// Get all properties with value

const properties = statement.members.filter(ts.isPropertyDeclaration).filter(member => member.initializer);

// Divide properties into static and non-static

const staticFields = properties.filter(tsHelper.isStaticNode);

const instanceFields = properties.filter(prop => !tsHelper.isStaticNode(prop));

const result: tstl.Statement[] = [];

// Overwrite the original className with the class we are overriding for extensions

if (isMetaExtension) {

if (!extendsType) {

throw TSTLErrors.MissingMetaExtension(statement);

}

const extendsName = tstl.createStringLiteral(extendsType.symbol.escapedName as string);

className = tstl.createIdentifier("__meta__" + extendsName.value);

// local className = debug.getregistry()["extendsName"]

const assignDebugCallIndex = tstl.createVariableDeclarationStatement(

className,

tstl.createTableIndexExpression(

tstl.createCallExpression(

tstl.createTableIndexExpression(

tstl.createIdentifier("debug"),

tstl.createStringLiteral("getregistry")

),

[]

),

extendsName

),

statement

);

result.push(assignDebugCallIndex);

}

if (extensionDirective !== undefined) {

const extensionNameArg = extensionDirective.args[0];

if (extensionNameArg) {

className = tstl.createIdentifier(extensionNameArg);

} else if (extendsType) {

className = tstl.createIdentifier(extendsType.symbol.escapedName as string);

}

}

let localClassName: tstl.Identifier;

if (this.isUnsafeName(className.text)) {

localClassName = tstl.createIdentifier(

this.createSafeName(className.text),

undefined,

className.symbolId,

className.text

);

tstl.setNodePosition(localClassName, className);

} else {

localClassName = className;

}

if (!isExtension && !isMetaExtension) {

const classCreationMethods = this.createClassCreationMethods(

statement,

className,

localClassName,

classNameText,

extendsType

);

result.push(...classCreationMethods);

} else {

for (const f of instanceFields) {

const fieldName = this.transformPropertyName(f.name);

const value = f.initializer !== undefined ? this.transformExpression(f.initializer) : undefined;

// className["fieldName"]

const classField = tstl.createTableIndexExpression(tstl.cloneIdentifier(className), fieldName);

// className["fieldName"] = value;

const assignClassField = tstl.createAssignmentStatement(classField, value);

result.push(assignClassField);

}

}

// Find first constructor with body

if (!isExtension && !isMetaExtension) {

const constructor = statement.members.filter(

n => ts.isConstructorDeclaration(n) && n.body

)[0] as ts.ConstructorDeclaration;

if (constructor) {

// Add constructor plus initialization of instance fields

const constructorResult = this.transformConstructorDeclaration(

constructor,

localClassName,

instanceFields,

statement

);

result.push(...this.statementVisitResultToArray(constructorResult));

} else if (!extendsType) {

// Generate a constructor if none was defined in a base class

const constructorResult = this.transformConstructorDeclaration(

ts.createConstructor([], [], [], ts.createBlock([], true)),

localClassName,

instanceFields,

statement

);

result.push(...this.statementVisitResultToArray(constructorResult));

} else if (

instanceFields.length > 0 ||

statement.members.some(m => tsHelper.isGetAccessorOverride(m, statement, this.checker))

) {

// Generate a constructor if none was defined in a class with instance fields that need initialization

// localClassName.prototype.____constructor = function(self, ...)

// baseClassName.prototype.____constructor(self, ...)

// ...

const constructorBody = this.transformClassInstanceFields(statement, instanceFields);

const superCall = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createTableIndexExpression(

this.transformSuperKeyword(ts.createSuper()),

tstl.createStringLiteral("____constructor")

),

[this.createSelfIdentifier(), tstl.createDotsLiteral()]

)

);

constructorBody.unshift(superCall);

const constructorFunction = tstl.createFunctionExpression(

tstl.createBlock(constructorBody),

[this.createSelfIdentifier()],

tstl.createDotsLiteral(),

undefined,

tstl.FunctionExpressionFlags.Declaration

);

result.push(

tstl.createAssignmentStatement(

this.createConstructorName(localClassName),

constructorFunction,

statement

)

);

}

}

// Transform get accessors

statement.members.filter(ts.isGetAccessor).forEach(getAccessor => {

const transformResult = this.transformGetAccessorDeclaration(getAccessor, localClassName);

result.push(...this.statementVisitResultToArray(transformResult));

});

// Transform set accessors

statement.members.filter(ts.isSetAccessor).forEach(setAccessor => {

const transformResult = this.transformSetAccessorDeclaration(setAccessor, localClassName);

result.push(...this.statementVisitResultToArray(transformResult));

});

// Transform methods

statement.members.filter(ts.isMethodDeclaration).forEach(method => {

const methodResult = this.transformMethodDeclaration(

method,

localClassName,

isExtension || isMetaExtension

);

result.push(...this.statementVisitResultToArray(methodResult));

});

// Add static declarations

for (const field of staticFields) {

this.validateClassElement(field);

const fieldName = this.transformPropertyName(field.name);

const value = field.initializer ? this.transformExpression(field.initializer) : undefined;

const classField = tstl.createTableIndexExpression(tstl.cloneIdentifier(localClassName), fieldName);

const fieldAssign = tstl.createAssignmentStatement(classField, value);

result.push(fieldAssign);

}

const decorationStatement = this.createConstructorDecorationStatement(statement);

if (decorationStatement) {

result.push(decorationStatement);

}

this.classStack.pop();

return result;

}

protected createClassCreationMethods(

statement: ts.ClassLikeDeclarationBase,

className: tstl.Identifier,

localClassName: tstl.Identifier,

classNameText: string,

extendsType?: ts.Type

): tstl.Statement[] {

const result: tstl.Statement[] = [];

// [____exports.]className = {}

const classTable: tstl.Expression = tstl.createTableExpression();

const isDefaultExport = tsHelper.hasDefaultExportModifier(statement.modifiers);

const defaultExportLeftHandSide = isDefaultExport

? tstl.createTableIndexExpression(

this.createExportsIdentifier(),

this.createDefaultExportStringLiteral(statement)

)

: undefined;

const classVar = defaultExportLeftHandSide

? [tstl.createAssignmentStatement(defaultExportLeftHandSide, classTable, statement)]

: this.createLocalOrExportedOrGlobalDeclaration(className, classTable, statement);

result.push(...classVar);

if (defaultExportLeftHandSide) {

// local localClassName = ____exports.default

result.push(tstl.createVariableDeclarationStatement(localClassName, defaultExportLeftHandSide));

} else {

const exportScope = this.getIdentifierExportScope(className);

if (exportScope) {

// local localClassName = ____exports.className

result.push(

tstl.createVariableDeclarationStatement(

localClassName,

this.createExportedIdentifier(tstl.cloneIdentifier(className), exportScope)

)

);

}

}

// localClassName.name = className

result.push(

tstl.createAssignmentStatement(

tstl.createTableIndexExpression(tstl.cloneIdentifier(localClassName), tstl.createStringLiteral("name")),

tstl.createStringLiteral(classNameText),

statement

)

);

// localClassName.____getters = {}

if (statement.members.some(m => ts.isGetAccessor(m) && tsHelper.isStaticNode(m))) {

const classGetters = tstl.createTableIndexExpression(

tstl.cloneIdentifier(localClassName),

tstl.createStringLiteral("____getters")

);

const assignClassGetters = tstl.createAssignmentStatement(

classGetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassGetters);

this.importLuaLibFeature(LuaLibFeature.ClassIndex);

}

// localClassName.__index = localClassName

const classIndex = tstl.createTableIndexExpression(

tstl.cloneIdentifier(localClassName),

tstl.createStringLiteral("__index")

);

const assignClassIndex = tstl.createAssignmentStatement(

classIndex,

tstl.cloneIdentifier(localClassName),

statement

);

result.push(assignClassIndex);

// localClassName.____setters = {}

if (statement.members.some(m => ts.isSetAccessor(m) && tsHelper.isStaticNode(m))) {

const classSetters = tstl.createTableIndexExpression(

tstl.cloneIdentifier(localClassName),

tstl.createStringLiteral("____setters")

);

const assignClassSetters = tstl.createAssignmentStatement(

classSetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassSetters);

this.importLuaLibFeature(LuaLibFeature.ClassNewIndex);

}

// localClassName.prototype = {}

const createClassPrototype = () =>

tstl.createTableIndexExpression(

tstl.cloneIdentifier(localClassName),

tstl.createStringLiteral("prototype")

);

const classPrototypeTable = tstl.createTableExpression();

const assignClassPrototype = tstl.createAssignmentStatement(

createClassPrototype(),

classPrototypeTable,

statement

);

result.push(assignClassPrototype);

// localClassName.prototype.____getters = {}

if (statement.members.some(m => ts.isGetAccessor(m) && !tsHelper.isStaticNode(m))) {

const classPrototypeGetters = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("____getters")

);

const assignClassPrototypeGetters = tstl.createAssignmentStatement(

classPrototypeGetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassPrototypeGetters);

}

const classPrototypeIndex = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("__index")

);

if (tsHelper.hasGetAccessorInClassOrAncestor(statement, false, this.checker)) {

// localClassName.prototype.__index = __TS__Index(localClassName.prototype)

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeIndex,

this.transformLuaLibFunction(LuaLibFeature.Index, undefined, createClassPrototype()),

statement

);

result.push(assignClassPrototypeIndex);

} else {

// localClassName.prototype.__index = localClassName.prototype

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeIndex,

createClassPrototype(),

statement

);

result.push(assignClassPrototypeIndex);

}

if (statement.members.some(m => ts.isSetAccessor(m) && !tsHelper.isStaticNode(m))) {

// localClassName.prototype.____setters = {}

const classPrototypeSetters = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("____setters")

);

const assignClassPrototypeSetters = tstl.createAssignmentStatement(

classPrototypeSetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassPrototypeSetters);

}

if (tsHelper.hasSetAccessorInClassOrAncestor(statement, false, this.checker)) {

// localClassName.prototype.__newindex = __TS__NewIndex(localClassName.prototype)

const classPrototypeNewIndex = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("__newindex")

);

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeNewIndex,

this.transformLuaLibFunction(LuaLibFeature.NewIndex, undefined, createClassPrototype()),

statement

);

result.push(assignClassPrototypeIndex);

}

// localClassName.prototype.constructor = localClassName