ruby-internal 0.7.3 → 0.8.0

data/ext/internal/node/block.h

@@ -7,6 +7,26 @@
 #include "env.h"
 #endif
 
+struct BLOCK {
+    NODE *var;
+    NODE *body;
+    VALUE self;
+    struct FRAME frame;
+    struct SCOPE *scope;
+    VALUE klass;
+    NODE *cref;
+    int iter;
+    int vmode;
+    int flags;
+    int uniq;
+    struct RVarmap *dyna_vars;
+    VALUE orig_thread;
+    VALUE wrapper;
+    VALUE block_obj;
+    struct BLOCK *outer;
+    struct BLOCK *prev;
+};
+
 
 #endif
 

data/ext/internal/node/extconf.rb

@@ -40,5 +40,7 @@ $CPPFLAGS << " -DRUBY_VERSION_CODE=#{ruby_version_code}"
 
 have_header('ruby/node.h') or have_header('node.h')
 
+have_type('struct RTypedData')
+
 create_ruby_internal_makefile 'internal/node/node'
 

data/ext/internal/node/global_entry.h

@@ -3,30 +3,39 @@
 
 st_table * rb_global_tbl;
 
-#define global_entry rb_global_entry
-#define gvar_getter_t rb_gvar_getter_t
-#define gvar_setter_t rb_gvar_setter_t
-#define gvar_marker_t rb_gvar_marker_t
-
+struct trace_var {
+    int removed;
+    void (*func)();
+    VALUE data;
+    struct trace_var *next;
+};
 struct global_variable {
     int   counter;
     void *data;
-    gvar_getter_t *getter;
-    gvar_setter_t *setter;
-    gvar_marker_t *marker;
+    VALUE (*getter)();
+    void  (*setter)();
+    void  (*marker)();
     int block_trace;
     struct trace_var *trace;
 };
-#define undef_getter	rb_gvar_undef_getter
-#define undef_setter	rb_gvar_undef_setter
-#define undef_marker	rb_gvar_undef_marker
+struct global_entry {
+    struct global_variable *var;
+    ID id;
+};
+static VALUE undef_getter();
+static void  undef_setter();
+static void  undef_marker();
+static VALUE val_getter();
+static void  val_setter();
+static void  val_marker();
 struct global_entry*
