ruby_parser 1.0.0 → 2.0.0

data/test/test_ruby_parser.rb

@@ -8,59 +8,29 @@ $: << File.expand_path('~/Work/p4/zss/src/ParseTree/dev/test')
 
 require 'pt_testcase'
 
-class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
-
-  # Regular ParseTreeTestCase tests
-  eval ParseTreeTestCase.testcases.map { |node, data|
-    next if node.to_s =~ /bmethod|dmethod/
-    next if Array === data['Ruby'] # runtime only crap
-    "def test_#{node}
-       rb = #{data['Ruby'].inspect}
-       pt = #{data['ParseTree'].inspect}
-
-       assert_not_nil rb, \"Ruby for #{node} undefined\"
-       assert_not_nil pt, \"ParseTree for #{node} undefined\"
-
-       assert_equal Sexp.from_array(pt), @processor.parse(rb)
-     end"
-  }.compact.join("\n")
-
-  # Scour the world and compare against ParseTree
-  if ENV['ZOMGPONIES'] or File.exist? 'zomgponies' then
-    require 'parse_tree'
-
-    base = "/usr/lib/ruby"
-    base = "unit"
-
-    files = Dir[File.join(base, "**/*.rb")]
-
-    # these files/patterns cause parse_tree_show to bus error (or just suck):
-    files.reject! { |f| f =~ /environments.environment|rss.maker.base|rails_generator|ferret.browser|rubinius.spec.core.module.(constants|name|remove_const)_spec|tkextlib.tcllib.tablelist/ }
-
-    # these are rejected for dasgn_curr ordering failures... I'll fix them later.
-    # (or mri parse errors--I should have separated them out)
-    files.reject! { |f| f =~ /lib.flog|lib.autotest.notify|lib.analyzer.tools.rails.stat|flog.lib.flog|rakelib.struct.generator|rubinius.kernel.core.array|lib.rbosa.rb|src.rbosa.rb|spec.spec.mocks.mock.spec.rb|dsl.shared.behaviour.spec.rb|spec.spec.dsl.behaviour.spec|lib.hpricot.parse.rb|resolve.rb|parsers.parse.f95|rubinius.shotgun.lib.primitives.ltm|rubinius.lib.bin.compile|rubinius.kernel.core.object|rubinius.kernel.core.file|rubinius.compiler2.garnet.bindingagent|ruby_to_c_test_r2ctestcase|lib.more.like.this|resolv\.rb|test.r2ctestcase/ }
-
-    warn "Generating #{files.size} tests from #{base}"
-
-    eval files.map { |file|
-      name = file[base.size..-1].gsub(/\W+/, '_')
+class RubyParser
+  def process input
+    parse input
+  end
+end
 
-      loc = `wc -l #{file}`.strip.to_i
+class RubyParserTestCase < ParseTreeTestCase
+  def self.previous key
+    "Ruby"
+  end
 
-      "def test#{name}_#{loc}
-         file = #{file.inspect}
-         rb = File.read(file)
+  def self.generate_test klass, node, data, input_name, output_name
+    return if node.to_s =~ /bmethod|dmethod/
+    return if Array === data['Ruby']
 
-         pt = ParseTree.new.parse_tree_for_string rb
-         assert_not_nil pt, \"ParseTree for #{name} undefined\"
+    output_name = "ParseTree"
 
-         rp = @processor.parse rb
-         assert_equal Sexp.from_array(pt).first, rp, \"RP different from PT\"
-         File.unlink #{file.inspect}
-       end"
-    }.compact.join("\n")
+    super
   end
+end
+
+class TestRubyParser < RubyParserTestCase
+  alias :refute_nil :assert_not_nil unless defined? Mini
 
   def setup
     super
@@ -70,29 +40,29 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     @processor = RubyParser.new
   end
 
-  def test_block_append
-    head = s(:args)
-    tail = s(:zsuper)
-    expected = s(:block, s(:args), s(:zsuper))
-    assert_equal expected, @processor.block_append(head, tail)
+  def test_attrasgn_array_lhs
+    rb = '[1, 2, 3, 4][from .. to] = ["a", "b", "c"]'
+    pt = s(:attrasgn,
+           s(:array, s(:lit, 1), s(:lit, 2), s(:lit, 3), s(:lit, 4)),
+           :[]=,
+           s(:arglist,
+             s(:dot2,
+               s(:call, nil, :from, s(:arglist)),
+               s(:call, nil, :to, s(:arglist))),
+             s(:array, s(:str, "a"), s(:str, "b"), s(:str, "c"))))
+
+    result = @processor.parse(rb)
+
+    assert_equal pt, result
   end
 
