json-as 0.9.29 → 1.0.0-alpha.2

package/transform/lib/builder.js

@@ -0,0 +1,1275 @@
+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);
+    }
+  }
+  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