node_dump.c

   1 /**********************************************************************
   2
   3   node_dump.c - dump ruby node tree
   4
   5   $Author: mame $
   6   created at: 09/12/06 21:23:44 JST
   7
   8   Copyright (C) 2009 Yusuke Endoh
   9
  10 **********************************************************************/
  11
  12 #include "internal.h"
  13 #include "internal/class.h"
  14 #include "internal/hash.h"
  15 #include "internal/ruby_parser.h"
  16 #include "internal/variable.h"
  17 #include "ruby/ruby.h"
  18 #include "vm_core.h"
  19
  20 #define A(str) rb_str_cat2(buf, (str))
  21 #define AR(str) rb_str_concat(buf, (str))
  22
  23 #define A_INDENT add_indent(buf, indent)
  24 #define D_INDENT rb_str_cat2(indent, next_indent)
  25 #define D_DEDENT rb_str_resize(indent, RSTRING_LEN(indent) - 4)
  26 #define A_ID(id) add_id(buf, (id))
  27 #define A_INT(val) rb_str_catf(buf, "%d", (val))
  28 #define A_LONG(val) rb_str_catf(buf, "%ld", (val))
  29 #define A_LIT(lit) AR(rb_dump_literal(lit))
  30 #define A_LOC(loc) \
  31     rb_str_catf(buf, "(%d,%d)-(%d,%d)", \
  32                 loc.beg_pos.lineno, loc.beg_pos.column, \
  33                 loc.end_pos.lineno, loc.end_pos.column)
  34 #define A_NODE_HEADER(node, term) \
  35     rb_str_catf(buf, "@ %s (id: %d, line: %d, location: (%d,%d)-(%d,%d))%s"term, \
  36                 ruby_node_name(nd_type(node)), nd_node_id(node), nd_line(node), \
  37                 nd_first_lineno(node), nd_first_column(node), \
  38                 nd_last_lineno(node), nd_last_column(node), \
  39                 (nd_fl_newline(node) ? "*" : ""))
  40 #define A_FIELD_HEADER(len, name, term) \
  41     rb_str_catf(buf, "+- %.*s:"term, (len), (name))
  42 #define D_FIELD_HEADER(len, name, term) (A_INDENT, A_FIELD_HEADER(len, name, term))
  43
  44 #define D_NULL_NODE (A_INDENT, A("(null node)\n"))
  45 #define D_NODE_HEADER(node) (A_INDENT, A_NODE_HEADER(node, "\n"))
  46
  47 #define COMPOUND_FIELD(len, name) \
  48     FIELD_BLOCK((D_FIELD_HEADER((len), (name), "\n"), D_INDENT), D_DEDENT)
  49
  50 #define COMPOUND_FIELD1(name, ann) \
  51     COMPOUND_FIELD(FIELD_NAME_LEN(name, ann), \
  52                    FIELD_NAME_DESC(name, ann))
  53
  54 #define FIELD_NAME_DESC(name, ann) name " (" ann ")"
  55 #define FIELD_NAME_LEN(name, ann) (int)( \
  56         comment ? \
  57         rb_strlen_lit(FIELD_NAME_DESC(name, ann)) : \
  58         rb_strlen_lit(name))
  59 #define SIMPLE_FIELD(len, name) \
  60     FIELD_BLOCK(D_FIELD_HEADER((len), (name), " "), A("\n"))
  61
  62 #define FIELD_BLOCK(init, reset) \
  63     for (init, field_flag = 1; \
  64          field_flag; /* should be optimized away */ \
  65          reset, field_flag = 0)
  66
  67 #define A_SHAREABILITY(shareability) \
  68     switch (shareability) { \
  69       case rb_parser_shareable_none: \
  70         rb_str_cat_cstr(buf, "none"); \
  71         break; \
  72       case rb_parser_shareable_literal: \
  73         rb_str_cat_cstr(buf, "literal"); \
  74         break; \
  75       case rb_parser_shareable_copy: \
  76         rb_str_cat_cstr(buf, "experimental_copy"); \
  77         break; \
  78       case rb_parser_shareable_everything: \
  79         rb_str_cat_cstr(buf, "experimental_everything"); \
  80         break; \
  81     }
  82
  83 #define SIMPLE_FIELD1(name, ann)    SIMPLE_FIELD(FIELD_NAME_LEN(name, ann), FIELD_NAME_DESC(name, ann))
  84 #define F_CUSTOM1(name, ann)        SIMPLE_FIELD1(#name, ann)
  85 #define F_ID(name, type, ann)       SIMPLE_FIELD1(#name, ann) A_ID(type(node)->name)
  86 #define F_INT(name, type, ann)      SIMPLE_FIELD1(#name, ann) A_INT(type(node)->name)
  87 #define F_LONG(name, type, ann)     SIMPLE_FIELD1(#name, ann) A_LONG(type(node)->name)
  88 #define F_LIT(name, type, ann)      SIMPLE_FIELD1(#name, ann) A_LIT(type(node)->name)
  89 #define F_VALUE(name, val, ann)     SIMPLE_FIELD1(#name, ann) A_LIT(val)
  90 #define F_MSG(name, ann, desc)      SIMPLE_FIELD1(#name, ann) A(desc)
  91 #define F_LOC(name, type)           SIMPLE_FIELD1(#name, "")  A_LOC(type(node)->name)
  92 #define F_SHAREABILITY(name, type, ann) SIMPLE_FIELD1(#name, ann) A_SHAREABILITY(type(node)->name)
  93
  94 #define F_NODE(name, type, ann) \
  95     COMPOUND_FIELD1(#name, ann) {dump_node(buf, indent, comment, RNODE(type(node)->name));}
  96
  97 #define F_NODE2(name, n, ann) \
  98     COMPOUND_FIELD1(#name, ann) {dump_node(buf, indent, comment, n);}
  99
 100 #define F_ARRAY(name, type, ann) \
 101     COMPOUND_FIELD1(#name, ann) {dump_parser_array(buf, indent, comment, type(node)->name);}
 102
 103 #define ANN(ann) \
 104     if (comment) { \
 105         A_INDENT; A("| # " ann "\n"); \
 106     }
 107
 108 #define LAST_NODE (next_indent = "    ")
 109
 110 VALUE
 111 rb_dump_literal(VALUE lit)
 112 {
 113     if (!RB_SPECIAL_CONST_P(lit)) {
 114         VALUE str;
 115         switch (RB_BUILTIN_TYPE(lit)) {
 116           case T_CLASS: case T_MODULE: case T_ICLASS:
 117             str = rb_class_path(lit);
 118             if (RCLASS_SINGLETON_P(lit)) {
 119                 str = rb_sprintf("<%"PRIsVALUE">", str);
 120             }
 121             return str;
 122           default:
 123             break;
 124         }
 125     }
 126     return rb_inspect(lit);
 127 }
 128
 129 static void
 130 add_indent(VALUE buf, VALUE indent)
 131 {
 132     AR(indent);
 133 }
 134
 135 static void
 136 add_id(VALUE buf, ID id)
 137 {
 138     if (id == 0) {
 139         A("(null)");
 140     }
 141     else {
 142         VALUE str = rb_id2str(id);
 143         if (str) {
 144             A(":"); AR(str);
 145         }
 146         else {
 147             rb_str_catf(buf, "(internal variable: 0x%"PRIsVALUE")", id);
 148         }
 149     }
 150 }
 151
 152 struct add_option_arg {
 153     VALUE buf, indent;
 154     st_index_t count;
 155 };
 156
 157 static void dump_node(VALUE, VALUE, int, const NODE *);
 158 static const char default_indent[] = "|   ";
 159
 160 static void
 161 dump_array(VALUE buf, VALUE indent, int comment, const NODE *node)
 162 {
 163     int field_flag;
 164     const char *next_indent = default_indent;
 165     F_LONG(as.nd_alen, RNODE_LIST, "length");
 166     F_NODE(nd_head, RNODE_LIST, "element");
 167     while (RNODE_LIST(node)->nd_next && nd_type_p(RNODE_LIST(node)->nd_next, NODE_LIST)) {
 168         node = RNODE_LIST(node)->nd_next;
 169         F_NODE(nd_head, RNODE_LIST, "element");
 170     }
 171     LAST_NODE;
 172     F_NODE(nd_next, RNODE_LIST, "next element");
 173 }
 174
 175 static void
 176 dump_parser_array(VALUE buf, VALUE indent, int comment, const rb_parser_ary_t *ary)
 177 {
 178     int field_flag;
 179     const char *next_indent = default_indent;
 180
 181     if (ary->data_type != PARSER_ARY_DATA_NODE) {
 182         rb_bug("unexpected rb_parser_ary_data_type: %d", ary->data_type);
 183     }
 184
 185     F_CUSTOM1(length, "length") { A_LONG(ary->len); }
 186     for (long i = 0; i < ary->len; i++) {
 187         if (i == ary->len - 1) LAST_NODE;
 188         A_INDENT;
 189         rb_str_catf(buf, "+- element (%s%ld):\n",
 190                     comment ? "statement #" : "", i);
 191         D_INDENT;
 192         dump_node(buf, indent, comment, ary->data[i]);
 193         D_DEDENT;
 194     }
 195 }
 196
 197 static void
 198 dump_node(VALUE buf, VALUE indent, int comment, const NODE * node)
 199 {
 200     int field_flag;
 201     int i;
 202     const char *next_indent = default_indent;
 203     enum node_type type;
 204
 205     if (!node) {
 206         D_NULL_NODE;
 207         return;
 208     }
 209
 210     D_NODE_HEADER(node);
 211
 212     type = nd_type(node);
 213     switch (type) {
 214       case NODE_BLOCK:
 215         ANN("statement sequence");
 216         ANN("format: [nd_head]; ...; [nd_next]");
 217         ANN("example: foo; bar");
 218         i = 0;
 219         do {
 220             A_INDENT;
 221             rb_str_catf(buf, "+- nd_head (%s%d):\n",
 222                         comment ? "statement #" : "", ++i);
 223             if (!RNODE_BLOCK(node)->nd_next) LAST_NODE;
 224             D_INDENT;
 225             dump_node(buf, indent, comment, RNODE_BLOCK(node)->nd_head);
 226             D_DEDENT;
 227         } while (RNODE_BLOCK(node)->nd_next &&
 228                  nd_type_p(RNODE_BLOCK(node)->nd_next, NODE_BLOCK) &&
 229                  (node = RNODE_BLOCK(node)->nd_next, 1));
 230         if (RNODE_BLOCK(node)->nd_next) {
 231             LAST_NODE;
 232             F_NODE(nd_next, RNODE_BLOCK, "next block");
 233         }
 234         return;
 235
 236       case NODE_IF:
 237         ANN("if statement");
 238         ANN("format: if [nd_cond] then [nd_body] else [nd_else] end");
 239         ANN("example: if x == 1 then foo else bar end");
 240         F_NODE(nd_cond, RNODE_IF, "condition expr");
 241         F_NODE(nd_body, RNODE_IF, "then clause");
 242         F_NODE(nd_else, RNODE_IF, "else clause");
 243         F_LOC(if_keyword_loc, RNODE_IF);
 244         F_LOC(then_keyword_loc, RNODE_IF);
 245         LAST_NODE;
 246         F_LOC(end_keyword_loc, RNODE_IF);
 247         return;
 248
 249       case NODE_UNLESS:
 250         ANN("unless statement");
 251         ANN("format: unless [nd_cond] then [nd_body] else [nd_else] end");
 252         ANN("example: unless x == 1 then foo else bar end");
 253         F_NODE(nd_cond, RNODE_UNLESS, "condition expr");
 254         F_NODE(nd_body, RNODE_UNLESS, "then clause");
 255         F_NODE(nd_else, RNODE_UNLESS, "else clause");
 256         F_LOC(keyword_loc, RNODE_UNLESS);
 257         F_LOC(then_keyword_loc, RNODE_UNLESS);
 258         LAST_NODE;
 259         F_LOC(end_keyword_loc, RNODE_UNLESS);
 260         return;
 261
 262       case NODE_CASE:
 263         ANN("case statement");
 264         ANN("format: case [nd_head]; [nd_body]; end");
 265         ANN("example: case x; when 1; foo; when 2; bar; else baz; end");
 266         F_NODE(nd_head, RNODE_CASE, "case expr");
 267         F_NODE(nd_body, RNODE_CASE, "when clauses");
 268         F_LOC(case_keyword_loc, RNODE_CASE);
 269         LAST_NODE;
 270         F_LOC(end_keyword_loc, RNODE_CASE);
 271         return;
 272       case NODE_CASE2:
 273         ANN("case statement with no head");
 274         ANN("format: case; [nd_body]; end");
 275         ANN("example: case; when 1; foo; when 2; bar; else baz; end");
 276         F_NODE(nd_head, RNODE_CASE2, "case expr");
 277         F_NODE(nd_body, RNODE_CASE2, "when clauses");
 278         F_LOC(case_keyword_loc, RNODE_CASE2);
 279         LAST_NODE;
 280         F_LOC(end_keyword_loc, RNODE_CASE2);
 281         return;
 282       case NODE_CASE3:
 283         ANN("case statement (pattern matching)");
 284         ANN("format: case [nd_head]; [nd_body]; end");
 285         ANN("example: case x; in 1; foo; in 2; bar; else baz; end");
 286         F_NODE(nd_head, RNODE_CASE3, "case expr");
 287         F_NODE(nd_body, RNODE_CASE3, "in clauses");
 288         F_LOC(case_keyword_loc, RNODE_CASE3);
 289         LAST_NODE;
 290         F_LOC(end_keyword_loc, RNODE_CASE3);
 291         return;
 292
 293       case NODE_WHEN:
 294         ANN("when clause");
 295         ANN("format: when [nd_head]; [nd_body]; (when or else) [nd_next]");
 296         ANN("example: case x; when 1; foo; when 2; bar; else baz; end");
 297         F_NODE(nd_head, RNODE_WHEN, "when value");
 298         F_NODE(nd_body, RNODE_WHEN, "when body");
 299         LAST_NODE;
 300         F_NODE(nd_next, RNODE_WHEN, "next when clause");
 301         F_LOC(keyword_loc, RNODE_WHEN);
 302         LAST_NODE;
 303         F_LOC(then_keyword_loc, RNODE_WHEN);
 304         return;
 305
 306       case NODE_IN:
 307         ANN("in clause");
 308         ANN("format: in [nd_head]; [nd_body]; (in or else) [nd_next]");
 309         ANN("example: case x; in 1; foo; in 2; bar; else baz; end");
 310         F_NODE(nd_head, RNODE_IN, "in pattern");
 311         F_NODE(nd_body, RNODE_IN, "in body");
 312         LAST_NODE;
 313         F_NODE(nd_next, RNODE_IN, "next in clause");
 314         return;
 315
 316       case NODE_WHILE:
 317         ANN("while statement");
 318         ANN("format: while [nd_cond]; [nd_body]; end");
 319         ANN("example: while x == 1; foo; end");
 320         goto loop;
 321       case NODE_UNTIL:
 322         ANN("until statement");
 323         ANN("format: until [nd_cond]; [nd_body]; end");
 324         ANN("example: until x == 1; foo; end");
 325       loop:
 326         F_CUSTOM1(nd_state, "begin-end-while?") {
 327             A_INT((int)RNODE_WHILE(node)->nd_state);
 328             A((RNODE_WHILE(node)->nd_state == 1) ? " (while-end)" : " (begin-end-while)");
 329         }
 330         F_NODE(nd_cond, RNODE_WHILE, "condition");
 331         F_NODE(nd_body, RNODE_WHILE, "body");
 332         F_LOC(keyword_loc, RNODE_WHILE);
 333         LAST_NODE;
 334         F_LOC(closing_loc, RNODE_WHILE);
 335         return;
 336
 337       case NODE_ITER:
 338         ANN("method call with block");
 339         ANN("format: [nd_iter] { [nd_body] }");
 340         ANN("example: 3.times { foo }");
 341         F_NODE(nd_iter, RNODE_ITER, "iteration receiver");
 342         LAST_NODE;
 343         F_NODE(nd_body, RNODE_ITER, "body");
 344         return;
 345
 346       case NODE_FOR:
 347         ANN("for statement");
 348         ANN("format: for * in [nd_iter] do [nd_body] end");
 349         ANN("example: for i in 1..3 do foo end");
 350         F_NODE(nd_iter, RNODE_FOR, "iteration receiver");
 351         F_NODE(nd_body, RNODE_FOR, "body");
 352         F_LOC(for_keyword_loc, RNODE_FOR);
 353         F_LOC(in_keyword_loc, RNODE_FOR);
 354         F_LOC(do_keyword_loc, RNODE_FOR);
 355         LAST_NODE;
 356         F_LOC(end_keyword_loc, RNODE_FOR);
 357         return;
 358
 359       case NODE_FOR_MASGN:
 360         ANN("vars of for statement with masgn");
 361         ANN("format: for [nd_var] in ... do ... end");
 362         ANN("example: for x, y in 1..3 do foo end");
 363         LAST_NODE;
 364         F_NODE(nd_var, RNODE_FOR_MASGN, "var");
 365         return;
 366
 367       case NODE_BREAK:
 368         ANN("break statement");
 369         ANN("format: break [nd_stts]");
 370         ANN("example: break 1");
 371         F_NODE(nd_stts, RNODE_BREAK, "value");
 372         LAST_NODE;
 373         F_LOC(keyword_loc, RNODE_BREAK);
 374         return;
 375       case NODE_NEXT:
 376         ANN("next statement");
 377         ANN("format: next [nd_stts]");
 378         ANN("example: next 1");
 379         F_NODE(nd_stts, RNODE_NEXT, "value");
 380         LAST_NODE;
 381         F_LOC(keyword_loc, RNODE_NEXT);
 382         return;
 383       case NODE_RETURN:
 384         ANN("return statement");
 385         ANN("format: return [nd_stts]");
 386         ANN("example: return 1");
 387         F_NODE(nd_stts, RNODE_RETURN, "value");
 388         LAST_NODE;
 389         F_LOC(keyword_loc, RNODE_RETURN);
 390         return;
 391
 392       case NODE_REDO:
 393         ANN("redo statement");
 394         ANN("format: redo");
 395         ANN("example: redo");
 396         F_LOC(keyword_loc, RNODE_REDO);
 397         return;
 398
 399       case NODE_RETRY:
 400         ANN("retry statement");
 401         ANN("format: retry");
 402         ANN("example: retry");
 403         return;
 404
 405       case NODE_BEGIN:
 406         ANN("begin statement");
 407         ANN("format: begin; [nd_body]; end");
 408         ANN("example: begin; 1; end");
 409         LAST_NODE;
 410         F_NODE(nd_body, RNODE_BEGIN, "body");
 411         return;
 412
 413       case NODE_RESCUE:
 414         ANN("rescue clause");
 415         ANN("format: begin; [nd_body]; (rescue) [nd_resq]; else [nd_else]; end");
 416         ANN("example: begin; foo; rescue; bar; else; baz; end");
 417         F_NODE(nd_head, RNODE_RESCUE, "body");
 418         F_NODE(nd_resq, RNODE_RESCUE, "rescue clause list");
 419         LAST_NODE;
 420         F_NODE(nd_else, RNODE_RESCUE, "rescue else clause");
 421         return;
 422
 423       case NODE_RESBODY:
 424         ANN("rescue clause (cont'd)");
 425         ANN("format: rescue [nd_args] (=> [nd_exc_var]); [nd_body]; (rescue) [nd_next]");
 426         ANN("example: begin; foo; rescue; bar; else; baz; end");
 427         F_NODE(nd_args, RNODE_RESBODY, "rescue exceptions");
 428         F_NODE(nd_exc_var, RNODE_RESBODY, "exception variable");
 429         F_NODE(nd_body, RNODE_RESBODY, "rescue clause");
 430         LAST_NODE;
 431         F_NODE(nd_next, RNODE_RESBODY, "next rescue clause");
 432         return;
 433
 434       case NODE_ENSURE:
 435         ANN("ensure clause");
 436         ANN("format: begin; [nd_head]; ensure; [nd_ensr]; end");
 437         ANN("example: begin; foo; ensure; bar; end");
 438         F_NODE(nd_head, RNODE_ENSURE, "body");
 439         LAST_NODE;
 440         F_NODE(nd_ensr, RNODE_ENSURE, "ensure clause");
 441         return;
 442
 443       case NODE_AND:
 444         ANN("&& operator");
 445         ANN("format: [nd_1st] && [nd_2nd]");
 446         ANN("example: foo && bar");
 447         goto andor;
 448       case NODE_OR:
 449         ANN("|| operator");
 450         ANN("format: [nd_1st] || [nd_2nd]");
 451         ANN("example: foo || bar");
 452       andor:
 453         while (1) {
 454             F_NODE(nd_1st, RNODE_AND, "left expr");
 455             if (!RNODE_AND(node)->nd_2nd || !nd_type_p(RNODE_AND(node)->nd_2nd, type))
 456                 break;
 457             node = RNODE_AND(node)->nd_2nd;
 458         }
 459         F_NODE(nd_2nd, RNODE_AND, "right expr");
 460         LAST_NODE;
 461         F_LOC(operator_loc, RNODE_AND);
 462         return;
 463
 464       case NODE_MASGN:
 465         ANN("multiple assignment");
 466         ANN("format: [nd_head], [nd_args] = [nd_value]");
 467         ANN("example: a, b = foo");
 468         F_NODE(nd_value, RNODE_MASGN, "rhsn");
 469         F_NODE(nd_head, RNODE_MASGN, "lhsn");
 470         if (NODE_NAMED_REST_P(RNODE_MASGN(node)->nd_args)) {
 471             LAST_NODE;
 472             F_NODE(nd_args, RNODE_MASGN, "splatn");
 473         }
 474         else {
 475             F_MSG(nd_args, "splatn", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
 476         }
 477         return;
 478
 479       case NODE_LASGN:
 480         ANN("local variable assignment");
 481         ANN("format: [nd_vid](lvar) = [nd_value]");
 482         ANN("example: x = foo");
 483         F_ID(nd_vid, RNODE_LASGN, "local variable");
 484         if (NODE_REQUIRED_KEYWORD_P(RNODE_LASGN(node)->nd_value)) {
 485             F_MSG(nd_value, "rvalue", "NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)");
 486         }
 487         else {
 488             LAST_NODE;
 489             F_NODE(nd_value, RNODE_LASGN, "rvalue");
 490         }
 491         return;
 492       case NODE_DASGN:
 493         ANN("dynamic variable assignment");
 494         ANN("format: [nd_vid](dvar) = [nd_value]");
 495         ANN("example: x = nil; 1.times { x = foo }");
 496         ANN("example: 1.times { x = foo }");
 497         F_ID(nd_vid, RNODE_DASGN, "local variable");
 498         if (NODE_REQUIRED_KEYWORD_P(RNODE_DASGN(node)->nd_value)) {
 499             F_MSG(nd_value, "rvalue", "NODE_SPECIAL_REQUIRED_KEYWORD (required keyword argument)");
 500         }
 501         else {
 502             LAST_NODE;
 503             F_NODE(nd_value, RNODE_DASGN, "rvalue");
 504         }
 505         return;
 506       case NODE_IASGN:
 507         ANN("instance variable assignment");
 508         ANN("format: [nd_vid](ivar) = [nd_value]");
 509         ANN("example: @x = foo");
 510         F_ID(nd_vid, RNODE_IASGN, "instance variable");
 511         LAST_NODE;
 512         F_NODE(nd_value, RNODE_IASGN, "rvalue");
 513         return;
 514       case NODE_CVASGN:
 515         ANN("class variable assignment");
 516         ANN("format: [nd_vid](cvar) = [nd_value]");
 517         ANN("example: @@x = foo");
 518         F_ID(nd_vid, RNODE_CVASGN, "class variable");
 519         LAST_NODE;
 520         F_NODE(nd_value, RNODE_CVASGN, "rvalue");
 521         return;
 522       case NODE_GASGN:
 523         ANN("global variable assignment");
 524         ANN("format: [nd_vid](gvar) = [nd_value]");
 525         ANN("example: $x = foo");
 526         F_ID(nd_vid, RNODE_GASGN, "global variable");
 527         LAST_NODE;
 528         F_NODE(nd_value, RNODE_GASGN, "rvalue");
 529         return;
 530
 531       case NODE_CDECL:
 532         ANN("constant declaration");
 533         ANN("format: [nd_else]::[nd_vid](constant) = [nd_value]");
 534         ANN("example: X = foo");
 535         if (RNODE_CDECL(node)->nd_vid) {
 536             F_ID(nd_vid, RNODE_CDECL, "constant");
 537             F_MSG(nd_else, "extension", "not used");
 538         }
 539         else {
 540             F_MSG(nd_vid, "constant", "0 (see extension field)");
 541             F_NODE(nd_else, RNODE_CDECL, "extension");
 542         }
 543         F_SHAREABILITY(shareability, RNODE_CDECL, "shareability");
 544         LAST_NODE;
 545         F_NODE(nd_value, RNODE_CDECL, "rvalue");
 546         return;
 547
 548       case NODE_OP_ASGN1:
 549         ANN("array assignment with operator");
 550         ANN("format: [nd_recv] [ [nd_index] ] [nd_mid]= [nd_rvalue]");
 551         ANN("example: ary[1] += foo");
 552         F_NODE(nd_recv, RNODE_OP_ASGN1, "receiver");
 553         F_ID(nd_mid, RNODE_OP_ASGN1, "operator");
 554         F_NODE(nd_index, RNODE_OP_ASGN1, "index");
 555         F_NODE(nd_rvalue, RNODE_OP_ASGN1, "rvalue");
 556         F_LOC(call_operator_loc, RNODE_OP_ASGN1);
 557         F_LOC(opening_loc, RNODE_OP_ASGN1);
 558         F_LOC(closing_loc, RNODE_OP_ASGN1);
 559         LAST_NODE;
 560         F_LOC(binary_operator_loc, RNODE_OP_ASGN1);
 561         return;
 562
 563       case NODE_OP_ASGN2:
 564         ANN("attr assignment with operator");
 565         ANN("format: [nd_recv].[nd_vid] [nd_mid]= [nd_value]");
 566         ANN("example: struct.field += foo");
 567         F_NODE(nd_recv, RNODE_OP_ASGN2, "receiver");
 568         F_CUSTOM1(nd_vid, "attr") {
 569             if (RNODE_OP_ASGN2(node)->nd_aid) A("? ");
 570             A_ID(RNODE_OP_ASGN2(node)->nd_vid);
 571         }
 572         F_ID(nd_mid, RNODE_OP_ASGN2, "operator");
 573         F_NODE(nd_value, RNODE_OP_ASGN2, "rvalue");
 574         F_LOC(call_operator_loc, RNODE_OP_ASGN2);
 575         F_LOC(message_loc, RNODE_OP_ASGN2);
 576         LAST_NODE;
 577         F_LOC(binary_operator_loc, RNODE_OP_ASGN2);
 578         return;
 579
 580       case NODE_OP_ASGN_AND:
 581         ANN("assignment with && operator");
 582         ANN("format: [nd_head] &&= [nd_value]");
 583         ANN("example: foo &&= bar");
 584         goto asgn_andor;
 585       case NODE_OP_ASGN_OR:
 586         ANN("assignment with || operator");
 587         ANN("format: [nd_head] ||= [nd_value]");
 588         ANN("example: foo ||= bar");
 589       asgn_andor:
 590         F_NODE(nd_head, RNODE_OP_ASGN_AND, "variable");
 591         LAST_NODE;
 592         F_NODE(nd_value, RNODE_OP_ASGN_AND, "rvalue");
 593         return;
 594
 595       case NODE_OP_CDECL:
 596         ANN("constant declaration with operator");
 597         ANN("format: [nd_head](constant) [nd_aid]= [nd_value]");
 598         ANN("example: A::B ||= 1");
 599         F_NODE(nd_head, RNODE_OP_CDECL, "constant");
 600         F_ID(nd_aid, RNODE_OP_CDECL, "operator");
 601         F_SHAREABILITY(shareability, RNODE_OP_CDECL, "shareability");
 602         LAST_NODE;
 603         F_NODE(nd_value, RNODE_OP_CDECL, "rvalue");
 604         return;
 605
 606       case NODE_CALL:
 607         ANN("method invocation");
 608         ANN("format: [nd_recv].[nd_mid]([nd_args])");
 609         ANN("example: obj.foo(1)");
 610         F_ID(nd_mid, RNODE_CALL, "method id");
 611         F_NODE(nd_recv, RNODE_CALL, "receiver");
 612         LAST_NODE;
 613         F_NODE(nd_args, RNODE_CALL, "arguments");
 614         return;
 615
 616       case NODE_OPCALL:
 617         ANN("method invocation");
 618         ANN("format: [nd_recv] [nd_mid] [nd_args]");
 619         ANN("example: foo + bar");
 620         F_ID(nd_mid, RNODE_OPCALL, "method id");
 621         F_NODE(nd_recv, RNODE_OPCALL, "receiver");
 622         LAST_NODE;
 623         F_NODE(nd_args, RNODE_OPCALL, "arguments");
 624         return;
 625
 626       case NODE_FCALL:
 627         ANN("function call");
 628         ANN("format: [nd_mid]([nd_args])");
 629         ANN("example: foo(1)");
 630         F_ID(nd_mid, RNODE_FCALL, "method id");
 631         LAST_NODE;
 632         F_NODE(nd_args, RNODE_FCALL, "arguments");
 633         return;
 634
 635       case NODE_VCALL:
 636         ANN("function call with no argument");
 637         ANN("format: [nd_mid]");
 638         ANN("example: foo");
 639         F_ID(nd_mid, RNODE_VCALL, "method id");
 640         return;
 641
 642       case NODE_QCALL:
 643         ANN("safe method invocation");
 644         ANN("format: [nd_recv]&.[nd_mid]([nd_args])");
 645         ANN("example: obj&.foo(1)");
 646         F_ID(nd_mid, RNODE_QCALL, "method id");
 647         F_NODE(nd_recv, RNODE_QCALL, "receiver");
 648         LAST_NODE;
 649         F_NODE(nd_args, RNODE_QCALL, "arguments");
 650         return;
 651
 652       case NODE_SUPER:
 653         ANN("super invocation");
 654         ANN("format: super [nd_args]");
 655         ANN("example: super 1");
 656         F_NODE(nd_args, RNODE_SUPER, "arguments");
 657         F_LOC(keyword_loc, RNODE_SUPER);
 658         F_LOC(lparen_loc, RNODE_SUPER);
 659         LAST_NODE;
 660         F_LOC(rparen_loc, RNODE_SUPER);
 661         return;
 662
 663       case NODE_ZSUPER:
 664         ANN("super invocation with no argument");
 665         ANN("format: super");
 666         ANN("example: super");
 667         return;
 668
 669       case NODE_LIST:
 670         ANN("list constructor");
 671         ANN("format: [ [nd_head], [nd_next].. ] (length: [nd_alen])");
 672         ANN("example: [1, 2, 3]");
 673         dump_array(buf, indent, comment, node);
 674         return;
 675
 676       case NODE_ZLIST:
 677         ANN("empty list constructor");
 678         ANN("format: []");
 679         ANN("example: []");
 680         return;
 681
 682       case NODE_HASH:
 683         if (!RNODE_HASH(node)->nd_brace) {
 684             ANN("keyword arguments");
 685             ANN("format: [nd_head]");
 686             ANN("example: a: 1, b: 2");
 687         }
 688         else {
 689             ANN("hash constructor");
 690             ANN("format: { [nd_head] }");
 691             ANN("example: { 1 => 2, 3 => 4 }");
 692         }
 693         F_CUSTOM1(nd_brace, "keyword arguments or hash literal") {
 694             switch (RNODE_HASH(node)->nd_brace) {
 695               case 0: A("0 (keyword argument)"); break;
 696               case 1: A("1 (hash literal)"); break;
 697             }
 698         }
 699         LAST_NODE;
 700         F_NODE(nd_head, RNODE_HASH, "contents");
 701         return;
 702
 703       case NODE_YIELD:
 704         ANN("yield invocation");
 705         ANN("format: yield [nd_head]");
 706         ANN("example: yield 1");
 707         F_NODE(nd_head, RNODE_YIELD, "arguments");
 708         F_LOC(keyword_loc, RNODE_YIELD);
 709         F_LOC(lparen_loc, RNODE_YIELD);
 710         LAST_NODE;
 711         F_LOC(rparen_loc, RNODE_YIELD);
 712         return;
 713
 714       case NODE_LVAR:
 715         ANN("local variable reference");
 716         ANN("format: [nd_vid](lvar)");
 717         ANN("example: x");
 718         F_ID(nd_vid, RNODE_LVAR, "local variable");
 719         return;
 720       case NODE_DVAR:
 721         ANN("dynamic variable reference");
 722         ANN("format: [nd_vid](dvar)");
 723         ANN("example: 1.times { x = 1; x }");
 724         F_ID(nd_vid, RNODE_DVAR, "local variable");
 725         return;
 726       case NODE_IVAR:
 727         ANN("instance variable reference");
 728         ANN("format: [nd_vid](ivar)");
 729         ANN("example: @x");
 730         F_ID(nd_vid, RNODE_IVAR, "instance variable");
 731         return;
 732       case NODE_CONST:
 733         ANN("constant reference");
 734         ANN("format: [nd_vid](constant)");
 735         ANN("example: X");
 736         F_ID(nd_vid, RNODE_CONST, "constant");
 737         return;
 738       case NODE_CVAR:
 739         ANN("class variable reference");
 740         ANN("format: [nd_vid](cvar)");
 741         ANN("example: @@x");
 742         F_ID(nd_vid, RNODE_CVAR, "class variable");
 743         return;
 744
 745       case NODE_GVAR:
 746         ANN("global variable reference");
 747         ANN("format: [nd_vid](gvar)");
 748         ANN("example: $x");
 749         F_ID(nd_vid, RNODE_GVAR, "global variable");
 750         return;
 751
 752       case NODE_NTH_REF:
 753         ANN("nth special variable reference");
 754         ANN("format: $[nd_nth]");
 755         ANN("example: $1, $2, ..");
 756         F_CUSTOM1(nd_nth, "variable") { A("$"); A_LONG(RNODE_NTH_REF(node)->nd_nth); }
 757         return;
 758
 759       case NODE_BACK_REF:
 760         ANN("back special variable reference");
 761         ANN("format: $[nd_nth]");
 762         ANN("example: $&, $`, $', $+");
 763         F_CUSTOM1(nd_nth, "variable") {
 764             char name[3] = "$ ";
 765             name[1] = (char)RNODE_BACK_REF(node)->nd_nth;
 766             A(name);
 767         }
 768         return;
 769
 770       case NODE_MATCH:
 771         ANN("match expression (against $_ implicitly)");
 772         ANN("format: [nd_lit] (in condition)");
 773         ANN("example: if /foo/; foo; end");
 774         LAST_NODE;
 775         F_VALUE(string, rb_node_regx_string_val(node), "string");
 776         return;
 777
 778       case NODE_MATCH2:
 779         ANN("match expression (regexp first)");
 780         ANN("format: [nd_recv] =~ [nd_value]");
 781         ANN("example: /foo/ =~ 'foo'");
 782         F_NODE(nd_recv, RNODE_MATCH2, "regexp (receiver)");
 783         if (!RNODE_MATCH2(node)->nd_args) LAST_NODE;
 784         F_NODE(nd_value, RNODE_MATCH2, "string (argument)");
 785         if (RNODE_MATCH2(node)->nd_args) {
 786             LAST_NODE;
 787             F_NODE(nd_args, RNODE_MATCH2, "named captures");
 788         }
 789         return;
 790
 791       case NODE_MATCH3:
 792         ANN("match expression (regexp second)");
 793         ANN("format: [nd_recv] =~ [nd_value]");
 794         ANN("example: 'foo' =~ /foo/");
 795         F_NODE(nd_recv, RNODE_MATCH3, "string (receiver)");
 796         LAST_NODE;
 797         F_NODE(nd_value, RNODE_MATCH3, "regexp (argument)");
 798         return;
 799
 800       case NODE_STR:
 801         ANN("string literal");
 802         ANN("format: [nd_lit]");
 803         ANN("example: 'foo'");
 804         goto str;
 805       case NODE_XSTR:
 806         ANN("xstring literal");
 807         ANN("format: [nd_lit]");
 808         ANN("example: `foo`");
 809       str:
 810         F_VALUE(string, rb_node_str_string_val(node), "literal");
 811         return;
 812
 813       case NODE_INTEGER:
 814         ANN("integer literal");
 815         ANN("format: [val]");
 816         ANN("example: 1");
 817         F_VALUE(val, rb_node_integer_literal_val(node), "val");
 818         return;
 819
 820       case NODE_FLOAT:
 821         ANN("float literal");
 822         ANN("format: [val]");
 823         ANN("example: 1.2");
 824         F_VALUE(val, rb_node_float_literal_val(node), "val");
 825         return;
 826
 827       case NODE_RATIONAL:
 828         ANN("rational number literal");
 829         ANN("format: [val]");
 830         ANN("example: 1r");
 831         F_VALUE(val, rb_node_rational_literal_val(node), "val");
 832         return;
 833
 834       case NODE_IMAGINARY:
 835         ANN("complex number literal");
 836         ANN("format: [val]");
 837         ANN("example: 1i");
 838         F_VALUE(val, rb_node_imaginary_literal_val(node), "val");
 839         return;
 840
 841       case NODE_REGX:
 842         ANN("regexp literal");
 843         ANN("format: [string]");
 844         ANN("example: /foo/");
 845         F_VALUE(string, rb_node_regx_string_val(node), "string");
 846         F_LOC(opening_loc, RNODE_REGX);
 847         F_LOC(content_loc, RNODE_REGX);
 848         LAST_NODE;
 849         F_LOC(closing_loc, RNODE_REGX);
 850         return;
 851
 852       case NODE_ONCE:
 853         ANN("once evaluation");
 854         ANN("format: [nd_body]");
 855         ANN("example: /foo#{ bar }baz/o");
 856         LAST_NODE;
 857         F_NODE(nd_body, RNODE_ONCE, "body");
 858         return;
 859
 860       case NODE_DSTR:
 861         ANN("string literal with interpolation");
 862         ANN("format: [nd_lit]");
 863         ANN("example: \"foo#{ bar }baz\"");
 864         goto dlit;
 865       case NODE_DXSTR:
 866         ANN("xstring literal with interpolation");
 867         ANN("format: [nd_lit]");
 868         ANN("example: `foo#{ bar }baz`");
 869         goto dlit;
 870       case NODE_DREGX:
 871         ANN("regexp literal with interpolation");
 872         ANN("format: [nd_lit]");
 873         ANN("example: /foo#{ bar }baz/");
 874         goto dlit;
 875       case NODE_DSYM:
 876         ANN("symbol literal with interpolation");
 877         ANN("format: [nd_lit]");
 878         ANN("example: :\"foo#{ bar }baz\"");
 879       dlit:
 880         F_VALUE(string, rb_node_dstr_string_val(node), "preceding string");
 881         if (!RNODE_DSTR(node)->nd_next) return;
 882         F_NODE(nd_next->nd_head, RNODE_DSTR, "interpolation");
 883         LAST_NODE;
 884         F_NODE(nd_next->nd_next, RNODE_DSTR, "tailing strings");
 885         return;
 886
 887       case NODE_SYM:
 888         ANN("symbol literal");
 889         ANN("format: [string]");
 890         ANN("example: :foo");
 891         F_VALUE(string, rb_node_sym_string_val(node), "string");
 892         return;
 893
 894       case NODE_EVSTR:
 895         ANN("interpolation expression");
 896         ANN("format: \"..#{ [nd_body] }..\"");
 897         ANN("example: \"foo#{ bar }baz\"");
 898         F_NODE(nd_body, RNODE_EVSTR, "body");
 899         F_LOC(opening_loc, RNODE_EVSTR);
 900         LAST_NODE;
 901         F_LOC(closing_loc, RNODE_EVSTR);
 902         return;
 903
 904       case NODE_ARGSCAT:
 905         ANN("splat argument following arguments");
 906         ANN("format: ..(*[nd_head], [nd_body..])");
 907         ANN("example: foo(*ary, post_arg1, post_arg2)");
 908         F_NODE(nd_head, RNODE_ARGSCAT, "preceding array");
 909         LAST_NODE;
 910         F_NODE(nd_body, RNODE_ARGSCAT, "following array");
 911         return;
 912
 913       case NODE_ARGSPUSH:
 914         ANN("splat argument following one argument");
 915         ANN("format: ..(*[nd_head], [nd_body])");
 916         ANN("example: foo(*ary, post_arg)");
 917         F_NODE(nd_head, RNODE_ARGSPUSH, "preceding array");
 918         LAST_NODE;
 919         F_NODE(nd_body, RNODE_ARGSPUSH, "following element");
 920         return;
 921
 922       case NODE_SPLAT:
 923         ANN("splat argument");
 924         ANN("format: *[nd_head]");
 925         ANN("example: foo(*ary)");
 926         F_NODE(nd_head, RNODE_SPLAT, "splat'ed array");
 927         LAST_NODE;
 928         F_LOC(operator_loc, RNODE_SPLAT);
 929         return;
 930
 931       case NODE_BLOCK_PASS:
 932         ANN("arguments with block argument");
 933         ANN("format: ..([nd_head], &[nd_body])");
 934         ANN("example: foo(x, &blk)");
 935         F_CUSTOM1(forwarding, "arguments forwarding or not") {
 936             switch (RNODE_BLOCK_PASS(node)->forwarding) {
 937               case 0: A("0 (no forwarding)"); break;
 938               case 1: A("1 (forwarding)"); break;
 939             }
 940         }
 941         F_NODE(nd_head, RNODE_BLOCK_PASS, "other arguments");
 942         F_NODE(nd_body, RNODE_BLOCK_PASS, "block argument");
 943         LAST_NODE;
 944         F_LOC(operator_loc, RNODE_BLOCK_PASS);
 945         return;
 946
 947       case NODE_DEFN:
 948         ANN("method definition");
 949         ANN("format: def [nd_mid] [nd_defn]; end");
 950         ANN("example: def foo; bar; end");
 951         F_ID(nd_mid, RNODE_DEFN, "method name");
 952         LAST_NODE;
 953         F_NODE(nd_defn, RNODE_DEFN, "method definition");
 954         return;
 955
 956       case NODE_DEFS:
 957         ANN("singleton method definition");
 958         ANN("format: def [nd_recv].[nd_mid] [nd_defn]; end");
 959         ANN("example: def obj.foo; bar; end");
 960         F_NODE(nd_recv, RNODE_DEFS, "receiver");
 961         F_ID(nd_mid, RNODE_DEFS, "method name");
 962         LAST_NODE;
 963         F_NODE(nd_defn, RNODE_DEFS, "method definition");
 964         return;
 965
 966       case NODE_ALIAS:
 967         ANN("method alias statement");
 968         ANN("format: alias [nd_1st] [nd_2nd]");
 969         ANN("example: alias bar foo");
 970         F_NODE(nd_1st, RNODE_ALIAS, "new name");
 971         F_NODE(nd_2nd, RNODE_ALIAS, "old name");
 972         LAST_NODE;
 973         F_LOC(keyword_loc, RNODE_ALIAS);
 974         return;
 975
 976       case NODE_VALIAS:
 977         ANN("global variable alias statement");
 978         ANN("format: alias [nd_alias](gvar) [nd_orig](gvar)");
 979         ANN("example: alias $y $x");
 980         F_ID(nd_alias, RNODE_VALIAS, "new name");
 981         F_ID(nd_orig, RNODE_VALIAS, "old name");
 982         F_LOC(keyword_loc, RNODE_VALIAS);
 983         return;
 984
 985       case NODE_UNDEF:
 986         ANN("method undef statement");
 987         ANN("format: undef [nd_undefs]");
 988         ANN("example: undef foo");
 989         LAST_NODE;
 990         F_ARRAY(nd_undefs, RNODE_UNDEF, "nd_undefs");
 991         F_LOC(keyword_loc, RNODE_UNDEF);
 992         return;
 993
 994       case NODE_CLASS:
 995         ANN("class definition");
 996         ANN("format: class [nd_cpath] < [nd_super]; [nd_body]; end");
 997         ANN("example: class C2 < C; ..; end");
 998         F_NODE(nd_cpath, RNODE_CLASS, "class path");
 999         F_NODE(nd_super, RNODE_CLASS, "superclass");
1000         F_NODE(nd_body, RNODE_CLASS, "class definition");
1001         F_LOC(class_keyword_loc, RNODE_CLASS);
1002         F_LOC(inheritance_operator_loc, RNODE_CLASS);
1003         LAST_NODE;
1004         F_LOC(end_keyword_loc, RNODE_CLASS);
1005         return;
1006
1007       case NODE_MODULE:
1008         ANN("module definition");
1009         ANN("format: module [nd_cpath]; [nd_body]; end");
1010         ANN("example: module M; ..; end");
1011         F_NODE(nd_cpath, RNODE_MODULE, "module path");
1012         LAST_NODE;
1013         F_NODE(nd_body, RNODE_MODULE, "module definition");
1014         return;
1015
1016       case NODE_SCLASS:
1017         ANN("singleton class definition");
1018         ANN("format: class << [nd_recv]; [nd_body]; end");
1019         ANN("example: class << obj; ..; end");
1020         F_NODE(nd_recv, RNODE_SCLASS, "receiver");
1021         LAST_NODE;
1022         F_NODE(nd_body, RNODE_SCLASS, "singleton class definition");
1023         return;
1024
1025       case NODE_COLON2:
1026         ANN("scoped constant reference");
1027         ANN("format: [nd_head]::[nd_mid]");
1028         ANN("example: M::C");
1029         F_ID(nd_mid, RNODE_COLON2, "constant name");
1030         LAST_NODE;
1031         F_NODE(nd_head, RNODE_COLON2, "receiver");
1032         return;
1033
1034       case NODE_COLON3:
1035         ANN("top-level constant reference");
1036         ANN("format: ::[nd_mid]");
1037         ANN("example: ::Object");
1038         F_ID(nd_mid, RNODE_COLON3, "constant name");
1039         return;
1040
1041       case NODE_DOT2:
1042         ANN("range constructor (incl.)");
1043         ANN("format: [nd_beg]..[nd_end]");
1044         ANN("example: 1..5");
1045         goto dot;
1046       case NODE_DOT3:
1047         ANN("range constructor (excl.)");
1048         ANN("format: [nd_beg]...[nd_end]");
1049         ANN("example: 1...5");
1050         goto dot;
1051       case NODE_FLIP2:
1052         ANN("flip-flop condition (incl.)");
1053         ANN("format: [nd_beg]..[nd_end]");
1054         ANN("example: if (x==1)..(x==5); foo; end");
1055         goto dot;
1056       case NODE_FLIP3:
1057         ANN("flip-flop condition (excl.)");
1058         ANN("format: [nd_beg]...[nd_end]");
1059         ANN("example: if (x==1)...(x==5); foo; end");
1060       dot:
1061         F_NODE(nd_beg, RNODE_DOT2, "begin");
1062         F_NODE(nd_end, RNODE_DOT2, "end");
1063         LAST_NODE;
1064         F_LOC(operator_loc, RNODE_DOT2);
1065         return;
1066
1067       case NODE_SELF:
1068         ANN("self");
1069         ANN("format: self");
1070         ANN("example: self");
1071         F_CUSTOM1(nd_state, "nd_state") {
1072             A_INT((int)RNODE_SELF(node)->nd_state);
1073         }
1074         return;
1075
1076       case NODE_NIL:
1077         ANN("nil");
1078         ANN("format: nil");
1079         ANN("example: nil");
1080         return;
1081
1082       case NODE_TRUE:
1083         ANN("true");
1084         ANN("format: true");
1085         ANN("example: true");
1086         return;
1087
1088       case NODE_FALSE:
1089         ANN("false");
1090         ANN("format: false");
1091         ANN("example: false");
1092         return;
1093
1094       case NODE_ERRINFO:
1095         ANN("virtual reference to $!");
1096         ANN("format: rescue => id");
1097         ANN("example: rescue => id");
1098         return;
1099
1100       case NODE_DEFINED:
1101         ANN("defined? expression");
1102         ANN("format: defined?([nd_head])");
1103         ANN("example: defined?(foo)");
1104         LAST_NODE;
1105         F_NODE(nd_head, RNODE_DEFINED, "expr");
1106         return;
1107
1108       case NODE_POSTEXE:
1109         ANN("post-execution");
1110         ANN("format: END { [nd_body] }");
1111         ANN("example: END { foo }");
1112         F_NODE(nd_body, RNODE_POSTEXE, "END clause");
1113         F_LOC(keyword_loc, RNODE_POSTEXE);
1114         F_LOC(opening_loc, RNODE_POSTEXE);
1115         LAST_NODE;
1116         F_LOC(closing_loc, RNODE_POSTEXE);
1117         return;
1118
1119       case NODE_ATTRASGN:
1120         ANN("attr assignment");
1121         ANN("format: [nd_recv].[nd_mid] = [nd_args]");
1122         ANN("example: struct.field = foo");
1123         F_NODE(nd_recv, RNODE_ATTRASGN, "receiver");
1124         F_ID(nd_mid, RNODE_ATTRASGN, "method name");
1125         LAST_NODE;
1126         F_NODE(nd_args, RNODE_ATTRASGN, "arguments");
1127         return;
1128
1129       case NODE_LAMBDA:
1130         ANN("lambda expression");
1131         ANN("format: -> [nd_body]");
1132         ANN("example: -> { foo }");
1133         F_NODE(nd_body, RNODE_LAMBDA, "lambda clause");
1134         F_LOC(operator_loc, RNODE_LAMBDA);
1135         F_LOC(opening_loc, RNODE_LAMBDA);
1136         LAST_NODE;
1137         F_LOC(closing_loc, RNODE_LAMBDA);
1138         return;
1139
1140       case NODE_OPT_ARG:
1141         ANN("optional arguments");
1142         ANN("format: def method_name([nd_body=some], [nd_next..])");
1143         ANN("example: def foo(a, b=1, c); end");
1144         F_NODE(nd_body, RNODE_OPT_ARG, "body");
1145         LAST_NODE;
1146         F_NODE(nd_next, RNODE_OPT_ARG, "next");
1147         return;
1148
1149       case NODE_KW_ARG:
1150         ANN("keyword arguments");
1151         ANN("format: def method_name([nd_body=some], [nd_next..])");
1152         ANN("example: def foo(a:1, b:2); end");
1153         F_NODE(nd_body, RNODE_KW_ARG, "body");
1154         LAST_NODE;
1155         F_NODE(nd_next, RNODE_KW_ARG, "next");
1156         return;
1157
1158       case NODE_POSTARG:
1159         ANN("post arguments");
1160         ANN("format: *[nd_1st], [nd_2nd..] = ..");
1161         ANN("example: a, *rest, z = foo");
1162         if (NODE_NAMED_REST_P(RNODE_POSTARG(node)->nd_1st)) {
1163             F_NODE(nd_1st, RNODE_POSTARG, "rest argument");
1164         }
1165         else {
1166             F_MSG(nd_1st, "rest argument", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
1167         }
1168         LAST_NODE;
1169         F_NODE(nd_2nd, RNODE_POSTARG, "post arguments");
1170         return;
1171
1172       case NODE_ARGS:
1173         ANN("method parameters");
1174         ANN("format: def method_name(.., [nd_ainfo.nd_optargs], *[nd_ainfo.rest_arg], [nd_ainfo.first_post_arg], .., [nd_ainfo.kw_args], **[nd_ainfo.kw_rest_arg], &[nd_ainfo.block_arg])");
1175         ANN("example: def foo(a, b, opt1=1, opt2=2, *rest, y, z, kw: 1, **kwrest, &blk); end");
1176         F_CUSTOM1(nd_ainfo.forwarding, "arguments forwarding or not") {
1177             switch (RNODE_ARGS(node)->nd_ainfo.forwarding) {
1178               case 0: A("0 (no forwarding)"); break;
1179               case 1: A("1 (forwarding)"); break;
1180             }
1181         }
1182         F_INT(nd_ainfo.pre_args_num, RNODE_ARGS, "count of mandatory (pre-)arguments");
1183         F_NODE(nd_ainfo.pre_init, RNODE_ARGS, "initialization of (pre-)arguments");
1184         F_INT(nd_ainfo.post_args_num, RNODE_ARGS, "count of mandatory post-arguments");
1185         F_NODE(nd_ainfo.post_init, RNODE_ARGS, "initialization of post-arguments");
1186         F_ID(nd_ainfo.first_post_arg, RNODE_ARGS, "first post argument");
1187         F_CUSTOM1(nd_ainfo.rest_arg, "rest argument") {
1188             if (RNODE_ARGS(node)->nd_ainfo.rest_arg == NODE_SPECIAL_EXCESSIVE_COMMA) {
1189                 A("1 (excessed comma)");
1190             }
1191             else {
1192                 A_ID(RNODE_ARGS(node)->nd_ainfo.rest_arg);
1193             }
1194         }
1195         F_ID(nd_ainfo.block_arg, RNODE_ARGS, "block argument");
1196         F_NODE(nd_ainfo.opt_args, RNODE_ARGS, "optional arguments");
1197         F_NODE(nd_ainfo.kw_args, RNODE_ARGS, "keyword arguments");
1198         LAST_NODE;
1199         F_NODE(nd_ainfo.kw_rest_arg, RNODE_ARGS, "keyword rest argument");
1200         return;
1201
1202       case NODE_SCOPE:
1203         ANN("new scope");
1204         ANN("format: [nd_tbl]: local table, [nd_args]: arguments, [nd_body]: body");
1205         F_CUSTOM1(nd_tbl, "local table") {
1206             rb_ast_id_table_t *tbl = RNODE_SCOPE(node)->nd_tbl;
1207             int i;
1208             int size = tbl ? tbl->size : 0;
1209             if (size == 0) A("(empty)");
1210             for (i = 0; i < size; i++) {
1211                 A_ID(tbl->ids[i]); if (i < size - 1) A(",");
1212             }
1213         }
1214         F_NODE(nd_args, RNODE_SCOPE, "arguments");
1215         LAST_NODE;
1216         F_NODE(nd_body, RNODE_SCOPE, "body");
1217         return;
1218
1219       case NODE_ARYPTN:
1220         ANN("array pattern");
1221         ANN("format: [nd_pconst]([pre_args], ..., *[rest_arg], [post_args], ...)");
1222         F_NODE(nd_pconst, RNODE_ARYPTN, "constant");
1223         F_NODE(pre_args, RNODE_ARYPTN, "pre arguments");
1224         if (NODE_NAMED_REST_P(RNODE_ARYPTN(node)->rest_arg)) {
1225             F_NODE(rest_arg, RNODE_ARYPTN, "rest argument");
1226         }
1227         else {
1228             F_MSG(rest_arg, "rest argument", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
1229         }
1230         LAST_NODE;
1231         F_NODE(post_args, RNODE_ARYPTN, "post arguments");
1232         return;
1233
1234       case NODE_FNDPTN:
1235         ANN("find pattern");
1236         ANN("format: [nd_pconst](*[pre_rest_arg], args, ..., *[post_rest_arg])");
1237         F_NODE(nd_pconst, RNODE_FNDPTN, "constant");
1238         if (NODE_NAMED_REST_P(RNODE_FNDPTN(node)->pre_rest_arg)) {
1239             F_NODE(pre_rest_arg, RNODE_FNDPTN, "pre rest argument");
1240         }
1241         else {
1242             F_MSG(pre_rest_arg, "pre rest argument", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
1243         }
1244         F_NODE(args, RNODE_FNDPTN, "arguments");
1245
1246         LAST_NODE;
1247         if (NODE_NAMED_REST_P(RNODE_FNDPTN(node)->post_rest_arg)) {
1248             F_NODE(post_rest_arg, RNODE_FNDPTN, "post rest argument");
1249         }
1250         else {
1251             F_MSG(post_rest_arg, "post rest argument", "NODE_SPECIAL_NO_NAME_REST (rest argument without name)");
1252         }
1253         return;
1254
1255       case NODE_HSHPTN:
1256         ANN("hash pattern");
1257         ANN("format: [nd_pconst]([nd_pkwargs], ..., **[nd_pkwrestarg])");
1258         F_NODE(nd_pconst, RNODE_HSHPTN, "constant");
1259         F_NODE(nd_pkwargs, RNODE_HSHPTN, "keyword arguments");
1260         LAST_NODE;
1261         if (RNODE_HSHPTN(node)->nd_pkwrestarg == NODE_SPECIAL_NO_REST_KEYWORD) {
1262             F_MSG(nd_pkwrestarg, "keyword rest argument", "NODE_SPECIAL_NO_REST_KEYWORD (**nil)");
1263         }
1264         else {
1265             F_NODE(nd_pkwrestarg, RNODE_HSHPTN, "keyword rest argument");
1266         }
1267         return;
1268
1269       case NODE_LINE:
1270         ANN("line");
1271         ANN("format: [lineno]");
1272         ANN("example: __LINE__");
1273         return;
1274
1275       case NODE_FILE:
1276         ANN("line");
1277         ANN("format: [path]");
1278         ANN("example: __FILE__");
1279         F_VALUE(path, rb_node_file_path_val(node), "path");
1280         return;
1281
1282       case NODE_ENCODING:
1283         ANN("encoding");
1284         ANN("format: [enc]");
1285         ANN("example: __ENCODING__");
1286         F_VALUE(enc, rb_node_encoding_val(node), "enc");
1287         return;
1288
1289       case NODE_ERROR:
1290         ANN("Broken input recovered by Error Tolerant mode");
1291         return;
1292
1293       case NODE_ARGS_AUX:
1294       case NODE_LAST:
1295         break;
1296     }
1297
1298     rb_bug("dump_node: unknown node: %s", ruby_node_name(nd_type(node)));
1299 }
1300
1301 VALUE
1302 rb_parser_dump_tree(const NODE *node, int comment)
1303 {
1304     VALUE buf = rb_str_new_cstr(
1305         "###########################################################\n"
1306         "## Do NOT use this node dump for any purpose other than  ##\n"
1307         "## debug and research.  Compatibility is not guaranteed. ##\n"
1308         "###########################################################\n\n"
1309     );
1310     dump_node(buf, rb_str_new_cstr("# "), comment, node);
1311     return buf;
1312 }