-  def test_block_append_block
-    head = s(:block, s(:args))
+  def test_block_append
+    head = s(:args)
     tail = s(:zsuper)
     expected = s(:block, s(:args), s(:zsuper))
     assert_equal expected, @processor.block_append(head, tail)
   end
 
-  def test_block_append_tail_block
-    head = s(:vcall, :f1)
-    tail = s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y)))
-    expected = s(:block,
-                 s(:vcall, :f1),
-                 s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y))))
-    assert_equal expected, @processor.block_append(head, tail)
-  end
-
   def test_block_append_begin_begin
     head = s(:begin, s(:args))
     tail = s(:begin, s(:args))
@@ -100,6 +70,13 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal expected, @processor.block_append(head, tail)
   end
 
+  def test_block_append_block
+    head = s(:block, s(:args))
+    tail = s(:zsuper)
+    expected = s(:block, s(:args), s(:zsuper))
+    assert_equal expected, @processor.block_append(head, tail)
+  end
+
   def test_block_append_nil_head
     head = nil
     tail = s(:zsuper)
@@ -114,18 +91,123 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal expected, @processor.block_append(head, tail)
   end
 
+  def test_block_append_tail_block
+    head = s(:call, nil, :f1, s(:arglist))
+    tail = s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y)))
+    expected = s(:block,
+                 s(:call, nil, :f1, s(:arglist)),
+                 s(:block, s(:undef, s(:lit, :x)), s(:undef, s(:lit, :y))))
+    assert_equal expected, @processor.block_append(head, tail)
+  end
+
   def test_call_env
     @processor.env[:a] = :lvar
-    expected = s(:call, s(:lvar, :a), :happy)
+    expected = s(:call, s(:lvar, :a), :happy, s(:arglist))
 
     assert_equal expected, @processor.parse('a.happy')
   end
 
+  def test_dasgn_icky2
+    rb = "a do\n  v = nil\n  begin\n    yield\n  rescue Exception => v\n    break\n  end\nend"
+    pt = s(:iter,
+           s(:call, nil, :a, s(:arglist)),
+           nil,
+           s(:block,
+             s(:lasgn, :v, s(:nil)),
+             s(:rescue,
+               s(:yield),
+               s(:resbody,
+                 s(:array, s(:const, :Exception), s(:lasgn, :v, s(:gvar, :$!))),
+                 s(:break)))))
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_class_comments
+    rb = "# blah 1\n# blah 2\n\nclass X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
+    pt = s(:class, :X, nil,
+           s(:scope,
+             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+
+    actual = @processor.parse(rb)
+    assert_equal pt, actual
+
+    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+    assert_equal "# blah 3\n", actual.scope.defn.comments
+  end
+
+  def test_module_comments
+    rb = "# blah 1\n  \n  # blah 2\n\nmodule X\n  # blah 3\n  def blah\n    # blah 4\n  end\nend"
+    pt = s(:module, :X,
+           s(:scope,
+             s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))))
+
+    actual = @processor.parse(rb)
+    assert_equal pt, actual
+    assert_equal "# blah 1\n\n# blah 2\n\n", actual.comments
+    assert_equal "# blah 3\n", actual.scope.defn.comments
+  end
+
+  def test_defn_comments
+    rb = "# blah 1\n# blah 2\n\ndef blah\nend"
+    pt = s(:defn, :blah, s(:args), s(:scope, s(:block, s(:nil))))
+
+    actual = @processor.parse(rb)
+    assert_equal pt, actual
+    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+  end
+
+  def test_defs_comments
+    rb = "# blah 1\n# blah 2\n\ndef self.blah\nend"
+    pt = s(:defs, s(:self), :blah, s(:args), s(:scope, s(:block)))
+
+    actual = @processor.parse(rb)
+    assert_equal pt, actual
+    assert_equal "# blah 1\n# blah 2\n\n", actual.comments
+  end
+
   def test_do_bug # TODO: rename
     rb = "a 1\na.b do |c|\n  # do nothing\nend"
     pt = s(:block,
-           s(:fcall, :a, s(:array, s(:lit, 1))),
-           s(:iter, s(:call, s(:vcall, :a), :b), s(:dasgn_curr, :c)))
+           s(:call, nil, :a, s(:arglist, s(:lit, 1))),
+           s(:iter,
+             s(:call, s(:call, nil, :a, s(:arglist)), :b, s(:arglist)),
+             s(:lasgn, :c)))
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_dstr_evstr
+    rb = "\"#\{'a'}#\{b}\""
+    pt = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_dstr_str
+    rb = "\"#\{'a'} b\""
+    pt = s(:str, "a b")
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_empty
+    rb = ""
+    pt = nil
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_evstr_evstr
+    rb = "\"#\{a}#\{b}\""
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:evstr, s(:call, nil, :b, s(:arglist))))
+
+    assert_equal pt, @processor.parse(rb)
+  end
+
+  def test_evstr_str
+    rb = "\"#\{a} b\""
+    pt = s(:dstr, "", s(:evstr, s(:call, nil, :a, s(:arglist))), s(:str, " b"))
 
     assert_equal pt, @processor.parse(rb)
   end
