ripper-plus 1.0.1 → 1.1.0.pre2

data/Gemfile

@@ -10,5 +10,4 @@ group :development do
   gem "yard", "~> 0.6.0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
-  gem "rcov", ">= 0"
 end

data/README.md

@@ -29,11 +29,11 @@ If one takes the intuitive approach, one would assume it prints "Label: hello",
 
 `say_what?` prints a blank line! This is because as soon as the `x` on the LHS is parsed, `x` is a local variable with value `nil`. By the time `defined?(x)` is executed, `x` has long since been a local variable!
 
-## Ripper's Mistake
+## Ripper's Bareword Behavior
 
-Ripper doesn't carry scope information as it parses, and as such, parses any lone identifier as an AST node of type `:var_ref`. It is up to consumers of the AST to figure out the meaning of the `:var_ref` node. It can be reasonably argued that the semantics of the `:var_ref` node should not be part of the AST, as my thesis adviser pointed out when I complained about this, as the two are syntactically identical. Unfortunately, the meaning of the `var_ref` node comes from the parser itself; any attempt to determine semantics based solely on the AST is simply re-creating the work the parser ordinarily does! Indeed, when Ruby parses the code for execution, it *does* create different internal node types upon seeing a method-call bareword and a local variable bareword!
+Ripper doesn't carry scope information as it parses, and as such, parses any lone identifier as an AST node of type `:var_ref`. It is up to consumers of the AST to figure out the meaning of the `:var_ref` node. It can be reasonably argued that the semantics of the `:var_ref` node should not be part of the AST, as my thesis adviser pointed out when I complained about this, as the two are syntactically identical. Unfortunately, the meaning of the `var_ref` node comes from the parser itself; any attempt to determine semantics based solely on the AST is simply re-creating the work the parser ordinarily does. Indeed, when Ruby parses the code for execution, it *does* create different internal AST node types upon seeing a method-call bareword and a local variable bareword!
 
-I'd like to see this behavior rolled into Ripper proper. Until then, `ripper-plus` is a reasonable replacement.
+I'd like to see this behavior rolled into Ripper proper. Until then, `ripper-plus` does it.
 
 ## ripper-plus
 
@@ -47,9 +47,64 @@ Need to be properly resolved. Did you know that, unlike the `label = label` exam
     def foo(x, y = y())
     end
 
-Anyway, ripper-plus turns all method-call `:var_ref` nodes into `zcall` nodes; the node structure is otherwise unchanged.
+Anyway, ripper-plus turns all method-call `:var_ref` nodes into `:zcall` nodes; the node structure is otherwise unchanged. It runs in O(N) time and O(h) space, where h is the height of the tree.
 