-rb_global_entry(ID id)
+rb_global_entry(id)
+    ID id;
 {
     struct global_entry *entry;
     st_data_t data;
 
-    if (!st_lookup(rb_global_tbl, (st_data_t)id, &data)) {
+    if (!st_lookup(rb_global_tbl, id, &data)) {
 	struct global_variable *var;
 	entry = ALLOC(struct global_entry);
 	var = ALLOC(struct global_variable);
@@ -47,6 +56,53 @@ rb_global_entry(ID id)
     }
     return entry;
 }
+static VALUE
+undef_getter(id)
+    ID id;
+{
+    rb_warning("global variable `%s' not initialized", rb_id2name(id));
+
+    return Qnil;
+}
+static void
+undef_setter(val, id, data, var)
+    VALUE val;
+    ID id;
+    void *data;
+    struct global_variable *var;
+{
+    var->getter = val_getter;
+    var->setter = val_setter;
+    var->marker = val_marker;
+
+    var->data = (void*)val;
+}
+static void
+undef_marker()
+{
+}
+static VALUE
+val_getter(id, val)
+    ID id;
+    VALUE val;
+{
+    return val;
+}
+static void
+val_setter(val, id, data, var)
+    VALUE val;
+    ID id;
+    void *data;
+    struct global_variable *var;
+{
+    var->data = (void*)val;
+}
+static void
+val_marker(data)
+    VALUE data;
+{
+    if (data) rb_gc_mark_maybe(data);
+}
 
 #endif
 

data/ext/internal/node/global_entry.h.rpp

@@ -14,8 +14,17 @@ st_table * rb_global_tbl;
     prev_line = ''
     while (line = variable_c.gets) != nil do
       case line
-      when /^rb_global_entry\(.*\)/,
-           /^struct global_variable {/
+      when /^struct (global_entry|global_variable|trace_var)\s*\{/
+        write = true
+        stopwrite = false
+      when /^static\s+(VALUE|void)\s+(undef_getter|undef_setter|undef_marker)\(\)/,
+           /^static\s+(VALUE|void)\s+(val_getter|val_setter|val_marker)\(\)/
+        write = true
+        stopwrite = true
+      when /^(rb_global_entry)\(.*\)/,
+           /^(undef_getter|undef_setter|undef_marker)\(.*\)/,
+           /^(val_getter|val_setter|val_marker)\(.*\)/,
+           /^struct global_variable \{/
         puts prev_line
         write = true
         stopwrite = false

data/ext/internal/node/node.c

@@ -32,6 +32,22 @@
 #define RARRAY_PTR(a) RARRAY(a)->ptr
 #endif
 
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+
+#  undef GetThreadPtr
+#  define GetThreadPtr(obj, ptr) \
+   TypedData_Get_Struct((obj), rb_thread_t, p_ruby_threadptr_data_type, (ptr))
+
+  static rb_data_type_t const * p_ruby_threadptr_data_type;
+
+  static void init_ruby_threadptr_data_type()
+  {
+    VALUE thread = rb_thread_current();
+    p_ruby_threadptr_data_type = RTYPEDDATA_TYPE(thread);
+  }
+
+#endif
+
 static VALUE rb_cNode = Qnil;
 static VALUE rb_cNodeType = Qnil;
 VALUE rb_cNodeSubclass[NODE_LAST];
@@ -524,8 +540,12 @@ VALUE eval_ruby_node(NODE * node, VALUE self, VALUE cref)
     if(nd_type(node) != NODE_SCOPE)
     {
       /* TODO: This is kinda hokey */
-      ID * local_tbl = ruby_current_thread->cfp->iseq
-        ? ruby_current_thread->cfp->iseq->local_table
+      VALUE thread = rb_thread_current();
+      rb_thread_t * th;
+      ID * local_tbl;
+      GetThreadPtr(thread, th);
+      local_tbl = th->cfp->iseq
+        ? th->cfp->iseq->local_table
         : 0;
       node = NEW_NODE(NODE_SCOPE, local_tbl, node, 0);
     }
@@ -784,7 +804,10 @@ static VALUE node_compile_string(int argc, VALUE * argv, VALUE self)
 #ifdef RUBY_VM
   if(!node)
   {
-    rb_exc_raise(GET_THREAD()->errinfo);
+    VALUE thread = rb_thread_current();
+    rb_thread_t * th;
+    GetThreadPtr(thread, th);
+    rb_exc_raise(th->errinfo);
   }
 #else
   if(ruby_nerrs > 0)
@@ -1170,5 +1193,9 @@ void Init_node(void)
       ruby_cref_getter,
       ruby_cref_setter);
 #endif
+
+#ifdef HAVE_TYPE_STRUCT_RTYPEDDATA
+  init_ruby_threadptr_data_type();
+#endif
 }
 

data/ext/internal/node/node_type_descrip.c

@@ -2,100 +2,109 @@
 #include "version.h"
 
 Node_Type_Descrip node_type_descrips_unsorted[] = {
-  { NODE_ALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "ALIAS" },
+  { NODE_ALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "ALIAS" },
 #ifdef HAVE_NODE_ALLOCA
-  { NODE_ALLOCA, NEN_CFNC, NEN_VALUE, NEN_CNT, "ALLOCA" },
+  { NODE_ALLOCA, NEN_CNT, NEN_CFNC, NEN_VALUE, "ALLOCA" },
 #endif
   { NODE_AND, NEN_2ND, NEN_1ST, NEN_NONE, "AND" },
-  { NODE_ARGS, NEN_REST, NEN_OPT, NEN_CNT, "ARGS" },
+  { NODE_ARGS, NEN_REST, NEN_CNT, NEN_OPT, "ARGS" },
   { NODE_ARGSCAT, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSCAT" },
   { NODE_ARGSPUSH, NEN_HEAD, NEN_BODY, NEN_NONE, "ARGSPUSH" },
-  { NODE_ARRAY, NEN_ALEN, NEN_HEAD, NEN_NEXT, "ARRAY" },
-  { NODE_ATTRASGN, NEN_RECV, NEN_ARGS, NEN_MID, "ATTRASGN" },
-  { NODE_BACK_REF, NEN_NTH, NEN_CNT, NEN_NONE, "BACK_REF" },
+  { NODE_ARRAY, NEN_NEXT, NEN_HEAD, NEN_ALEN, "ARRAY" },
+  { NODE_ATTRASGN, NEN_ARGS, NEN_RECV, NEN_MID, "ATTRASGN" },
+  { NODE_ATTRSET, NEN_VID, NEN_NONE, NEN_NONE, "ATTRSET" },
+  { NODE_BACK_REF, NEN_CNT, NEN_NTH, NEN_NONE, "BACK_REF" },
   { NODE_BEGIN, NEN_BODY, NEN_NONE, NEN_NONE, "BEGIN" },
-  { NODE_BLOCK, NEN_HEAD, NEN_NEXT, NEN_NONE, "BLOCK" },
+  { NODE_BLOCK, NEN_NEXT, NEN_HEAD, NEN_NONE, "BLOCK" },
   { NODE_BLOCK_ARG, NEN_CNT, NEN_NONE, NEN_NONE, "BLOCK_ARG" },
-  { NODE_BLOCK_PASS, NEN_BODY, NEN_ITER, NEN_NONE, "BLOCK_PASS" },
+  { NODE_BLOCK_PASS, NEN_ITER, NEN_BODY, NEN_NONE, "BLOCK_PASS" },
   { NODE_BMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "BMETHOD" },
   { NODE_BREAK, NEN_STTS, NEN_NONE, NEN_NONE, "BREAK" },
   { NODE_CALL, NEN_ARGS, NEN_MID, NEN_RECV, "CALL" },
-  { NODE_CASE, NEN_HEAD, NEN_BODY, NEN_NEXT, "CASE" },
+  { NODE_CASE, NEN_NEXT, NEN_HEAD, NEN_BODY, "CASE" },
   { NODE_CDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CDECL" },
+  { NODE_CFUNC, NEN_ARGC, NEN_CFNC, NEN_NONE, "CFUNC" },
   { NODE_CLASS, NEN_SUPER, NEN_CPATH, NEN_BODY, "CLASS" },
   { NODE_COLON2, NEN_HEAD, NEN_MID, NEN_NONE, "COLON2" },
   { NODE_COLON3, NEN_MID, NEN_NONE, NEN_NONE, "COLON3" },
   { NODE_CONST, NEN_VID, NEN_NONE, NEN_NONE, "CONST" },
+  { NODE_CREF, NEN_NEXT, NEN_BODY, NEN_CLSS, "CREF" },
   { NODE_CVAR, NEN_VID, NEN_NONE, NEN_NONE, "CVAR" },
   { NODE_CVASGN, NEN_VALUE, NEN_VID, NEN_NONE, "CVASGN" },
   { NODE_CVDECL, NEN_VALUE, NEN_VID, NEN_NONE, "CVDECL" },
   { NODE_DASGN, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN" },
   { NODE_DASGN_CURR, NEN_VALUE, NEN_VID, NEN_NONE, "DASGN_CURR" },
   { NODE_DEFINED, NEN_HEAD, NEN_NONE, NEN_NONE, "DEFINED" },
-  { NODE_DEFN, NEN_DEFN, NEN_MID, NEN_NOEX, "DEFN" },
-  { NODE_DEFS, NEN_DEFN, NEN_RECV, NEN_MID, "DEFS" },
-  { NODE_DOT2, NEN_BEG, NEN_END, NEN_STATE, "DOT2" },
-  { NODE_DOT3, NEN_BEG, NEN_END, NEN_STATE, "DOT3" },
-  { NODE_DREGX, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX" },
-  { NODE_DREGX_ONCE, NEN_LIT, NEN_NEXT, NEN_CFLAG, "DREGX_ONCE" },
-  { NODE_DSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DSTR" },
-  { NODE_DSYM, NEN_LIT, NEN_NEXT, NEN_NONE, "DSYM" },
+  { NODE_DEFN, NEN_MID, NEN_NOEX, NEN_DEFN, "DEFN" },
+  { NODE_DEFS, NEN_RECV, NEN_MID, NEN_DEFN, "DEFS" },
+  { NODE_DMETHOD, NEN_CVAL, NEN_NONE, NEN_NONE, "DMETHOD" },
+  { NODE_DOT2, NEN_END, NEN_STATE, NEN_BEG, "DOT2" },
+  { NODE_DOT3, NEN_END, NEN_STATE, NEN_BEG, "DOT3" },
+  { NODE_DREGX, NEN_NEXT, NEN_LIT, NEN_CFLAG, "DREGX" },
+  { NODE_DREGX_ONCE, NEN_NEXT, NEN_LIT, NEN_CFLAG, "DREGX_ONCE" },
+  { NODE_DSTR, NEN_NEXT, NEN_LIT, NEN_NONE, "DSTR" },
+  { NODE_DSYM, NEN_NEXT, NEN_LIT, NEN_NONE, "DSYM" },
   { NODE_DVAR, NEN_VID, NEN_NONE, NEN_NONE, "DVAR" },
-  { NODE_DXSTR, NEN_LIT, NEN_NEXT, NEN_NONE, "DXSTR" },
+  { NODE_DXSTR, NEN_NEXT, NEN_LIT, NEN_NONE, "DXSTR" },
   { NODE_ENSURE, NEN_HEAD, NEN_ENSR, NEN_NONE, "ENSURE" },
   { NODE_EVSTR, NEN_BODY, NEN_NONE, NEN_NONE, "EVSTR" },
   { NODE_FALSE, NEN_NONE, NEN_NONE, NEN_NONE, "FALSE" },
+  { NODE_FBODY, NEN_ORIG, NEN_HEAD, NEN_MID, "FBODY" },
   { NODE_FCALL, NEN_ARGS, NEN_MID, NEN_NONE, "FCALL" },
-  { NODE_FLIP2, NEN_CNT, NEN_BEG, NEN_END, "FLIP2" },
-  { NODE_FLIP3, NEN_CNT, NEN_BEG, NEN_END, "FLIP3" },
-  { NODE_FOR, NEN_BODY, NEN_ITER, NEN_VAR, "FOR" },
-  { NODE_GASGN, NEN_VALUE, NEN_VID, NEN_ENTRY, "GASGN" },
-  { NODE_GVAR, NEN_VID, NEN_ENTRY, NEN_NONE, "GVAR" },
+  { NODE_FLIP2, NEN_CNT, NEN_END, NEN_BEG, "FLIP2" },
+  { NODE_FLIP3, NEN_CNT, NEN_END, NEN_BEG, "FLIP3" },
+  { NODE_FOR, NEN_ITER, NEN_BODY, NEN_VAR, "FOR" },
+  { NODE_GASGN, NEN_ENTRY, NEN_VALUE, NEN_VID, "GASGN" },
+  { NODE_GVAR, NEN_ENTRY, NEN_VID, NEN_NONE, "GVAR" },
   { NODE_HASH, NEN_HEAD, NEN_NONE, NEN_NONE, "HASH" },
   { NODE_IASGN, NEN_VALUE, NEN_VID, NEN_NONE, "IASGN" },
-  { NODE_IF, NEN_COND, NEN_BODY, NEN_ELSE, "IF" },
-  { NODE_IFUNC, NEN_CFNC, NEN_TVAL, NEN_STATE, "IFUNC" },
-  { NODE_ITER, NEN_BODY, NEN_ITER, NEN_VAR, "ITER" },
+  { NODE_IF, NEN_ELSE, NEN_BODY, NEN_COND, "IF" },
+  { NODE_IFUNC, NEN_TVAL, NEN_CFNC, NEN_STATE, "IFUNC" },
+  { NODE_ITER, NEN_ITER, NEN_BODY, NEN_VAR, "ITER" },
   { NODE_IVAR, NEN_VID, NEN_NONE, NEN_NONE, "IVAR" },
-  { NODE_LASGN, NEN_VALUE, NEN_VID, NEN_CNT, "LASGN" },
+  { NODE_LASGN, NEN_CNT, NEN_VALUE, NEN_VID, "LASGN" },
   { NODE_LIT, NEN_LIT, NEN_NONE, NEN_NONE, "LIT" },
-  { NODE_LVAR, NEN_VID, NEN_CNT, NEN_NONE, "LVAR" },
+  { NODE_LVAR, NEN_CNT, NEN_VID, NEN_NONE, "LVAR" },
   { NODE_MASGN, NEN_ARGS, NEN_HEAD, NEN_VALUE, "MASGN" },
   { NODE_MATCH, NEN_LIT, NEN_VALUE, NEN_NONE, "MATCH" },
   { NODE_MATCH2, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH2" },
   { NODE_MATCH3, NEN_RECV, NEN_VALUE, NEN_NONE, "MATCH3" },
   { NODE_MEMO, NEN_NONE, NEN_NONE, NEN_NONE, "MEMO" },
+  { NODE_METHOD, NEN_BODY, NEN_NOEX, NEN_NONE, "METHOD" },
   { NODE_MODULE, NEN_CPATH, NEN_BODY, NEN_NONE, "MODULE" },
+  { NODE_NEWLINE, NEN_NEXT, NEN_NONE, NEN_NONE, "NEWLINE" },
   { NODE_NEXT, NEN_STTS, NEN_NONE, NEN_NONE, "NEXT" },
   { NODE_NIL, NEN_NONE, NEN_NONE, NEN_NONE, "NIL" },
-  { NODE_NTH_REF, NEN_NTH, NEN_CNT, NEN_NONE, "NTH_REF" },
+  { NODE_NOT, NEN_BODY, NEN_NONE, NEN_NONE, "NOT" },
+  { NODE_NTH_REF, NEN_CNT, NEN_NTH, NEN_NONE, "NTH_REF" },
   { NODE_OPT_N, NEN_BODY, NEN_NONE, NEN_NONE, "OPT_N" },
   { NODE_OP_ASGN1, NEN_ARGS, NEN_MID, NEN_RECV, "OP_ASGN1" },
-  { NODE_OP_ASGN2, NEN_RECV, NEN_NEXT, NEN_VALUE, "OP_ASGN2" },
-  { NODE_OP_ASGN2_ARG, NEN_VID, NEN_AID, NEN_MID, "OP_ASGN2_ARG" },
+  { NODE_OP_ASGN2, NEN_NEXT, NEN_RECV, NEN_VALUE, "OP_ASGN2" },
+  { NODE_OP_ASGN2_ARG, NEN_AID, NEN_MID, NEN_VID, "OP_ASGN2_ARG" },
   { NODE_OP_ASGN_AND, NEN_RECV, NEN_VALUE, NEN_NONE, "OP_ASGN_AND" },
   { NODE_OP_ASGN_OR, NEN_AID, NEN_VALUE, NEN_RECV, "OP_ASGN_OR" },
   { NODE_OR, NEN_2ND, NEN_1ST, NEN_NONE, "OR" },
   { NODE_POSTEXE, NEN_NONE, NEN_NONE, NEN_NONE, "POSTEXE" },
   { NODE_REDO, NEN_NONE, NEN_NONE, NEN_NONE, "REDO" },
-  { NODE_RESBODY, NEN_HEAD, NEN_BODY, NEN_ARGS, "RESBODY" },
-  { NODE_RESCUE, NEN_HEAD, NEN_RESQ, NEN_ELSE, "RESCUE" },
+  { NODE_RESBODY, NEN_ARGS, NEN_HEAD, NEN_BODY, "RESBODY" },
+  { NODE_RESCUE, NEN_RESQ, NEN_HEAD, NEN_ELSE, "RESCUE" },
   { NODE_RETRY, NEN_NONE, NEN_NONE, NEN_NONE, "RETRY" },
   { NODE_RETURN, NEN_STTS, NEN_NONE, NEN_NONE, "RETURN" },
   { NODE_SCLASS, NEN_BODY, NEN_RECV, NEN_NONE, "SCLASS" },
-  { NODE_SCOPE, NEN_TBL, NEN_RVAL, NEN_NEXT, "SCOPE" },
+  { NODE_SCOPE, NEN_NEXT, NEN_TBL, NEN_RVAL, "SCOPE" },
   { NODE_SELF, NEN_NONE, NEN_NONE, NEN_NONE, "SELF" },
   { NODE_SPLAT, NEN_HEAD, NEN_NONE, NEN_NONE, "SPLAT" },
   { NODE_STR, NEN_LIT, NEN_NONE, NEN_NONE, "STR" },
   { NODE_SUPER, NEN_ARGS, NEN_NONE, NEN_NONE, "SUPER" },
+  { NODE_SVALUE, NEN_HEAD, NEN_NONE, NEN_NONE, "SVALUE" },
   { NODE_TO_ARY, NEN_HEAD, NEN_NONE, NEN_NONE, "TO_ARY" },
   { NODE_TRUE, NEN_NONE, NEN_NONE, NEN_NONE, "TRUE" },
   { NODE_UNDEF, NEN_BODY, NEN_NONE, NEN_NONE, "UNDEF" },
-  { NODE_UNTIL, NEN_BODY, NEN_COND, NEN_STATE, "UNTIL" },
-  { NODE_VALIAS, NEN_1ST, NEN_2ND, NEN_NONE, "VALIAS" },
+  { NODE_UNTIL, NEN_BODY, NEN_STATE, NEN_COND, "UNTIL" },
+  { NODE_VALIAS, NEN_2ND, NEN_1ST, NEN_NONE, "VALIAS" },
   { NODE_VCALL, NEN_MID, NEN_NONE, NEN_NONE, "VCALL" },
-  { NODE_WHEN, NEN_HEAD, NEN_BODY, NEN_NEXT, "WHEN" },
-  { NODE_WHILE, NEN_BODY, NEN_COND, NEN_STATE, "WHILE" },
+  { NODE_WHEN, NEN_NEXT, NEN_HEAD, NEN_BODY, "WHEN" },
+  { NODE_WHILE, NEN_BODY, NEN_STATE, NEN_COND, "WHILE" },
   { NODE_XSTR, NEN_LIT, NEN_NONE, NEN_NONE, "XSTR" },
   { NODE_YIELD, NEN_HEAD, NEN_STATE, NEN_NONE, "YIELD" },
   { NODE_ZARRAY, NEN_NONE, NEN_NONE, NEN_NONE, "ZARRAY" },

data/ext/internal/node/nodeinfo.c

@@ -450,8 +450,28 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
         return ID2SYM(n->nd_entry->id);
       }
     case NEN_FRML:
+      if(n->nd_frml)
       {
-      return LONG2NUM((long)n->nd_frml);
+        int node_type;
+        if(0 && nd_type(n) == NODE_OP_ASGN2)
+        {
+          /* All children of NODE_OP_ASGN2 are NODE_OP_ASGN2_ARG */
+          node_type = NODE_OP_ASGN2_ARG;
+        }
+        else
+        {
+          node_type = nd_type(n->nd_frml);
+        }
+
+        dump_node_or_iseq_to_hash(
+          (VALUE)n->nd_frml,
+          node_type,
+          node_hash);
+        return node_id(n->nd_frml);
+      }
+      else
+      {
+        return Qnil;
       }
     case NEN_HEAD:
       if(n->nd_head)
@@ -477,6 +497,30 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
       {
         return Qnil;
       }
+    case NEN_IBDY:
+      if(n->nd_ibdy)
+      {
+        int node_type;
+        if(0 && nd_type(n) == NODE_OP_ASGN2)
+        {
+          /* All children of NODE_OP_ASGN2 are NODE_OP_ASGN2_ARG */
+          node_type = NODE_OP_ASGN2_ARG;
+        }
+        else
+        {
+          node_type = nd_type(n->nd_ibdy);
+        }
+
+        dump_node_or_iseq_to_hash(
+          (VALUE)n->nd_ibdy,
+          node_type,
+          node_hash);
+        return node_id(n->nd_ibdy);
+      }
+      else
+      {
+        return Qnil;
+      }
     case NEN_ITER:
       if(n->nd_iter)
       {
@@ -601,19 +645,6 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
       {
       return LONG2NUM((long)n->nd_nth);
       }
-    case NEN_OID:
-      if(n->nd_oid == 0)
-      {
-        return Qfalse;
-      }
-      else if(n->nd_oid == 1)
-      {
-        return Qtrue;
-      }
-      else
-      {
-        return ID2SYM(n->nd_oid);
-      }
     case NEN_OPT:
       if(n->nd_opt)
       {
@@ -680,23 +711,6 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
               INT2NUM(TYPE((VALUE)n->nd_orig)),
               (VALUE)n->nd_orig);
       }
-    case NEN_PID:
-      if(n->nd_pid == 0)
-      {
-        return Qfalse;
-      }
-      else if(n->nd_pid == 1)
-      {
-        return Qtrue;
-      }
-      else
-      {
-        return ID2SYM(n->nd_pid);
-      }
-    case NEN_PLEN:
-      {
-      return LONG2NUM((long)n->nd_plen);
-      }
     case NEN_RECV:
       if(n->nd_recv)
       {
@@ -746,17 +760,28 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
         return Qnil;
       }
     case NEN_REST:
-      if(n->nd_rest == 0)
+      if(n->nd_rest)
       {
-        return Qfalse;
-      }
-      else if(n->nd_rest == 1)
-      {
-        return Qtrue;
+        int node_type;
+        if(0 && nd_type(n) == NODE_OP_ASGN2)
+        {
+          /* All children of NODE_OP_ASGN2 are NODE_OP_ASGN2_ARG */
+          node_type = NODE_OP_ASGN2_ARG;
+        }
+        else
+        {
+          node_type = nd_type(n->nd_rest);
+        }
+
+        dump_node_or_iseq_to_hash(
+          (VALUE)n->nd_rest,
+          node_type,
+          node_hash);
+        return node_id(n->nd_rest);
       }
       else
       {
-        return ID2SYM(n->nd_rest);
+        return Qnil;
       }
     case NEN_RVAL:
       if(n->nd_2nd)
@@ -955,10 +980,6 @@ VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash)
       {
         return ID2SYM(n->nd_vid);
       }
-    case NEN_VISI:
-      {
-      return LONG2NUM((long)n->nd_visi);
-      }
   }
   rb_raise(rb_eArgError, "Invalid Node_Elem_Name %d", nen);
 }
@@ -1365,7 +1386,27 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_FRML:
     {
-      n->nd_frml = NUM2LONG(v);
+      if(v == Qnil)
+      {
+        n->nd_frml = 0;
+      }
+      else
+      {
+        VALUE nid = rb_hash_aref(id_hash, v);
+        if(RTEST(nid))
+        {
+          n->nd_frml = id_to_node(nid);
+        }
+        else
+        {
+          n->u1.node = (NODE *)load_node_or_iseq_from_hash(
+              v, node_hash, id_hash);
+          if(nd_type(n->u1.node) == NODE_OP_ASGN2_ARG)
+          {
+            nd_set_type(n->u1.node, NODE_OP_ASGN2);
+          }
+        }
+      }
       return;
       }
     case NEN_HEAD:
@@ -1393,6 +1434,31 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
       return;
       }
+    case NEN_IBDY:
+    {
+      if(v == Qnil)
+      {
+        n->nd_ibdy = 0;
+      }
+      else
+      {
+        VALUE nid = rb_hash_aref(id_hash, v);
+        if(RTEST(nid))
+        {
+          n->nd_ibdy = id_to_node(nid);
+        }
+        else
+        {
+          n->u2.node = (NODE *)load_node_or_iseq_from_hash(
+              v, node_hash, id_hash);
+          if(nd_type(n->u2.node) == NODE_OP_ASGN2_ARG)
+          {
+            nd_set_type(n->u2.node, NODE_OP_ASGN2);
+          }
+        }
+      }
+      return;
+      }
     case NEN_ITER:
     {
       if(v == Qnil)
@@ -1522,22 +1588,6 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       n->nd_nth = NUM2LONG(v);
       return;
       }
-    case NEN_OID:
-    {
-      if(v == Qfalse)
-      {
-        n->nd_oid = 0;
-      }
-      else if(v == Qfalse)
-      {
-        n->nd_oid = 1;
-      }
-      else
-      {
-        n->nd_oid = SYM2ID(v);
-      }
-      return;
-      }
     case NEN_OPT:
     {
       if(v == Qnil)
@@ -1600,27 +1650,6 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
       return;
       }
-    case NEN_PID:
-    {
-      if(v == Qfalse)
-      {
-        n->nd_pid = 0;
-      }
-      else if(v == Qfalse)
-      {
-        n->nd_pid = 1;
-      }
-      else
-      {
-        n->nd_pid = SYM2ID(v);
-      }
-      return;
-      }
-    case NEN_PLEN:
-    {
-      n->nd_plen = NUM2LONG(v);
-      return;
-      }
     case NEN_RECV:
     {
       if(v == Qnil)
@@ -1673,17 +1702,26 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
     case NEN_REST:
     {
-      if(v == Qfalse)
+      if(v == Qnil)
       {
         n->nd_rest = 0;
       }
-      else if(v == Qfalse)
-      {
-        n->nd_rest = 1;
-      }
       else
       {
-        n->nd_rest = SYM2ID(v);
+        VALUE nid = rb_hash_aref(id_hash, v);
+        if(RTEST(nid))
+        {
+          n->nd_rest = id_to_node(nid);
+        }
+        else
+        {
+          n->u2.node = (NODE *)load_node_or_iseq_from_hash(
+              v, node_hash, id_hash);
+          if(nd_type(n->u2.node) == NODE_OP_ASGN2_ARG)
+          {
+            nd_set_type(n->u2.node, NODE_OP_ASGN2);
+          }
+        }
       }
       return;
       }
@@ -1921,11 +1959,6 @@ void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash,
       }
       return;
       }
-    case NEN_VISI:
-    {
-      n->nd_visi = NUM2LONG(v);
-      return;
-      }
   }
   rb_raise(rb_eRuntimeError, "Internal error: invalid Node_Elem_Name %d", nen);
 }
@@ -2015,6 +2048,16 @@ static VALUE node_alen(VALUE self)
   Data_Get_Struct(self, NODE, n);
   return LONG2NUM(n->nd_alen);
 }
