import * as path from "path";

import * as ts from "typescript";

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

import {DecoratorKind} from "./Decorator";

import * as tstl from "./LuaAST";

import {LuaLib, LuaLibFeature} from "./LuaLib";

import {ContextType, TSHelper as tsHelper} from "./TSHelper";

import {TSTLErrors} from "./TSTLErrors";

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

export type ExpressionVisitResult = tstl.Expression | undefined;

export enum ScopeType {

File = 0x1,

Function = 0x2,

Switch = 0x4,

Loop = 0x8,

Conditional = 0x10,

Block = 0x20,

}

interface SymbolInfo {

symbol: ts.Symbol;

firstSeenAtPos: number;

}

interface FunctionDefinitionInfo {

referencedSymbols: Set<tstl.SymbolId>;

assignment?: tstl.AssignmentStatement;

}

interface Scope {

type: ScopeType;

id: number;

referencedSymbols?: Set<tstl.SymbolId>;

variableDeclarations?: tstl.VariableDeclarationStatement[];

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

}

export class LuaTransformer {

public luaKeywords: Set<string> = new Set([

"and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if", "in", "local", "new", "nil",

"not", "or", "repeat", "return", "self", "then", "until", "while",

]);

private isStrict = true;

private checker: ts.TypeChecker;

protected options: CompilerOptions;

private isModule: boolean;

private currentSourceFile?: ts.SourceFile;

private currentNamespace: ts.ModuleDeclaration;

private classStack: ts.ClassLikeDeclaration[];

private scopeStack: Scope[];

private genVarCounter: number;

private luaLibFeatureSet: Set<LuaLibFeature>;

private symbolInfo: Map<tstl.SymbolId, SymbolInfo>;

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

private genSymbolIdCounter: number;

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

public constructor(program: ts.Program, options: CompilerOptions) {

this.checker = program.getTypeChecker();

this.options = options;

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

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

if (!this.options.luaTarget) {

this.options.luaTarget = LuaTarget.LuaJIT;

}

this.setupState();

}

public setupState(): void {

this.genVarCounter = 0;

this.currentSourceFile = undefined;

this.isModule = false;

this.scopeStack = [];

this.classStack = [];

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

this.symbolIds = new Map();

this.symbolInfo = new Map();

this.genSymbolIdCounter = 1;

}

// TODO make all other methods private???

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

this.setupState();

this.currentSourceFile = node;

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

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

this.isModule = false;

const statement = node.statements[0];

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

throw TSTLErrors.InvalidJsonFileContent(node);

}

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

} else {

this.pushScope(ScopeType.File, node);

this.isModule = tsHelper.isFileModule(node);

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

this.popScope();

if (this.isModule) {

statements.unshift(

tstl.createVariableDeclarationStatement(

tstl.createIdentifier("exports"),

tstl.createBinaryExpression(

tstl.createIdentifier("exports"),

tstl.createTableExpression(),

tstl.SyntaxKind.OrOperator

)));

statements.push(

tstl.createReturnStatement(

[tstl.createIdentifier("exports")]

));

}

}

return [tstl.createBlock(statements, node), this.luaLibFeatureSet];

}

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.ExportDeclaration:

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

case ts.SyntaxKind.ImportDeclaration:

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

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.transformReturn(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 */

public transformStatements(statements: ts.Statement[] | ReadonlyArray<ts.Statement>): tstl.Statement[] {

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

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

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

});

return tstlStatements;

}

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

this.pushScope(ScopeType.Block, block);

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

this.popScope();

return tstl.createBlock(statements, block);

}

public transformBlockAsDoStatement(block: ts.Block): tstl.DoStatement {

this.pushScope(ScopeType.Block, block);

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

this.popScope();

return tstl.createDoStatement(statements, block);

}

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

if (statement.moduleSpecifier === undefined) {

const result = [];

for (const exportElement of statement.exportClause.elements) {

result.push(

tstl.createAssignmentStatement(

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

this.transformIdentifier(exportElement.propertyName || exportElement.name)

)

);

}

return result;

}