-The truth is, everybody who is using Ripper right now *should* be doing *all* of this. Anything short, and you have bugs. [Laser](https://github.com/michaeledgar/laser/) has bugs as a result. It's a pain in the ass to get it all right. `ripper-plus` probably has bugs - I'm not gonna lie. So hopefully, in Ruby 1.9.x, this will be the default. For now, you *should* use ripper-plus.
+## Syntax Errors
+
+Not all syntax errors in Ruby fail to parse as valid Ruby. Using `next`/`redo`/`break`/`retry` when they have no meaning will cause a "compile error (SyntaxError)" exception to be raised during parsing. Attempting to use those expressions in a value context will also fail to compile. Ripper, however, doesn't do any of this validation:
+
+    pp Ripper.sexp('x = 5; next x')
+    #=>
+    [:program,
+     [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+      [:next, [:args_add_block, [[:var_ref, [:@ident, "x", [1, 12]]]], false]]]]
+
+Assigning to set read-only variables is also caught by the Ruby parser, and not at runtime. An easy way to verify this is to put a simple print statement before the offending syntax error:
+
+    $ ruby -e 'p 5; $1 = "5"'
+    -e:1: Can't set variable $1
+
+Ripper catches this by wrapping the offending assignment in an `:assign_error` node. But not all such invalid assignments are caught:
+
+    pp Ripper.sexp('$1 = 5')
+    #=>
+    [:program,
+     [[:assign, [:assign_error, [:@backref, "$1", [1, 0]]], [:@int, "5", [1, 5]]]]]
+
+    pp Ripper.sexp('nil = self')
+    #=>
+    [:program,
+     [[:assign,
+       [:var_field, [:@kw, "nil", [1, 0]]],
+       [:var_ref, [:@kw, "self", [1, 6]]]]]]
+
+Ripper has at least one other error node type, `:class_name_error`:
+
+    pp Ripper.sexp('class abc; end')
+    #=>
+    [:program,
+     [[:class,
+       [:const_ref, [:class_name_error, [:@ident, "foo", [1, 6]]]],
+       nil,
+       [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+
+Ruby has a few dozen of these syntax errors that are caught at compile time, and most of them are things you would be hard-pressed to justify: re-using argument names (`def foo(x, x); end`), creating classes or modules in method bodies, and so on.  Yet Ripper does not provide an easy way to check if these errors are present in a given AST.
+
+I'm not convinced that wrapping offending nodes in different node types is the best way to handle this issue. Firstly, the error nodes are not always high enough in the tree (`:alias_error`, which arises when aliasing `$1, $2, ...`, is a notable exception). The position of the `:class_name_error` node forces every consumption of a `:class` node to check if the name subtree contains a `:class_name_error` node. The whole class is invalid though! If anything, the entire `:class` node should be inside an `:error` node. The same holds true for `:assign` nodes. This isn't really the Ripper designer's faults: Ripper is essentially a separate set of action routines in the same bison grammar used by YARV proper, and as an SAX-style parser, it'd be much harder to push errors upward.
+
+It does seem reasonable, however, that while we are transforming `:var_ref` into `:zcall` nodes, we can find these errors (including ones ignored by Ripper), wrap them in `:error` nodes, and provide a list of exceptions corresponding to the semantic errors. `ripper-plus` does just that. For example, the above error will transform into this:
+
+    [:program,
+     [[:error,
+       [:class,
+        [:const_ref, [:class_name_error, [:@ident, "foo", [1, 6]]]],
+        nil,
+        [:bodystmt, [[:void_stmt]], nil, nil, nil]],
+       'class/module name must be CONSTANT']]]
+
+## You Should be Using ripper-plus
+
+The truth is, everybody who is using Ripper right now *should* be doing *all* of this. Anything short, and you have bugs. [Laser](https://github.com/michaeledgar/laser/) has bugs as a result. It's a pain in the ass to get it all right. `ripper-plus` probably has bugs - I'm not gonna lie, I found one while writing this. But I'm pretty damn sure it's solid. Hopefully, in Ruby 1.9.x, this will be the default. For now, you *should* use ripper-plus.
 
 ## Contributing to ripper-plus
  

data/Rakefile

@@ -10,6 +10,7 @@ end
 require 'rake'
 
 require 'jeweler'
+require './lib/ripper-plus/version'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "ripper-plus"
@@ -21,6 +22,7 @@ with Ruby 1.9. While quite complete, it has some quirks that can
 make use frustrating. This gem intends to correct them.}
   gem.email = "michael.j.edgar@dartmouth.edu"
   gem.authors = ["Michael Edgar"]
+  gem.version = RipperPlus::Version::STRING
   # Include your dependencies below. Runtime dependencies are required when using your gem,
   # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
   #  gem.add_runtime_dependency 'jabber4r', '> 0.1'

data/lib/ripper-plus.rb

@@ -2,6 +2,7 @@ if RUBY_VERSION < "1.9"
   raise 'ripper-plus requires Ruby 1.9+'
 end
 require 'ripper'
+require 'ripper-plus/version'
 require 'ripper-plus/ripper-plus'
 require 'ripper-plus/scope_stack'
 require 'ripper-plus/transformer'

data/lib/ripper-plus/scope_stack.rb

@@ -2,11 +2,18 @@ module RipperPlus
   # internal class that manages the current scopes.
   class ScopeStack
     SCOPE_BLOCKER_9000 = :scope_block
+
     def initialize
       # simplifies algorithm to have the scope blocker be the stack base
       @stack = [SCOPE_BLOCKER_9000, Set.new]
+      @in_method = false
+    end
+
+    def in_method?
+      @in_method
     end
 
+    # For debugging purposes
     def inspect
       middle = @stack.map do |scope|
         if SCOPE_BLOCKER_9000 == scope
@@ -31,13 +38,16 @@ module RipperPlus
     end
   
     # An open scope denies reference to local variables in enclosing scopes.
-    def with_closed_scope
+    def with_closed_scope(is_method = false)
+      old_in_method = @in_method
+      @in_method ||= is_method
       @stack.push(SCOPE_BLOCKER_9000)
       @stack.push(Set.new)
       yield
     ensure
       @stack.pop  # pop closed scope
       @stack.pop  # pop scope blocker
+      @in_method = old_in_method
     end
   
     # Checks if the given variable is in scope.

data/lib/ripper-plus/transformer.rb

@@ -43,6 +43,11 @@ module RipperPlus
   module Transformer
     extend self
 
+    class SyntaxError < StandardError; end
+    class LHSError < SyntaxError; end
+    class DynamicConstantError < SyntaxError; end
+    class InvalidArgumentError < SyntaxError; end
+
     # Transforms the given AST into a RipperPlus AST.
     def transform(root)
       new_copy = clone_sexp(root)
@@ -51,31 +56,48 @@ module RipperPlus
       new_copy
     end
 
-    # Transforms the given tree into a RipperPlus AST.
+    # Transforms the given tree into a RipperPlus AST, using a scope stack.
+    # This will be recursively called through each level of the tree.
     def transform_tree(tree, scope_stack)
       case tree[0]
       when :assign, :massign
         lhs, rhs = tree[1..2]
-        add_variables_from_lhs(lhs, scope_stack)
-        transform_tree(rhs, scope_stack)
+        begin
+          add_variables_from_node(lhs, scope_stack)
+        rescue SyntaxError => err
+          wrap_node_with_error(tree)
+        else
+          transform_tree(rhs, scope_stack)
+        end
       when :for
         vars, iterated, body = tree[1..3]
-        add_variables_from_lhs(vars, scope_stack)
+        add_variables_from_node(vars, scope_stack)
         transform_tree(iterated, scope_stack)
         transform_tree(body, scope_stack)
       when :var_ref
+        # When we reach a :var_ref, we should know everything we need to know
+        # in order to tell if it should be transformed into a :zcall.
         if tree[1][0] == :@ident && !scope_stack.has_variable?(tree[1][1])
           tree[0] = :zcall
         end
       when :class
-        superclass, body = tree[2..3]
-        transform_tree(superclass, scope_stack) if superclass  # superclass node
-        scope_stack.with_closed_scope do
-          transform_tree(body, scope_stack)
+        name, superclass, body = tree[1..3]
+        if name[1][0] == :class_name_error || scope_stack.in_method?
+          wrap_node_with_error(tree)
+        else
+          transform_tree(superclass, scope_stack) if superclass  # superclass node
+          scope_stack.with_closed_scope do
+            transform_tree(body, scope_stack)
+          end
         end
       when :module
-        scope_stack.with_closed_scope do
-          transform_tree(tree[2], scope_stack)  # body
+        name, body = tree[1..2]
+        if name[1][0] == :class_name_error || scope_stack.in_method?
+          wrap_node_with_error(tree)
+        else
+          scope_stack.with_closed_scope do
+            transform_tree(body, scope_stack)  # body
+          end
         end
       when :sclass
         singleton, body = tree[1..2]
@@ -84,25 +106,36 @@ module RipperPlus
           transform_tree(body, scope_stack)
         end
       when :def
-        scope_stack.with_closed_scope do
+        scope_stack.with_closed_scope(true) do
           param_node = tree[2]
           body = tree[3]
-          transform_params(param_node, scope_stack)
-          transform_tree(body, scope_stack)
+          begin
+            transform_params(param_node, scope_stack)
+          rescue SyntaxError
+            wrap_node_with_error(tree)
+          else
+            transform_tree(body, scope_stack)
+          end
         end
       when :defs
         transform_tree(tree[1], scope_stack)  # singleton could be a method call!
-        scope_stack.with_closed_scope do
+        scope_stack.with_closed_scope(true) do
           param_node = tree[4]
           body = tree[5]
-          transform_params(param_node, scope_stack)
-          transform_tree(body, scope_stack)
+          begin
+            transform_params(param_node, scope_stack)
+          rescue SyntaxError
+            wrap_node_with_error(tree)
+          else
+            transform_tree(body, scope_stack)
+          end
         end
       when :rescue
         list, name, body = tree[1..3]
         transform_tree(list, scope_stack)
+        # Don't forget the rescue argument!
         if name
-          add_variables_from_lhs(name, scope_stack)
+          add_variables_from_node(name, scope_stack)
         end
         transform_tree(body, scope_stack)
       when :method_add_block
@@ -115,7 +148,7 @@ module RipperPlus
           if block_args
             transform_params(block_args[1], scope_stack)
             if block_args[2]
-              block_args[2].each { |var| add_variables_from_lhs(var, scope_stack) }
+              block_args[2].each { |var| add_variables_from_node(var, scope_stack) }
             end
           end
           transform_tree(block_body, scope_stack)
@@ -124,28 +157,41 @@ module RipperPlus
         # The AST is the reverse of the parse order for these nodes.
         transform_tree(tree[2], scope_stack)
         transform_tree(tree[1], scope_stack)
+      when :alias_error, :assign_error  # error already top-level! wrap it again.
+        wrap_node_with_error(tree)
       else
         transform_in_order(tree, scope_stack)
       end
     end
 
-    def add_variables_from_lhs(lhs, scope_stack)
+    # Adds variables to the given scope stack from the given node. Allows
+    # nodes from parameter lists, left-hand-sides, block argument lists, and
+    # so on.
+    def add_variables_from_node(lhs, scope_stack)
       case lhs[0]
       when :@ident
         scope_stack.add_variable(lhs[1])
+      when :const_path_field, :@const, :top_const_field
+        if scope_stack.in_method?
+          raise DynamicConstantError.new
+        end
       when Array
-        lhs.each { |var| add_variables_from_lhs(var, scope_stack) }
+        lhs.each { |var| add_variables_from_node(var, scope_stack) }
       when :mlhs_paren, :var_field, :rest_param, :blockarg
-        add_variables_from_lhs(lhs[1], scope_stack)
+        add_variables_from_node(lhs[1], scope_stack)
       when :mlhs_add_star
         pre_star, star, post_star = lhs[1..3]
-        pre_star.each { |var| add_variables_from_lhs(var, scope_stack) }
+        pre_star.each { |var| add_variables_from_node(var, scope_stack) }
         if star
-          add_variables_from_lhs(star, scope_stack)
+          add_variables_from_node(star, scope_stack)
         end
         if post_star
-          post_star.each { |var| add_variables_from_lhs(var, scope_stack) }
+          post_star.each { |var| add_variables_from_node(var, scope_stack) }
         end
+      when :param_error
+        raise InvalidArgumentError.new
+      when :assign_error
+        raise LHSError.new
       end
     end
 
@@ -169,27 +215,33 @@ module RipperPlus
       if param_node
         positional_1, optional, rest, positional_2, block = param_node[1..5]
         if positional_1
-          positional_1.each { |var| add_variables_from_lhs(var, scope_stack) }
+          positional_1.each { |var| add_variables_from_node(var, scope_stack) }
         end
         if optional
           optional.each do |var, value|
             # MUST walk value first. (def foo(y=y); end) == (def foo(y=y()); end)
             transform_tree(value, scope_stack)
-            add_variables_from_lhs(var, scope_stack)
+            add_variables_from_node(var, scope_stack)
           end
         end
         if rest && rest[1]
-          add_variables_from_lhs(rest, scope_stack)
+          add_variables_from_node(rest, scope_stack)
         end
         if positional_2
-          positional_2.each { |var| add_variables_from_lhs(var, scope_stack) }
+          positional_2.each { |var| add_variables_from_node(var, scope_stack) }
         end
         if block
-          add_variables_from_lhs(block, scope_stack)
+          add_variables_from_node(block, scope_stack)
         end
       end
     end
 
+    # Wraps the given node as an error node with minimal space overhead.
+    def wrap_node_with_error(tree)
+      new_tree = [:error, tree.dup]
+      tree.replace(new_tree)
+    end
+
     # Deep-copies the sexp. I wish Array#clone did deep copies...
     def clone_sexp(node)
       node.map do |part|

data/lib/ripper-plus/version.rb

@@ -0,0 +1,10 @@
+module RipperPlus
+  module Version
+    MAJOR = 1
+    MINOR = 1
+    PATCH = 0
+    BUILD = 'pre2'
+
+    STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/spec/scope_stack_spec.rb

@@ -26,4 +26,24 @@ describe RipperPlus::ScopeStack do
     end
     @stack.should have_variable(:hello)
   end
+  
+  it 'tracks entry and exit of methods' do
+    @stack.should_not be_in_method
+    @stack.with_open_scope do
+      @stack.should_not be_in_method
+      @stack.with_closed_scope do
+        @stack.should_not be_in_method
+        @stack.with_closed_scope(true) do
+          @stack.should be_in_method
+          @stack.with_closed_scope do
+            @stack.should be_in_method
+          end
+          @stack.should be_in_method
+        end
+        @stack.should_not be_in_method
+      end
+      @stack.should_not be_in_method
+    end
+    @stack.should_not be_in_method
+  end
 end

data/spec/spec_helper.rb

@@ -11,6 +11,20 @@ RSpec::Matchers.define :transform_to do |output|
   match do |input|
     RipperPlus::Transformer.transform(input) == output
   end
+
+  diffable
+end
+
+def dfs_for_node_type(tree, type)
+  if tree[0] == type
+    return tree
+  else
+    tree.select { |child| Array === child }.each do |child|
+      result = dfs_for_node_type(child, type)
+      return result if result
+    end
+  end
+  nil
 end
 
 RSpec.configure do |config|

data/spec/transformer_spec.rb

@@ -1,565 +1,825 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe RipperPlus::Transformer do
-  it 'should transform a simple zcall in a method' do
-    input_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
-         [:bodystmt,
-          [[:void_stmt],
-           [:var_ref, [:@ident, "y", [1, 12]]],
-           [:assign,
-            [:var_field, [:@ident, "y", [1, 15]]],
-            [:var_ref, [:@ident, "x", [1, 19]]]]],
-          nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
-         [:bodystmt,
-          [[:void_stmt],
-           [:zcall, [:@ident, "y", [1, 12]]],
-           [:assign,
-            [:var_field, [:@ident, "y", [1, 15]]],
-            [:var_ref, [:@ident, "x", [1, 19]]]]],
-          nil, nil, nil]]]]
-    input_tree.should transform_to(output_tree)
-  end
+  describe 'zcall detection' do
+    it 'should transform a simple zcall in a method' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
+           [:bodystmt,
+            [[:void_stmt],
+             [:var_ref, [:@ident, "y", [1, 12]]],
+             [:assign,
+              [:var_field, [:@ident, "y", [1, 15]]],
+              [:var_ref, [:@ident, "x", [1, 19]]]]],
+            nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
+           [:bodystmt,
+            [[:void_stmt],
+             [:zcall, [:@ident, "y", [1, 12]]],
+             [:assign,
+              [:var_field, [:@ident, "y", [1, 15]]],
+              [:var_ref, [:@ident, "x", [1, 19]]]]],
+            nil, nil, nil]]]]
+      input_tree.should transform_to(output_tree)
+    end
 
-  it 'should respect argument order in method definitions' do
-    input_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren,
-          [:params,
-           [[:@ident, "x", [1, 8]]],
-           [[[:@ident, "y", [1, 11]], [:var_ref, [:@ident, "z", [1, 13]]]],
-            [[:@ident, "z", [1, 16]], [:var_ref, [:@ident, "y", [1, 18]]]]],
-           nil,
-           nil,
-           nil]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren,
-          [:params,
-           [[:@ident, "x", [1, 8]]],
-           [[[:@ident, "y", [1, 11]], [:zcall, [:@ident, "z", [1, 13]]]],
-            [[:@ident, "z", [1, 16]], [:var_ref, [:@ident, "y", [1, 18]]]]],
-           nil,
-           nil,
-           nil]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    input_tree.should transform_to(output_tree)
-  end
+    it 'should respect argument order in method definitions' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren,
+            [:params,
+             [[:@ident, "x", [1, 8]]],
+             [[[:@ident, "y", [1, 11]], [:var_ref, [:@ident, "z", [1, 13]]]],
+              [[:@ident, "z", [1, 16]], [:var_ref, [:@ident, "y", [1, 18]]]]],
+             nil,
+             nil,
+             nil]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren,
+            [:params,
+             [[:@ident, "x", [1, 8]]],
+             [[[:@ident, "y", [1, 11]], [:zcall, [:@ident, "z", [1, 13]]]],
+              [[:@ident, "z", [1, 16]], [:var_ref, [:@ident, "y", [1, 18]]]]],
+             nil,
+             nil,
+             nil]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      input_tree.should transform_to(output_tree)
+    end
 
-  it 'should respect argument order in block argument definitions' do
-    input_tree =
-      [:program,
-       [[:method_add_block,
-         [:zsuper],
-         [:do_block,
-          [:block_var,
-           [:params,
-            [[:@ident, "x", [1, 10]]],
-            [[[:@ident, "y", [1, 13]], [:var_ref, [:@ident, "x", [1, 15]]]],
-             [[:@ident, "z", [1, 18]], [:var_ref, [:@ident, "a", [1, 20]]]]],
-            [:rest_param, [:@ident, "a", [1, 24]]],
-            nil,
-            nil],
-           nil],
-          [[:void_stmt],
-           [:command,
-            [:@ident, "p", [1, 28]],
-            [:args_add_block,
-             [[:var_ref, [:@ident, "x", [1, 30]]],
-              [:var_ref, [:@ident, "y", [1, 33]]],
-              [:var_ref, [:@ident, "z", [1, 36]]],
-              [:var_ref, [:@ident, "a", [1, 39]]]],
-             false]]]]]]]
-    output_tree =
-      [:program,
-       [[:method_add_block,
-         [:zsuper],
-         [:do_block,
-          [:block_var,
-           [:params,
-            [[:@ident, "x", [1, 10]]],
-            [[[:@ident, "y", [1, 13]], [:var_ref, [:@ident, "x", [1, 15]]]],
-             [[:@ident, "z", [1, 18]], [:zcall, [:@ident, "a", [1, 20]]]]],
-            [:rest_param, [:@ident, "a", [1, 24]]],
-            nil,
-            nil],
-           nil],
-          [[:void_stmt],
-           [:command,
-            [:@ident, "p", [1, 28]],
-            [:args_add_block,
-             [[:var_ref, [:@ident, "x", [1, 30]]],
-              [:var_ref, [:@ident, "y", [1, 33]]],
-              [:var_ref, [:@ident, "z", [1, 36]]],
-              [:var_ref, [:@ident, "a", [1, 39]]]],
-             false]]]]]]]
-    input_tree.should transform_to(output_tree)
-  end
+    it 'should respect argument order in block argument definitions' do
+      input_tree =
+        [:program,
+         [[:method_add_block,
+           [:zsuper],
+           [:do_block,
+            [:block_var,
+             [:params,
+              [[:@ident, "x", [1, 10]]],
+              [[[:@ident, "y", [1, 13]], [:var_ref, [:@ident, "x", [1, 15]]]],
+               [[:@ident, "z", [1, 18]], [:var_ref, [:@ident, "a", [1, 20]]]]],
+              [:rest_param, [:@ident, "a", [1, 24]]],
+              nil,
+              nil],
+             nil],
+            [[:void_stmt],
+             [:command,
+              [:@ident, "p", [1, 28]],
+              [:args_add_block,
+               [[:var_ref, [:@ident, "x", [1, 30]]],
+                [:var_ref, [:@ident, "y", [1, 33]]],
+                [:var_ref, [:@ident, "z", [1, 36]]],
+                [:var_ref, [:@ident, "a", [1, 39]]]],
+               false]]]]]]]
+      output_tree =
+        [:program,
+         [[:method_add_block,
+           [:zsuper],
+           [:do_block,
+            [:block_var,
+             [:params,
+              [[:@ident, "x", [1, 10]]],
+              [[[:@ident, "y", [1, 13]], [:var_ref, [:@ident, "x", [1, 15]]]],
+               [[:@ident, "z", [1, 18]], [:zcall, [:@ident, "a", [1, 20]]]]],
+              [:rest_param, [:@ident, "a", [1, 24]]],
+              nil,
+              nil],
+             nil],
+            [[:void_stmt],
+             [:command,
+              [:@ident, "p", [1, 28]],
+              [:args_add_block,
+               [[:var_ref, [:@ident, "x", [1, 30]]],
+                [:var_ref, [:@ident, "y", [1, 33]]],
+                [:var_ref, [:@ident, "z", [1, 36]]],
+                [:var_ref, [:@ident, "a", [1, 39]]]],
+               false]]]]]]]
+      input_tree.should transform_to(output_tree)
+    end
 
-  it 'should transform singleton names in singleton method definitions' do
-    input_tree =
-      [:program,
-       [[:defs,
-         [:var_ref, [:@ident, "foo", [1, 4]]],
-         [:@period, ".", [1, 7]],
-         [:@ident, "silly", [1, 8]],
-         [:paren, [:params, nil, nil, nil, nil, nil]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:defs,
-         [:zcall, [:@ident, "foo", [1, 4]]],
-         [:@period, ".", [1, 7]],
-         [:@ident, "silly", [1, 8]],
-         [:paren, [:params, nil, nil, nil, nil, nil]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    input_tree.should transform_to(output_tree)
-  end
+    it 'should transform singleton names in singleton method definitions' do
+      input_tree =
+        [:program,
+         [[:defs,
+           [:var_ref, [:@ident, "foo", [1, 4]]],
+           [:@period, ".", [1, 7]],
+           [:@ident, "silly", [1, 8]],
+           [:paren, [:params, nil, nil, nil, nil, nil]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:defs,
+           [:zcall, [:@ident, "foo", [1, 4]]],
+           [:@period, ".", [1, 7]],
+           [:@ident, "silly", [1, 8]],
+           [:paren, [:params, nil, nil, nil, nil, nil]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      input_tree.should transform_to(output_tree)
+    end
   
-  it 'should not transform singleton names when an appropriate local variable exists' do
-    input_tree =
-      [:program,
-       [[:assign,
-         [:var_field, [:@ident, "foo", [1, 0]]],
-         [:var_ref, [:@kw, "self", [1, 6]]]],
-        [:defs,
-         [:var_ref, [:@ident, "foo", [1, 16]]],
-         [:@period, ".", [1, 19]],
-         [:@ident, "silly", [1, 20]],
-         [:params, nil, nil, nil, nil, nil],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    input_tree.should transform_to(input_tree)
-  end
+    it 'should not transform singleton names when an appropriate local variable exists' do
+      input_tree =
+        [:program,
+         [[:assign,
+           [:var_field, [:@ident, "foo", [1, 0]]],
+           [:var_ref, [:@kw, "self", [1, 6]]]],
+          [:defs,
+           [:var_ref, [:@ident, "foo", [1, 16]]],
+           [:@period, ".", [1, 19]],
+           [:@ident, "silly", [1, 20]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      input_tree.should transform_to(input_tree)
+    end
   
-  it 'does not transform the tricky x = 5 unless defined?(x) case' do
-    input_tree =
-      [:program,
-       [[:unless_mod,
-         [:defined, [:var_ref, [:@ident, "x", [1, 22]]]],
-         [:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]]]]]
-    input_tree.should transform_to(input_tree)
-  end
+    it 'does not transform the tricky x = 5 unless defined?(x) case' do
+      input_tree =
+        [:program,
+         [[:unless_mod,
+           [:defined, [:var_ref, [:@ident, "x", [1, 22]]]],
+           [:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]]]]]
+      input_tree.should transform_to(input_tree)
+    end
   
-  it 'finds all LHS vars before transforming an MLHS' do
-    input_tree =
-      [:program,
-       [[:massign,
-         [[:@ident, "a", [1, 0]],
-          [:@const, "B", [1, 3]],
-          [:mlhs_paren,
-           [:mlhs_add_star,
-            [[:@gvar, "$c", [1, 7]]],
-            [:@ident, "rest", [1, 12]],
-            [[:@ident, "d", [1, 18]], [:@ident, "e", [1, 21]]]]]],
-         [:method_add_arg,
-          [:fcall, [:@ident, "foo", [1, 26]]],
-          [:arg_paren,
-           [:args_add_block,
-            [[:var_ref, [:@ident, "a", [1, 30]]],
-             [:var_ref, [:@ident, "c", [1, 33]]],
-             [:var_ref, [:@ident, "d", [1, 36]]]],
-            false]]]]]]
-    output_tree =
-      [:program,
-       [[:massign,
-         [[:@ident, "a", [1, 0]],
-          [:@const, "B", [1, 3]],
-          [:mlhs_paren,
-           [:mlhs_add_star,
-            [[:@gvar, "$c", [1, 7]]],
-            [:@ident, "rest", [1, 12]],
-            [[:@ident, "d", [1, 18]], [:@ident, "e", [1, 21]]]]]],
-         [:method_add_arg,
-          [:fcall, [:@ident, "foo", [1, 26]]],
-          [:arg_paren,
-           [:args_add_block,
-            [[:var_ref, [:@ident, "a", [1, 30]]],
-             [:zcall, [:@ident, "c", [1, 33]]],
-             [:var_ref, [:@ident, "d", [1, 36]]]],
-            false]]]]]]
-    input_tree.should transform_to(output_tree)
-  end
-  
-  it 'creates for-loop MLHS vars before transforming the iteratee' do
-    input_tree =
-      [:program,
-       [[:for,
-         [[:@ident, "a", [1, 4]],
-          [:@ident, "b", [1, 7]],
-          [:mlhs_paren,
-           [[:@ident, "c", [1, 11]],
+    it 'finds all LHS vars before transforming an MLHS' do
+      input_tree =
+        [:program,
+         [[:massign,
+           [[:@ident, "a", [1, 0]],
+            [:@const, "B", [1, 3]],
             [:mlhs_paren,
              [:mlhs_add_star,
-              [],
-              [:@ident, "d", [1, 16]],
-              [[:@ident, "e", [1, 19]]]]]]]],
-         [:method_add_arg,
-          [:fcall, [:@ident, "foo", [1, 26]]],
-          [:arg_paren,
-           [:args_add_block,
-            [[:var_ref, [:@ident, "a", [1, 30]]],
-             [:var_ref, [:@ident, "b", [1, 33]]],
-             [:var_ref, [:@ident, "c", [1, 36]]],
-             [:var_ref, [:@ident, "d", [1, 39]]],
-             [:var_ref, [:@ident, "e", [1, 42]]],
-             [:var_ref, [:@ident, "f", [1, 45]]],
-             [:var_ref, [:@ident, "g", [1, 48]]]],
-            false]]],
-         [[:void_stmt]]]]]
-    output_tree =
-      [:program,
-       [[:for,
-         [[:@ident, "a", [1, 4]],
-          [:@ident, "b", [1, 7]],
-          [:mlhs_paren,
-           [[:@ident, "c", [1, 11]],
+              [[:@gvar, "$c", [1, 7]]],
+              [:@ident, "rest", [1, 12]],
+              [[:@ident, "d", [1, 18]], [:@ident, "e", [1, 21]]]]]],
+           [:method_add_arg,
+            [:fcall, [:@ident, "foo", [1, 26]]],
+            [:arg_paren,
+             [:args_add_block,
+              [[:var_ref, [:@ident, "a", [1, 30]]],
+               [:var_ref, [:@ident, "c", [1, 33]]],
+               [:var_ref, [:@ident, "d", [1, 36]]]],
+              false]]]]]]
+      output_tree =
+        [:program,
+         [[:massign,
+           [[:@ident, "a", [1, 0]],
+            [:@const, "B", [1, 3]],
             [:mlhs_paren,
              [:mlhs_add_star,
-              [],
-              [:@ident, "d", [1, 16]],
-              [[:@ident, "e", [1, 19]]]]]]]],
-         [:method_add_arg,
-          [:fcall, [:@ident, "foo", [1, 26]]],
-          [:arg_paren,
-           [:args_add_block,
-            [[:var_ref, [:@ident, "a", [1, 30]]],
-             [:var_ref, [:@ident, "b", [1, 33]]],
-             [:var_ref, [:@ident, "c", [1, 36]]],
-             [:var_ref, [:@ident, "d", [1, 39]]],
-             [:var_ref, [:@ident, "e", [1, 42]]],
-             [:zcall, [:@ident, "f", [1, 45]]],
-             [:zcall, [:@ident, "g", [1, 48]]]],
-            false]]],
-         [[:void_stmt]]]]]
-    input_tree.should transform_to(output_tree)
-  end
+              [[:@gvar, "$c", [1, 7]]],
+              [:@ident, "rest", [1, 12]],
+              [[:@ident, "d", [1, 18]], [:@ident, "e", [1, 21]]]]]],
+           [:method_add_arg,
+            [:fcall, [:@ident, "foo", [1, 26]]],
+            [:arg_paren,
+             [:args_add_block,
+              [[:var_ref, [:@ident, "a", [1, 30]]],
+               [:zcall, [:@ident, "c", [1, 33]]],
+               [:var_ref, [:@ident, "d", [1, 36]]]],
+              false]]]]]]
+      input_tree.should transform_to(output_tree)
+    end
   
-  it 'should transform respecting subassignments in block arguments' do
-    input_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "10", [1, 4]]],
-        [:method_add_block,
-         [:call,
-          [:top_const_ref, [:@const, "ARR", [1, 10]]],
-          :".",
-          [:@ident, "each", [1, 14]]],
-         [:brace_block,
-          [:block_var,
-           [:params,
-            [[:@ident, "y", [1, 22]],
-             [:mlhs_paren,
-              [[:mlhs_paren, [:@ident, "z", [1, 26]]],
-               [:mlhs_paren, [:@ident, "a", [1, 29]]]]]],
-            [[[:@ident, "k", [1, 33]], [:var_ref, [:@ident, "z", [1, 37]]]],
-             [[:@ident, "j", [1, 40]], [:var_ref, [:@ident, "d", [1, 44]]]]],
-            [:rest_param, [:@ident, "r", [1, 48]]],
-            nil,
-            [:blockarg, [:@ident, "blk", [1, 52]]]],
-           [[:@ident, "local", [1, 57]]]],
-          [[:command,
-            [:@ident, "p", [1, 64]],
-            [:args_add_block,
-             [[:var_ref, [:@ident, "x", [1, 66]]],
-              [:var_ref, [:@ident, "y", [1, 69]]],
-              [:var_ref, [:@ident, "z", [1, 72]]],
-              [:var_ref, [:@ident, "a", [1, 75]]],
-              [:var_ref, [:@ident, "k", [1, 78]]],
-              [:var_ref, [:@ident, "j", [1, 81]]],
-              [:var_ref, [:@ident, "r", [1, 84]]],
-              [:var_ref, [:@ident, "blk", [1, 87]]],
-              [:var_ref, [:@ident, "local", [1, 92]]],
-              [:var_ref, [:@ident, "foo", [1, 99]]]],
-             false]]]]]]]
-    output_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "10", [1, 4]]],
-        [:method_add_block,
-         [:call,
-          [:top_const_ref, [:@const, "ARR", [1, 10]]],
-          :".",
-          [:@ident, "each", [1, 14]]],
-         [:brace_block,
-          [:block_var,
-           [:params,
-            [[:@ident, "y", [1, 22]],
-             [:mlhs_paren,
-              [[:mlhs_paren, [:@ident, "z", [1, 26]]],
-               [:mlhs_paren, [:@ident, "a", [1, 29]]]]]],
-            [[[:@ident, "k", [1, 33]], [:var_ref, [:@ident, "z", [1, 37]]]],
-             [[:@ident, "j", [1, 40]], [:zcall, [:@ident, "d", [1, 44]]]]],
-            [:rest_param, [:@ident, "r", [1, 48]]],
-            nil,
-            [:blockarg, [:@ident, "blk", [1, 52]]]],
-           [[:@ident, "local", [1, 57]]]],
-          [[:command,
-            [:@ident, "p", [1, 64]],
-            [:args_add_block,
-             [[:var_ref, [:@ident, "x", [1, 66]]],
-              [:var_ref, [:@ident, "y", [1, 69]]],
-              [:var_ref, [:@ident, "z", [1, 72]]],
-              [:var_ref, [:@ident, "a", [1, 75]]],
-              [:var_ref, [:@ident, "k", [1, 78]]],
-              [:var_ref, [:@ident, "j", [1, 81]]],
-              [:var_ref, [:@ident, "r", [1, 84]]],
-              [:var_ref, [:@ident, "blk", [1, 87]]],
-              [:var_ref, [:@ident, "local", [1, 92]]],
-              [:zcall, [:@ident, "foo", [1, 99]]]],
-             false]]]]]]]
-    input_tree.should transform_to(output_tree)  
-  end
+    it 'creates for-loop MLHS vars before transforming the iteratee' do
+      input_tree =
+        [:program,
+         [[:for,
+           [[:@ident, "a", [1, 4]],
+            [:@ident, "b", [1, 7]],
+            [:mlhs_paren,
+             [[:@ident, "c", [1, 11]],
+              [:mlhs_paren,
+               [:mlhs_add_star,
+                [],
+                [:@ident, "d", [1, 16]],
+                [[:@ident, "e", [1, 19]]]]]]]],
+           [:method_add_arg,
+            [:fcall, [:@ident, "foo", [1, 26]]],
+            [:arg_paren,
+             [:args_add_block,
+              [[:var_ref, [:@ident, "a", [1, 30]]],
+               [:var_ref, [:@ident, "b", [1, 33]]],
+               [:var_ref, [:@ident, "c", [1, 36]]],
+               [:var_ref, [:@ident, "d", [1, 39]]],
+               [:var_ref, [:@ident, "e", [1, 42]]],
+               [:var_ref, [:@ident, "f", [1, 45]]],
+               [:var_ref, [:@ident, "g", [1, 48]]]],
+              false]]],
+           [[:void_stmt]]]]]
+      output_tree =
+        [:program,
+         [[:for,
+           [[:@ident, "a", [1, 4]],
+            [:@ident, "b", [1, 7]],
+            [:mlhs_paren,
+             [[:@ident, "c", [1, 11]],
+              [:mlhs_paren,
+               [:mlhs_add_star,
+                [],
+                [:@ident, "d", [1, 16]],
+                [[:@ident, "e", [1, 19]]]]]]]],
+           [:method_add_arg,
+            [:fcall, [:@ident, "foo", [1, 26]]],
+            [:arg_paren,
+             [:args_add_block,
+              [[:var_ref, [:@ident, "a", [1, 30]]],
+               [:var_ref, [:@ident, "b", [1, 33]]],
+               [:var_ref, [:@ident, "c", [1, 36]]],
+               [:var_ref, [:@ident, "d", [1, 39]]],
+               [:var_ref, [:@ident, "e", [1, 42]]],
+               [:zcall, [:@ident, "f", [1, 45]]],
+               [:zcall, [:@ident, "g", [1, 48]]]],
+              false]]],
+           [[:void_stmt]]]]]
+      input_tree.should transform_to(output_tree)
+    end
   
-  it 'does not let block variables escape into enclosing scopes' do
-    input_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:method_add_block,
-         [:call, [:array, nil], :".", [:@ident, "each", [1, 10]]],
-         [:brace_block,
-          [:block_var,
-           [:params, [[:@ident, "y", [1, 18]]], nil, nil, nil, nil],
-           [[:@ident, "z", [1, 20]], [:@ident, "x", [1, 23]]]],
-          [[:var_ref, [:@ident, "x", [1, 26]]],
-           [:var_ref, [:@ident, "y", [1, 28]]],
-           [:var_ref, [:@ident, "z", [1, 30]]]]]],
-        [:var_ref, [:@ident, "x", [1, 36]]],
-        [:var_ref, [:@ident, "y", [1, 39]]],
-        [:var_ref, [:@ident, "z", [1, 42]]]]]
-    output_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:method_add_block,
-         [:call, [:array, nil], :".", [:@ident, "each", [1, 10]]],
-         [:brace_block,
-          [:block_var,
-           [:params, [[:@ident, "y", [1, 18]]], nil, nil, nil, nil],
-           [[:@ident, "z", [1, 20]], [:@ident, "x", [1, 23]]]],
-          [[:var_ref, [:@ident, "x", [1, 26]]],
-           [:var_ref, [:@ident, "y", [1, 28]]],
-           [:var_ref, [:@ident, "z", [1, 30]]]]]],
-        [:var_ref, [:@ident, "x", [1, 36]]],
-        [:zcall, [:@ident, "y", [1, 39]]],
-        [:zcall, [:@ident, "z", [1, 42]]]]]
-    input_tree.should transform_to(output_tree)
-  end
+    it 'should transform respecting subassignments in block arguments' do
+      input_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "10", [1, 4]]],
+          [:method_add_block,
+           [:call,
+            [:top_const_ref, [:@const, "ARR", [1, 10]]],
+            :".",
+            [:@ident, "each", [1, 14]]],
+           [:brace_block,
+            [:block_var,
+             [:params,
+              [[:@ident, "y", [1, 22]],
+               [:mlhs_paren,
+                [[:mlhs_paren, [:@ident, "z", [1, 26]]],
+                 [:mlhs_paren, [:@ident, "a", [1, 29]]]]]],
+              [[[:@ident, "k", [1, 33]], [:var_ref, [:@ident, "z", [1, 37]]]],
+               [[:@ident, "j", [1, 40]], [:var_ref, [:@ident, "d", [1, 44]]]]],
+              [:rest_param, [:@ident, "r", [1, 48]]],
+              nil,
+              [:blockarg, [:@ident, "blk", [1, 52]]]],
+             [[:@ident, "local", [1, 57]]]],
+            [[:command,
+              [:@ident, "p", [1, 64]],
+              [:args_add_block,
+               [[:var_ref, [:@ident, "x", [1, 66]]],
+                [:var_ref, [:@ident, "y", [1, 69]]],
+                [:var_ref, [:@ident, "z", [1, 72]]],
+                [:var_ref, [:@ident, "a", [1, 75]]],
+                [:var_ref, [:@ident, "k", [1, 78]]],
+                [:var_ref, [:@ident, "j", [1, 81]]],
+                [:var_ref, [:@ident, "r", [1, 84]]],
+                [:var_ref, [:@ident, "blk", [1, 87]]],
+                [:var_ref, [:@ident, "local", [1, 92]]],
+                [:var_ref, [:@ident, "foo", [1, 99]]]],
+               false]]]]]]]
+      output_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "10", [1, 4]]],
+          [:method_add_block,
+           [:call,
+            [:top_const_ref, [:@const, "ARR", [1, 10]]],
+            :".",
+            [:@ident, "each", [1, 14]]],
+           [:brace_block,
+            [:block_var,
+             [:params,
+              [[:@ident, "y", [1, 22]],
+               [:mlhs_paren,
+                [[:mlhs_paren, [:@ident, "z", [1, 26]]],
+                 [:mlhs_paren, [:@ident, "a", [1, 29]]]]]],
+              [[[:@ident, "k", [1, 33]], [:var_ref, [:@ident, "z", [1, 37]]]],
+               [[:@ident, "j", [1, 40]], [:zcall, [:@ident, "d", [1, 44]]]]],
+              [:rest_param, [:@ident, "r", [1, 48]]],
+              nil,
+              [:blockarg, [:@ident, "blk", [1, 52]]]],
+             [[:@ident, "local", [1, 57]]]],
+            [[:command,
+              [:@ident, "p", [1, 64]],
+              [:args_add_block,
+               [[:var_ref, [:@ident, "x", [1, 66]]],
+                [:var_ref, [:@ident, "y", [1, 69]]],
+                [:var_ref, [:@ident, "z", [1, 72]]],
+                [:var_ref, [:@ident, "a", [1, 75]]],
+                [:var_ref, [:@ident, "k", [1, 78]]],
+                [:var_ref, [:@ident, "j", [1, 81]]],
+                [:var_ref, [:@ident, "r", [1, 84]]],
+                [:var_ref, [:@ident, "blk", [1, 87]]],
+                [:var_ref, [:@ident, "local", [1, 92]]],
+                [:zcall, [:@ident, "foo", [1, 99]]]],
+               false]]]]]]]
+      input_tree.should transform_to(output_tree)  
+    end
   