+/*
+ * Return the Node's _argc_ member.  The return type is an
+ * Integer.
+ */
+static VALUE node_argc(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+  return LONG2NUM(n->nd_argc);
+}
 /*
  * Return the Node's _args_ member.  The return type is
  * either a Node or an Object.
@@ -2112,6 +2155,33 @@ static VALUE node_cfnc(VALUE self)
   Data_Get_Struct(self, NODE, n);
   return LONG2NUM((long)(n->nd_cfnc));
 }
+/*
+ * Return the Node's _clss_ member.  The return type is
+ * either a Node or an Object.
+ */
+static VALUE node_clss(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+
+  if(TYPE(n->nd_clss) == T_NODE)
+  {
+    if(0 && nd_type(n) == NODE_OP_ASGN2)
+    {
+      return wrap_node_as(
+        (NODE *)n->nd_clss,
+        rb_cNodeSubclass[NODE_OP_ASGN2_ARG]);
+    }
+    else
+    {
+      return wrap_node((NODE *)n->nd_clss);
+    }
+  }
+  else
+  {
+    return (VALUE)n->nd_clss;
+  }
+}
 /*
  * Return the Node's _cnt_ member.  The return type is an
  * Integer.
@@ -2504,6 +2574,33 @@ static VALUE node_opt(VALUE self)
     return (VALUE)n->nd_opt;
   }
 }
+/*
+ * Return the Node's _orig_ member.  The return type is
+ * either a Node or an Object.
+ */
+static VALUE node_orig(VALUE self)
+{
+  NODE * n;
+  Data_Get_Struct(self, NODE, n);
+
+  if(TYPE(n->nd_orig) == T_NODE)
+  {
+    if(0 && nd_type(n) == NODE_OP_ASGN2)
+    {
+      return wrap_node_as(
+        (NODE *)n->nd_orig,
+        rb_cNodeSubclass[NODE_OP_ASGN2_ARG]);
+    }
+    else
+    {
+      return wrap_node((NODE *)n->nd_orig);
+    }
+  }
+  else
+  {
+    return (VALUE)n->nd_orig;
+  }
+}
 /*
  * Return the Node's _recv_ member.  The return type is
  * either a Node or an Object.
@@ -2559,24 +2656,30 @@ static VALUE node_resq(VALUE self)
   }
 }
 /*
- * Return the Node's _rest_ member.  The return type is a
- * Symbol.
+ * Return the Node's _rest_ member.  The return type is
+ * either a Node or an Object.
  */
 static VALUE node_rest(VALUE self)
 {
   NODE * n;
   Data_Get_Struct(self, NODE, n);
-  if(n->nd_rest == 0)
-  {
-    return Qfalse;
-  }
-  else if(n->nd_rest == 1)
+
+  if(TYPE(n->nd_rest) == T_NODE)
   {
-    return Qtrue;
+    if(0 && nd_type(n) == NODE_OP_ASGN2)
+    {
+      return wrap_node_as(
+        (NODE *)n->nd_rest,
+        rb_cNodeSubclass[NODE_OP_ASGN2_ARG]);
+    }
+    else
+    {
+      return wrap_node((NODE *)n->nd_rest);
+    }
   }
   else
   {
-    return ID2SYM(n->nd_rest);
+    return (VALUE)n->nd_rest;
   }
 }
 /*
@@ -2822,10 +2925,10 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cALIAS, "__member__", members);
     rb_iv_set(rb_cALIAS, "__type__", INT2NUM(NODE_ALIAS));
     rb_define_singleton_method(rb_cALIAS, "members", node_s_members, 0);
-    rb_define_method(rb_cALIAS, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
     rb_define_method(rb_cALIAS, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+    rb_define_method(rb_cALIAS, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::ALLOCA
@@ -2843,12 +2946,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cALLOCA, "__type__", INT2NUM(NODE_ALLOCA));
     rb_define_singleton_method(rb_cALLOCA, "members", node_s_members, 0);
 
-    /* Document-method: cfnc
-     * a pointer to the allocated memory
-     */
-    rb_define_method(rb_cALLOCA, "cfnc", node_cfnc, 0);
-    rb_ary_push(members, rb_str_new2("cfnc"));
-
     /* Document-method: value
      * a pointer to the previously allocated temporary node
      */