@@ -134,11 +216,91 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     rb = 'a = 42'
     pt = s(:lasgn, :a, s(:lit, 42))
     expected_env = { :a => :lvar }
-    
+
     assert_equal pt, @processor.parse(rb)
     assert_equal expected_env, @processor.env.all
   end
 
+  def test_list_append
+    a = s(:lit, 1)
+    b = s(:lit, 2)
+    c = s(:lit, 3)
+
+    result = @processor.list_append(s(:array, b.dup), c.dup)
+
+    assert_equal s(:array, b, c), result
+
+    result = @processor.list_append(b.dup, c.dup)
+
+    assert_equal s(:array, b, c), result
+
+    result = @processor.list_append(result, a.dup)
+
+    assert_equal s(:array, b, c, a), result
+
+    lhs, rhs = s(:array, s(:lit, :iter)), s(:when, s(:const, :BRANCHING), nil)
+    expected = s(:array, s(:lit, :iter), s(:when, s(:const, :BRANCHING), nil))
+
+    assert_equal expected, @processor.list_append(lhs, rhs)
+  end
+
+  def test_list_prepend
+    a = s(:lit, 1)
+    b = s(:lit, 2)
+    c = s(:lit, 3)
+
+    result = @processor.list_prepend(b.dup, s(:array, c.dup))
+
+    assert_equal s(:array, b, c), result
+
+    result = @processor.list_prepend(b.dup, c.dup)
+
+    assert_equal s(:array, b, c), result
+
+    result = @processor.list_prepend(a.dup, result)
+
+    assert_equal s(:array, a, b, c), result
+  end
+
+  def test_literal_concat_dstr_dstr
+    lhs      = s(:dstr, "Failed to download spec ",
+                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:str, " from "),
+                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:str, ":\n"))
+    rhs      = s(:dstr, "\t",
+                 s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
+    expected = s(:dstr, "Failed to download spec ",
+                 s(:evstr, s(:call, nil, :spec_name, s(:arglist))),
+                 s(:str, " from "),
+                 s(:evstr, s(:call, nil, :source_uri, s(:arglist))),
+                 s(:str, ":\n"),
+                 s(:str, "\t"),
+                 s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
+
+    assert_equal expected, @processor.literal_concat(lhs, rhs)
+  end
+
+  def test_literal_concat_dstr_evstr
+    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:call, nil, :b, s(:arglist)))
+    expected = s(:dstr, "a", s(:evstr, s(:call, nil, :b, s(:arglist))))
+
+    assert_equal expected, @processor.literal_concat(lhs, rhs)
+  end
+
+  def test_literal_concat_evstr_evstr
+    lhs, rhs = s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2))
+    expected = s(:dstr, "", s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2)))
+
+    assert_equal expected, @processor.literal_concat(lhs, rhs)
+  end
+
+  def test_literal_concat_str_evstr
+    lhs, rhs = s(:str, ""), s(:evstr, s(:str, "blah"))
+
+    assert_equal s(:str, "blah"), @processor.literal_concat(lhs, rhs)
+  end
+
   def test_logop_12
     lhs = s(:lit, 1)
     rhs = s(:lit, 2)
@@ -147,10 +309,18 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal exp, @processor.logop(:and, lhs, rhs)
   end
 
-  def test_logop_12_3
-    lhs = s(:and, s(:lit, 1), s(:lit, 2))
-    rhs = s(:lit, 3)
-    exp = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
+  def test_logop_1234_5
+    lhs = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:and, s(:lit, 3), s(:lit, 4))))
+    rhs = s(:lit, 5)
+    exp = s(:and,
+            s(:lit, 1),
+            s(:and,
+              s(:lit, 2),
+              s(:and,
+                s(:lit, 3),
+                s(:and,
+                  s(:lit, 4),
+                  s(:lit, 5)))))
 
     assert_equal exp, @processor.logop(:and, lhs, rhs)
   end
@@ -169,28 +339,20 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal exp, @processor.logop(:and, lhs, rhs)
   end
 