-  it 'creates closed scopes when classes are created' do
-    input_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:class,
-         [:const_ref, [:@const, "Foo", [1, 13]]],
-         nil,
-         [:bodystmt, [[:var_ref, [:@ident, "x", [1, 18]]]], nil, nil, nil]],
-        [:var_ref, [:@ident, "x", [1, 26]]]]]
-    output_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:class,
-         [:const_ref, [:@const, "Foo", [1, 13]]],
-         nil,
-         [:bodystmt, [[:zcall, [:@ident, "x", [1, 18]]]], nil, nil, nil]],
-        [:var_ref, [:@ident, "x", [1, 26]]]]]
-    input_tree.should transform_to(output_tree)
-  end
+    it 'does not let block variables escape into enclosing scopes' do
+      input_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:method_add_block,
+           [:call, [:array, nil], :".", [:@ident, "each", [1, 10]]],
+           [:brace_block,
+            [:block_var,
+             [:params, [[:@ident, "y", [1, 18]]], nil, nil, nil, nil],
+             [[:@ident, "z", [1, 20]], [:@ident, "x", [1, 23]]]],
+            [[:var_ref, [:@ident, "x", [1, 26]]],
+             [:var_ref, [:@ident, "y", [1, 28]]],
+             [:var_ref, [:@ident, "z", [1, 30]]]]]],
+          [:var_ref, [:@ident, "x", [1, 36]]],
+          [:var_ref, [:@ident, "y", [1, 39]]],
+          [:var_ref, [:@ident, "z", [1, 42]]]]]
+      output_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:method_add_block,
+           [:call, [:array, nil], :".", [:@ident, "each", [1, 10]]],
+           [:brace_block,
+            [:block_var,
+             [:params, [[:@ident, "y", [1, 18]]], nil, nil, nil, nil],
+             [[:@ident, "z", [1, 20]], [:@ident, "x", [1, 23]]]],
+            [[:var_ref, [:@ident, "x", [1, 26]]],
+             [:var_ref, [:@ident, "y", [1, 28]]],
+             [:var_ref, [:@ident, "z", [1, 30]]]]]],
+          [:var_ref, [:@ident, "x", [1, 36]]],
+          [:zcall, [:@ident, "y", [1, 39]]],
+          [:zcall, [:@ident, "z", [1, 42]]]]]
+      input_tree.should transform_to(output_tree)
+    end
   