@@ -2860,6 +2957,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cALLOCA, "cnt", node_cnt, 0);
     rb_ary_push(members, rb_str_new2("cnt"));
+
+    /* Document-method: cfnc
+     * a pointer to the allocated memory
+     */
+    rb_define_method(rb_cALLOCA, "cfnc", node_cfnc, 0);
+    rb_ary_push(members, rb_str_new2("cfnc"));
   }
 #endif
 
@@ -2908,19 +3011,19 @@ void define_node_subclass_methods()
     rb_define_method(rb_cARGS, "rest", node_rest, 0);
     rb_ary_push(members, rb_str_new2("rest"));
 
+    /* Document-method: cnt
+     * the number of required arguments
+     */
+    rb_define_method(rb_cARGS, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
+
     /* Document-method: opt
      * a list of assignment nodes to assign default values to the
      * optional arguments if no argument is specified
      */
     rb_define_method(rb_cARGS, "opt", node_opt, 0);
     rb_ary_push(members, rb_str_new2("opt"));
-
-    /* Document-method: cnt
-     * the number of required arguments
-     */
-    rb_define_method(rb_cARGS, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
-  }
+  }
 
   /* Document-class: Node::ARGSCAT
    * Represents the concatenation of a list of arguments and a splatted
@@ -2985,20 +3088,20 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cARRAY, "__member__", members);
     rb_iv_set(rb_cARRAY, "__type__", INT2NUM(NODE_ARRAY));
     rb_define_singleton_method(rb_cARRAY, "members", node_s_members, 0);
-    rb_define_method(rb_cARRAY, "alen", node_alen, 0);
-    rb_ary_push(members, rb_str_new2("alen"));
-
-    /* Document-method: head
-     * the first element of the array
-     */
-    rb_define_method(rb_cARRAY, "head", node_head, 0);
-    rb_ary_push(members, rb_str_new2("head"));
 
     /* Document-method: next
      * the tail of the array
      */
     rb_define_method(rb_cARRAY, "next", node_next, 0);
     rb_ary_push(members, rb_str_new2("next"));