if (statement.exportClause) {

if (statement.exportClause.elements.some(e =>

(e.name && e.name.originalKeywordKind === ts.SyntaxKind.DefaultKeyword)

|| (e.propertyName && e.propertyName.originalKeywordKind === ts.SyntaxKind.DefaultKeyword))

) {

throw TSTLErrors.UnsupportedDefaultExport(statement);

}

// First transpile as import clause

const importClause = ts.createImportClause(

undefined,

ts.createNamedImports(statement.exportClause.elements

.map(e => ts.createImportSpecifier(e.propertyName, e.name))

)

);

const importDeclaration = ts.createImportDeclaration(

statement.decorators,

statement.modifiers,

importClause,

statement.moduleSpecifier

);

const importResult = this.transformImportDeclaration(importDeclaration);

const result = Array.isArray(importResult) ? importResult : [importResult];

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

for (const exportVariable of statement.exportClause.elements) {

result.push(

tstl.createAssignmentStatement(

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

this.transformIdentifier(exportVariable.name)

)

);

}

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

return tstl.createDoStatement(result, statement);

} else {

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

const tempModuleIdentifier = tstl.createIdentifier("__TSTL_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(

tstl.createIdentifier("exports"),

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 {

if (statement.importClause && !statement.importClause.namedBindings) {

throw TSTLErrors.DefaultImportsNotSupported(statement);

}

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

const moduleSpecifier = statement.moduleSpecifier as ts.StringLiteral;

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

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

if (!statement.importClause) {

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

return result;

}

const imports = statement.importClause.namedBindings;

if (ts.isNamedImports(imports)) {

const filteredElements = imports.elements.filter(e => {

// ignore interface imports

const declaredType = this.checker.getDeclaredTypeOfSymbol((e as any).symbol);

if (declaredType.isClassOrInterface() && !declaredType.isClass()) {

return false;

}

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

return !decorators.has(DecoratorKind.Extension) && !decorators.has(DecoratorKind.MetaExtension);

});

// Elide import if all imported types are extension classes

if (filteredElements.length === 0) {

return undefined;

}

const tstlIdentifier = (name: string) => "__TSTL_" + name.replace(new RegExp("-|\\$| |#|'", "g"), "_");

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

const requireStatement = tstl.createVariableDeclarationStatement(

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

requireCall,

statement

);

result.push(requireStatement);

filteredElements.forEach(importSpecifier => {

if (importSpecifier.propertyName) {

const propertyIdentifier = this.transformIdentifier(importSpecifier.propertyName);

const propertyName = tstl.createStringLiteral(propertyIdentifier.text);

const renamedImport = this.createHoistableVariableDeclarationStatement(

importSpecifier.name,

tstl.createTableIndexExpression(importUniqueName, propertyName),

importSpecifier);

result.push(renamedImport);

} else {

const name = tstl.createStringLiteral(importSpecifier.name.text);

const namedImport = this.createHoistableVariableDeclarationStatement(

importSpecifier.name,

tstl.createTableIndexExpression(importUniqueName, name),

importSpecifier

);

result.push(namedImport);

}

});

return result;

} else if (ts.isNamespaceImport(imports)) {

const requireStatement = this.createHoistableVariableDeclarationStatement(

imports.name,

requireCall,

statement

);

result.push(requireStatement);

return result;

} else {

throw TSTLErrors.UnsupportedImportType(imports);

}

}

private createModuleRequire(moduleSpecifier: ts.StringLiteral): tstl.CallExpression {

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

const resolvedModuleSpecifier = tstl.createStringLiteral(this.getImportPath(importPath));

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

}

public transformClassDeclaration(

statement: ts.ClassLikeDeclaration,

nameOverride?: tstl.Identifier

): tstl.Statement[]

{

this.classStack.push(statement);

let className = statement.name ? this.transformIdentifier(statement.name) : nameOverride;

if (!className) {

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 isExtension = decorators.has(DecoratorKind.Extension);

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

if (isExtension && isMetaExtension) {

throw TSTLErrors.InvalidExtensionMetaExtension(statement);

}

if ((isExtension || isMetaExtension) && this.isIdentifierExported(className)) {

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

}

}

// 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.isStatic);

const instanceFields = properties.filter(prop => !tsHelper.isStatic(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 (isExtension) {

const extensionNameArg = decorators.get(DecoratorKind.Extension).args[0];

if (extensionNameArg) {

className = tstl.createIdentifier(extensionNameArg);

} else if (extendsType) {

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

}

}

if (!isExtension && !isMetaExtension) {

const classCreationMethods = this.createClassCreationMethods(

statement,

className,

extendsType

);

result.push(...classCreationMethods);

} else {

for (const f of instanceFields) {

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

const value = this.transformExpression(f.initializer);

// className["fieldName"]

const classField = tstl.createTableIndexExpression(

tstl.cloneIdentifier(className),

fieldName);

// className["fieldName"] = value;

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

result.push(assignClassField);

}

}

// Add static declarations

for (const field of staticFields) {

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

const value = this.transformExpression(field.initializer);

const classField = tstl.createTableIndexExpression(

this.addExportToIdentifier(tstl.cloneIdentifier(className)),

fieldName

);

const fieldAssign = tstl.createAssignmentStatement(

classField,

value

);

result.push(fieldAssign);

}

// 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

result.push(this.transformConstructor(constructor, className, instanceFields, statement));

} else if (!extendsType) {

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

result.push(this.transformConstructor(

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

className,

instanceFields,

statement

));

} 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

// className.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()

);

result.push(tstl.createAssignmentStatement(

this.createConstructorName(className),

constructorFunction,

statement

));

}

}

// Transform get accessors

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

result.push(this.transformGetAccessorDeclaration(getAccessor, className, statement));

});