-  it 'uses the previous scope for superclass specification' do
-    input_tree =
-      [:program,
-       [[:assign,
-         [:var_field, [:@ident, "x", [1, 0]]],
-         [:var_ref, [:@const, "String", [1, 4]]]],
-        [:class,
-         [:const_ref, [:@const, "A", [1, 18]]],
-         [:var_ref, [:@ident, "x", [1, 22]]],
-         [:bodystmt, [[:var_ref, [:@ident, "x", [1, 25]]]], nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:assign,
-         [:var_field, [:@ident, "x", [1, 0]]],
-         [:var_ref, [:@const, "String", [1, 4]]]],
-        [:class,
-         [:const_ref, [:@const, "A", [1, 18]]],
-         [:var_ref, [:@ident, "x", [1, 22]]],
-         [:bodystmt, [[:zcall, [:@ident, "x", [1, 25]]]], nil, nil, nil]]]]
-    input_tree.should transform_to output_tree
-  end
+    it 'creates closed scopes when classes are created' do
+      input_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:class,
+           [:const_ref, [:@const, "Foo", [1, 13]]],
+           nil,
+           [:bodystmt, [[:var_ref, [:@ident, "x", [1, 18]]]], nil, nil, nil]],
+          [:var_ref, [:@ident, "x", [1, 26]]]]]
+      output_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:class,
+           [:const_ref, [:@const, "Foo", [1, 13]]],
+           nil,
+           [:bodystmt, [[:zcall, [:@ident, "x", [1, 18]]]], nil, nil, nil]],
+          [:var_ref, [:@ident, "x", [1, 26]]]]]
+      input_tree.should transform_to(output_tree)
+    end
   