+
+    /* Document-method: head
+     * the first element of the array
+     */
+    rb_define_method(rb_cARRAY, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
+    rb_define_method(rb_cARRAY, "alen", node_alen, 0);
+    rb_ary_push(members, rb_str_new2("alen"));
   }
 
   /* Document-class: Node::ATTRASGN
@@ -3015,6 +3118,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cATTRASGN, "__type__", INT2NUM(NODE_ATTRASGN));
     rb_define_singleton_method(rb_cATTRASGN, "members", node_s_members, 0);
 
+    /* Document-method: mid
+     * the id of the attribute, with a trailing '=' sign
+     */
+    rb_define_method(rb_cATTRASGN, "mid", node_mid, 0);
+    rb_ary_push(members, rb_str_new2("mid"));
+
     /* Document-method: recv
      * the receiver of the method
      */
@@ -3026,12 +3135,27 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cATTRASGN, "args", node_args, 0);
     rb_ary_push(members, rb_str_new2("args"));
+  }
 
-    /* Document-method: mid
-     * the id of the attribute, with a trailing '=' sign
+  /* Document-class: Node::ATTRSET
+   * A placeholder for an attribute writer method, which can added to a
+   * class by using attr_writer:
+   *   attr_writer :attribute
+   * Its reader counterpart is IVAR.
+   */
+  {
+    VALUE rb_cATTRSET = rb_define_class_under(rb_cNode, "ATTRSET", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_ATTRSET] = rb_cATTRSET;
+    rb_iv_set(rb_cATTRSET, "__member__", members);
+    rb_iv_set(rb_cATTRSET, "__type__", INT2NUM(NODE_ATTRSET));
+    rb_define_singleton_method(rb_cATTRSET, "members", node_s_members, 0);
+
+    /* Document-method: vid
+     * the name of the attribute, with a leading '@' sign
      */
-    rb_define_method(rb_cATTRASGN, "mid", node_mid, 0);
-    rb_ary_push(members, rb_str_new2("mid"));
+    rb_define_method(rb_cATTRSET, "vid", node_vid, 0);
+    rb_ary_push(members, rb_str_new2("vid"));
   }
 
   /* Document-class: Node::BACK_REF
@@ -3098,17 +3222,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cBLOCK, "__type__", INT2NUM(NODE_BLOCK));
     rb_define_singleton_method(rb_cBLOCK, "members", node_s_members, 0);
 
-    /* Document-method: head
-     * the first expression in the block of code
-     */
-    rb_define_method(rb_cBLOCK, "head", node_head, 0);
-    rb_ary_push(members, rb_str_new2("head"));
-
     /* Document-method: next
      * the second expression in the block of code
      */
     rb_define_method(rb_cBLOCK, "next", node_next, 0);
     rb_ary_push(members, rb_str_new2("next"));