// Transform set accessors

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

result.push(this.transformSetAccessorDeclaration(setAccessor, className, statement));

});

// Transform methods

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

result.push(this.transformMethodDeclaration(method, className, isExtension || isMetaExtension));

});

this.classStack.pop();

return result;

}

public createClassCreationMethods(

statement: ts.ClassLikeDeclarationBase,

className: tstl.Identifier,

extendsType: ts.Type

): tstl.Statement[]

{

let noClassOr = false;

if (extendsType) {

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

noClassOr = decorators.has(DecoratorKind.NoClassOr);

}

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

// className = className or {}

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

if (!noClassOr) {

classTable = tstl.createBinaryExpression(

this.addExportToIdentifier(className), // Use original identifier node in declaration

classTable,

tstl.SyntaxKind.OrOperator

);

}

const classVar = this.createLocalOrExportedOrGlobalDeclaration(className, classTable, statement);

result.push(...classVar);

const createClassNameWithExport = () => this.addExportToIdentifier(tstl.cloneIdentifier(className));

// className.____getters = {}

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

const classGetters = tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("____getters")

);

const assignClassGetters = tstl.createAssignmentStatement(

classGetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassGetters);

this.importLuaLibFeature(LuaLibFeature.ClassIndex);

}

// className.__index = className

const classIndex = tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("__index")

);

const assignClassIndex = tstl.createAssignmentStatement(classIndex, createClassNameWithExport(), statement);

result.push(assignClassIndex);

// className.____setters = {}

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

const classSetters = tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("____setters")

);

const assignClassSetters = tstl.createAssignmentStatement(

classSetters,

tstl.createTableExpression(),

statement

);

result.push(assignClassSetters);

this.importLuaLibFeature(LuaLibFeature.ClassNewIndex);

}

// className.prototype = className.prototype or {}

const createClassPrototype = () => tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("prototype")

);

const classPrototypeTable = noClassOr

? tstl.createTableExpression()

: tstl.createBinaryExpression(

createClassPrototype(),

tstl.createTableExpression(),

tstl.SyntaxKind.OrOperator

);

const assignClassPrototype = tstl.createAssignmentStatement(createClassPrototype(), classPrototypeTable);

result.push(assignClassPrototype);

// className.prototype.____getters = {}

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

const classPrototypeGetters = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("____getters")

);

const assignClassPrototypeGetters = tstl.createAssignmentStatement(

classPrototypeGetters,

tstl.createTableExpression()

);

result.push(assignClassPrototypeGetters);

}

const classPrototypeIndex = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("__index")

);

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

// className.prototype.__index = __TS_Index(className.prototype)

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeIndex,

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

);

result.push(assignClassPrototypeIndex);

} else {

// className.prototype.__index = className.prototype

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeIndex,

createClassPrototype()

);

result.push(assignClassPrototypeIndex);

}

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

