ParseTree 2.1.1 → 2.2.0

data/History.txt

@@ -1,3 +1,32 @@
+=== 2.2.0 / 2008-06-09
+
+* 18 minor enhancements:
+
+  * Added 1.9 and rubinius to multiruby skip list.
+  * Added 1.9 fixes for SexpProcessor.
+  * Added compatibility changes for regexp option values.
+  * Added custom compact since Array#compact is hostile to subclasses.
+  * Added some tests for wonky index edge cases. some commented out.
+  * Added test changes for 1.9 and r2r changes. Esp fixed regexp differences.
+  * Added tests for dasgn, proc arities, 
+  * Added/updated some tests for ruby_parser.
+  * Changed tests to default to nil for verbose.
+  * Fixed all assertions deprecated in miniunit.
+  * Raises LoadError if incompatible ruby, allows fallback to ruby_parser.
+  * Removed Unified's rewrite_fbody and moved up into defn... not sure about that.
+  * Removed argscat rewriter from unified_ruby.rb
+  * Renamed shadowed variable name.
+  * Reworked parse_tree_for_(method|string) to take optional verbose arg.
+  * Started removing ending newlines from pt_testcase.rb.
+  * Uncommented all commented out tests. ruby_parser must not be a pansy.
+  * Updated rakefile for new hoe abilities.
+
+* 3 bug fixes:
+
+  * Fixed 1.8.[45] wrt dasgn_curr declaration removal.
+  * Fixed pt_testcase bug.
+  * Fixes for colon2/3 in class/module/cdecls.
+
 === 2.1.1 / 2007-12-22
 
 * 1 bug fix:

data/README.txt

@@ -1,7 +1,8 @@
-ParseTree
-    http://rubyforge.org/projects/parsetree/
-    http://www.zenspider.com/ZSS/Products/ParseTree/
-    support@zenspider.com
+= ParseTree
+
+* http://rubyforge.org/projects/parsetree/
+* http://www.zenspider.com/ZSS/Products/ParseTree/
+* ryand-ruby@zenspider.com
 
 == DESCRIPTION:
 

data/Rakefile

@@ -3,25 +3,23 @@
 require 'rubygems'
 require 'hoe'
 
-$: << "../../RubyInline/dev"
+$: << "../../RubyInline/dev/lib"
 require './lib/parse_tree.rb'
 
-Hoe.new("ParseTree", ParseTree::VERSION) do |p|
-  p.rubyforge_name = "parsetree"
-  p.summary = "Extract and enumerate ruby parse trees."
-  p.summary = p.paragraphs_of("README.txt", 2).join("\n\n")
-  p.description = p.paragraphs_of("README.txt", 2..6, 8).join("\n\n")
-  p.changes = p.paragraphs_of("History.txt", 0..2).join("\n\n")
-  p.clean_globs << File.expand_path("~/.ruby_inline")
-  p.extra_deps << ['RubyInline', '>= 3.6.0']
-  p.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
-end
+Hoe.new("ParseTree", ParseTree::VERSION) do |pt|
+  pt.rubyforge_name = "parsetree"
+
+  pt.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+
+  pt.clean_globs << File.expand_path("~/.ruby_inline")
+  pt.extra_deps << ['RubyInline', '>= 3.6.0']
+  pt.spec_extras[:require_paths] = proc { |paths| paths << 'test' }
 
-desc 'Run against ruby 1.9 (from a multiruby install) with -d.'
-task :test19 do
-  sh "~/.multiruby/install/1_9/bin/ruby -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
+  pt.multiruby_skip << "1.9" << "rubinius"
 end
 
+Hoe::RUBY_FLAGS.sub! /-I/, '-I../../RubyInline/dev/lib:test:'
+
 desc 'Run in gdb'
 task :debug do
   puts "RUN: r -d #{Hoe::RUBY_FLAGS} test/test_all.rb #{Hoe::FILTER}"
@@ -32,17 +30,3 @@ desc 'Run a very basic demo'
 task :demo do
   sh "echo 1+1 | ruby #{Hoe::RUBY_FLAGS} ./bin/parse_tree_show -f"
 end
-
-desc 'Show what tests are not sorted'
-task :sort do
-  begin
-    sh "pgrep '^    \\\"(\\w+)' test/pt_testcase.rb | cut -f 2 -d\\\" > x"
-    sh "sort x > y"
-    sh "diff x y"
-
-    sh 'for f in lib/*.rb; do echo $f; grep "^ *def " $f | grep -v sort=skip > x; sort x > y; echo $f; echo; diff x y; done'
-    sh 'for f in test/test_*.rb; do echo $f; grep "^ *def.test_" $f > x; sort x > y; echo $f; echo; diff x y; done'
-  ensure
-    sh 'rm -f x y'
-  end
-end

data/lib/parse_tree.rb

@@ -1,10 +1,11 @@
 #!/usr/local/bin/ruby -w
 
-abort "*** Sorry, ParseTree doesn't work with ruby #{RUBY_VERSION}" if
+raise LoadError, "ParseTree doesn't work with ruby #{RUBY_VERSION}" if
   RUBY_VERSION >= "1.9"
+raise LoadError, "ParseTree isn't needed with rubinius" if
+  defined? RUBY_ENGINE and RUBY_ENGINE == "rbx"
 
-begin require 'rubygems'; rescue LoadError; end
-
+require 'rubygems'
 require 'inline'
 
 class Module
@@ -41,7 +42,7 @@ end
 
 class ParseTree
 
