json-as
Version:
The only JSON library you'll need for AssemblyScript. SIMD enabled
1,356 lines • 42.1 kB
JavaScript
import { isTypeOmitted, operatorTokenToString, util } from "assemblyscript/dist/assemblyscript.js";
import { Visitor } from "./visitor.js";
function assert(isTruish, message = "assertion error") {
if (!isTruish)
throw new Error(message);
return isTruish;
}
export class ASTBuilder extends Visitor {
static build(node) {
var builder = new ASTBuilder();
builder.visitNode(node);
return builder.finish();
}
sb = [];
indentLevel = 0;
visitNode(node) {
return this.visit(node);
}
visitSource(source) {
var statements = source.statements;
for (let i = 0, k = statements.length; i < k; ++i) {
this.visitNodeAndTerminate(statements[i]);
}
}
visitTypeNode(node) {
switch (node.kind) {
case 1: {
this.visitNamedTypeNode(node);
break;
}
case 2: {
this.visitFunctionTypeNode(node);
break;
}
default:
assert(false);
}
}
visitThisExpression(node, ref) {
this.sb.push("this");
}
visitTypeName(node) {
this.visitIdentifierExpression(node.identifier);
var sb = this.sb;
var current = node.next;
while (current) {
sb.push(".");
this.visitIdentifierExpression(current.identifier);
current = current.next;
}
}
visitNamedTypeNode(node) {
this.visitTypeName(node.name);
var typeArguments = node.typeArguments;
if (typeArguments) {
let numTypeArguments = typeArguments.length;
let sb = this.sb;
if (numTypeArguments) {
sb.push("<");
this.visitTypeNode(typeArguments[0]);
for (let i = 1; i < numTypeArguments; ++i) {
sb.push(", ");
this.visitTypeNode(typeArguments[i]);
}
sb.push(">");
}
if (node.isNullable)
sb.push(" | null");
}
}
visitFunctionTypeNode(node) {
var isNullable = node.isNullable;
var sb = this.sb;
sb.push(isNullable ? "((" : "(");
var explicitThisType = node.explicitThisType;
if (explicitThisType) {
sb.push("this: ");
this.visitTypeNode(explicitThisType);
}
var parameters = node.parameters;
var numParameters = parameters.length;
if (numParameters) {
if (explicitThisType)
sb.push(", ");
this.serializeParameter(parameters[0]);
for (let i = 1; i < numParameters; ++i) {
sb.push(", ");
this.serializeParameter(parameters[i]);
}
}
var returnType = node.returnType;
if (returnType) {
sb.push(") => ");
this.visitTypeNode(returnType);
}
else {
sb.push(") => void");
}
if (isNullable)
sb.push(") | null");
}
visitTypeParameter(node) {
this.visitIdentifierExpression(node.name);
var extendsType = node.extendsType;
if (extendsType) {
this.sb.push(" extends ");
this.visitTypeNode(extendsType);
}
var defaultType = node.defaultType;
if (defaultType) {
this.sb.push("=");
this.visitTypeNode(defaultType);
}
}
visitIdentifierExpression(node) {
if (node.isQuoted)
this.visitStringLiteral(node.text);
else
this.sb.push(node.text);
}
visitArrayLiteralExpression(node) {
var sb = this.sb;
sb.push("[");
var elements = node.elementExpressions;
var numElements = elements.length;
if (numElements) {
let element = elements[0];
if (element)
this.visitNode(element);
for (let i = 1; i < numElements; ++i) {
element = elements[i];
sb.push(", ");
if (element)
this.visitNode(element);
}
}
sb.push("]");
}
visitObjectLiteralExpression(node) {
var sb = this.sb;
var names = node.names;
var values = node.values;
var numElements = names.length;
assert(numElements == values.length);
if (numElements) {
sb.push("{\n");
util.indent(sb, ++this.indentLevel);
this.visitNode(names[0]);
sb.push(": ");
this.visitNode(values[0]);
for (let i = 1; i < numElements; ++i) {
sb.push(",\n");
util.indent(sb, this.indentLevel);
let name = names[i];
let value = values[i];
if (name == value) {
this.visitNode(name);
}
else {
this.visitNode(name);
sb.push(": ");
this.visitNode(value);
}
}
sb.push("\n");
util.indent(sb, --this.indentLevel);
sb.push("}");
}
else {
sb.push("{}");
}
}
visitAssertionExpression(node) {
var sb = this.sb;
switch (node.assertionKind) {
case 0: {
sb.push("<");
if (node.toType)
this.visitTypeNode(node.toType);
sb.push(">");
this.visitNode(node.expression);
break;
}
case 1: {
this.visitNode(node.expression);
sb.push(" as ");
if (node.toType)
this.visitTypeNode(node.toType);
break;
}
case 2: {
this.visitNode(node.expression);
sb.push("!");
break;
}
case 3: {
this.visitNode(node.expression);
sb.push(" as const");
break;
}
default:
assert(false);
}
}
visitBinaryExpression(node) {
var sb = this.sb;
this.visitNode(node.left);
sb.push(" ");
sb.push(operatorTokenToString(node.operator));
sb.push(" ");
this.visitNode(node.right);
}
visitCallExpression(node) {
this.visitNode(node.expression);
this.visitArguments(node.typeArguments, node.args);
}
visitArguments(typeArguments, args) {
var sb = this.sb;
if (typeArguments) {
let numTypeArguments = typeArguments.length;
if (numTypeArguments) {
sb.push("<");
this.visitTypeNode(typeArguments[0]);
for (let i = 1; i < numTypeArguments; ++i) {
sb.push(", ");
this.visitTypeNode(typeArguments[i]);
}
sb.push(">(");
}
}
else {
sb.push("(");
}
var numArgs = args.length;
if (numArgs) {
this.visitNode(args[0]);
for (let i = 1; i < numArgs; ++i) {
sb.push(", ");
this.visitNode(args[i]);
}
}
sb.push(")");
}
visitClassExpression(node) {
var declaration = node.declaration;
this.visitClassDeclaration(declaration);
}
visitCommaExpression(node) {
var expressions = node.expressions;
var numExpressions = expressions.length;
this.visitNode(expressions[0]);
var sb = this.sb;
for (let i = 1; i < numExpressions; ++i) {
sb.push(",");
this.visitNode(expressions[i]);
}
}
visitElementAccessExpression(node) {
var sb = this.sb;
this.visitNode(node.expression);
sb.push("[");
this.visitNode(node.elementExpression);
sb.push("]");
}
visitFunctionExpression(node) {
var declaration = node.declaration;
if (!declaration.arrowKind) {
if (declaration.name.text.length) {
this.sb.push("function ");
}
else {
this.sb.push("function");
}
}
else {
assert(declaration.name.text.length == 0);
}
this.visitFunctionCommon(declaration);
}
visitLiteralExpression(node) {
switch (node.literalKind) {
case 0: {
this.visitFloatLiteralExpression(node);
break;
}
case 1: {
this.visitIntegerLiteralExpression(node);
break;
}
case 2: {
this.visitStringLiteralExpression(node);
break;
}
case 3: {
this.visitTemplateLiteralExpression(node);
break;
}
case 4: {
this.visitRegexpLiteralExpression(node);
break;
}
case 5: {
this.visitArrayLiteralExpression(node);
break;
}
case 6: {
this.visitObjectLiteralExpression(node);
break;
}
default: {
assert(false);
break;
}
}
}
visitFloatLiteralExpression(node) {
this.sb.push(node.value.toString());
}
visitInstanceOfExpression(node) {
this.visitNode(node.expression);
this.sb.push(" instanceof ");
this.visitTypeNode(node.isType);
}
visitIntegerLiteralExpression(node) {
this.sb.push(i64_to_string(node.value));
}
visitStringLiteral(str) {
var sb = this.sb;
sb.push('"');
this.visitRawString(str, 34);
sb.push('"');
}
visitRawString(str, quote) {
var sb = this.sb;
var off = 0;
var i = 0;
for (let k = str.length; i < k;) {
switch (str.charCodeAt(i)) {
case 0: {
if (i > off)
sb.push(str.substring(off, (off = i + 1)));
sb.push("\\0");
off = ++i;
break;
}
case 92: {
if (i > off)
sb.push(str.substring(off, i));
off = ++i;
sb.push("\\b");
break;
}
case 9: {
if (i > off)
sb.push(str.substring(off, i));
off = ++i;
sb.push("\\t");
break;
}
case 10: {
if (i > off)
sb.push(str.substring(off, i));
off = ++i;
sb.push("\\n");
break;
}
case 11: {
if (i > off)
sb.push(str.substring(off, i));
off = ++i;
sb.push("\\v");
break;
}
case 12: {
if (i > off)
sb.push(str.substring(off, i));
off = ++i;
sb.push("\\f");
break;
}
case 13: {
if (i > off)
sb.push(str.substring(off, i));
sb.push("\\r");
off = ++i;
break;
}
case 34: {
if (quote == 34) {
if (i > off)
sb.push(str.substring(off, i));
sb.push('\\"');
off = ++i;
}
else {
++i;
}
break;
}
case 39: {
if (quote == 39) {
if (i > off)
sb.push(str.substring(off, i));
sb.push("\\'");
off = ++i;
}
else {
++i;
}
break;
}
case 92: {
if (i > off)
sb.push(str.substring(off, i));
sb.push("\\\\");
off = ++i;
break;
}
case 96: {
if (quote == 96) {
if (i > off)
sb.push(str.substring(off, i));
sb.push("\\`");
off = ++i;
}
else {
++i;
}
break;
}
default: {
++i;
break;
}
}
}
if (i > off)
sb.push(str.substring(off, i));
}
visitStringLiteralExpression(node) {
this.visitStringLiteral(node.value);
}
visitTemplateLiteralExpression(node) {
var sb = this.sb;
var tag = node.tag;
var parts = node.parts;
var expressions = node.expressions;
if (tag)
this.visitNode(tag);
sb.push("`");
this.visitRawString(parts[0], 96);
assert(parts.length == expressions.length + 1);
for (let i = 0, k = expressions.length; i < k; ++i) {
sb.push("${");
this.visitNode(expressions[i]);
sb.push("}");
this.visitRawString(parts[i + 1], 96);
}
sb.push("`");
}
visitRegexpLiteralExpression(node) {
var sb = this.sb;
sb.push("/");
sb.push(node.pattern);
sb.push("/");
sb.push(node.patternFlags);
}
visitNewExpression(node) {
this.sb.push("new ");
this.visitTypeName(node.typeName);
this.visitArguments(node.typeArguments, node.args);
}
visitParenthesizedExpression(node) {
var sb = this.sb;
sb.push("(");
this.visitNode(node.expression);
sb.push(")");
}
visitPropertyAccessExpression(node) {
this.visitNode(node.expression);
this.sb.push(".");
this.visitIdentifierExpression(node.property);
}
visitTernaryExpression(node) {
var sb = this.sb;
this.visitNode(node.condition);
sb.push(" ? ");
this.visitNode(node.ifThen);
sb.push(" : ");
this.visitNode(node.ifElse);
}
visitUnaryExpression(node) {
switch (node.kind) {
case 27: {
this.visitUnaryPostfixExpression(node);
break;
}
case 28: {
this.visitUnaryPrefixExpression(node);
break;
}
default:
assert(false);
}
}
visitUnaryPostfixExpression(node) {
this.visitNode(node.operand);
this.sb.push(operatorTokenToString(node.operator));
}
visitUnaryPrefixExpression(node) {
this.sb.push(operatorTokenToString(node.operator));
this.visitNode(node.operand);
}
visitNodeAndTerminate(node) {
this.visitNode(node);
var sb = this.sb;
if (!sb.length ||
node.kind == 47 ||
node.kind == 38) {
sb.push(";\n");
}
else {
let last = sb[sb.length - 1];
let lastCharPos = last.length - 1;
if (lastCharPos >= 0 && (last.charCodeAt(lastCharPos) == 125 || last.charCodeAt(lastCharPos) == 59)) {
sb.push("\n");
}
else {
sb.push(";\n");
}
}
}
visitBlockStatement(node) {
var sb = this.sb;
var statements = node.statements;
var numStatements = statements.length;
if (numStatements) {
sb.push("{\n");
let indentLevel = ++this.indentLevel;
for (let i = 0; i < numStatements; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(statements[i]);
}
util.indent(sb, --this.indentLevel);
sb.push("}");
}
else {
sb.push("{}");
}
}
visitBreakStatement(node) {
var label = node.label;
if (label) {
this.sb.push("break ");
this.visitIdentifierExpression(label);
}
else {
this.sb.push("break");
}
}
visitContinueStatement(node) {
var label = node.label;
if (label) {
this.sb.push("continue ");
this.visitIdentifierExpression(label);
}
else {
this.sb.push("continue");
}
}
visitClassDeclaration(node, isDefault = false) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
var sb = this.sb;
if (isDefault) {
sb.push("export default ");
}
else {
this.serializeExternalModifiers(node);
}
if (node.is(128))
sb.push("abstract ");
if (node.name.text.length) {
sb.push("class ");
this.visitIdentifierExpression(node.name);
}
else {
sb.push("class");
}
var typeParameters = node.typeParameters;
if (typeParameters != null && typeParameters.length > 0) {
sb.push("<");
this.visitTypeParameter(typeParameters[0]);
for (let i = 1, k = typeParameters.length; i < k; ++i) {
sb.push(", ");
this.visitTypeParameter(typeParameters[i]);
}
sb.push(">");
}
var extendsType = node.extendsType;
if (extendsType) {
sb.push(" extends ");
this.visitTypeNode(extendsType);
}
var implementsTypes = node.implementsTypes;
if (implementsTypes) {
let numImplementsTypes = implementsTypes.length;
if (numImplementsTypes) {
sb.push(" implements ");
this.visitTypeNode(implementsTypes[0]);
for (let i = 1; i < numImplementsTypes; ++i) {
sb.push(", ");
this.visitTypeNode(implementsTypes[i]);
}
}
}
var indexSignature = node.indexSignature;
var members = node.members;
var numMembers = members.length;
if (indexSignature !== null || numMembers) {
sb.push(" {\n");
let indentLevel = ++this.indentLevel;
if (indexSignature) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(indexSignature);
}
for (let i = 0, k = members.length; i < k; ++i) {
let member = members[i];
if (member.kind != 54 || member.parameterIndex < 0) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(member);
}
}
util.indent(sb, --this.indentLevel);
sb.push("}");
}
else {
sb.push(" {}");
}
}
visitDoStatement(node) {
var sb = this.sb;
sb.push("do ");
this.visitNode(node.body);
if (node.body.kind == 30) {
sb.push(" while (");
}
else {
util.indent(sb, this.indentLevel);
sb.push("while (");
}
this.visitNode(node.condition);
sb.push(")");
}
visitEmptyStatement(node) {
}
visitEnumDeclaration(node, isDefault = false) {
var sb = this.sb;
if (isDefault) {
sb.push("export default ");
}
else {
this.serializeExternalModifiers(node);
}
if (node.is(8))
sb.push("const ");
sb.push("enum ");
this.visitIdentifierExpression(node.name);
var values = node.values;
var numValues = values.length;
if (numValues) {
sb.push(" {\n");
let indentLevel = ++this.indentLevel;
util.indent(sb, indentLevel);
this.visitEnumValueDeclaration(node.values[0]);
for (let i = 1; i < numValues; ++i) {
sb.push(",\n");
util.indent(sb, indentLevel);
this.visitEnumValueDeclaration(node.values[i]);
}
sb.push("\n");
util.indent(sb, --this.indentLevel);
sb.push("}");
}
else {
sb.push(" {}");
}
}
visitEnumValueDeclaration(node) {
this.visitIdentifierExpression(node.name);
var initializer = node.initializer;
if (initializer) {
this.sb.push(" = ");
this.visitNode(initializer);
}
}
visitExportImportStatement(node) {
var sb = this.sb;
sb.push("export import ");
this.visitIdentifierExpression(node.externalName);
sb.push(" = ");
this.visitIdentifierExpression(node.name);
}
visitExportMember(node) {
this.visitIdentifierExpression(node.localName);
if (node.exportedName.text != node.localName.text) {
this.sb.push(" as ");
this.visitIdentifierExpression(node.exportedName);
}
}
visitExportStatement(node) {
var sb = this.sb;
if (node.isDeclare) {
sb.push("declare ");
}
var members = node.members;
if (members == null) {
sb.push("export *");
}
else if (members.length > 0) {
let numMembers = members.length;
sb.push("export {\n");
let indentLevel = ++this.indentLevel;
util.indent(sb, indentLevel);
this.visitExportMember(members[0]);
for (let i = 1; i < numMembers; ++i) {
sb.push(",\n");
util.indent(sb, indentLevel);
this.visitExportMember(members[i]);
}
--this.indentLevel;
sb.push("\n}");
}
else {
sb.push("export {}");
}
var path = node.path;
if (path) {
sb.push(" from ");
this.visitStringLiteralExpression(path);
}
sb.push(";");
}
visitExportDefaultStatement(node) {
var declaration = node.declaration;
switch (declaration.kind) {
case 52: {
this.visitEnumDeclaration(declaration, true);
break;
}
case 55: {
this.visitFunctionDeclaration(declaration, true);
break;
}
case 51: {
this.visitClassDeclaration(declaration, true);
break;
}
case 57: {
this.visitInterfaceDeclaration(declaration, true);
break;
}
case 59: {
this.visitNamespaceDeclaration(declaration, true);
break;
}
default:
assert(false);
}
}
visitExpressionStatement(node) {
this.visitNode(node.expression);
}
visitFieldDeclaration(node) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
this.serializeAccessModifiers(node);
this.visitIdentifierExpression(node.name);
var sb = this.sb;
if (node.flags & 16384) {
sb.push("!");
}
var type = node.type;
if (type) {
sb.push(": ");
this.visitTypeNode(type);
}
var initializer = node.initializer;
if (initializer) {
sb.push(" = ");
this.visitNode(initializer);
}
}
visitForStatement(node) {
var sb = this.sb;
sb.push("for (");
var initializer = node.initializer;
if (initializer) {
this.visitNode(initializer);
}
var condition = node.condition;
if (condition) {
sb.push("; ");
this.visitNode(condition);
}
else {
sb.push(";");
}
var incrementor = node.incrementor;
if (incrementor) {
sb.push("; ");
this.visitNode(incrementor);
}
else {
sb.push(";");
}
sb.push(") ");
this.visitNode(node.body);
}
visitForOfStatement(node) {
var sb = this.sb;
sb.push("for (");
this.visitNode(node.variable);
sb.push(" of ");
this.visitNode(node.iterable);
sb.push(") ");
this.visitNode(node.body);
}
visitFunctionDeclaration(node, isDefault = false) {
var sb = this.sb;
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
if (isDefault) {
sb.push("export default ");
}
else {
this.serializeExternalModifiers(node);
this.serializeAccessModifiers(node);
}
if (node.name.text.length) {
sb.push("function ");
}
else {
sb.push("function");
}
this.visitFunctionCommon(node);
}
visitFunctionCommon(node) {
var sb = this.sb;
this.visitIdentifierExpression(node.name);
var signature = node.signature;
var typeParameters = node.typeParameters;
if (typeParameters) {
let numTypeParameters = typeParameters.length;
if (numTypeParameters) {
sb.push("<");
this.visitTypeParameter(typeParameters[0]);
for (let i = 1; i < numTypeParameters; ++i) {
sb.push(", ");
this.visitTypeParameter(typeParameters[i]);
}
sb.push(">");
}
}
if (node.arrowKind == 2) {
let parameters = signature.parameters;
assert(parameters.length == 1);
assert(!signature.explicitThisType);
this.serializeParameter(parameters[0]);
}
else {
sb.push("(");
let parameters = signature.parameters;
let numParameters = parameters.length;
let explicitThisType = signature.explicitThisType;
if (explicitThisType) {
sb.push("this: ");
this.visitTypeNode(explicitThisType);
}
if (numParameters) {
if (explicitThisType)
sb.push(", ");
this.serializeParameter(parameters[0]);
for (let i = 1; i < numParameters; ++i) {
sb.push(", ");
this.serializeParameter(parameters[i]);
}
}
}
var body = node.body;
var returnType = signature.returnType;
if (node.arrowKind) {
if (body) {
if (node.arrowKind == 2) {
assert(isTypeOmitted(returnType));
}
else {
if (isTypeOmitted(returnType)) {
sb.push(")");
}
else {
sb.push("): ");
this.visitTypeNode(returnType);
}
}
sb.push(" => ");
this.visitNode(body);
}
else {
assert(!isTypeOmitted(returnType));
sb.push(" => ");
this.visitTypeNode(returnType);
}
}
else {
if (!isTypeOmitted(returnType) && !node.isAny(524288 | 4096)) {
sb.push("): ");
this.visitTypeNode(returnType);
}
else {
sb.push(")");
}
if (body) {
sb.push(" ");
this.visitNode(body);
}
}
}
visitIfStatement(node) {
var sb = this.sb;
sb.push("if (");
this.visitNode(node.condition);
sb.push(") ");
var ifTrue = node.ifTrue;
this.visitNode(ifTrue);
if (ifTrue.kind != 30) {
sb.push(";\n");
}
var ifFalse = node.ifFalse;
if (ifFalse) {
if (ifTrue.kind == 30) {
sb.push(" else ");
}
else {
sb.push("else ");
}
this.visitNode(ifFalse);
}
}
visitImportDeclaration(node) {
var externalName = node.foreignName;
var name = node.name;
this.visitIdentifierExpression(externalName);
if (externalName.text != name.text) {
this.sb.push(" as ");
this.visitIdentifierExpression(name);
}
}
visitImportStatement(node) {
var sb = this.sb;
sb.push("import ");
var declarations = node.declarations;
var namespaceName = node.namespaceName;
if (declarations) {
let numDeclarations = declarations.length;
if (numDeclarations) {
sb.push("{\n");
let indentLevel = ++this.indentLevel;
util.indent(sb, indentLevel);
this.visitImportDeclaration(declarations[0]);
for (let i = 1; i < numDeclarations; ++i) {
sb.push(",\n");
util.indent(sb, indentLevel);
this.visitImportDeclaration(declarations[i]);
}
--this.indentLevel;
sb.push("\n} from ");
}
else {
sb.push("{} from ");
}
}
else if (namespaceName) {
sb.push("* as ");
this.visitIdentifierExpression(namespaceName);
sb.push(" from ");
}
this.visitStringLiteralExpression(node.path);
}
visitIndexSignature(node) {
var sb = this.sb;
sb.push("[key: ");
this.visitTypeNode(node.keyType);
sb.push("]: ");
this.visitTypeNode(node.valueType);
}
visitInterfaceDeclaration(node, isDefault = false) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
var sb = this.sb;
if (isDefault) {
sb.push("export default ");
}
else {
this.serializeExternalModifiers(node);
}
sb.push("interface ");
this.visitIdentifierExpression(node.name);
var typeParameters = node.typeParameters;
if (typeParameters != null && typeParameters.length > 0) {
sb.push("<");
this.visitTypeParameter(typeParameters[0]);
for (let i = 1, k = typeParameters.length; i < k; ++i) {
sb.push(", ");
this.visitTypeParameter(typeParameters[i]);
}
sb.push(">");
}
var extendsType = node.extendsType;
if (extendsType) {
sb.push(" extends ");
this.visitTypeNode(extendsType);
}
sb.push(" {\n");
var indentLevel = ++this.indentLevel;
var members = node.members;
for (let i = 0, k = members.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(members[i]);
}
--this.indentLevel;
sb.push("}");
}
visitMethodDeclaration(node) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
this.serializeAccessModifiers(node);
if (node.is(2048)) {
this.sb.push("get ");
}
else if (node.is(4096)) {
this.sb.push("set ");
}
this.visitFunctionCommon(node);
}
visitNamespaceDeclaration(node, isDefault = false) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
var sb = this.sb;
if (isDefault) {
sb.push("export default ");
}
else {
this.serializeExternalModifiers(node);
}
sb.push("namespace ");
this.visitIdentifierExpression(node.name);
var members = node.members;
var numMembers = members.length;
if (numMembers) {
sb.push(" {\n");
let indentLevel = ++this.indentLevel;
for (let i = 0, k = members.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(members[i]);
}
util.indent(sb, --this.indentLevel);
sb.push("}");
}
else {
sb.push(" {}");
}
}
visitReturnStatement(node) {
var value = node.value;
if (value) {
this.sb.push("return ");
this.visitNode(value);
}
else {
this.sb.push("return");
}
}
visitTrueExpression(node) {
this.sb.push("true");
}
visitFalseExpression(node) {
this.sb.push("false");
}
visitNullExpression(node) {
this.sb.push("null");
}
visitSwitchCase(node) {
var sb = this.sb;
var label = node.label;
if (label) {
sb.push("case ");
this.visitNode(label);
sb.push(":\n");
}
else {
sb.push("default:\n");
}
var statements = node.statements;
var numStatements = statements.length;
if (numStatements) {
let indentLevel = ++this.indentLevel;
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(statements[0]);
for (let i = 1; i < numStatements; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(statements[i]);
}
--this.indentLevel;
}
}
visitSwitchStatement(node) {
var sb = this.sb;
sb.push("switch (");
this.visitNode(node.condition);
sb.push(") {\n");
var indentLevel = ++this.indentLevel;
var cases = node.cases;
for (let i = 0, k = cases.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitSwitchCase(cases[i]);
sb.push("\n");
}
--this.indentLevel;
sb.push("}");
}
visitThrowStatement(node) {
this.sb.push("throw ");
this.visitNode(node.value);
}
visitTryStatement(node) {
var sb = this.sb;
sb.push("try {\n");
var indentLevel = ++this.indentLevel;
var statements = node.bodyStatements;
for (let i = 0, k = statements.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(statements[i]);
}
var catchVariable = node.catchVariable;
if (catchVariable) {
util.indent(sb, indentLevel - 1);
sb.push("} catch (");
this.visitIdentifierExpression(catchVariable);
sb.push(") {\n");
let catchStatements = node.catchStatements;
if (catchStatements) {
for (let i = 0, k = catchStatements.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(catchStatements[i]);
}
}
}
var finallyStatements = node.finallyStatements;
if (finallyStatements) {
util.indent(sb, indentLevel - 1);
sb.push("} finally {\n");
for (let i = 0, k = finallyStatements.length; i < k; ++i) {
util.indent(sb, indentLevel);
this.visitNodeAndTerminate(finallyStatements[i]);
}
}
util.indent(sb, indentLevel - 1);
sb.push("}");
}
visitTypeDeclaration(node) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
var sb = this.sb;
this.serializeExternalModifiers(node);
sb.push("type ");
this.visitIdentifierExpression(node.name);
var typeParameters = node.typeParameters;
if (typeParameters) {
let numTypeParameters = typeParameters.length;
if (numTypeParameters) {
sb.push("<");
for (let i = 0; i < numTypeParameters; ++i) {
this.visitTypeParameter(typeParameters[i]);
}
sb.push(">");
}
}
sb.push(" = ");
this.visitTypeNode(node.type);
}
visitVariableDeclaration(node) {
this.visitIdentifierExpression(node.name);
var type = node.type;
var sb = this.sb;
if (node.flags & 16384) {
sb.push("!");
}
if (type) {
sb.push(": ");
this.visitTypeNode(type);
}
var initializer = node.initializer;
if (initializer) {
sb.push(" = ");
this.visitNode(initializer);
}
}
visitVariableStatement(node) {
var decorators = node.decorators;
if (decorators) {
for (let i = 0, k = decorators.length; i < k; ++i) {
this.serializeDecorator(decorators[i]);
}
}
var sb = this.sb;
var declarations = node.declarations;
var numDeclarations = declarations.length;
var firstDeclaration = declarations[0];
this.serializeExternalModifiers(firstDeclaration);
sb.push(firstDeclaration.is(8) ? "const " : firstDeclaration.is(16) ? "let " : "var ");
this.visitVariableDeclaration(node.declarations[0]);
for (let i = 1; i < numDeclarations; ++i) {
sb.push(", ");
this.visitVariableDeclaration(node.declarations[i]);
}
}
visitWhileStatement(node) {
var sb = this.sb;
sb.push("while (");
this.visitNode(node.condition);
var statement = node.body;
if (statement.kind == 34) {
sb.push(")");
}
else {
sb.push(") ");
this.visitNode(node.body);
}
}
serializeDecorator(node) {
var sb = this.sb;
sb.push("@");
this.visitNode(node.name);
var args = node.args;
if (args) {
sb.push("(");
let numArgs = args.length;
if (numArgs) {
this.visitNode(args[0]);
for (let i = 1; i < numArgs; ++i) {
sb.push(", ");
this.visitNode(args[i]);
}
}
sb.push(")\n");
}
else {
sb.push("\n");
}
util.indent(sb, this.indentLevel);
}
serializeParameter(node) {
var sb = this.sb;
var kind = node.parameterKind;
var implicitFieldDeclaration = node.implicitFieldDeclaration;
if (implicitFieldDeclaration) {
this.serializeAccessModifiers(implicitFieldDeclaration);
}
if (kind == 2) {
sb.push("...");
}
this.visitIdentifierExpression(node.name);
var type = node.type;
var initializer = node.initializer;
if (type) {
if (kind == 1 && !initializer)
sb.push("?");
if (!isTypeOmitted(type)) {
sb.push(": ");
this.visitTypeNode(type);
}
}
if (initializer) {
sb.push(" = ");
this.visitNode(initializer);
}
}
serializeExternalModifiers(node) {
var sb = this.sb;
if (node.is(2)) {
sb.push("export ");
}
else if (node.is(1)) {
sb.push("import ");
}
else if (node.is(4)) {
sb.push("declare ");
}
}
serializeAccessModifiers(node) {
var sb = this.sb;
if (node.is(256)) {
sb.push("public ");
}
else if (node.is(512)) {
sb.push("private ");
}
else if (node.is(1024)) {
sb.push("protected ");
}
if (node.is(32)) {
sb.push("static ");
}
else if (node.is(128)) {
sb.push("abstract ");
}
if (node.is(64)) {
sb.push("readonly ");
}
}
finish() {
var ret = this.sb.join("");
this.sb = [];
return ret;
}
}
//# sourceMappingURL=builder.js.map