as-test 0.4.0 → 0.4.2

package/transform/lib/builder.js

@@ -0,0 +1,1361 @@
+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