import * as ts from "typescript";

import { CompilerOptions } from "./CommandLineParser";

import * as path from "path";

this.namespace = [];

this.importCount = 0;

this.sourceFile = sourceFile;

}

public pushIndent(): void {

public transpileNamespace(node: ts.ModuleDeclaration): string {

// If phantom namespace just transpile the body as normal

return this.transpileNode(node.body);

}

let result = "";

const type = this.checker.getTypeAtLocation(node);

if (!membersOnly) {

const name = node.name.escapedText;

const expression = this.transpileExpression(node.expression);

// Use ipairs for array types, pairs otherwise

const pairs = isArray ? "ipairs" : "pairs";

// Make header

// Transpile expression

const expression = this.transpileExpression(node.expression);

throw new TranspileError("Iterating over arrays with 'for in' is not allowed.", node);

}

this.transpilingSwitch--;

let i = index + 1;

let nextClause = clauses[i];

while (i < clauses.length

&& ts.isCaseClause(nextClause)

if (node.expression) {

// If parent function is a TupleReturn function

// and return expression is an array literal, leave out brackets.

&& ts.isArrayLiteralExpression(node.expression)) {

return "return " + node.expression.elements.map(elem => this.transpileExpression(elem)).join(",");

}

return this.transpileExpression((node as ts.AsExpression).expression);

default:

throw new TranspileError(

node

);

}

result = `bit.band(${lhs},${rhs})`;

break;

case ts.SyntaxKind.AmpersandEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression,

`bit.band(${lhs},${rhs})`);

}

result = `bit.bor(${lhs},${rhs})`;

break;

case ts.SyntaxKind.BarEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression,

`bit.bor(${lhs},${rhs})`);

}

result = `bit.lshift(${lhs},${rhs})`;

break;

case ts.SyntaxKind.LessThanLessThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression,

`bit.lshift(${lhs},${rhs})`);

}

result = `bit.arshift(${lhs},${rhs})`;

break;

case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression,

`bit.arshift(${lhs},${rhs})`);

}

result = `bit.rshift(${lhs},${rhs})`;

break;

case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression,

`bit.rshift(${lhs},${rhs})`);

}

result = `${lhs}&${rhs}`;

break;

case ts.SyntaxKind.AmpersandEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}&${rhs}`);

}

result = `${lhs}=${lhs}&${rhs}`;

result = `${lhs}|${rhs}`;

break;

case ts.SyntaxKind.BarEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}|${rhs}`);

}

result = `${lhs}=${lhs}|${rhs}`;

result = `${lhs}<<${rhs}`;

break;

case ts.SyntaxKind.LessThanLessThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}<<${rhs}`);

}

result = `${lhs}=${lhs}<<${rhs}`;

result = `${lhs}>>${rhs}`;

break;

case ts.SyntaxKind.GreaterThanGreaterThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}>>${rhs}`);

}

result = `${lhs}=${lhs}>>${rhs}`;

result = `${lhs}>>>${rhs}`;

break;

case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}>>>${rhs}`);

}

result = `${lhs}=${lhs}>>>${rhs}`;

if (result === "") {

switch (node.operatorToken.kind) {

case ts.SyntaxKind.PlusEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}+${rhs}`);

}

result = `${lhs}=${lhs}+${rhs}`;

break;

case ts.SyntaxKind.MinusEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}-${rhs}`);

}

result = `${lhs}=${lhs}-${rhs}`;

break;

case ts.SyntaxKind.AsteriskEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}*${rhs}`);

}

result = `${lhs}=${lhs}*${rhs}`;

break;

case ts.SyntaxKind.SlashEqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, `${lhs}/${rhs}`);

}

result = `${lhs}=${lhs}/${rhs}`;

result = `${lhs}<=${rhs}`;

break;

case ts.SyntaxKind.EqualsToken:

return this.transpileSetAccessor(node.left as ts.PropertyAccessExpression, rhs);

}

result = `${lhs}=${rhs}`;

case ts.SyntaxKind.MinusMinusToken:

return `${operand}=${operand}-1`;

default:

}

}

case ts.SyntaxKind.MinusToken:

return `-${operand}`;

default:

}

}

return this.transpileStringCallExpression(node);

}

return this.transpileArrayCallExpression(node);

}

case ts.TypeFlags.StringLiteral:

return this.transpileStringProperty(node);

case ts.TypeFlags.Object:

return this.transpileArrayProperty(node);

return this.transpileGetAccessor(node);

}

}

// Do not output path for member only enums

return property;

}

const index = this.transpileExpression(node.argumentExpression);

const type = this.checker.getTypeAtLocation(node.expression);

return `${element}[${index}+1]`;

return `string.sub(${element},${index}+1,${index}+1)`;

} else {

return `${element}[${index}]`;

// Don't unpack TupleReturn decorated functions

if (ts.isCallExpression(node.initializer)

) {

return `local ${vars}=${value}\n`;

} else {

return `local ${vars}=unpack(${value})\n`;

}

} else {

throw new TranspileError(

node

);

}

if (clause.token === ts.SyntaxKind.ExtendsKeyword) {

const superType = this.checker.getTypeAtLocation(clause.types[0]);

// Ignore purely abstract types (decorated with /** @PureAbstract */)

extendsType = clause.types[0];

}

}

});

}

let result = "";

// Skip header if this is an extension class

if (!isExtension) {

// Write class declaration

const classOr = noClassOr ? "" : `${className} or `;