-  def test_logop_1234_5
-    lhs = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:and, s(:lit, 3), s(:lit, 4))))
-    rhs = s(:lit, 5)
-    exp = s(:and,
-            s(:lit, 1),
-            s(:and,
-              s(:lit, 2),
-              s(:and,
-                s(:lit, 3),
-                s(:and,
-                  s(:lit, 4),
-                  s(:lit, 5)))))
+  def test_logop_12_3
+    lhs = s(:and, s(:lit, 1), s(:lit, 2))
+    rhs = s(:lit, 3)
+    exp = s(:and, s(:lit, 1), s(:and, s(:lit, 2), s(:lit, 3)))
 
     assert_equal exp, @processor.logop(:and, lhs, rhs)
   end
 
   def test_logop_nested_mix
-    lhs = s(:or, s(:vcall, :a), s(:vcall, :b))
-    rhs = s(:and, s(:vcall, :c), s(:vcall, :d))
+    lhs = s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist)))
+    rhs = s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist)))
     exp = s(:or,
-            s(:or, s(:vcall, :a), s(:vcall, :b)),
-            s(:and, s(:vcall, :c), s(:vcall, :d)))
+            s(:or, s(:call, nil, :a, s(:arglist)), s(:call, nil, :b, s(:arglist))),
+            s(:and, s(:call, nil, :c, s(:arglist)), s(:call, nil, :d, s(:arglist))))
 
     lhs.paren = true
     rhs.paren = true
@@ -198,48 +360,16 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal exp, @processor.logop(:or, lhs, rhs)
   end
 