-  it 'creates closed scopes when modules are created' do
-    input_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:module,
-         [:const_ref, [:@const, "Foo", [1, 14]]],
-         [:bodystmt,
-          [[:void_stmt], [:var_ref, [:@ident, "x", [1, 19]]]],
-          nil,
-          nil,
-          nil]],
-        [:var_ref, [:@ident, "x", [1, 27]]]]]
-    output_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:module,
-         [:const_ref, [:@const, "Foo", [1, 14]]],
-         [:bodystmt,
-          [[:void_stmt], [:zcall, [:@ident, "x", [1, 19]]]],
-          nil,
-          nil,
-          nil]],
-        [:var_ref, [:@ident, "x", [1, 27]]]]]
-    input_tree.should transform_to output_tree
-  end
+    it 'uses the previous scope for superclass specification' do
+      input_tree =
+        [:program,
+         [[:assign,
+           [:var_field, [:@ident, "x", [1, 0]]],
+           [:var_ref, [:@const, "String", [1, 4]]]],
+          [:class,
+           [:const_ref, [:@const, "A", [1, 18]]],
+           [:var_ref, [:@ident, "x", [1, 22]]],
+           [:bodystmt, [[:var_ref, [:@ident, "x", [1, 25]]]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:assign,
+           [:var_field, [:@ident, "x", [1, 0]]],
+           [:var_ref, [:@const, "String", [1, 4]]]],
+          [:class,
+           [:const_ref, [:@const, "A", [1, 18]]],
+           [:var_ref, [:@ident, "x", [1, 22]]],
+           [:bodystmt, [[:zcall, [:@ident, "x", [1, 25]]]], nil, nil, nil]]]]
+      input_tree.should transform_to output_tree
+    end
   
-  it 'creates closed scopes when singleton classes are opened' do
-    input_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:sclass,
-         [:var_ref, [:@const, "String", [1, 16]]],
-         [:bodystmt, [[:var_ref, [:@ident, "x", [1, 24]]]], nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
-        [:sclass,
-         [:var_ref, [:@const, "String", [1, 16]]],
-         [:bodystmt, [[:zcall, [:@ident, "x", [1, 24]]]], nil, nil, nil]]]]
-    input_tree.should transform_to output_tree
-  end
+    it 'creates closed scopes when modules are created' do
+      input_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:module,
+           [:const_ref, [:@const, "Foo", [1, 14]]],
+           [:bodystmt,
+            [[:void_stmt], [:var_ref, [:@ident, "x", [1, 19]]]],
+            nil,
+            nil,
+            nil]],
+          [:var_ref, [:@ident, "x", [1, 27]]]]]
+      output_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:module,
+           [:const_ref, [:@const, "Foo", [1, 14]]],
+           [:bodystmt,
+            [[:void_stmt], [:zcall, [:@ident, "x", [1, 19]]]],
+            nil,
+            nil,
+            nil]],
+          [:var_ref, [:@ident, "x", [1, 27]]]]]
+      input_tree.should transform_to output_tree
+    end
   