// className.prototype.____setters = {}

const classPrototypeSetters = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("____setters")

);

const assignClassPrototypeSetters = tstl.createAssignmentStatement(

classPrototypeSetters,

tstl.createTableExpression()

);

result.push(assignClassPrototypeSetters);

}

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

// className.prototype.__newindex = __TS_NewIndex(className.prototype)

const classPrototypeNewIndex = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("__newindex")

);

const assignClassPrototypeIndex = tstl.createAssignmentStatement(

classPrototypeNewIndex,

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

);

result.push(assignClassPrototypeIndex);

}

// className.prototype.constructor = className

const classPrototypeConstructor = tstl.createTableIndexExpression(

createClassPrototype(),

tstl.createStringLiteral("constructor")

);

const assignClassPrototypeConstructor = tstl.createAssignmentStatement(

classPrototypeConstructor,

createClassNameWithExport(),

statement

);

result.push(assignClassPrototypeConstructor);

const hasStaticGetters = tsHelper.hasGetAccessorInClassOrAncestor(statement, true, this.checker);

const hasStaticSetters = tsHelper.hasSetAccessorInClassOrAncestor(statement, true, this.checker);

if (extendsType) {

const extendedTypeNode = tsHelper.getExtendedTypeNode(statement, this.checker);

const baseName = this.transformExpression(extendedTypeNode.expression);

// className.____super = baseName

const createClassBase = () => tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("____super")

);

const assignClassBase = tstl.createAssignmentStatement(createClassBase(), baseName, statement);

result.push(assignClassBase);

if (hasStaticGetters || hasStaticSetters) {

const metatableFields: tstl.TableFieldExpression[] = [];

if (hasStaticGetters) {

// __index = __TS__ClassIndex

metatableFields.push(

tstl.createTableFieldExpression(

tstl.createIdentifier("__TS__ClassIndex"),

tstl.createStringLiteral("__index")

)

);

} else {

// __index = className.____super

metatableFields.push(

tstl.createTableFieldExpression(createClassBase(), tstl.createStringLiteral("__index"))

);

}

if (hasStaticSetters) {

// __newindex = __TS__ClassNewIndex

metatableFields.push(

tstl.createTableFieldExpression(

tstl.createIdentifier("__TS__ClassNewIndex"),

tstl.createStringLiteral("__newindex")

)

);

}

const setClassMetatable = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createIdentifier("setmetatable"),

[createClassNameWithExport(), tstl.createTableExpression(metatableFields)]

)

);

result.push(setClassMetatable);

} else {

// setmetatable(className, className.____super)

const setClassMetatable = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createIdentifier("setmetatable"),

[createClassNameWithExport(), createClassBase()]

)

);

result.push(setClassMetatable);

}

// setmetatable(className.prototype, className.____super.prototype)

const basePrototype = tstl.createTableIndexExpression(

createClassBase(),

tstl.createStringLiteral("prototype")

);

const setClassPrototypeMetatable = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createIdentifier("setmetatable"),

[createClassPrototype(), basePrototype]

)

);

result.push(setClassPrototypeMetatable);

} else if (hasStaticGetters || hasStaticSetters) {

const metatableFields: tstl.TableFieldExpression[] = [];

if (hasStaticGetters) {

// __index = __TS__ClassIndex

metatableFields.push(

tstl.createTableFieldExpression(

tstl.createIdentifier("__TS__ClassIndex"),

tstl.createStringLiteral("__index")

)

);

}

if (hasStaticSetters) {

// __newindex = __TS__ClassNewIndex

metatableFields.push(

tstl.createTableFieldExpression(

tstl.createIdentifier("__TS__ClassNewIndex"),

tstl.createStringLiteral("__newindex")

)

);

}

const setClassMetatable = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createIdentifier("setmetatable"),

[createClassNameWithExport(), tstl.createTableExpression(metatableFields)]

)

);

result.push(setClassMetatable);

}

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

// local self = setmetatable({}, className.prototype)

const assignSelf = tstl.createVariableDeclarationStatement(

this.createSelfIdentifier(),

tstl.createCallExpression(

tstl.createIdentifier("setmetatable"),

[tstl.createTableExpression(), createClassPrototype()]

)

);