-  def test_literal_concat_str_evstr
-    lhs, rhs = s(:str, ""), s(:evstr, s(:str, "blah"))
-
-    assert_equal s(:str, "blah"), @processor.literal_concat(lhs, rhs)
-  end
-
-  def test_literal_concat_evstr_evstr
-    lhs, rhs = s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2))
-    expected = s(:dstr, "", s(:evstr, s(:lit, 1)), s(:evstr, s(:lit, 2)))
-
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
-  end
-
-  def test_literal_concat_dstr_evstr
-    lhs, rhs = s(:dstr, "a"), s(:evstr, s(:vcall, :b))
-    expected = s(:dstr, "a", s(:evstr, s(:vcall, :b)))
-
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
-  end
-
-  def test_literal_concat_dstr_dstr
-    lhs      = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:vcall, :spec_name)),
-                 s(:str, " from "),
-                 s(:evstr, s(:vcall, :source_uri)),
-                 s(:str, ":\n"))
-    rhs      = s(:dstr, "\t",
-                 s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
-    expected = s(:dstr, "Failed to download spec ",
-                 s(:evstr, s(:vcall, :spec_name)),
-                 s(:str, " from "),
-                 s(:evstr, s(:vcall, :source_uri)),
-                 s(:str, ":\n"),
-                 s(:str, "\t"),
-                 s(:evstr, s(:call, s(:ivar, :@fetch_error), :message)))
+  def test_str_evstr
+    rb = "\"a #\{b}\""
+    pt = s(:dstr, "a ", s(:evstr, s(:call, nil, :b, s(:arglist))))
 
-    assert_equal expected, @processor.literal_concat(lhs, rhs)
+    assert_equal pt, @processor.parse(rb)
   end
 
   def test_str_pct_Q_nested
     rb = "%Q[before [#\{nest}] after]"
-    pt = s(:dstr, "before [", s(:evstr, s(:vcall, :nest)), s(:str, "] after"))
+    pt = s(:dstr, "before [", s(:evstr, s(:call, nil, :nest, s(:arglist))), s(:str, "] after"))
 
     assert_equal pt, @processor.parse(rb)
   end
@@ -258,69 +388,81 @@ class TestRubyParser < Test::Unit::TestCase # ParseTreeTestCase
     assert_equal pt, @processor.parse(rb)
   end
 
-  def test_dstr_str
-    rb = "\"#\{'a'} b\""
-    pt = s(:str, "a b")
-
-    assert_equal pt, @processor.parse(rb)
+  STARTING_LINE = {
+    "begin_def"                           => 2,
+    "block_stmt_after"                    => 2,
+    "block_stmt_after_mri_verbose_flag"   => 2,
+    "block_stmt_before"                   => 2,
+    "block_stmt_before_mri_verbose_flag"  => 2,
+    "block_stmt_both"                     => 2,
+    "block_stmt_both_mri_verbose_flag"    => 2,
+    "case_nested_inner_no_expr"           => 2,
+    "case_no_expr"                        => 2,
+    "case_splat"                          => 2,
+    "cvasgn"                              => 2,
+    "defn_args_none"                      => 2,
+    "defn_zarray"                         => 2,
+    "structure_unused_literal_wwtt"       => 3, # yes, 3... odd test
+    "super_0"                             => 2,
+    "super_1"                             => 2,
+    "super_1_array"                       => 2,
+    "super_n"                             => 2,
+    "super_multi"                         => 2,
+    "undef_block_1"                       => 2,
+    "undef_block_2"                       => 2,
+    "undef_block_3"                       => 2,
+    "undef_block_wtf"                     => 2,
+    "zsuper"                              => 2,
+  }
+
+  def after_process_hook klass, node, data, input_name, output_name
+    expected = STARTING_LINE[node] || 1
+    assert_equal expected, @result.line, "should have proper line number"
   end
 
-  def test_str_evstr
-    rb = "\"a #\{b}\""
-    pt = s(:dstr, "a ", s(:evstr, s(:vcall, :b)))
-
-    assert_equal pt, @processor.parse(rb)
-  end
+  def test_position_info
+    rb = "a = 42\np a"
+    pt = s(:block,
+           s(:lasgn, :a, s(:lit, 42)),
+           s(:call, nil, :p, s(:arglist, s(:lvar, :a))))
 
-  def test_dstr_evstr
-    rb = "\"#\{'a'}#\{b}\""
-    pt = s(:dstr, "a", s(:evstr, s(:vcall, :b)))
+    result = @processor.parse(rb, "blah.rb")
 
-    assert_equal pt, @processor.parse(rb)
-  end
+    assert_equal pt, result
 
-  def test_evstr_str
-    rb = "\"#\{a} b\""
-    pt = s(:dstr, "", s(:evstr, s(:vcall, :a)), s(:str, " b"))
+    assert_equal 1, result.line,       "block should have line number"
+    assert_equal 1, result.lasgn.line, "lasgn should have line number"
+    assert_equal 2, result.call.line,  "call should have line number"
 
-    assert_equal pt, @processor.parse(rb)
-  end
+    expected = "blah.rb"
 
-  def test_evstr_evstr
-    rb = "\"#\{a}#\{b}\""
-    pt = s(:dstr, "", s(:evstr, s(:vcall, :a)), s(:evstr, s(:vcall, :b)))
+    assert_equal expected, result.file
+    assert_equal expected, result.lasgn.file
+    assert_equal expected, result.call.file
 
-    assert_equal pt, @processor.parse(rb)
+    assert_same result.file, result.lasgn.file
+    assert_same result.file, result.call.file
   end
 
+  def test_position_info2
+    rb = "def x(y)\n  p(y)\n  y *= 2\n  return y;\nend" # TODO: remove () & ;
+    pt = s(:defn, :x, s(:args, :y),
+           s(:scope,
+             s(:block,
+               s(:call, nil, :p, s(:arglist, s(:lvar, :y))),
+               s(:lasgn, :y,
+                 s(:call, s(:lvar, :y), :*, s(:arglist, s(:lit, 2)))),
+               s(:return, s(:lvar, :y)))))
 
-  def test_dasgn_icky2
-    rb = "a do\n  v = nil\n  begin\n    yield\n  rescue Exception => v\n    break\n  end\nend"
-    pt = s(:iter,
-           s(:fcall, :a),
-           nil,
-           s(:block,
-             s(:dasgn_curr, :v, s(:nil)),
-             s(:begin,
-               s(:rescue,
-                 s(:yield),
-                 s(:resbody,
-                   s(:array, s(:const, :Exception)),
-                   s(:block, s(:dasgn_curr, :v, s(:gvar, :$!)), s(:break)))))))
+    result = @processor.parse(rb)
 
-    assert_equal pt, @processor.parse(rb)
-  end
+    assert_equal pt, result
 
-  def test_list_append
-    lhs, rhs = s(:array, s(:lit, :iter)), s(:when, s(:const, :BRANCHING), nil)
-    expected = s(:array, s(:lit, :iter), s(:when, s(:const, :BRANCHING), nil))
+    body = result.scope.block
 
-    assert_equal expected, @processor.list_append(lhs, rhs)
+    assert_equal 1, result.line,      "defn should have line number"
+    assert_equal 2, body.call.line,   "call should have line number"
+    assert_equal 3, body.lasgn.line,  "lasgn should have line number"
+    assert_equal 4, body.return.line, "return should have line number"
   end
 end
-
-__END__
-
-# blah18.rb
-
-assert_equal("sub", $_)