docs: public Node transform(AstNode node) {
          switch (node.getType()) {
            case Token.ARRAYCOMP:
                return transformArrayComp((ArrayComprehension)node);
            case Token.ARRAYLIT:
                return transformArrayLiteral((ArrayLiteral)node);
            case Token.BLOCK:
                return transformBlock(node);
            case Token.BREAK:
                return transformBreak((BreakStatement)node);
            case Token.CALL:
                return transformFunctionCall((FunctionCall)node);
            case Token.CONTINUE:
                return transformContinue((ContinueStatement)node);
            case Token.DO:
                return transformDoLoop((DoLoop)node);
            case Token.EMPTY:
                return node;
            case Token.FOR:
                if (node instanceof ForInLoop) {
                    return transformForInLoop((ForInLoop)node);
                }
                return transformForLoop((ForLoop)node);
            case Token.FUNCTION:
                return transformFunction((FunctionNode)node);
            case Token.GENEXPR:
                return transformGenExpr((GeneratorExpression)node);
            case Token.GETELEM:
                return transformElementGet((ElementGet)node);
            case Token.GETPROP:
                return transformPropertyGet((PropertyGet)node);
            case Token.HOOK:
                return transformCondExpr((ConditionalExpression)node);
            case Token.IF:
                return transformIf((IfStatement)node);
  
            case Token.TRUE:
            case Token.FALSE:
            case Token.THIS:
            case Token.NULL:
            case Token.DEBUGGER:
                return transformLiteral(node);
  
            case Token.NAME:
                return transformName((Name)node);
            case Token.NUMBER:
                return transformNumber((NumberLiteral)node);
            case Token.NEW:
                return transformNewExpr((NewExpression)node);
            case Token.OBJECTLIT:
                return transformObjectLiteral((ObjectLiteral)node);
            case Token.REGEXP:
                return transformRegExp((RegExpLiteral)node);
            case Token.RETURN:
                return transformReturn((ReturnStatement)node);
            case Token.SCRIPT:
                return transformScript((ScriptNode)node);
            case Token.STRING:
                return transformString((StringLiteral)node);
            case Token.SWITCH:
                return transformSwitch((SwitchStatement)node);
            case Token.THROW:
                return transformThrow((ThrowStatement)node);
            case Token.TRY:
                return transformTry((TryStatement)node);
            case Token.WHILE:
                return transformWhileLoop((WhileLoop)node);
            case Token.WITH:
                return transformWith((WithStatement)node);
            case Token.YIELD:
                return transformYield((Yield)node);
            default:
                if (node instanceof ExpressionStatement) {
                    return transformExprStmt((ExpressionStatement)node);
                }
                if (node instanceof Assignment) {
                    return transformAssignment((Assignment)node);
                }
                if (node instanceof UnaryExpression) {
                    return transformUnary((UnaryExpression)node);
                }
                if (node instanceof XmlMemberGet) {
                    return transformXmlMemberGet((XmlMemberGet)node);
                }
                if (node instanceof InfixExpression) {
                    return transformInfix((InfixExpression)node);
                }
                if (node instanceof VariableDeclaration) {
                    return transformVariables((VariableDeclaration)node);
                }
                if (node instanceof ParenthesizedExpression) {
                    return transformParenExpr((ParenthesizedExpression)node);
                }
                if (node instanceof LabeledStatement) {
                    return transformLabeledStatement((LabeledStatement)node);
                }
                if (node instanceof LetNode) {
                    return transformLetNode((LetNode)node);
                }
                if (node instanceof XmlRef) {
                    return transformXmlRef((XmlRef)node);
                }
                if (node instanceof XmlLiteral) {
                    return transformXmlLiteral((XmlLiteral)node);
                }
                throw new IllegalArgumentException("Can't transform: " + node);
          }
      }