newFuncStatements.push(assignSelf);

// self:____constructor(...)

const callConstructor = tstl.createExpressionStatement(

tstl.createMethodCallExpression(

this.createSelfIdentifier(),

tstl.createIdentifier("____constructor"),

[tstl.createDotsLiteral()]

)

);

newFuncStatements.push(callConstructor);

// return self

const returnSelf = tstl.createReturnStatement([this.createSelfIdentifier()]);

newFuncStatements.push(returnSelf);

// function className.new(construct, ...) ... end

// or function export.className.new(construct, ...) ... end

const newFunc = tstl.createAssignmentStatement(

tstl.createTableIndexExpression(

createClassNameWithExport(),

tstl.createStringLiteral("new")),

tstl.createFunctionExpression(

tstl.createBlock(newFuncStatements),

undefined,

tstl.createDotsLiteral(),

undefined,

statement

)

);

result.push(newFunc);

return result;

}

public transformClassInstanceFields(

classDeclarataion: ts.ClassLikeDeclaration,

instanceFields: ts.PropertyDeclaration[]

): tstl.Statement[]

{

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

for (const f of instanceFields) {

// Get identifier

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

const value = this.transformExpression(f.initializer);

// self[fieldName]

const selfIndex = tstl.createTableIndexExpression(this.createSelfIdentifier(), fieldName);

// self[fieldName] = value

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

statements.push(assignClassField);

}

const getOverrides = classDeclarataion.members.filter(

m => tsHelper.isGetAccessorOverride(m, classDeclarataion, this.checker)

);

for (const getter of getOverrides) {

const resetGetter = tstl.createExpressionStatement(

tstl.createCallExpression(

tstl.createIdentifier("rawset"),

[this.createSelfIdentifier(), this.transformPropertyName(getter.name), tstl.createNilLiteral()]

)

);

statements.push(resetGetter);

}

return statements;

}

public createConstructorName(className: tstl.Identifier): tstl.TableIndexExpression {

return tstl.createTableIndexExpression(

tstl.createTableIndexExpression(

this.addExportToIdentifier(tstl.cloneIdentifier(className)),

tstl.createStringLiteral("prototype")

),

tstl.createStringLiteral("____constructor")

);

}

public transformConstructor(

statement: ts.ConstructorDeclaration,

className: tstl.Identifier,

instanceFields: ts.PropertyDeclaration[],

classDeclaration: ts.ClassLikeDeclaration

): tstl.AssignmentStatement

{

// Don't transform methods without body (overload declarations)

if (!statement.body) {

return undefined;

}

const bodyStatements: tstl.Statement[] = this.transformClassInstanceFields(classDeclaration, instanceFields);

// Check for field declarations in constructor

const constructorFieldsDeclarations = statement.parameters.filter(p => p.modifiers !== undefined);

// Add in instance field declarations

for (const declaration of constructorFieldsDeclarations) {

const declarationName = this.transformIdentifier(declaration.name as ts.Identifier);

if (declaration.initializer) {

// self.declarationName = declarationName or initializer

const assignement = tstl.createAssignmentStatement(

tstl.createTableIndexExpression(

this.createSelfIdentifier(), tstl.createStringLiteral(declarationName.text)

),

tstl.createBinaryExpression(

declarationName,

this.transformExpression(declaration.initializer), tstl.SyntaxKind.OrOperator

)

);

bodyStatements.push(assignement);

} else {

// self.declarationName = declarationName

const assignement = tstl.createAssignmentStatement(

tstl.createTableIndexExpression(

this.createSelfIdentifier(),

tstl.createStringLiteral(declarationName.text)

),

declarationName

);

bodyStatements.push(assignement);

}

}

// function className.constructor(self, params) ... end

const [params, dotsLiteral, restParamName] = this.transformParameters(

statement.parameters,

this.createSelfIdentifier()

);

const [body] = this.transformFunctionBody(statement.parameters, statement.body, restParamName);

bodyStatements.push(...body);

const block: tstl.Block = tstl.createBlock(bodyStatements);

const result = tstl.createAssignmentStatement(

this.createConstructorName(className),

tstl.createFunctionExpression(block, params, dotsLiteral, restParamName, undefined, undefined),

statement

);