-  VERSION = '2.1.1'
+  VERSION = '2.2.0'
 
   ##
   # Front end translation method.
@@ -144,10 +145,13 @@ class ParseTree
   #
   #   [:defn, :name, :body]
 
-  def parse_tree_for_method(klass, method, is_cls_meth=false)
+  def parse_tree_for_method(klass, method, is_cls_meth=false, verbose = true)
     $stderr.puts "** parse_tree_for_method(#{klass}, #{method}):" if $DEBUG
+    old_verbose, $VERBOSE = $VERBOSE, verbose
     r = parse_tree_for_meth(klass, method.to_sym, is_cls_meth)
     r
+  ensure
+    $VERBOSE = old_verbose
   end
 
   ##
@@ -157,8 +161,9 @@ class ParseTree
   #
   #   [[sexps] ... ]
 
-  def parse_tree_for_string(source, filename = '(string)', line = 1)
-    old_verbose, $VERBOSE = $VERBOSE, true
+  def parse_tree_for_string(source,
+                            filename = '(string)', line = 1, verbose = true)
+    old_verbose, $VERBOSE = $VERBOSE, verbose
     return parse_tree_for_str0(source, filename, line)
   ensure
     $VERBOSE = old_verbose
@@ -252,6 +257,11 @@ class ParseTree
     builder.include '"st.h"'
     builder.include '"env.h"'
 
+    if RUBY_VERSION < "1.8.6" then
+      builder.prefix '#define RARRAY_PTR(s) (RARRAY(s)->ptr)'
+      builder.prefix '#define RARRAY_LEN(s) (RARRAY(s)->len)'
+    end
+
     if ENV['ANAL'] or ENV['DOMAIN'] =~ /zenspider/ then
       builder.add_compile_flags "-Wall"
       builder.add_compile_flags "-W"
@@ -337,6 +347,7 @@ void add_to_parse_tree(VALUE self, VALUE ary, NODE * n, ID * locals) {
   VALUE current;
   VALUE node_name;
   static VALUE node_names = Qnil;
+  static int masgn_level = 0;
 
   if (NIL_P(node_names)) {
     node_names = rb_const_get_at(rb_path2class("ParseTree"),rb_intern("NODE_NAMES"));
@@ -371,6 +382,11 @@ again:
           add_to_parse_tree(self, current, node->nd_head, locals);
           node = node->nd_next;
         }
+        if (!masgn_level && RARRAY_LEN(current) == 2) {
+          rb_ary_pop(ary);
+          rb_ary_push(ary, rb_ary_pop(current));
+          return;
+        }
       }
       break;
 
@@ -472,6 +488,7 @@ again:
   case NODE_ITER:
   case NODE_FOR:
     add_to_parse_tree(self, current, node->nd_iter, locals);
+    masgn_level++;
     if (node->nd_var != (NODE *)1
         && node->nd_var != (NODE *)2
         && node->nd_var != NULL) {
@@ -485,6 +502,7 @@ again:
         rb_ary_push(current, INT2FIX(0));
       }
     }
+    masgn_level--;
     add_to_parse_tree(self, current, node->nd_body, locals);
     break;
 
@@ -571,10 +589,11 @@ again:
       if (data->var == 0 || data->var == (NODE *)1 || data->var == (NODE *)2) {
         rb_ary_push(current, Qnil);
       } else {
+        masgn_level++;
         add_to_parse_tree(self, current, data->var, locals);
+        masgn_level--;
       }
       add_to_parse_tree(self, current, data->body, locals);
-      break;
     }
     break;
 
@@ -645,6 +664,7 @@ again:
     break;
 
   case NODE_MASGN:
+    masgn_level++;
     add_to_parse_tree(self, current, node->nd_head, locals);
     if (node->nd_args) {
       if (node->nd_args != (NODE *)-1) {
@@ -654,13 +674,12 @@ again:
       }
     }
     add_to_parse_tree(self, current, node->nd_value, locals);
+    masgn_level--;
     break;
 
   case NODE_LASGN:
   case NODE_IASGN:
   case NODE_DASGN:
-  case NODE_DASGN_CURR:
-  case NODE_CDECL:
   case NODE_CVASGN:
   case NODE_CVDECL:
   case NODE_GASGN:
@@ -668,6 +687,32 @@ again:
     add_to_parse_tree(self, current, node->nd_value, locals);
     break;
 
+  case NODE_CDECL:
+    if (node->nd_vid) {
+      rb_ary_push(current, ID2SYM(node->nd_vid));
+    } else {
+      add_to_parse_tree(self, current, node->nd_else, locals);
+    }
+
+    add_to_parse_tree(self, current, node->nd_value, locals);
+    break;
+
+  case NODE_DASGN_CURR:
+    rb_ary_push(current, ID2SYM(node->nd_vid));
+    if (node->nd_value) {
+      add_to_parse_tree(self, current, node->nd_value, locals);
+      if (!masgn_level && RARRAY_LEN(current) == 2) {
+        rb_ary_pop(ary);
+        return;
+      }
+    } else {
+      if (!masgn_level) {
+        rb_ary_pop(ary);
+        return;
+      }
+    }
+    break;
+
   case NODE_VALIAS:           /* u1 u2 (alias $global $global2) */
 #if RUBY_VERSION_CODE < 185
     rb_ary_push(current, ID2SYM(node->u2.id));
@@ -768,7 +813,12 @@ again:
 
   case NODE_CLASS:
   case NODE_MODULE:
-    rb_ary_push(current, ID2SYM((ID)node->nd_cpath->nd_mid));
+    if (nd_type(node->nd_cpath) == NODE_COLON2 && ! node->nd_cpath->nd_vid) {
+      rb_ary_push(current, ID2SYM((ID)node->nd_cpath->nd_mid));
+    } else {
+      add_to_parse_tree(self, current, node->nd_cpath, locals);
+    }
+
     if (nd_type(node) == NODE_CLASS) {
       if (node->nd_super) {
         add_to_parse_tree(self, current, node->nd_super, locals);
@@ -794,6 +844,7 @@ again:
     }
 
     /* look for optional arguments */
+    masgn_level++;
     optnode = node->nd_opt;
     while (optnode) {
       rb_ary_push(current, ID2SYM(locals[i + 3]));
@@ -840,6 +891,7 @@ again:
     if (optnode) {
       add_to_parse_tree(self, current, node->nd_opt, locals);
     }
+    masgn_level--;
   }  break;
 
   case NODE_LVAR:

data/lib/sexp.rb

@@ -27,8 +27,8 @@ class Sexp < Array # ZenTest FULL
   def self.for(klass, method = nil, walk_ancestors = false)
     require 'parse_tree'
     sexp = if walk_ancestors and method then
-             klass.ancestors.each do |klass|
-               sexp = ParseTree.translate klass, method
+             klass.ancestors.each do |kls|
+               sexp = ParseTree.translate kls, method
                break sexp unless sexp == [nil]
              end
            else
@@ -101,6 +101,10 @@ class Sexp < Array # ZenTest FULL
     @@array_types.include? type
   end
 
+  def compact # :nodoc:
+    self.delete_if { |o| o.nil? }
+  end
+
   ##
   # Enumeratates the sexp yielding to +b+ when the node_type == +t+.
 

data/lib/sexp_processor.rb

@@ -194,7 +194,7 @@ class SexpProcessor
     return nil if exp.nil?
 
     unless @unsupported_checked then
-      m = public_methods.grep(/^process_/) { |o| o.sub(/^process_/, '').intern }
+      m = public_methods.grep(/^process_/) { |o| o.to_s.sub(/^process_/, '').intern }
       supported = m - (m - @unsupported)
 
       raise UnsupportedNodeError, "#{supported.inspect} shouldn't be in @unsupported" unless supported.empty?

data/lib/unified_ruby.rb

@@ -2,12 +2,6 @@
 $TESTING ||= false
 
 module UnifiedRuby
-  def rewrite_argscat(exp)
-    raise "unknown type #{exp.inspect}" unless exp[1][0] == :array
-    exp[1][0] = :arglist
-    exp
-  end
-
   def rewrite_bmethod(exp)
     exp[0] = :scope
 
@@ -45,7 +39,7 @@ module UnifiedRuby
       when :argscat, :splat then
         # do nothing
       else
-        raise "unknown type in call #{args.first.inspect}"
+        raise "unknown type in call #{args.first.inspect} in #{exp.inspect}"
       end
       return exp
     end
@@ -85,12 +79,13 @@ module UnifiedRuby
   #
   #   s(:defn, :reader, s(:args), s(:ivar, :@name))
   #
-  #
 
   def rewrite_defn(exp)
     weirdo = exp.ivar || exp.attrset
 
-    # move args up
+    fbody = exp.fbody(true)
+    exp.push(fbody.scope) if fbody
+
     args = exp.scope.block.args(true) unless weirdo
     exp.insert 2, args if args
 
@@ -124,10 +119,6 @@ module UnifiedRuby
     exp.shift # scope / block / body
   end
 
-  def rewrite_fbody(exp)
-    return *exp.sexp_body
-  end
-
   def rewrite_fcall(exp)
     exp[0] = :call
     exp.insert 1, nil

data/test/pt_testcase.rb

@@ -135,6 +135,15 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:attrasgn, [:vcall, :a], :[]=, [:array, [:lit, 42], [:lit, 24]]],
     },
 
+    "attrasgn_index_equals_space" => {
+      "Ruby"        => "a = []; a [42] = 24",
+      "ParseTree"   => [:block,
+                        [:lasgn, :a, [:zarray]],
+                        [:attrasgn, [:lvar, :a], :[]=,
+                         [:array, [:lit, 42], [:lit, 24]]]],
+      "Ruby2Ruby"  => "a = []\na[42] = 24\n",
+    },
+
     "attrset" => {
       "Ruby"        => [Examples, :writer=],
       "ParseTree"   => [:defn, :writer=, [:attrset, :@writer]],
@@ -145,8 +154,8 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby"        => "[$&, $`, $', $+]",
       "ParseTree"   => [:array,
                         [:back_ref, :&],
-                        [:back_ref, "`".intern], # symbol was fucking up emacs
-                        [:back_ref, "'".intern], # s->e
+                        [:back_ref, :"`"],
+                        [:back_ref, :"'"],
                         [:back_ref, :+]],
     },
 
