1 /*
   2  * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package jdk.nashorn.internal.ir.debug;
  27 
  28 import static jdk.nashorn.internal.runtime.Source.sourceFor;
  29 
  30 import java.util.ArrayList;
  31 import java.util.List;
  32 import jdk.nashorn.internal.ir.AccessNode;
  33 import jdk.nashorn.internal.ir.BinaryNode;
  34 import jdk.nashorn.internal.ir.Block;
  35 import jdk.nashorn.internal.ir.BlockStatement;
  36 import jdk.nashorn.internal.ir.BreakNode;
  37 import jdk.nashorn.internal.ir.CallNode;
  38 import jdk.nashorn.internal.ir.CaseNode;
  39 import jdk.nashorn.internal.ir.CatchNode;
  40 import jdk.nashorn.internal.ir.ContinueNode;
  41 import jdk.nashorn.internal.ir.DebuggerNode;
  42 import jdk.nashorn.internal.ir.EmptyNode;
  43 import jdk.nashorn.internal.ir.Expression;
  44 import jdk.nashorn.internal.ir.ExpressionStatement;
  45 import jdk.nashorn.internal.ir.ForNode;
  46 import jdk.nashorn.internal.ir.FunctionNode;
  47 import jdk.nashorn.internal.ir.IdentNode;
  48 import jdk.nashorn.internal.ir.IfNode;
  49 import jdk.nashorn.internal.ir.IndexNode;
  50 import jdk.nashorn.internal.ir.JoinPredecessorExpression;
  51 import jdk.nashorn.internal.ir.LabelNode;
  52 import jdk.nashorn.internal.ir.LexicalContext;
  53 import jdk.nashorn.internal.ir.LiteralNode;
  54 import jdk.nashorn.internal.ir.Node;
  55 import jdk.nashorn.internal.ir.ObjectNode;
  56 import jdk.nashorn.internal.ir.PropertyNode;
  57 import jdk.nashorn.internal.ir.ReturnNode;
  58 import jdk.nashorn.internal.ir.RuntimeNode;
  59 import jdk.nashorn.internal.ir.SplitNode;
  60 import jdk.nashorn.internal.ir.Statement;
  61 import jdk.nashorn.internal.ir.SwitchNode;
  62 import jdk.nashorn.internal.ir.TernaryNode;
  63 import jdk.nashorn.internal.ir.ThrowNode;
  64 import jdk.nashorn.internal.ir.TryNode;
  65 import jdk.nashorn.internal.ir.UnaryNode;
  66 import jdk.nashorn.internal.ir.VarNode;
  67 import jdk.nashorn.internal.ir.WhileNode;
  68 import jdk.nashorn.internal.ir.WithNode;
  69 import jdk.nashorn.internal.ir.visitor.NodeVisitor;
  70 import jdk.nashorn.internal.parser.JSONParser;
  71 import jdk.nashorn.internal.parser.Lexer.RegexToken;
  72 import jdk.nashorn.internal.parser.Parser;
  73 import jdk.nashorn.internal.parser.TokenType;
  74 import jdk.nashorn.internal.runtime.Context;
  75 import jdk.nashorn.internal.runtime.ParserException;
  76 import jdk.nashorn.internal.runtime.Source;
  77 
  78 /**
  79  * This IR writer produces a JSON string that represents AST as a JSON string.
  80  */
  81 public final class JSONWriter extends NodeVisitor<LexicalContext> {
  82 
  83     /**
  84      * Returns AST as JSON compatible string.
  85      *
  86      * @param context context
  87      * @param code code to be parsed
  88      * @param name name of the code source (used for location)
  89      * @param includeLoc tells whether to include location information for nodes or not
  90      * @return JSON string representation of AST of the supplied code
  91      */
  92     public static String parse(final Context context, final String code, final String name, final boolean includeLoc) {
  93         final Parser       parser     = new Parser(context.getEnv(), sourceFor(name, code), new Context.ThrowErrorManager(), context.getEnv()._strict, context.getLogger(Parser.class));
  94         final JSONWriter   jsonWriter = new JSONWriter(includeLoc);
  95         try {
  96             final FunctionNode functionNode = parser.parse(); //symbol name is ":program", default
  97             functionNode.accept(jsonWriter);
  98             return jsonWriter.getString();
  99         } catch (final ParserException e) {
 100             e.throwAsEcmaException();
 101             return null;
 102         }
 103     }
 104 
 105     @Override
 106     public boolean enterJoinPredecessorExpression(final JoinPredecessorExpression joinPredecessorExpression) {
 107         final Expression expr = joinPredecessorExpression.getExpression();
 108         if(expr != null) {
 109             expr.accept(this);
 110         } else {
 111             nullValue();
 112         }
 113         return false;
 114     }
 115 
 116     @Override
 117     protected boolean enterDefault(final Node node) {
 118         objectStart();
 119         location(node);
 120 
 121         return true;
 122     }
 123 
 124     private boolean leave() {
 125         objectEnd();
 126         return false;
 127     }
 128 
 129     @Override
 130     protected Node leaveDefault(final Node node) {
 131         objectEnd();
 132         return null;
 133     }
 134 
 135     @Override
 136     public boolean enterAccessNode(final AccessNode accessNode) {
 137         enterDefault(accessNode);
 138 
 139         type("MemberExpression");
 140         comma();
 141 
 142         property("object");
 143         accessNode.getBase().accept(this);
 144         comma();
 145 
 146         property("property", accessNode.getProperty());
 147         comma();
 148 
 149         property("computed", false);
 150 
 151         return leave();
 152     }
 153 
 154     @Override
 155     public boolean enterBlock(final Block block) {
 156         enterDefault(block);
 157 
 158         type("BlockStatement");
 159         comma();
 160 
 161         array("body", block.getStatements());
 162 
 163         return leave();
 164     }
 165 
 166     @Override
 167     public boolean enterBinaryNode(final BinaryNode binaryNode) {
 168         enterDefault(binaryNode);
 169 
 170         final String name;
 171         if (binaryNode.isAssignment()) {
 172             name = "AssignmentExpression";
 173         } else if (binaryNode.isLogical()) {
 174             name = "LogicalExpression";
 175         } else {
 176             name = "BinaryExpression";
 177         }
 178 
 179         type(name);
 180         comma();
 181 
 182         property("operator", binaryNode.tokenType().getName());
 183         comma();
 184 
 185         property("left");
 186         binaryNode.lhs().accept(this);
 187         comma();
 188 
 189         property("right");
 190         binaryNode.rhs().accept(this);
 191 
 192         return leave();
 193     }
 194 
 195     @Override
 196     public boolean enterBreakNode(final BreakNode breakNode) {
 197         enterDefault(breakNode);
 198 
 199         type("BreakStatement");
 200         comma();
 201 
 202         final String label = breakNode.getLabelName();
 203         if(label != null) {
 204             property("label", label);
 205         } else {
 206             property("label");
 207             nullValue();
 208         }
 209 
 210         return leave();
 211     }
 212 
 213     @Override
 214     public boolean enterCallNode(final CallNode callNode) {
 215         enterDefault(callNode);
 216 
 217         type("CallExpression");
 218         comma();
 219 
 220         property("callee");
 221         callNode.getFunction().accept(this);
 222         comma();
 223 
 224         array("arguments", callNode.getArgs());
 225 
 226         return leave();
 227     }
 228 
 229     @Override
 230     public boolean enterCaseNode(final CaseNode caseNode) {
 231         enterDefault(caseNode);
 232 
 233         type("SwitchCase");
 234         comma();
 235 
 236         final Node test = caseNode.getTest();
 237         property("test");
 238         if (test != null) {
 239             test.accept(this);
 240         } else {
 241             nullValue();
 242         }
 243         comma();
 244 
 245         array("consequent", caseNode.getBody().getStatements());
 246 
 247         return leave();
 248     }
 249 
 250     @Override
 251     public boolean enterCatchNode(final CatchNode catchNode) {
 252         enterDefault(catchNode);
 253 
 254         type("CatchClause");
 255         comma();
 256 
 257         property("param");
 258         catchNode.getException().accept(this);
 259         comma();
 260 
 261         final Node guard = catchNode.getExceptionCondition();
 262         if (guard != null) {
 263             property("guard");
 264             guard.accept(this);
 265             comma();
 266         }
 267 
 268         property("body");
 269         catchNode.getBody().accept(this);
 270 
 271         return leave();
 272     }
 273 
 274     @Override
 275     public boolean enterContinueNode(final ContinueNode continueNode) {
 276         enterDefault(continueNode);
 277 
 278         type("ContinueStatement");
 279         comma();
 280 
 281         final String label = continueNode.getLabelName();
 282         if(label != null) {
 283             property("label", label);
 284         } else {
 285             property("label");
 286             nullValue();
 287         }
 288 
 289         return leave();
 290     }
 291 
 292     @Override
 293     public boolean enterDebuggerNode(final DebuggerNode debuggerNode) {
 294         enterDefault(debuggerNode);
 295         type("DebuggerStatement");
 296         return leave();
 297     }
 298 
 299     @Override
 300     public boolean enterEmptyNode(final EmptyNode emptyNode) {
 301         enterDefault(emptyNode);
 302 
 303         type("EmptyStatement");
 304 
 305         return leave();
 306     }
 307 
 308     @Override
 309     public boolean enterExpressionStatement(final ExpressionStatement expressionStatement) {
 310         // handle debugger statement
 311         final Node expression = expressionStatement.getExpression();
 312         if (expression instanceof RuntimeNode) {
 313             assert false : "should not reach here: RuntimeNode";
 314             return false;
 315         }
 316 
 317         enterDefault(expressionStatement);
 318 
 319         type("ExpressionStatement");
 320         comma();
 321 
 322         property("expression");
 323         expression.accept(this);
 324 
 325         return leave();
 326     }
 327 
 328     @Override
 329     public boolean enterBlockStatement(final BlockStatement blockStatement) {
 330         if (blockStatement.isSynthetic()) {
 331             final Block blk = blockStatement.getBlock();
 332             blk.getStatements().get(0).accept(this);
 333             return false;
 334         }
 335 
 336         enterDefault(blockStatement);
 337 
 338         type("BlockStatement");
 339         comma();
 340 
 341         array("body", blockStatement.getBlock().getStatements());
 342         return leave();
 343     }
 344 
 345     @Override
 346     public boolean enterForNode(final ForNode forNode) {
 347         enterDefault(forNode);
 348 
 349         if (forNode.isForIn() || (forNode.isForEach() && forNode.getInit() != null)) {
 350             type("ForInStatement");
 351             comma();
 352 
 353             final Node init = forNode.getInit();
 354             assert init != null;
 355             property("left");
 356             init.accept(this);
 357             comma();
 358 
 359             final Node modify = forNode.getModify();
 360             assert modify != null;
 361             property("right");
 362             modify.accept(this);
 363             comma();
 364 
 365             property("body");
 366             forNode.getBody().accept(this);
 367             comma();
 368 
 369             property("each", forNode.isForEach());
 370         } else {
 371             type("ForStatement");
 372             comma();
 373 
 374             final Node init = forNode.getInit();
 375             property("init");
 376             if (init != null) {
 377                 init.accept(this);
 378             } else {
 379                 nullValue();
 380             }
 381             comma();
 382 
 383             final Node test = forNode.getTest();
 384             property("test");
 385             if (test != null) {
 386                 test.accept(this);
 387             } else {
 388                 nullValue();
 389             }
 390             comma();
 391 
 392             final Node update = forNode.getModify();
 393             property("update");
 394             if (update != null) {
 395                 update.accept(this);
 396             } else {
 397                 nullValue();
 398             }
 399             comma();
 400 
 401             property("body");
 402             forNode.getBody().accept(this);
 403         }
 404 
 405         return leave();
 406     }
 407 
 408     @Override
 409     public boolean enterFunctionNode(final FunctionNode functionNode) {
 410         final boolean program = functionNode.isProgram();
 411         if (program) {
 412             return emitProgram(functionNode);
 413         }
 414 
 415         enterDefault(functionNode);
 416         final String name;
 417         if (functionNode.isDeclared()) {
 418             name = "FunctionDeclaration";
 419         } else {
 420             name = "FunctionExpression";
 421         }
 422         type(name);
 423         comma();
 424 
 425         property("id");
 426         final FunctionNode.Kind kind = functionNode.getKind();
 427         if (functionNode.isAnonymous() || kind == FunctionNode.Kind.GETTER || kind == FunctionNode.Kind.SETTER) {
 428             nullValue();
 429         } else {
 430             functionNode.getIdent().accept(this);
 431         }
 432         comma();
 433 
 434         array("params", functionNode.getParameters());
 435         comma();
 436 
 437         arrayStart("defaults");
 438         arrayEnd();
 439         comma();
 440 
 441         property("rest");
 442         nullValue();
 443         comma();
 444 
 445         property("body");
 446         functionNode.getBody().accept(this);
 447         comma();
 448 
 449         property("generator", false);
 450         comma();
 451 
 452         property("expression", false);
 453 
 454         return leave();
 455     }
 456 
 457     private boolean emitProgram(final FunctionNode functionNode) {
 458         enterDefault(functionNode);
 459         type("Program");
 460         comma();
 461 
 462         // body consists of nested functions and statements
 463         final List<Statement> stats = functionNode.getBody().getStatements();
 464         final int size = stats.size();
 465         int idx = 0;
 466         arrayStart("body");
 467 
 468         for (final Node stat : stats) {
 469             stat.accept(this);
 470             if (idx != (size - 1)) {
 471                 comma();
 472             }
 473             idx++;
 474         }
 475         arrayEnd();
 476 
 477         return leave();
 478     }
 479 
 480     @Override
 481     public boolean enterIdentNode(final IdentNode identNode) {
 482         enterDefault(identNode);
 483 
 484         final String name = identNode.getName();
 485         if ("this".equals(name)) {
 486             type("ThisExpression");
 487         } else {
 488             type("Identifier");
 489             comma();
 490             property("name", identNode.getName());
 491         }
 492 
 493         return leave();
 494     }
 495 
 496     @Override
 497     public boolean enterIfNode(final IfNode ifNode) {
 498         enterDefault(ifNode);
 499 
 500         type("IfStatement");
 501         comma();
 502 
 503         property("test");
 504         ifNode.getTest().accept(this);
 505         comma();
 506 
 507         property("consequent");
 508         ifNode.getPass().accept(this);
 509         final Node elsePart = ifNode.getFail();
 510         comma();
 511 
 512         property("alternate");
 513         if (elsePart != null) {
 514             elsePart.accept(this);
 515         } else {
 516             nullValue();
 517         }
 518 
 519         return leave();
 520     }
 521 
 522     @Override
 523     public boolean enterIndexNode(final IndexNode indexNode) {
 524         enterDefault(indexNode);
 525 
 526         type("MemberExpression");
 527         comma();
 528 
 529         property("object");
 530         indexNode.getBase().accept(this);
 531         comma();
 532 
 533         property("property");
 534         indexNode.getIndex().accept(this);
 535         comma();
 536 
 537         property("computed", true);
 538 
 539         return leave();
 540     }
 541 
 542     @Override
 543     public boolean enterLabelNode(final LabelNode labelNode) {
 544         enterDefault(labelNode);
 545 
 546         type("LabeledStatement");
 547         comma();
 548 
 549         property("label", labelNode.getLabelName());
 550         comma();
 551 
 552         property("body");
 553         labelNode.getBody().accept(this);
 554 
 555         return leave();
 556     }
 557 
 558     @SuppressWarnings("rawtypes")
 559     @Override
 560     public boolean enterLiteralNode(final LiteralNode literalNode) {
 561         enterDefault(literalNode);
 562 
 563         if (literalNode instanceof LiteralNode.ArrayLiteralNode) {
 564             type("ArrayExpression");
 565             comma();
 566 
 567             array("elements", ((LiteralNode.ArrayLiteralNode)literalNode).getElementExpressions());
 568         } else {
 569             type("Literal");
 570             comma();
 571 
 572             property("value");
 573             final Object value = literalNode.getValue();
 574             if (value instanceof RegexToken) {
 575                 // encode RegExp literals as Strings of the form /.../<flags>
 576                 final RegexToken regex = (RegexToken)value;
 577                 final StringBuilder regexBuf = new StringBuilder();
 578                 regexBuf.append('/');
 579                 regexBuf.append(regex.getExpression());
 580                 regexBuf.append('/');
 581                 regexBuf.append(regex.getOptions());
 582                 buf.append(quote(regexBuf.toString()));
 583             } else {
 584                 final String str = literalNode.getString();
 585                 // encode every String literal with prefix '$' so that script
 586                 // can differentiate b/w RegExps as Strings and Strings.
 587                 buf.append(literalNode.isString()? quote("$" + str) : str);
 588             }
 589         }
 590 
 591         return leave();
 592     }
 593 
 594     @Override
 595     public boolean enterObjectNode(final ObjectNode objectNode) {
 596         enterDefault(objectNode);
 597 
 598         type("ObjectExpression");
 599         comma();
 600 
 601         array("properties", objectNode.getElements());
 602 
 603         return leave();
 604     }
 605 
 606     @Override
 607     public boolean enterPropertyNode(final PropertyNode propertyNode) {
 608         final Node key = propertyNode.getKey();
 609 
 610         final Node value = propertyNode.getValue();
 611         if (value != null) {
 612             objectStart();
 613             location(propertyNode);
 614 
 615             property("key");
 616             key.accept(this);
 617             comma();
 618 
 619             property("value");
 620             value.accept(this);
 621             comma();
 622 
 623             property("kind", "init");
 624 
 625             objectEnd();
 626         } else {
 627             // getter
 628             final Node getter = propertyNode.getGetter();
 629             if (getter != null) {
 630                 objectStart();
 631                 location(propertyNode);
 632 
 633                 property("key");
 634                 key.accept(this);
 635                 comma();
 636 
 637                 property("value");
 638                 getter.accept(this);
 639                 comma();
 640 
 641                 property("kind", "get");
 642 
 643                 objectEnd();
 644             }
 645 
 646             // setter
 647             final Node setter = propertyNode.getSetter();
 648             if (setter != null) {
 649                 if (getter != null) {
 650                     comma();
 651                 }
 652                 objectStart();
 653                 location(propertyNode);
 654 
 655                 property("key");
 656                 key.accept(this);
 657                 comma();
 658 
 659                 property("value");
 660                 setter.accept(this);
 661                 comma();
 662 
 663                 property("kind", "set");
 664 
 665                 objectEnd();
 666             }
 667         }
 668 
 669         return false;
 670     }
 671 
 672     @Override
 673     public boolean enterReturnNode(final ReturnNode returnNode) {
 674         enterDefault(returnNode);
 675 
 676         type("ReturnStatement");
 677         comma();
 678 
 679         final Node arg = returnNode.getExpression();
 680         property("argument");
 681         if (arg != null) {
 682             arg.accept(this);
 683         } else {
 684             nullValue();
 685         }
 686 
 687         return leave();
 688     }
 689 
 690     @Override
 691     public boolean enterRuntimeNode(final RuntimeNode runtimeNode) {
 692         assert false : "should not reach here: RuntimeNode";
 693         return false;
 694     }
 695 
 696     @Override
 697     public boolean enterSplitNode(final SplitNode splitNode) {
 698         assert false : "should reach here: SplitNode";
 699         return false;
 700     }
 701 
 702     @Override
 703     public boolean enterSwitchNode(final SwitchNode switchNode) {
 704         enterDefault(switchNode);
 705 
 706         type("SwitchStatement");
 707         comma();
 708 
 709         property("discriminant");
 710         switchNode.getExpression().accept(this);
 711         comma();
 712 
 713         array("cases", switchNode.getCases());
 714 
 715         return leave();
 716     }
 717 
 718     @Override
 719     public boolean enterTernaryNode(final TernaryNode ternaryNode) {
 720         enterDefault(ternaryNode);
 721 
 722         type("ConditionalExpression");
 723         comma();
 724 
 725         property("test");
 726         ternaryNode.getTest().accept(this);
 727         comma();
 728 
 729         property("consequent");
 730         ternaryNode.getTrueExpression().accept(this);
 731         comma();
 732 
 733         property("alternate");
 734         ternaryNode.getFalseExpression().accept(this);
 735 
 736         return leave();
 737     }
 738 
 739     @Override
 740     public boolean enterThrowNode(final ThrowNode throwNode) {
 741         enterDefault(throwNode);
 742 
 743         type("ThrowStatement");
 744         comma();
 745 
 746         property("argument");
 747         throwNode.getExpression().accept(this);
 748 
 749         return leave();
 750     }
 751 
 752     @Override
 753     public boolean enterTryNode(final TryNode tryNode) {
 754         enterDefault(tryNode);
 755 
 756         type("TryStatement");
 757         comma();
 758 
 759         property("block");
 760         tryNode.getBody().accept(this);
 761         comma();
 762 
 763 
 764         final List<? extends Node> catches = tryNode.getCatches();
 765         final List<CatchNode> guarded = new ArrayList<>();
 766         CatchNode unguarded = null;
 767         if (catches != null) {
 768             for (final Node n : catches) {
 769                 final CatchNode cn = (CatchNode)n;
 770                 if (cn.getExceptionCondition() != null) {
 771                     guarded.add(cn);
 772                 } else {
 773                     assert unguarded == null: "too many unguarded?";
 774                     unguarded = cn;
 775                 }
 776             }
 777         }
 778 
 779         array("guardedHandlers", guarded);
 780         comma();
 781 
 782         property("handler");
 783         if (unguarded != null) {
 784             unguarded.accept(this);
 785         } else {
 786             nullValue();
 787         }
 788         comma();
 789 
 790         property("finalizer");
 791         final Node finallyNode = tryNode.getFinallyBody();
 792         if (finallyNode != null) {
 793             finallyNode.accept(this);
 794         } else {
 795             nullValue();
 796         }
 797 
 798         return leave();
 799     }
 800 
 801     @Override
 802     public boolean enterUnaryNode(final UnaryNode unaryNode) {
 803         enterDefault(unaryNode);
 804 
 805         final TokenType tokenType = unaryNode.tokenType();
 806         if (tokenType == TokenType.NEW) {
 807             type("NewExpression");
 808             comma();
 809 
 810             final CallNode callNode = (CallNode)unaryNode.getExpression();
 811             property("callee");
 812             callNode.getFunction().accept(this);
 813             comma();
 814 
 815             array("arguments", callNode.getArgs());
 816         } else {
 817             final String operator;
 818             final boolean prefix;
 819             switch (tokenType) {
 820             case INCPOSTFIX:
 821                 prefix = false;
 822                 operator = "++";
 823                 break;
 824             case DECPOSTFIX:
 825                 prefix = false;
 826                 operator = "--";
 827                 break;
 828             case INCPREFIX:
 829                 operator = "++";
 830                 prefix = true;
 831                 break;
 832             case DECPREFIX:
 833                 operator = "--";
 834                 prefix = true;
 835                 break;
 836             default:
 837                 prefix = true;
 838                 operator = tokenType.getName();
 839                 break;
 840             }
 841 
 842             type(unaryNode.isAssignment()? "UpdateExpression" : "UnaryExpression");
 843             comma();
 844 
 845             property("operator", operator);
 846             comma();
 847 
 848             property("prefix", prefix);
 849             comma();
 850 
 851             property("argument");
 852             unaryNode.getExpression().accept(this);
 853         }
 854 
 855         return leave();
 856     }
 857 
 858     @Override
 859     public boolean enterVarNode(final VarNode varNode) {
 860         final Node init = varNode.getInit();
 861         if (init instanceof FunctionNode && ((FunctionNode)init).isDeclared()) {
 862             // function declaration - don't emit VariableDeclaration instead
 863             // just emit FunctionDeclaration using 'init' Node.
 864             init.accept(this);
 865             return false;
 866         }
 867 
 868         enterDefault(varNode);
 869 
 870         type("VariableDeclaration");
 871         comma();
 872 
 873         arrayStart("declarations");
 874 
 875         // VariableDeclarator
 876         objectStart();
 877         location(varNode.getName());
 878 
 879         type("VariableDeclarator");
 880         comma();
 881 
 882         property("id");
 883         varNode.getName().accept(this);
 884         comma();
 885 
 886         property("init");
 887         if (init != null) {
 888             init.accept(this);
 889         } else {
 890             nullValue();
 891         }
 892 
 893         // VariableDeclarator
 894         objectEnd();
 895 
 896         // declarations
 897         arrayEnd();
 898 
 899         return leave();
 900     }
 901 
 902     @Override
 903     public boolean enterWhileNode(final WhileNode whileNode) {
 904         enterDefault(whileNode);
 905 
 906         type(whileNode.isDoWhile() ? "DoWhileStatement" : "WhileStatement");
 907         comma();
 908 
 909         if (whileNode.isDoWhile()) {
 910             property("body");
 911             whileNode.getBody().accept(this);
 912             comma();
 913 
 914             property("test");
 915             whileNode.getTest().accept(this);
 916         } else {
 917             property("test");
 918             whileNode.getTest().accept(this);
 919             comma();
 920 
 921             property("body");
 922             whileNode.getBody().accept(this);
 923         }
 924 
 925         return leave();
 926     }
 927 
 928     @Override
 929     public boolean enterWithNode(final WithNode withNode) {
 930         enterDefault(withNode);
 931 
 932         type("WithStatement");
 933         comma();
 934 
 935         property("object");
 936         withNode.getExpression().accept(this);
 937         comma();
 938 
 939         property("body");
 940         withNode.getBody().accept(this);
 941 
 942         return leave();
 943    }
 944 
 945     // Internals below
 946 
 947     private JSONWriter(final boolean includeLocation) {
 948         super(new LexicalContext());
 949         this.buf             = new StringBuilder();
 950         this.includeLocation = includeLocation;
 951     }
 952 
 953     private final StringBuilder buf;
 954     private final boolean includeLocation;
 955 
 956     private String getString() {
 957         return buf.toString();
 958     }
 959 
 960     private void property(final String key, final String value, final boolean escape) {
 961         buf.append('"');
 962         buf.append(key);
 963         buf.append("\":");
 964         if (value != null) {
 965             if (escape) {
 966                 buf.append('"');
 967             }
 968             buf.append(value);
 969             if (escape) {
 970                 buf.append('"');
 971             }
 972         }
 973     }
 974 
 975     private void property(final String key, final String value) {
 976         property(key, value, true);
 977     }
 978 
 979     private void property(final String key, final boolean value) {
 980         property(key, Boolean.toString(value), false);
 981     }
 982 
 983     private void property(final String key, final int value) {
 984         property(key, Integer.toString(value), false);
 985     }
 986 
 987     private void property(final String key) {
 988         property(key, null);
 989     }
 990 
 991     private void type(final String value) {
 992         property("type", value);
 993     }
 994 
 995     private void objectStart(final String name) {
 996         buf.append('"');
 997         buf.append(name);
 998         buf.append("\":{");
 999     }
1000 
1001     private void objectStart() {
1002         buf.append('{');
1003     }
1004 
1005     private void objectEnd() {
1006         buf.append('}');
1007     }
1008 
1009     private void array(final String name, final List<? extends Node> nodes) {
1010         // The size, idx comparison is just to avoid trailing comma..
1011         final int size = nodes.size();
1012         int idx = 0;
1013         arrayStart(name);
1014         for (final Node node : nodes) {
1015             if (node != null) {
1016                 node.accept(this);
1017             } else {
1018                 nullValue();
1019             }
1020             if (idx != (size - 1)) {
1021                 comma();
1022             }
1023             idx++;
1024         }
1025         arrayEnd();
1026     }
1027 
1028     private void arrayStart(final String name) {
1029         buf.append('"');
1030         buf.append(name);
1031         buf.append('"');
1032         buf.append(':');
1033         buf.append('[');
1034     }
1035 
1036     private void arrayEnd() {
1037         buf.append(']');
1038     }
1039 
1040     private void comma() {
1041         buf.append(',');
1042     }
1043 
1044     private void nullValue() {
1045         buf.append("null");
1046     }
1047 
1048     private void location(final Node node) {
1049         if (includeLocation) {
1050             objectStart("loc");
1051 
1052             // source name
1053             final Source src = lc.getCurrentFunction().getSource();
1054             property("source", src.getName());
1055             comma();
1056 
1057             // start position
1058             objectStart("start");
1059             final int start = node.getStart();
1060             property("line", src.getLine(start));
1061             comma();
1062             property("column", src.getColumn(start));
1063             objectEnd();
1064             comma();
1065 
1066             // end position
1067             objectStart("end");
1068             final int end = node.getFinish();
1069             property("line", src.getLine(end));
1070             comma();
1071             property("column", src.getColumn(end));
1072             objectEnd();
1073 
1074             // end 'loc'
1075             objectEnd();
1076 
1077             comma();
1078         }
1079     }
1080 
1081     private static String quote(final String str) {
1082         return JSONParser.quote(str);
1083     }
1084 }