-  it 'refers to the enclosing environment to determine the singleton to open' do
-    input_tree =
-      [:program,
-       [[:assign,
-         [:var_field, [:@ident, "x", [1, 0]]],
-         [:string_literal, [:string_content, [:@tstring_content, "hi", [1, 5]]]]],
-        [:sclass,
-         [:var_ref, [:@ident, "x", [1, 19]]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    input_tree.should transform_to input_tree
-  end
+    it 'creates closed scopes when singleton classes are opened' do
+      input_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:sclass,
+           [:var_ref, [:@const, "String", [1, 16]]],
+           [:bodystmt, [[:var_ref, [:@ident, "x", [1, 24]]]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:assign, [:var_field, [:@ident, "x", [1, 0]]], [:@int, "5", [1, 4]]],
+          [:sclass,
+           [:var_ref, [:@const, "String", [1, 16]]],
+           [:bodystmt, [[:zcall, [:@ident, "x", [1, 24]]]], nil, nil, nil]]]]
+      input_tree.should transform_to output_tree
+    end
   
-  it 'refers to the enclosing environment to determine the singleton to open - resulting in zcall' do
-    input_tree =
-      [:program,
-       [[:sclass,
-         [:var_ref, [:@ident, "x", [1, 19]]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    output_tree =
-      [:program,
-       [[:sclass,
-         [:zcall, [:@ident, "x", [1, 19]]],
-         [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
-    input_tree.should transform_to output_tree
-  end
+    it 'refers to the enclosing environment to determine the singleton to open' do
+      input_tree =
+        [:program,
+         [[:assign,
+           [:var_field, [:@ident, "x", [1, 0]]],
+           [:string_literal, [:string_content, [:@tstring_content, "hi", [1, 5]]]]],
+          [:sclass,
+           [:var_ref, [:@ident, "x", [1, 19]]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      input_tree.should transform_to input_tree
+    end
   
-  it 'observes the creation of local variables by rescue clauses' do
-    input_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
-         [:bodystmt,
-          [[:void_stmt],
-           [:assign,
-            [:var_field, [:@ident, "y", [1, 12]]],
-            [:binary,
-             [:@int, "1", [1, 16]],
-             :/,
-             [:var_ref, [:@ident, "x", [1, 20]]]]]],
-          [:rescue,
-           [[:var_ref, [:@const, "Exception", [1, 30]]]],
-           [:var_field, [:@ident, "err", [1, 43]]],
-           [[:command,
-             [:@ident, "p", [1, 48]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 50]]]], false]]],
-           nil],
-          [:else,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 61]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 63]]]], false]]]],
-          [:ensure,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 76]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 78]]]], false]]]]]]]]
-    input_tree.should transform_to input_tree
-  end
+    it 'refers to the enclosing environment to determine the singleton to open - resulting in zcall' do
+      input_tree =
+        [:program,
+         [[:sclass,
+           [:var_ref, [:@ident, "x", [1, 19]]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:sclass,
+           [:zcall, [:@ident, "x", [1, 19]]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      input_tree.should transform_to output_tree
+    end
   
-  it 'handles rescue clauses normally otherwise' do
-    input_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
-         [:bodystmt,
-          [[:void_stmt],
-           [:assign,
-            [:var_field, [:@ident, "y", [1, 12]]],
-            [:binary,
-             [:@int, "1", [1, 16]],
-             :/,
-             [:var_ref, [:@ident, "x", [1, 20]]]]]],
-          [:rescue,
-           [[:var_ref, [:@const, "Exception", [1, 30]]]],
-           nil,
-           [[:command,
-             [:@ident, "p", [1, 48]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 50]]]], false]]],
-           nil],
-          [:else,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 61]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 63]]]], false]]]],
-          [:ensure,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 76]],
-             [:args_add_block, [[:var_ref, [:@ident, "err", [1, 78]]]], false]]]]]]]]
-    output_tree =
-      [:program,
-       [[:def,
-         [:@ident, "foo", [1, 4]],
-         [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
-         [:bodystmt,
-          [[:void_stmt],
-           [:assign,
-            [:var_field, [:@ident, "y", [1, 12]]],
-            [:binary,
-             [:@int, "1", [1, 16]],
-             :/,
-             [:var_ref, [:@ident, "x", [1, 20]]]]]],
-          [:rescue,
-           [[:var_ref, [:@const, "Exception", [1, 30]]]],
+    it 'observes the creation of local variables by rescue clauses' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
+           [:bodystmt,
+            [[:void_stmt],
+             [:assign,
+              [:var_field, [:@ident, "y", [1, 12]]],
+              [:binary,
+               [:@int, "1", [1, 16]],
+               :/,
+               [:var_ref, [:@ident, "x", [1, 20]]]]]],
+            [:rescue,
+             [[:var_ref, [:@const, "Exception", [1, 30]]]],
+             [:var_field, [:@ident, "err", [1, 43]]],
+             [[:command,
+               [:@ident, "p", [1, 48]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 50]]]], false]]],
+             nil],
+            [:else,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 61]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 63]]]], false]]]],
+            [:ensure,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 76]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 78]]]], false]]]]]]]]
+      input_tree.should transform_to input_tree
+    end
+  
+    it 'handles rescue clauses normally otherwise' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
+           [:bodystmt,
+            [[:void_stmt],
+             [:assign,
+              [:var_field, [:@ident, "y", [1, 12]]],
+              [:binary,
+               [:@int, "1", [1, 16]],
+               :/,
+               [:var_ref, [:@ident, "x", [1, 20]]]]]],
+            [:rescue,
+             [[:var_ref, [:@const, "Exception", [1, 30]]]],
+             nil,
+             [[:command,
+               [:@ident, "p", [1, 48]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 50]]]], false]]],
+             nil],
+            [:else,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 61]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 63]]]], false]]]],
+            [:ensure,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 76]],
+               [:args_add_block, [[:var_ref, [:@ident, "err", [1, 78]]]], false]]]]]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:paren, [:params, [[:@ident, "x", [1, 8]]], nil, nil, nil, nil]],
+           [:bodystmt,
+            [[:void_stmt],
+             [:assign,
+              [:var_field, [:@ident, "y", [1, 12]]],
+              [:binary,
+               [:@int, "1", [1, 16]],
+               :/,
+               [:var_ref, [:@ident, "x", [1, 20]]]]]],
+            [:rescue,
+             [[:var_ref, [:@const, "Exception", [1, 30]]]],
+             nil,
+             [[:command,
+               [:@ident, "p", [1, 48]],
+               [:args_add_block, [[:zcall, [:@ident, "err", [1, 50]]]], false]]],
+             nil],
+            [:else,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 61]],
+               [:args_add_block, [[:zcall, [:@ident, "err", [1, 63]]]], false]]]],
+            [:ensure,
+             [[:void_stmt],
+              [:command,
+               [:@ident, "p", [1, 76]],
+               [:args_add_block, [[:zcall, [:@ident, "err", [1, 78]]]], false]]]]]]]]
+      input_tree.should transform_to output_tree
+    end
+  end
+  describe 'error transformation' do
+    it 'should push up module name errors' do
+      input_tree =
+        [:program,
+         [[:module,
+           [:const_ref, [:class_name_error, [:@ident, "a", [1, 7]]]],
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:error,
+           [:module,
+            [:const_ref, [:class_name_error, [:@ident, "a", [1, 7]]]],
+            [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'should push up class name errors' do
+      input_tree =
+        [:program,
+         [[:class,
+           [:const_ref, [:class_name_error, [:@ident, "a", [1, 6]]]],
            nil,
-           [[:command,
-             [:@ident, "p", [1, 48]],
-             [:args_add_block, [[:zcall, [:@ident, "err", [1, 50]]]], false]]],
-           nil],
-          [:else,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 61]],
-             [:args_add_block, [[:zcall, [:@ident, "err", [1, 63]]]], false]]]],
-          [:ensure,
-           [[:void_stmt],
-            [:command,
-             [:@ident, "p", [1, 76]],
-             [:args_add_block, [[:zcall, [:@ident, "err", [1, 78]]]], false]]]]]]]]
-    input_tree.should transform_to output_tree
+           [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:error,
+           [:class,
+            [:const_ref, [:class_name_error, [:@ident, "a", [1, 6]]]],
+            nil,
+            [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]]
+      input_tree.should transform_to output_tree
+    end
+
+    it 'wraps single assignments in :error if they assign read-only gvars' do
+      input_tree =
+        [:program,
+         [[:assign, [:assign_error, [:@backref, "$`", [1, 0]]], [:@int, "3", [1, 5]]]]]
+      output_tree =
+        [:program,
+         [[:error, [:assign, [:assign_error, [:@backref, "$`", [1, 0]]], [:@int, "3", [1, 5]]]]]]
+      input_tree.should transform_to output_tree
+    end
+
+    it 'wraps multiple assignments in :error if they assign read-only gvars' do
+      input_tree =
+        [:program,
+         [[:massign,
+           [[:@ident, "a", [1, 0]],
+            [:@ident, "b", [1, 3]],
+            [:assign_error, [:var_field, [:@backref, "$&", [1, 6]]]]],
+           [:mrhs_add_star,
+            [],
+            [:paren, [[:dot2, [:@int, "1", [1, 13]], [:@int, "3", [1, 16]]]]]]]]]
+      output_tree =
+        [:program,
+         [[:error,
+           [:massign,
+            [[:@ident, "a", [1, 0]],
+             [:@ident, "b", [1, 3]],
+             [:assign_error, [:var_field, [:@backref, "$&", [1, 6]]]]],
+            [:mrhs_add_star,
+             [],
+             [:paren, [[:dot2, [:@int, "1", [1, 13]], [:@int, "3", [1, 16]]]]]]]]]]
+      input_tree.should transform_to output_tree
+    end
+
+    it 'wraps assignments in :error if they assign read-only vars deep in subassignments' do
+      input_tree =
+        [:program,
+         [[:massign,
+           [[:@ident, "a", [1, 0]],
+            [:mlhs_paren,
+             [:mlhs_add_star,
+              [[:@ident, "b", [1, 4]]],
+              [:@ident, "c", [1, 8]],
+              [[:mlhs_paren,
+                [[:assign_error, [:var_field, [:@backref, "$1", [1, 12]]]],
+                 [:@ident, "d", [1, 16]]]]]]]],
+           [:mrhs_add_star,
+            [],
+            [:method_add_arg,
+             [:fcall, [:@ident, "foo", [1, 23]]],
+             [:arg_paren, nil]]]]]]
+      output_tree =
+        [:program,
+         [[:error,
+           [:massign,
+            [[:@ident, "a", [1, 0]],
+             [:mlhs_paren,
+              [:mlhs_add_star,
+               [[:@ident, "b", [1, 4]]],
+               [:@ident, "c", [1, 8]],
+               [[:mlhs_paren,
+                 [[:assign_error, [:var_field, [:@backref, "$1", [1, 12]]]],
+                  [:@ident, "d", [1, 16]]]]]]]],
+            [:mrhs_add_star,
+             [],
+             [:method_add_arg,
+              [:fcall, [:@ident, "foo", [1, 23]]],
+              [:arg_paren, nil]]]]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'wraps alias errors with a standard :error node' do
+      input_tree =
+        [:program,
+         [[:alias_error,
+           [:var_alias, [:@gvar, "$foo", [1, 6]], [:@backref, "$1", [1, 11]]]]]]
+      output_tree =
+        [:program,
+         [[:error, [:alias_error,
+           [:var_alias, [:@gvar, "$foo", [1, 6]], [:@backref, "$1", [1, 11]]]]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'wraps dynamic assignments to constants in :error nodes' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:assign, [:var_field, [:@const, "C", [1, 9]]], [:@int, "5", [1, 13]]]],
+            nil,
+            nil,
+            nil]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:error, [:assign, [:var_field, [:@const, "C", [1, 9]]], [:@int, "5", [1, 13]]]]],
+            nil,
+            nil,
+            nil]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'wraps dynamic assignments in massigns in :error nodes' do
+      input_tree =
+        [:program,
+         [[:defs,
+           [:var_ref, [:@kw, "self", [1, 4]]],
+           [:@period, ".", [1, 8]],
+           [:@ident, "foo", [1, 9]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:massign,
+              [[:@ident, "a", [1, 14]],
+               [:mlhs_paren,
+                [[:@ident, "b", [1, 18]],
+                 [:mlhs_paren,
+                  [[:@gvar, "$c", [1, 22]],
+                   [:const_path_field,
+                    [:var_ref, [:@kw, "self", [1, 26]]],
+                    [:@const, "D", [1, 32]]]]]]]],
+              [:mrhs_add_star, [], [:var_ref, [:@const, "CONST", [1, 39]]]]]],
+            nil, nil, nil]]]]
+      output_tree =
+        [:program,
+         [[:defs,
+           [:var_ref, [:@kw, "self", [1, 4]]],
+           [:@period, ".", [1, 8]],
+           [:@ident, "foo", [1, 9]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:error, [:massign,
+              [[:@ident, "a", [1, 14]],
+               [:mlhs_paren,
+                [[:@ident, "b", [1, 18]],
+                 [:mlhs_paren,
+                  [[:@gvar, "$c", [1, 22]],
+                   [:const_path_field,
+                    [:var_ref, [:@kw, "self", [1, 26]]],
+                    [:@const, "D", [1, 32]]]]]]]],
+              [:mrhs_add_star, [], [:var_ref, [:@const, "CONST", [1, 39]]]]]]],
+            nil, nil, nil]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'wraps classes in method bodies with error nodes' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:class,
+              [:const_ref, [:@const, "A", [1, 15]]],
+              nil,
+              [:bodystmt, [[:void_stmt]], nil, nil, nil]]],
+            nil,
+            nil,
+            nil]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:error, [:class,
+              [:const_ref, [:@const, "A", [1, 15]]],
+              nil,
+              [:bodystmt, [[:void_stmt]], nil, nil, nil]]]],
+            nil,
+            nil,
+            nil]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    it 'wraps modules in method bodies with error nodes' do
+      input_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:module,
+              [:const_ref, [:@const, "A", [1, 15]]],
+              [:bodystmt, [[:void_stmt]], nil, nil, nil]]],
+            nil,
+            nil,
+            nil]]]]
+      output_tree =
+        [:program,
+         [[:def,
+           [:@ident, "foo", [1, 4]],
+           [:params, nil, nil, nil, nil, nil],
+           [:bodystmt,
+            [[:error, [:module,
+              [:const_ref, [:@const, "A", [1, 15]]],
+              [:bodystmt, [[:void_stmt]], nil, nil, nil]]]],
+            nil,
+            nil,
+            nil]]]]
+      input_tree.should transform_to output_tree
+    end
+    
+    %w(FOO @foo @@foo $foo).each do |bad_var|
+      [['singleton', 'String.', :defs], ['normal', '', :def]].each do |kind, prefix, fail_node|
+        it "wraps #{kind} definitions with #{bad_var} as a positional argument name with :error" do
+          input_code = "def #{prefix}foo(a, #{bad_var}, *rest); end"
+          tree = RipperPlus.sexp(input_code)
+          error = dfs_for_node_type(tree, :error)
+          error[1][0].should be fail_node
+        end
+
+        it "wraps #{kind} definitions with #{bad_var} as a second-section positional argument name with :error" do
+          input_code = "def #{prefix}foo(a, b=2, #{bad_var}); end"
+          tree = RipperPlus.sexp(input_code)
+          error = dfs_for_node_type(tree, :error)
+          error[1][0].should be fail_node
+        end
+      end
+    end
+    
   end
 end