+
+    /* Document-method: head
+     * the first expression in the block of code
+     */
+    rb_define_method(rb_cBLOCK, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
   }
 
   /* Document-class: Node::BLOCK_ARG
@@ -3216,12 +3340,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCALL, "__type__", INT2NUM(NODE_CALL));
     rb_define_singleton_method(rb_cCALL, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the method
-     */
-    rb_define_method(rb_cCALL, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * the method id
      */
@@ -3233,6 +3351,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cCALL, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: args
+     * the arguments to the method
+     */
+    rb_define_method(rb_cCALL, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::CASE
@@ -3249,6 +3373,8 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCASE, "__member__", members);
     rb_iv_set(rb_cCASE, "__type__", INT2NUM(NODE_CASE));
     rb_define_singleton_method(rb_cCASE, "members", node_s_members, 0);
+    rb_define_method(rb_cCASE, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
 
     /* Document-method: head
      * the value to select on
@@ -3262,8 +3388,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cCASE, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
-    rb_define_method(rb_cCASE, "next", node_next, 0);
-    rb_ary_push(members, rb_str_new2("next"));
   }
 
   /* Document-class: Node::CDECL
@@ -3291,6 +3415,22 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("vid"));
   }
 
+  /* Document-class: Node::CFUNC
+   * A placeholder for a function implemented in C.
+   */
+  {
+    VALUE rb_cCFUNC = rb_define_class_under(rb_cNode, "CFUNC", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_CFUNC] = rb_cCFUNC;
+    rb_iv_set(rb_cCFUNC, "__member__", members);
+    rb_iv_set(rb_cCFUNC, "__type__", INT2NUM(NODE_CFUNC));
+    rb_define_singleton_method(rb_cCFUNC, "members", node_s_members, 0);
+    rb_define_method(rb_cCFUNC, "cfnc", node_cfnc, 0);
+    rb_ary_push(members, rb_str_new2("cfnc"));
+    rb_define_method(rb_cCFUNC, "argc", node_argc, 0);
+    rb_ary_push(members, rb_str_new2("argc"));
+  }
+
   /* Document-class: Node::CLASS
    * Represents a class definition, e.g.:
    *   class cpath
@@ -3351,17 +3491,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cCOLON2, "__type__", INT2NUM(NODE_COLON2));
     rb_define_singleton_method(rb_cCOLON2, "members", node_s_members, 0);
 
-    /* Document-method: head
-     * an expression specifying the class in which to do the lookup
-     */
-    rb_define_method(rb_cCOLON2, "head", node_head, 0);
-    rb_ary_push(members, rb_str_new2("head"));
-
     /* Document-method: mid
      * the name of the method or constant to call/look up
      */
     rb_define_method(rb_cCOLON2, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
+
+    /* Document-method: head
+     * an expression specifying the class in which to do the lookup
+     */
+    rb_define_method(rb_cCOLON2, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
   }
 
   /* Document-class: Node::COLON3
@@ -3404,6 +3544,41 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("vid"));
   }
 
+  /* Document-class: Node::CREF
+   * A temporary node used to store the value of ruby_cref or
+   * ruby_top_cref and later restore it.  The cref holds a reference to
+   * the cbase, which, among other things, is used for constant and class
+   * variable lookup.
+   * 
+   * It should never be evaluated as an expression.
+   */
+  {
+    VALUE rb_cCREF = rb_define_class_under(rb_cNode, "CREF", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_CREF] = rb_cCREF;
+    rb_iv_set(rb_cCREF, "__member__", members);
+    rb_iv_set(rb_cCREF, "__type__", INT2NUM(NODE_CREF));
+    rb_define_singleton_method(rb_cCREF, "members", node_s_members, 0);
+
+    /* Document-method: next
+     * the previous value of ruby_cref or ruby_top_cref
+     */
+    rb_define_method(rb_cCREF, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+
+    /* Document-method: body
+     * always 0 (false)
+     */
+    rb_define_method(rb_cCREF, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
+
+    /* Document-method: clss
+     * the new class to use for the cbase.
+     */
+    rb_define_method(rb_cCREF, "clss", node_clss, 0);
+    rb_ary_push(members, rb_str_new2("clss"));
+  }
+
   /* Document-class: Node::CVAR
    * Represents a class variable retrieval.  The result of the expression
    * is the value of the class variable.
@@ -3566,12 +3741,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDEFN, "__type__", INT2NUM(NODE_DEFN));
     rb_define_singleton_method(rb_cDEFN, "members", node_s_members, 0);
 
-    /* Document-method: defn
-     * the body of the method definition
-     */
-    rb_define_method(rb_cDEFN, "defn", node_defn, 0);
-    rb_ary_push(members, rb_str_new2("defn"));
-
     /* Document-method: mid
      * the name of the method* defn the body of the method
      */
@@ -3583,6 +3752,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cDEFN, "noex", node_noex, 0);
     rb_ary_push(members, rb_str_new2("noex"));
+
+    /* Document-method: defn
+     * the body of the method definition
+     */
+    rb_define_method(rb_cDEFN, "defn", node_defn, 0);
+    rb_ary_push(members, rb_str_new2("defn"));
   }
 
   /* Document-class: Node::DEFS
@@ -3598,6 +3773,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDEFS, "__member__", members);
     rb_iv_set(rb_cDEFS, "__type__", INT2NUM(NODE_DEFS));
     rb_define_singleton_method(rb_cDEFS, "members", node_s_members, 0);
+
+    /* Document-method: mid
+     * the name of the method* defn the body of the method
+     */
+    rb_define_method(rb_cDEFS, "mid", node_mid, 0);
+    rb_ary_push(members, rb_str_new2("mid"));
     rb_define_method(rb_cDEFS, "defn", node_defn, 0);
     rb_ary_push(members, rb_str_new2("defn"));
 
@@ -3606,12 +3787,29 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cDEFS, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+  }
 
-    /* Document-method: mid
-     * the name of the method* defn the body of the method
+  /* Document-class: Node::DMETHOD
+   * A placeholder for a method defined using define_method where the
+   * passed block is created from a Method object, e.g.:
+   *   define_method(:name, method(:foo))
+   * 
+   * See also BMETHOD.
+   */
+  {
+    VALUE rb_cDMETHOD = rb_define_class_under(rb_cNode, "DMETHOD", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_DMETHOD] = rb_cDMETHOD;
+    rb_iv_set(rb_cDMETHOD, "__member__", members);
+    rb_iv_set(rb_cDMETHOD, "__type__", INT2NUM(NODE_DMETHOD));
+    rb_define_singleton_method(rb_cDMETHOD, "members", node_s_members, 0);
+
+    /* Document-method: cval
+     * the Method object passed to define_method, which contains the
+     * body of the method
      */
-    rb_define_method(rb_cDEFS, "mid", node_mid, 0);
-    rb_ary_push(members, rb_str_new2("mid"));
+    rb_define_method(rb_cDMETHOD, "cval", node_cval, 0);
+    rb_ary_push(members, rb_str_new2("cval"));
   }
 
   /* Document-class: Node::DOT2
@@ -3626,20 +3824,20 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDOT2, "__member__", members);
     rb_iv_set(rb_cDOT2, "__type__", INT2NUM(NODE_DOT2));
     rb_define_singleton_method(rb_cDOT2, "members", node_s_members, 0);
-
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cDOT2, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
+    rb_define_method(rb_cDOT2, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: end
      * the end of the range
      */
     rb_define_method(rb_cDOT2, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
-    rb_define_method(rb_cDOT2, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cDOT2, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::DOT3
@@ -3654,20 +3852,20 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cDOT3, "__member__", members);
     rb_iv_set(rb_cDOT3, "__type__", INT2NUM(NODE_DOT3));
     rb_define_singleton_method(rb_cDOT3, "members", node_s_members, 0);
-
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cDOT3, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
+    rb_define_method(rb_cDOT3, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: end
      * the end of the range
      */
     rb_define_method(rb_cDOT3, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
-    rb_define_method(rb_cDOT3, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cDOT3, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::DREGX
@@ -3923,6 +4121,38 @@ void define_node_subclass_methods()
     rb_define_singleton_method(rb_cFALSE, "members", node_s_members, 0);
   }
 
+  /* Document-class: Node::FBODY
+   * A placeholder for a method alias, which can be added to a class by
+   * using alias or alias_method:
+   *   alias old new
+   */
+  {
+    VALUE rb_cFBODY = rb_define_class_under(rb_cNode, "FBODY", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_FBODY] = rb_cFBODY;
+    rb_iv_set(rb_cFBODY, "__member__", members);
+    rb_iv_set(rb_cFBODY, "__type__", INT2NUM(NODE_FBODY));
+    rb_define_singleton_method(rb_cFBODY, "members", node_s_members, 0);
+
+    /* Document-method: orig
+     * the origin class
+     */
+    rb_define_method(rb_cFBODY, "orig", node_orig, 0);
+    rb_ary_push(members, rb_str_new2("orig"));
+
+    /* Document-method: mid
+     * the name of the method
+     */
+    rb_define_method(rb_cFBODY, "mid", node_mid, 0);
+    rb_ary_push(members, rb_str_new2("mid"));
+
+    /* Document-method: head
+     * the method body
+     */
+    rb_define_method(rb_cFBODY, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
+  }
+
   /* Document-class: Node::FCALL
    * Represents a method call in the form:
    *   mid(args).
@@ -3938,17 +4168,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cFCALL, "__type__", INT2NUM(NODE_FCALL));
     rb_define_singleton_method(rb_cFCALL, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the method
-     */
-    rb_define_method(rb_cFCALL, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * the method id
      */
     rb_define_method(rb_cFCALL, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
+
+    /* Document-method: args
+     * the arguments to the method
+     */
+    rb_define_method(rb_cFCALL, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::FLIP2
@@ -3972,17 +4202,17 @@ void define_node_subclass_methods()
     rb_define_method(rb_cFLIP2, "cnt", node_cnt, 0);
     rb_ary_push(members, rb_str_new2("cnt"));
 
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cFLIP2, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
-
     /* Document-method: end
      * the end of the range
      */
     rb_define_method(rb_cFLIP2, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cFLIP2, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::FLIP3
@@ -4006,17 +4236,17 @@ void define_node_subclass_methods()
     rb_define_method(rb_cFLIP3, "cnt", node_cnt, 0);
     rb_ary_push(members, rb_str_new2("cnt"));
 
-    /* Document-method: beg
-     * the beginning of the range
-     */
-    rb_define_method(rb_cFLIP3, "beg", node_beg, 0);
-    rb_ary_push(members, rb_str_new2("beg"));
-
     /* Document-method: end
      * the end of the range
      */
     rb_define_method(rb_cFLIP3, "end", node_end, 0);
     rb_ary_push(members, rb_str_new2("end"));
+
+    /* Document-method: beg
+     * the beginning of the range
+     */
+    rb_define_method(rb_cFLIP3, "beg", node_beg, 0);
+    rb_ary_push(members, rb_str_new2("beg"));
   }
 
   /* Document-class: Node::FOR
@@ -4041,6 +4271,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cFOR, "__type__", INT2NUM(NODE_FOR));
     rb_define_singleton_method(rb_cFOR, "members", node_s_members, 0);
 
+    /* Document-method: var
+     * an assignment node which assigns the next value in the sequence
+     * to a variable, which may or may not be local.  May also be a
+     * multiple assignment.
+     */
+    rb_define_method(rb_cFOR, "var", node_var, 0);
+    rb_ary_push(members, rb_str_new2("var"));
+
     /* Document-method: body
      * the body of the loop
      */
@@ -4052,14 +4290,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cFOR, "iter", node_iter, 0);
     rb_ary_push(members, rb_str_new2("iter"));
-
-    /* Document-method: var
-     * an assignment node which assigns the next value in the sequence
-     * to a variable, which may or may not be local.  May also be a
-     * multiple assignment.
-     */
-    rb_define_method(rb_cFOR, "var", node_var, 0);
-    rb_ary_push(members, rb_str_new2("var"));
   }
 
   /* Document-class: Node::GASGN
@@ -4180,12 +4410,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cIF, "__type__", INT2NUM(NODE_IF));
     rb_define_singleton_method(rb_cIF, "members", node_s_members, 0);
 
-    /* Document-method: cond
-     * the condition to evaluate
-     */
-    rb_define_method(rb_cIF, "cond", node_cond, 0);
-    rb_ary_push(members, rb_str_new2("cond"));
-
     /* Document-method: body
      * the expression to evaluate if the expression is true, or false
      * if the expression is empty
@@ -4199,6 +4423,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cIF, "else", node_else, 0);
     rb_ary_push(members, rb_str_new2("else"));
+
+    /* Document-method: cond
+     * the condition to evaluate
+     */
+    rb_define_method(rb_cIF, "cond", node_cond, 0);
+    rb_ary_push(members, rb_str_new2("cond"));
   }
 
   /* Document-class: Node::IFUNC
@@ -4212,11 +4442,11 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cIFUNC, "__type__", INT2NUM(NODE_IFUNC));
     rb_define_singleton_method(rb_cIFUNC, "members", node_s_members, 0);
 
-    /* Document-method: cfnc
-     * a pointer to the C function to which to yield
+    /* Document-method: state
+     * always 0
      */
-    rb_define_method(rb_cIFUNC, "cfnc", node_cfnc, 0);
-    rb_ary_push(members, rb_str_new2("cfnc"));
+    rb_define_method(rb_cIFUNC, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: tval
      * the user-specified data to be passed as the second argument to
@@ -4225,11 +4455,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cIFUNC, "tval", node_tval, 0);
     rb_ary_push(members, rb_str_new2("tval"));
 
-    /* Document-method: state
-     * always 0
+    /* Document-method: cfnc
+     * a pointer to the C function to which to yield
      */
-    rb_define_method(rb_cIFUNC, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
+    rb_define_method(rb_cIFUNC, "cfnc", node_cfnc, 0);
+    rb_ary_push(members, rb_str_new2("cfnc"));
   }
 
   /* Document-class: Node::ITER
@@ -4253,6 +4483,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cITER, "__type__", INT2NUM(NODE_ITER));
     rb_define_singleton_method(rb_cITER, "members", node_s_members, 0);
 
+    /* Document-method: var
+     * an assignment node which assigns the next value in the sequence
+     * to a variable, which may or may not be local.  May also be a
+     * multiple assignment.
+     */
+    rb_define_method(rb_cITER, "var", node_var, 0);
+    rb_ary_push(members, rb_str_new2("var"));
+
     /* Document-method: body
      * the body of the loop
      */
@@ -4265,14 +4503,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cITER, "iter", node_iter, 0);
     rb_ary_push(members, rb_str_new2("iter"));
-
-    /* Document-method: var
-     * an assignment node which assigns the next value in the sequence
-     * to a variable, which may or may not be local.  May also be a
-     * multiple assignment.
-     */
-    rb_define_method(rb_cITER, "var", node_var, 0);
-    rb_ary_push(members, rb_str_new2("var"));
   }
 
   /* Document-class: Node::IVAR
@@ -4312,14 +4542,14 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cLASGN, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
+    rb_define_method(rb_cLASGN, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: vid
      * the name of the local variable
      */
     rb_define_method(rb_cLASGN, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
-    rb_define_method(rb_cLASGN, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 
   /* Document-class: Node::LIT
@@ -4351,14 +4581,14 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cLVAR, "__member__", members);
     rb_iv_set(rb_cLVAR, "__type__", INT2NUM(NODE_LVAR));
     rb_define_singleton_method(rb_cLVAR, "members", node_s_members, 0);
+    rb_define_method(rb_cLVAR, "cnt", node_cnt, 0);
+    rb_ary_push(members, rb_str_new2("cnt"));
 
     /* Document-method: vid
      * the name of the local variable to retrieve.
      */
     rb_define_method(rb_cLVAR, "vid", node_vid, 0);
     rb_ary_push(members, rb_str_new2("vid"));
-    rb_define_method(rb_cLVAR, "cnt", node_cnt, 0);
-    rb_ary_push(members, rb_str_new2("cnt"));
   }
 
   /* Document-class: Node::MASGN
@@ -4372,11 +4602,11 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMASGN, "__type__", INT2NUM(NODE_MASGN));
     rb_define_singleton_method(rb_cMASGN, "members", node_s_members, 0);
 
-    /* Document-method: args
+    /* Document-method: value
      * TODO
      */
-    rb_define_method(rb_cMASGN, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
+    rb_define_method(rb_cMASGN, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
 
     /* Document-method: head
      * TODO
@@ -4384,11 +4614,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cMASGN, "head", node_head, 0);
     rb_ary_push(members, rb_str_new2("head"));
 
-    /* Document-method: value
+    /* Document-method: args
      * TODO
      */
-    rb_define_method(rb_cMASGN, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
+    rb_define_method(rb_cMASGN, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::MATCH
@@ -4413,17 +4643,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMATCH, "__type__", INT2NUM(NODE_MATCH));
     rb_define_singleton_method(rb_cMATCH, "members", node_s_members, 0);
 
-    /* Document-method: lit
-     * the regular expression to use in the condition.
-     */
-    rb_define_method(rb_cMATCH, "lit", node_lit, 0);
-    rb_ary_push(members, rb_str_new2("lit"));
-
     /* Document-method: value
      * the value to compare against
      */
     rb_define_method(rb_cMATCH, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
+
+    /* Document-method: lit
+     * the regular expression to use in the condition.
+     */
+    rb_define_method(rb_cMATCH, "lit", node_lit, 0);
+    rb_ary_push(members, rb_str_new2("lit"));
   }
 
   /* Document-class: Node::MATCH2
@@ -4451,13 +4681,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMATCH2, "__type__", INT2NUM(NODE_MATCH2));
     rb_define_singleton_method(rb_cMATCH2, "members", node_s_members, 0);
 
-    /* Document-method: recv
-     * the regular expression on the left hand side of the match
-     * operator
-     */
-    rb_define_method(rb_cMATCH2, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
-
     /* Document-method: value
      * the expression on the right hand side of the match operator, or
      * an expression returning $_ if there is nothing on the right hand
@@ -4465,6 +4688,13 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cMATCH2, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
+
+    /* Document-method: recv
+     * the regular expression on the left hand side of the match
+     * operator
+     */
+    rb_define_method(rb_cMATCH2, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::MATCH3
@@ -4482,17 +4712,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cMATCH3, "__type__", INT2NUM(NODE_MATCH3));
     rb_define_singleton_method(rb_cMATCH3, "members", node_s_members, 0);
 
-    /* Document-method: recv
-     * the left hand side of the match
-     */
-    rb_define_method(rb_cMATCH3, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
-
     /* Document-method: value
      * the right hand side of the match
      */
     rb_define_method(rb_cMATCH3, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
+
+    /* Document-method: recv
+     * the left hand side of the match
+     */
+    rb_define_method(rb_cMATCH3, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::MEMO
@@ -4518,6 +4748,30 @@ void define_node_subclass_methods()
     rb_define_singleton_method(rb_cMEMO, "members", node_s_members, 0);
   }
 
+  /* Document-class: Node::METHOD
+   * A placeholder for a method entry in a class's method table.
+   */
+  {
+    VALUE rb_cMETHOD = rb_define_class_under(rb_cNode, "METHOD", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_METHOD] = rb_cMETHOD;
+    rb_iv_set(rb_cMETHOD, "__member__", members);
+    rb_iv_set(rb_cMETHOD, "__type__", INT2NUM(NODE_METHOD));
+    rb_define_singleton_method(rb_cMETHOD, "members", node_s_members, 0);
+
+    /* Document-method: noex
+     * the method's flags
+     */
+    rb_define_method(rb_cMETHOD, "noex", node_noex, 0);
+    rb_ary_push(members, rb_str_new2("noex"));
+
+    /* Document-method: body
+     * the body of the method
+     */
+    rb_define_method(rb_cMETHOD, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
+  }
+
   /* Document-class: Node::MODULE
    * Represents a module definition, e.g.:
    *   module cpath
@@ -4550,6 +4804,25 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("body"));
   }
 
+  /* Document-class: Node::NEWLINE
+   * Represents the termination of a line.  This is used for calling
+   * event hooks when a new line of code is reached.
+   */
+  {
+    VALUE rb_cNEWLINE = rb_define_class_under(rb_cNode, "NEWLINE", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_NEWLINE] = rb_cNEWLINE;
+    rb_iv_set(rb_cNEWLINE, "__member__", members);
+    rb_iv_set(rb_cNEWLINE, "__type__", INT2NUM(NODE_NEWLINE));
+    rb_define_singleton_method(rb_cNEWLINE, "members", node_s_members, 0);
+
+    /* Document-method: next
+     * the expression on the next line
+     */
+    rb_define_method(rb_cNEWLINE, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+  }
+
   /* Document-class: Node::NEXT
    * Represents the 'next' keyword.
    * Causes control to be transferred to the end of the loop, causing the
@@ -4578,6 +4851,24 @@ void define_node_subclass_methods()
     rb_define_singleton_method(rb_cNIL, "members", node_s_members, 0);
   }
 
+  /* Document-class: Node::NOT
+   * Represents a logical negation.
+   */
+  {
+    VALUE rb_cNOT = rb_define_class_under(rb_cNode, "NOT", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_NOT] = rb_cNOT;
+    rb_iv_set(rb_cNOT, "__member__", members);
+    rb_iv_set(rb_cNOT, "__type__", INT2NUM(NODE_NOT));
+    rb_define_singleton_method(rb_cNOT, "members", node_s_members, 0);
+
+    /* Document-method: body
+     * the value to negate.
+     */
+    rb_define_method(rb_cNOT, "body", node_body, 0);
+    rb_ary_push(members, rb_str_new2("body"));
+  }
+
   /* Document-class: Node::NTH_REF
    * Represents the nth match data item, e.g. $1, $2, etc.
    */
@@ -4652,12 +4943,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN1, "__type__", INT2NUM(NODE_OP_ASGN1));
     rb_define_singleton_method(rb_cOP_ASGN1, "members", node_s_members, 0);
 
-    /* Document-method: args
-     * the arguments to the assigment
-     */
-    rb_define_method(rb_cOP_ASGN1, "args", node_args, 0);
-    rb_ary_push(members, rb_str_new2("args"));
-
     /* Document-method: mid
      * 0, 1, or the name a method to call to calculate the value of the
      * rhs
@@ -4670,6 +4955,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cOP_ASGN1, "recv", node_recv, 0);
     rb_ary_push(members, rb_str_new2("recv"));
+
+    /* Document-method: args
+     * the arguments to the assigment
+     */
+    rb_define_method(rb_cOP_ASGN1, "args", node_args, 0);
+    rb_ary_push(members, rb_str_new2("args"));
   }
 
   /* Document-class: Node::OP_ASGN2
@@ -4692,11 +4983,11 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN2, "__type__", INT2NUM(NODE_OP_ASGN2));
     rb_define_singleton_method(rb_cOP_ASGN2, "members", node_s_members, 0);
 
-    /* Document-method: recv
-     * the receiver of the attribute
+    /* Document-method: value
+     * the value to assign to the attribute
      */
-    rb_define_method(rb_cOP_ASGN2, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
+    rb_define_method(rb_cOP_ASGN2, "value", node_value, 0);
+    rb_ary_push(members, rb_str_new2("value"));
 
     /* Document-method: next
      * another node of type OP_ASGN2 which contains more information
@@ -4705,11 +4996,11 @@ void define_node_subclass_methods()
     rb_define_method(rb_cOP_ASGN2, "next", node_next, 0);
     rb_ary_push(members, rb_str_new2("next"));
 
-    /* Document-method: value
-     * the value to assign to the attribute
+    /* Document-method: recv
+     * the receiver of the attribute
      */
-    rb_define_method(rb_cOP_ASGN2, "value", node_value, 0);
-    rb_ary_push(members, rb_str_new2("value"));
+    rb_define_method(rb_cOP_ASGN2, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::OP_ASGN2_ARG
@@ -4725,12 +5016,6 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN2_ARG, "__type__", INT2NUM(NODE_OP_ASGN2_ARG));
     rb_define_singleton_method(rb_cOP_ASGN2_ARG, "members", node_s_members, 0);
 
-    /* Document-method: vid
-     * The method to call on the receiver to retrieve the attribute
-     */
-    rb_define_method(rb_cOP_ASGN2_ARG, "vid", node_vid, 0);
-    rb_ary_push(members, rb_str_new2("vid"));
-
     /* Document-method: aid
      * The method to call on the receiver to set the attribute
      */
@@ -4744,6 +5029,12 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cOP_ASGN2_ARG, "mid", node_mid, 0);
     rb_ary_push(members, rb_str_new2("mid"));
+
+    /* Document-method: vid
+     * The method to call on the receiver to retrieve the attribute
+     */
+    rb_define_method(rb_cOP_ASGN2_ARG, "vid", node_vid, 0);
+    rb_ary_push(members, rb_str_new2("vid"));
   }
 
   /* Document-class: Node::OP_ASGN_AND
@@ -4762,18 +5053,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cOP_ASGN_AND, "__type__", INT2NUM(NODE_OP_ASGN_AND));
     rb_define_singleton_method(rb_cOP_ASGN_AND, "members", node_s_members, 0);
 
-    /* Document-method: recv
-     * an expression representing the left hand side of the assignment
-     */
-    rb_define_method(rb_cOP_ASGN_AND, "recv", node_recv, 0);
-    rb_ary_push(members, rb_str_new2("recv"));
-
     /* Document-method: value
      * an expression representing the assignment that should be
      * performed if the left hand side is true
      */
     rb_define_method(rb_cOP_ASGN_AND, "value", node_value, 0);
     rb_ary_push(members, rb_str_new2("value"));
+
+    /* Document-method: recv
+     * an expression representing the left hand side of the assignment
+     */
+    rb_define_method(rb_cOP_ASGN_AND, "recv", node_recv, 0);
+    rb_ary_push(members, rb_str_new2("recv"));
   }
 
   /* Document-class: Node::OP_ASGN_OR
@@ -4946,18 +5237,18 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cRESCUE, "__type__", INT2NUM(NODE_RESCUE));
     rb_define_singleton_method(rb_cRESCUE, "members", node_s_members, 0);
 
-    /* Document-method: head
-     * the body of the block to evaluate
-     */
-    rb_define_method(rb_cRESCUE, "head", node_head, 0);
-    rb_ary_push(members, rb_str_new2("head"));
-
     /* Document-method: resq
      * the expression to be evaluated if an exception is raised
      */
     rb_define_method(rb_cRESCUE, "resq", node_resq, 0);
     rb_ary_push(members, rb_str_new2("resq"));
 
+    /* Document-method: head
+     * the body of the block to evaluate
+     */
+    rb_define_method(rb_cRESCUE, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
+
     /* Document-method: else
      * the expression to be evaluated if no exception is raised
      */
@@ -5059,18 +5350,18 @@ void define_node_subclass_methods()
     rb_define_method(rb_cSCOPE, "tbl", node_tbl, 0);
     rb_ary_push(members, rb_str_new2("tbl"));
 
+    /* Document-method: next
+     * the body of the lexical scope
+     */
+    rb_define_method(rb_cSCOPE, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+
     /* Document-method: rval
      * holds information about which class(es) to search for  constants
      * in this scope
      */
     rb_define_method(rb_cSCOPE, "rval", node_rval, 0);
     rb_ary_push(members, rb_str_new2("rval"));
-
-    /* Document-method: next
-     * the body of the lexical scope
-     */
-    rb_define_method(rb_cSCOPE, "next", node_next, 0);
-    rb_ary_push(members, rb_str_new2("next"));
   }
 
   /* Document-class: Node::SELF
@@ -5145,6 +5436,31 @@ void define_node_subclass_methods()
     rb_ary_push(members, rb_str_new2("args"));
   }
 
+  /* Document-class: Node::SVALUE
+   * Represents the collection of multiple values of the right hand side
+   * of an assignment into a single value, for use in single assignment,
+   * e.g.:
+   *   lhs = a, b, c
+   * The argument to this node is an Array.
+   * If it is length 0, returns nil.
+   * If it is length 1, returns the first element in the array.
+   * Otherwise, returns the array.
+   */
+  {
+    VALUE rb_cSVALUE = rb_define_class_under(rb_cNode, "SVALUE", rb_cNode);
+    members = rb_ary_new();
+    rb_cNodeSubclass[NODE_SVALUE] = rb_cSVALUE;
+    rb_iv_set(rb_cSVALUE, "__member__", members);
+    rb_iv_set(rb_cSVALUE, "__type__", INT2NUM(NODE_SVALUE));
+    rb_define_singleton_method(rb_cSVALUE, "members", node_s_members, 0);
+
+    /* Document-method: head
+     * an expression which returns an Array.
+     */
+    rb_define_method(rb_cSVALUE, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
+  }
+
   /* Document-class: Node::TO_ARY
    * Represents a conversion from one object type to an array type.
    * Evaluation of this node converts its argument to an array by calling
@@ -5212,6 +5528,8 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cUNTIL, "__member__", members);
     rb_iv_set(rb_cUNTIL, "__type__", INT2NUM(NODE_UNTIL));
     rb_define_singleton_method(rb_cUNTIL, "members", node_s_members, 0);
+    rb_define_method(rb_cUNTIL, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: body
      * the body of the loop
@@ -5224,8 +5542,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cUNTIL, "cond", node_cond, 0);
     rb_ary_push(members, rb_str_new2("cond"));
-    rb_define_method(rb_cUNTIL, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
   }
 
   /* Document-class: Node::VALIAS
@@ -5241,10 +5557,10 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cVALIAS, "__member__", members);
     rb_iv_set(rb_cVALIAS, "__type__", INT2NUM(NODE_VALIAS));
     rb_define_singleton_method(rb_cVALIAS, "members", node_s_members, 0);
-    rb_define_method(rb_cVALIAS, "first", node_1st, 0);
-    rb_ary_push(members, rb_str_new2("first"));
     rb_define_method(rb_cVALIAS, "second", node_2nd, 0);
     rb_ary_push(members, rb_str_new2("second"));
+    rb_define_method(rb_cVALIAS, "first", node_1st, 0);
+    rb_ary_push(members, rb_str_new2("first"));
   }
 
   /* Document-class: Node::VCALL
@@ -5304,6 +5620,12 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cWHEN, "__type__", INT2NUM(NODE_WHEN));
     rb_define_singleton_method(rb_cWHEN, "members", node_s_members, 0);
 
+    /* Document-method: next
+     * the next expression to be evaluated if the condition is false
+     */
+    rb_define_method(rb_cWHEN, "next", node_next, 0);
+    rb_ary_push(members, rb_str_new2("next"));
+
     /* Document-method: head
      * a value to compare against, or a condition to be tested
      */
@@ -5315,12 +5637,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cWHEN, "body", node_body, 0);
     rb_ary_push(members, rb_str_new2("body"));
-
-    /* Document-method: next
-     * the next expression to be evaluated if the condition is false
-     */
-    rb_define_method(rb_cWHEN, "next", node_next, 0);
-    rb_ary_push(members, rb_str_new2("next"));
   }
 
   /* Document-class: Node::WHILE
@@ -5336,6 +5652,8 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cWHILE, "__member__", members);
     rb_iv_set(rb_cWHILE, "__type__", INT2NUM(NODE_WHILE));
     rb_define_singleton_method(rb_cWHILE, "members", node_s_members, 0);
+    rb_define_method(rb_cWHILE, "state", node_state, 0);
+    rb_ary_push(members, rb_str_new2("state"));
 
     /* Document-method: body
      * the body of the loop
@@ -5348,8 +5666,6 @@ void define_node_subclass_methods()
      */
     rb_define_method(rb_cWHILE, "cond", node_cond, 0);
     rb_ary_push(members, rb_str_new2("cond"));
-    rb_define_method(rb_cWHILE, "state", node_state, 0);
-    rb_ary_push(members, rb_str_new2("state"));
   }
 
   /* Document-class: Node::XSTR
@@ -5386,17 +5702,17 @@ void define_node_subclass_methods()
     rb_iv_set(rb_cYIELD, "__type__", INT2NUM(NODE_YIELD));
     rb_define_singleton_method(rb_cYIELD, "members", node_s_members, 0);
 
-    /* Document-method: head
-     * the value to yield
-     */
-    rb_define_method(rb_cYIELD, "head", node_head, 0);
-    rb_ary_push(members, rb_str_new2("head"));
-
     /* Document-method: state
      * if nonzero, splats the value before yielding
      */
     rb_define_method(rb_cYIELD, "state", node_state, 0);
     rb_ary_push(members, rb_str_new2("state"));
+
+    /* Document-method: head
+     * the value to yield
+     */
+    rb_define_method(rb_cYIELD, "head", node_head, 0);
+    rb_ary_push(members, rb_str_new2("head"));
   }
 
   /* Document-class: Node::ZARRAY