@@ -191,22 +200,20 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "block_mystery_block"  => { # FIX: I don't like that extra return
-      "Ruby"        => "a(b) do\n  if b then\n    true\n  else\n    c = false\n    d { |x| c = true }\n    c\n  \n  end\nend",
+      "Ruby"        => "a(b) do\n  if b then\n    true\n  else\n    c = false\n    d { |x| c = true }\n    c\n  end\nend",
       "ParseTree"   => [:iter,
                         [:fcall, :a, [:array, [:vcall, :b]]],
                         nil,
-                        [:block,
-                         [:dasgn_curr, :c],
-                         [:if,
-                          [:vcall, :b],
-                          [:true],
-                          [:block,
-                           [:dasgn_curr, :c, [:false]],
-                           [:iter,
-                            [:fcall, :d],
-                            [:dasgn_curr, :x],
-                            [:dasgn, :c, [:true]]],
-                           [:dvar, :c]]]]],
+                        [:if,
+                         [:vcall, :b],
+                         [:true],
+                         [:block,
+                          [:dasgn_curr, :c, [:false]],
+                          [:iter,
+                           [:fcall, :d],
+                           [:dasgn_curr, :x],
+                           [:dasgn, :c, [:true]]],
+                          [:dvar, :c]]]],
     },
 
     "block_pass_args_and_splat" => {
@@ -214,7 +221,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:defn, :blah,
                       [:scope,
                        [:block,
-                        [:args, "*args".intern],
+                        [:args, :"*args"],
                         [:block_arg, :block],
                         [:block_pass,
                          [:lvar, :block],
@@ -278,7 +285,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:defn, :blah,
                       [:scope,
                        [:block,
-                        [:args, "*args".intern],
+                        [:args, :"*args"],
                         [:block_arg, :block],
                         [:block_pass,
                          [:lvar, :block],
@@ -295,8 +302,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "block_stmt_after"  => {
       "Ruby"        => "def f\n  begin\n    b\n  rescue\n    c\n  end\n\n  d\nend",
-      "ParseTree"   => [:defn,
-                        :f,
+      "ParseTree"   => [:defn, :f,
                         [:scope,
                          [:block,
                           [:args],
@@ -307,8 +313,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "block_stmt_before"  => {
       "Ruby"        => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\nend",
-      "ParseTree"   => [:defn,
-                        :f,
+      "ParseTree"   => [:defn, :f,
                         [:scope,
                          [:block,
                           [:args],
@@ -320,8 +325,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "block_stmt_both"  => {
       "Ruby"        => "def f\n  a\n  begin\n    b\n  rescue\n    c\n  end\n  d\nend",
-      "ParseTree"   => [:defn,
-                        :f,
+      "ParseTree"   => [:defn, :f,
                         [:scope,
                          [:block,
                           [:args],
@@ -333,8 +337,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "bmethod"  => {
       "Ruby"        => [Examples, :unsplatted],
-      "ParseTree"   => [:defn,
-                        :unsplatted,
+      "ParseTree"   => [:defn, :unsplatted,
                         [:bmethod,
                          [:dasgn_curr, :x],
                          [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]],
@@ -343,11 +346,10 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "bmethod_noargs"  => {
       "Ruby"        => [Examples, :bmethod_noargs],
-      "ParseTree"   => [:defn,
-                        :bmethod_noargs,
+      "ParseTree"   => [:defn, :bmethod_noargs,
                         [:bmethod,
                          nil,
-                         [:call, [:vcall, :x], "+".intern, [:array, [:lit, 1]]]]],
+                         [:call, [:vcall, :x], :"+", [:array, [:lit, 1]]]]],
       "Ruby2Ruby"   => "def bmethod_noargs\n  (x + 1)\nend"
     },
 
@@ -426,9 +428,11 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         :zero?],
     },
 
-    "call_index" => { # see attrasgn_index_equals for opposite
-      "Ruby"        => "a[42]",
-      "ParseTree"   => [:call, [:vcall, :a], :[], [:array, [:lit, 42]]],
+    "call_index" => { # see attrasgn_index_equals and fcall_index_space
+      "Ruby"        => "b = []\na[42]\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :b, [:zarray]],
+                        [:call, [:vcall, :a], :[], [:array, [:lit, 42]]]],
     },
 
     "call_index_no_args" => {
@@ -436,6 +440,14 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:call, [:vcall, :a], :[]],
     },
 
+    "call_index_space" => {
+      "Ruby"        => "a = []\na [42]\n",
+      "ParseTree"   => [:block,
+                        [:lasgn, :a, [:zarray]],
+                        [:call, [:lvar, :a], :[], [:array, [:lit, 42]]]],
+      "Ruby2Ruby"   => "a = []\na[42]\n",
+    },
+
     "call_unary_neg" => {
       "Ruby"        => "-2**31",
       "ParseTree"   => [:call,
@@ -544,14 +556,24 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:scope,
                          [:block,
                           [:fcall, :puts, [:array, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]]],
-                          [:defn,
-                           :blah,
+                          [:defn, :blah,
                            [:scope,
                             [:block,
                              [:args],
                              [:fcall, :puts, [:array, [:str, "hello"]]]]]]]]],
     },
 
+    "class_scoped" => {
+      "Ruby" => "class X::Y\n  c\nend",
+      "ParseTree" => [:class, [:colon2, [:const, :X], :Y], nil,
+                      [:scope, [:vcall, :c]]],
+    },
+
+    "class_scoped3" => {
+      "Ruby" => "class ::Y\n  c\nend",
+      "ParseTree" => [:class, [:colon3, :Y], nil, [:scope, [:vcall, :c]]],
+    },
+
     "class_super_array"  => {
       "Ruby"        => "class X < Array\nend",
       "ParseTree"   => [:class,
@@ -677,6 +699,21 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree"   => [:const, :X],
     },
 
+    "constX"  => {
+      "Ruby"        => "X = 1",
+      "ParseTree"   => [:cdecl, :X, [:lit, 1]],
+    },
+
+    "constY"  => {
+      "Ruby"        => "::X = 1",
+      "ParseTree"   => [:cdecl, [:colon3, :X], [:lit, 1]],
+    },
+
+    "constZ"  => {
+      "Ruby"        => "X::Y = 1",
+      "ParseTree"   => [:cdecl, [:colon2, [:const, :X], :Y], [:lit, 1]],
+    },
+
     "cvar"  => {
       "Ruby"        => "@@x",
       "ParseTree"   => [:cvar, :@@x],
@@ -729,21 +766,30 @@ class ParseTreeTestCase < Test::Unit::TestCase
     },
 
     "dasgn_2"  => { # WITH mystery block / dasgn_curr
-      "Ruby"        => "a.each do |x|\n  if true then\n    c = 0\n    b.each { |y| c = (c + 1) }\n  \n  end\nend", # FIX: hate that extra newline!
+      "Ruby"        => "a.each do |x|\n  if true then\n    c = 0\n    b.each { |y| c = (c + 1) }\n  end\nend", # FIX: hate that extra newline!
       "ParseTree"   => [:iter,
                         [:call, [:vcall, :a], :each],
                         [:dasgn_curr, :x],
+                        [:if, [:true],
+                         [:block,
+                          [:dasgn_curr, :c, [:lit, 0]],
+                          [:iter,
+                           [:call, [:vcall, :b], :each],
+                           [:dasgn_curr, :y],
+                           [:dasgn, :c,
+                            [:call, [:dvar, :c], :+, [:array, [:lit, 1]]]]]],
+                         nil]],
+    },
+
+    "dasgn_curr" => {
+      "Ruby"        => "data.each do |x, y|\n  a = 1\n  b = a\n  b = a = x\nend",
+      "ParseTree"   => [:iter,
+                        [:call, [:vcall, :data], :each],
+                        [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
                         [:block,
-                         [:dasgn_curr, :c],
-                         [:if, [:true],
-                          [:block,
-                           [:dasgn_curr, :c, [:lit, 0]],
-                           [:iter,
-                            [:call, [:vcall, :b], :each],
-                            [:dasgn_curr, :y],
-                            [:dasgn, :c,
-                             [:call, [:dvar, :c], :+, [:array, [:lit, 1]]]]]],
-                          nil]]],
+                         [:dasgn_curr, :a, [:lit, 1]],
+                         [:dasgn_curr, :b, [:dvar, :a]],
+                         [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
     },
 
     "dasgn_icky"  => { # WITH mystery block / dasgn_curr
@@ -752,7 +798,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                         [:fcall, :a],
                         nil,
                         [:block,
-                         [:dasgn_curr, :v],
                          [:dasgn_curr, :v, [:nil]],
                          [:iter,
                           [:fcall, :assert_block,
@@ -766,17 +811,6 @@ class ParseTreeTestCase < Test::Unit::TestCase
                              [:block, [:dasgn, :v, [:gvar, :$!]], [:break]]]]]]]],
     },
 
-    "dasgn_curr" => {
-      "Ruby"        => "data.each do |x, y|\n  a = 1\n  b = a\n  b = a = x\nend",
-      "ParseTree"   => [:iter,
-                        [:call, [:vcall, :data], :each],
-                        [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
-                        [:block,
-                         [:dasgn_curr, :a, [:lit, 1]],
-                         [:dasgn_curr, :b, [:dvar, :a]],
-                         [:dasgn_curr, :b, [:dasgn_curr, :a, [:dvar, :x]]]]],
-    },
-
     "dasgn_mixed" => {
       "Ruby"        => "t = 0\nns.each { |n| t += n }\n",
       "ParseTree"   => [:block,
@@ -822,7 +856,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:defn, :x,
                       [:scope,
                        [:block,
-                        [:args, :a, :b, "*c".intern, # s->e
+                        [:args, :a, :b, :"*c",
                          [:block, [:lasgn, :b, [:lit, 42]]]],
                         [:block_arg, :d],
                         [:fcall, :p,
@@ -900,7 +934,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:defn, :x,
                       [:scope,
                        [:block,
-                        [:args, :a, "*args".intern],
+                        [:args, :a, :"*args"],
                         [:fcall, :p,
                          [:array, [:lvar, :a], [:lvar, :args]]]]]],
     },
@@ -935,7 +969,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "ParseTree" => [:defn, :x,
                       [:scope,
                        [:block,
-                        [:args, :a, "*".intern],
+                        [:args, :a, :"*"],
                         [:fcall, :p,
                          [:array, [:lvar, :a]]]]]],
     },
@@ -982,8 +1016,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "dmethod" => {
       "Ruby"        => [Examples, :dmethod_added],
-      "ParseTree"   => [:defn,
-                        :dmethod_added,
+      "ParseTree"   => [:defn, :dmethod_added,
                         [:dmethod,
                          :a_method,
                          [:scope,
@@ -1016,7 +1049,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "dregx_n" => {
       "Ruby"        => '/#{1}/n',
-      "ParseTree"   => [:dregx, '', [:evstr, [:lit, 1]], 16], # TODO: use consts
+      "ParseTree"   => [:dregx, '', [:evstr, [:lit, 1]], /x/n.options],
       "Ruby2Ruby"   => "/#\{1}/", # HACK - need to support regexp flags
     },
 
@@ -1028,7 +1061,7 @@ class ParseTreeTestCase < Test::Unit::TestCase
 
     "dregx_once_n_interp" => {
       "Ruby"        => "/#\{IAC}#\{SB}/no",
-      "ParseTree"   => [:dregx_once, '', [:evstr, [:const, :IAC]], [:evstr, [:const, :SB]], 16],
+      "ParseTree"   => [:dregx_once, '', [:evstr, [:const, :IAC]], [:evstr, [:const, :SB]], /x/n.options],
       "Ruby2Ruby"   => "/#\{IAC}#\{SB}/o", # HACK
     },
 
@@ -1076,6 +1109,23 @@ class ParseTreeTestCase < Test::Unit::TestCase
       "Ruby2Ruby"   => '"#{22}aacd#{44}55#{66}"',
     },
 
+    "dstr_heredoc_expand" => {
+      "Ruby"        => "<<EOM\n  blah\n#\{1 + 1}blah\nEOM\n",
+      "ParseTree"   => [:dstr, "  blah\n",
+                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
+                        [:str, "blah\n"]],
+      "Ruby2Ruby"   => "\"  blah\\n#\{(1 + 1)}blah\\n\"",
+    },
+
+    "dstr_heredoc_windoze_sucks" => {
+      "Ruby"        => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n  EOF\r\n",
+      "ParseTree"   => [:dstr,
+                        'def test_',
+                        [:evstr, [:vcall, :action]],
+                        [:str, "_valid_feed\n"]],
+      "Ruby2Ruby"   => "\"def test_#\{action}_valid_feed\\n\"",
+    },
+
     "dstr_heredoc_yet_again"  => {
       "Ruby"        => "<<-EOF\ns1 '#\{RUBY_PLATFORM}' s2\n#\{__FILE__}\n        EOF\n",
       "ParseTree"   => [:dstr, "s1 '",
@@ -1204,6 +1254,12 @@ end",
                         [:lit, :c]],
     },
 
+    "fcall_index_space" => {
+      "Ruby"        => "a [42]",
+      "ParseTree"   => [:fcall, :a, [:array, [:array, [:lit, 42]]]],
+      "Ruby2Ruby"  => "a([42])",
+    },
+
     "fcall_keyword"  => {
       "Ruby"        => "42 if block_given?",
       "ParseTree"   => [:if, [:fcall, :block_given?], [:lit, 42], nil],
@@ -1374,13 +1430,13 @@ end",
       "ParseTree"   => [:block,
                         [:lasgn, :argl, [:lit, 10]],
                         [:while,
-                         [:call, [:lvar, :argl], ">=".intern, [:array, [:lit, 1]]],
+                         [:call, [:lvar, :argl], :">=", [:array, [:lit, 1]]],
                          [:block,
                           [:fcall, :puts, [:array, [:str, "hello"]]],
                           [:lasgn,
                            :argl,
                            [:call, [:lvar, :argl],
-                            "-".intern, [:array, [:lit, 1]]]]], true]],
+                            :"-", [:array, [:lit, 1]]]]], true]],
     },
 
     "iteration6" => {
@@ -1540,10 +1596,11 @@ end",
       "Ruby"        => 'str.split(//i)',
       "ParseTree"   => [:call, [:vcall, :str], :split, [:array, [:lit, //i]]],
     },
-    
+
     "lit_regexp_n" => {
       "Ruby"        => "/x/n",
       "ParseTree"   => [:lit, /x/n],
+      "Ruby2Ruby"   => /x/n.inspect, # HACK differs on 1.9 - this is easiest
     },
 
     "lit_regexp_once" => {
@@ -1566,8 +1623,7 @@ end",
       "Ruby"        => "b = 42\ndef a\n  c do\n    begin\n    rescue RuntimeError => b\n      puts(b)\n    end\n  end\nend\n",
       "ParseTree"   => [:block,
                         [:lasgn, :b, [:lit, 42]],
-                        [:defn,
-                         :a,
+                        [:defn, :a,
                          [:scope,
                           [:block,
                            [:args],
@@ -1610,7 +1666,7 @@ end",
     "masgn_iasgn"  => {
       "Ruby"        => "a, @b = c, d",
       "ParseTree"   => [:masgn,
-                        [:array, [:lasgn, :a], [:iasgn, "@b".intern]],
+                        [:array, [:lasgn, :a], [:iasgn, :"@b"]],
                         [:array,  [:vcall, :c], [:vcall, :d]]],
     },
 
@@ -1697,6 +1753,17 @@ end",
                          [:defn, :y, [:scope, [:block, [:args], [:nil]]]]]],
     },
 
+    "module_scoped" => {
+      "Ruby" => "module X::Y\n  c\nend",
+      "ParseTree" => [:module, [:colon2, [:const, :X], :Y],
+                      [:scope, [:vcall, :c]]],
+    },
+
+    "module_scoped3" => {
+      "Ruby" => "module ::Y\n  c\nend",
+      "ParseTree" => [:module, [:colon3, :Y], [:scope, [:vcall, :c]]],
+    },
+
     "next"  => {
       "Ruby"        => "loop { next if false }",
       "ParseTree"   => [:iter,
@@ -1728,13 +1795,25 @@ end",
       "ParseTree"   => [:block,
                         [:lasgn, :b, [:zarray]],
                         [:op_asgn1, [:lvar, :b],
-                         [:array, [:lit, 1]], "||".intern, [:lit, 10]], # s->e
+                         [:array, [:lit, 1]], :"||", [:lit, 10]],
                         [:op_asgn1, [:lvar, :b],
-                         [:array, [:lit, 2]], "&&".intern, [:lit, 11]], # s->e
+                         [:array, [:lit, 2]], :"&&", [:lit, 11]],
                         [:op_asgn1, [:lvar, :b],
                          [:array, [:lit, 3]], :+, [:lit, 12]]],
     },
 
+    "op_asgn1" => {
+      "Ruby"        => "@b = []\n@b[1] ||= 10\n@b[2] &&= 11\n@b[3] += 12\n",
+      "ParseTree"   => [:block,
+                        [:iasgn, :@b, [:zarray]],
+                        [:op_asgn1, [:ivar, :@b],
+                         [:array, [:lit, 1]], :"||", [:lit, 10]],
+                        [:op_asgn1, [:ivar, :@b],
+                         [:array, [:lit, 2]], :"&&", [:lit, 11]],
+                        [:op_asgn1, [:ivar, :@b],
+                         [:array, [:lit, 3]], :+, [:lit, 12]]],
+    },
+
     "op_asgn2" => {
       "Ruby"        => "s = Struct.new(:var)\nc = s.new(nil)\nc.var ||= 20\nc.var &&= 21\nc.var += 22\nc.d.e.f ||= 42\n",
       "ParseTree"   => [:block,
@@ -1744,15 +1823,15 @@ end",
                         [:lasgn, :c,
                          [:call, [:lvar, :s], :new, [:array, [:nil]]]],
 
-                        [:op_asgn2, [:lvar, :c], :var=, "||".intern, # s->e
+                        [:op_asgn2, [:lvar, :c], :var=, :"||",
                          [:lit, 20]],
-                        [:op_asgn2, [:lvar, :c], :var=, "&&".intern, # s->e
+                        [:op_asgn2, [:lvar, :c], :var=, :"&&",
                          [:lit, 21]],
                         [:op_asgn2, [:lvar, :c], :var=, :+, [:lit, 22]],
 
                         [:op_asgn2,
                          [:call,
-                          [:call, [:lvar, :c], :d], :e], :f=, "||".intern,
+                          [:call, [:lvar, :c], :d], :e], :f=, :"||",
                          [:lit, 42]]],
     },
 
@@ -1841,12 +1920,33 @@ end",
       "Ruby2Ruby"   => "((a or b) or (c and d))",
     },
 
+    "parse_floats_as_args" => {
+      "Ruby"        => "def x(a=0.0,b=0.0)\n  a+b\nend",
+      "ParseTree"   => [:defn, :x,
+                        [:scope,
+                         [:block,
+                          [:args, :a, :b,
+                           [:block,
+                            [:lasgn, :a, [:lit, 0.0]],
+                            [:lasgn, :b, [:lit, 0.0]]]],
+                          [:call, [:lvar, :a], :+, [:array, [:lvar, :b]]]]]],
+      "Ruby2Ruby"   => "def x(a = 0.0, b = 0.0)\n  (a + b)\nend",
+    },
+
     "postexe"  => {
       "Ruby"        => "END { 1 }",
       "ParseTree"   => [:iter, [:postexe], nil, [:lit, 1]],
     },
 
-    "proc_args" => {
+    "proc_args_0" => {
+      "Ruby" => "proc { || (x + 1) }",
+      "ParseTree" => [:iter,
+                      [:fcall, :proc],
+                      0,
+                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+    },
+
+    "proc_args_1" => {
       "Ruby" => "proc { |x| (x + 1) }",
       "ParseTree" => [:iter,
                       [:fcall, :proc],
@@ -1854,19 +1954,19 @@ end",
                       [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]],
     },
 
-    "proc_no_args" => {
-      "Ruby" => "proc { (x + 1) }",
+    "proc_args_2" => {
+      "Ruby" => "proc { |x, y| (x + y) }",
       "ParseTree" => [:iter,
                       [:fcall, :proc],
-                      nil,
-                      [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
+                      [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :y]]],
+                      [:call, [:dvar, :x], :+, [:array, [:dvar, :y]]]],
     },
 
-    "proc_zero_args" => {
-      "Ruby" => "proc { || (x + 1) }",
+    "proc_args_no" => {
+      "Ruby" => "proc { (x + 1) }",
       "ParseTree" => [:iter,
                       [:fcall, :proc],
-                      0,
+                      nil,
                       [:call, [:vcall, :x], :+, [:array, [:lit, 1]]]],
     },
 
@@ -1971,19 +2071,19 @@ end",
     },
 
     "str_heredoc" => {
-      "Ruby"        => "<<'EOM'\n  blah\nblah\nEOM\n",
+      "Ruby"        => "<<'EOM'\n  blah\nblah\nEOM",
       "ParseTree"   => [:str, "  blah\nblah\n"],
       "Ruby2Ruby"   => "\"  blah\\nblah\\n\"",
     },
 
     "str_heredoc_call" => {
-      "Ruby"        => "<<'EOM'.strip\n  blah\nblah\nEOM\n",
+      "Ruby"        => "<<'EOM'.strip\n  blah\nblah\nEOM",
       "ParseTree"   => [:call, [:str, "  blah\nblah\n"], :strip],
       "Ruby2Ruby"   => "\"  blah\\nblah\\n\".strip",
     },
 
     "str_heredoc_double" => {
-      "Ruby"       => "a += <<-BEGIN + b + <<-END\n  first\nBEGIN\n  second\nEND",
+      "Ruby"       => "a += <<-H1 + b + <<-H2\n  first\nH1\n  second\nH2",
       "ParseTree"  => [:lasgn, :a,
                        [:call,
                         [:lvar, :a],
@@ -1997,29 +2097,12 @@ end",
       "Ruby2Ruby"   => "a = (a + ((\"  first\\n\" + b) + \"  second\\n\"))",
     },
 
-    "dstr_heredoc_expand" => {
-      "Ruby"        => "<<EOM\n  blah\n#\{1 + 1}blah\nEOM\n",
-      "ParseTree"   => [:dstr, "  blah\n",
-                        [:evstr, [:call, [:lit, 1], :+, [:array, [:lit, 1]]]],
-                        [:str, "blah\n"]],
-      "Ruby2Ruby"   => "\"  blah\\n#\{(1 + 1)}blah\\n\"",
-    },
-
     "str_heredoc_indent" => {
-      "Ruby"        => "<<-EOM\n  blah\nblah\n\n  EOM\n",
+      "Ruby"        => "<<-EOM\n  blah\nblah\n\n  EOM",
       "ParseTree"   => [:str, "  blah\nblah\n\n"],
       "Ruby2Ruby"   => "\"  blah\\nblah\\n\\n\"",
     },
 
-    "dstr_heredoc_windoze_sucks" => {
-      "Ruby"        => "<<-EOF\r\ndef test_#\{action}_valid_feed\r\n  EOF\r\n",
-      "ParseTree"   => [:dstr,
-                        'def test_',
-                        [:evstr, [:vcall, :action]],
-                        [:str, "_valid_feed\n"]],
-      "Ruby2Ruby"   => "\"def test_#\{action}_valid_feed\\n\"",
-    },
-
     "str_interp_file" => {
       "Ruby"        => '"file = #{__FILE__}
 "',
@@ -2028,21 +2111,19 @@ end",
     },
 
     "structure_extra_block_for_dvar_scoping"  => {
-      "Ruby"        => "a.b do |c, d|\n  unless e.f(c) then\n    g = false\n    d.h { |x, i| g = true }\n  \n  end\nend", # FIX: don't like the extra return
+      "Ruby"        => "a.b do |c, d|\n  unless e.f(c) then\n    g = false\n    d.h { |x, i| g = true }\n  end\nend", # FIX: don't like the extra return
       "ParseTree"   => [:iter,
                         [:call, [:vcall, :a], :b],
                         [:masgn, [:array, [:dasgn_curr, :c], [:dasgn_curr, :d]]],
-                        [:block,
-                         [:dasgn_curr, :g],
-                         [:if,
-                          [:call, [:vcall, :e], :f, [:array, [:dvar, :c]]],
-                          nil,
-                          [:block,
-                           [:dasgn_curr, :g, [:false]],
-                           [:iter,
-                            [:call, [:dvar, :d], :h],
-                            [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :i]]],
-                            [:dasgn, :g, [:true]]]]]]],
+                        [:if,
+                         [:call, [:vcall, :e], :f, [:array, [:dvar, :c]]],
+                         nil,
+                         [:block,
+                          [:dasgn_curr, :g, [:false]],
+                          [:iter,
+                           [:call, [:dvar, :d], :h],
+                           [:masgn, [:array, [:dasgn_curr, :x], [:dasgn_curr, :i]]],
+                           [:dasgn, :g, [:true]]]]]],
       },
 
     "structure_remove_begin_1"  => {
@@ -2331,6 +2412,8 @@ end",
   end
 
   def self.inherited(c)
+    super
+
     output_name = c.name.to_s.sub(/^Test/, '')
     raise "Unknown class #{c} in @@testcase_order" unless
       @@testcase_order.include? output_name
@@ -2341,13 +2424,14 @@ end",
       next if [:skip, :unsupported].include? data[input_name]
       next if data[output_name] == :skip
 
-      c.send(:define_method, "test_#{node}".intern) do
+      c.send(:define_method, :"test_#{node}") do
         flunk "Processor is nil" if processor.nil?
         assert data.has_key?(input_name), "Unknown input data"
         unless data.has_key?(output_name) then
           $stderr.puts "add_test(#{node.inspect}, :same)"
         end
-        assert data.has_key?(output_name), "Missing test data: #{self.class} #{node}"
+        assert(data.has_key?(output_name),
+               "Missing test data: #{self.class} #{node}")
         input = data[input_name].deep_clone
 
         expected = if data[output_name] == :same then
@@ -2365,14 +2449,17 @@ end",
           extra_expected = []
           extra_input = []
 
-          _, expected, extra_expected = *expected if Array === expected and expected.first == :defx
-          _, input, extra_input = *input if Array === input and input.first == :defx
+          _, expected, extra_expected = *expected if
+            Array === expected and expected.first == :defx
+          _, input, extra_input = *input if
+            Array === input and input.first == :defx
 
           debug = input.deep_clone
-          $-w = nil if node == "match"
-          assert_equal expected, processor.process(input), "failed on input: #{debug.inspect}"
-          $-w = true if node == "match"
-          extra_input.each do |input| processor.process(input) end
+          assert_equal(expected, processor.process(input),
+                       "failed on input: #{debug.inspect}")
+          extra_input.each do |extra|
+            processor.process(extra)
+          end
           extra = processor.extra_methods rescue []
           assert_equal extra_expected, extra
         end