ruby_parser 2.0.5 → 3.0.0.a1

data/lib/ruby_parser_extras.rb

@@ -3,10 +3,15 @@ require 'racc/parser'
 require 'sexp'
 require 'strscan'
 
+def d o
+  $stderr.puts o.inspect
+end
+
 # WHY do I have to do this?!?
 class Regexp
-  unless defined? ONCE then
-    ONCE     = 0 # 16 # ?
+  ONCE = 0 unless defined? ONCE # FIX: remove this - it makes no sense
+
+  unless defined? ENC_NONE then
     ENC_NONE = /x/n.options
     ENC_EUC  = /x/e.options
     ENC_SJIS = /x/s.options
@@ -29,36 +34,31 @@ class RPStringScanner < StringScanner
 #       old_getch
 #     end
 #   end
-
   def current_line # HAHA fuck you (HACK)
     string[0..pos][/\A.*__LINE__/m].split(/\n/).size
   end
 
+  def extra_lines_added
+    @extra_lines_added ||= 0
+  end
+
+  def extra_lines_added= val
+    @extra_lines_added = val
+  end
+
   def lineno
-    string[0...pos].count("\n") + 1
+    string[0...pos].count("\n") + 1 - extra_lines_added
   end
 
   # TODO: once we get rid of these, we can make things like
   # TODO: current_line and lineno much more accurate and easy to do
-  def unread c # TODO: remove this entirely - we should not need it
-    return if c.nil? # UGH
-    warn({:unread => caller[0]}.inspect) if ENV['TALLY']
-    string[pos, 0] = c
-  end
 
   def unread_many str # TODO: remove this entirely - we should not need it
     warn({:unread_many => caller[0]}.inspect) if ENV['TALLY']
+    self.extra_lines_added += str.count("\n")
     string[pos, 0] = str
   end
 
-  def begin_of_line?
-    pos == 0 or string[pos-1] == ?\n
-  end
-
-  def was_begin_of_line # TODO: kill me
-    pos <= 2 or string[pos-2] == ?\n
-  end
-
   if ENV['DEBUG'] then
     alias :old_getch :getch
     def getch
@@ -70,7 +70,7 @@ class RPStringScanner < StringScanner
     alias :old_scan :scan
     def scan re
       s = old_scan re
-      p :scan => [s, caller.first] if s
+      d :scan => [s, caller.first] if s
       s
     end
   end
@@ -114,21 +114,12 @@ class RPStringScanner < StringScanner
   # end
 end
 
-class RubyParser < Racc::Parser
-  VERSION = '2.0.5' unless constants.include? "VERSION" # SIGH
+module RubyParserStuff
+  VERSION = '3.0.0.a1' unless constants.include? "VERSION" # SIGH
 
   attr_accessor :lexer, :in_def, :in_single, :file
   attr_reader :env, :comments
 
-  def append_to_block head, tail # FIX: wtf is this?!? switch to block_append
-    return head if tail.nil?
-    return tail if head.nil?
-
-    head = s(:block, head) unless head.node_type == :block
-    head << tail
-    head
-  end
-
   def arg_add(node1, node2) # TODO: nuke
     return s(:arglist, node2) unless node1
 
@@ -150,7 +141,32 @@ class RubyParser < Racc::Parser
     node1
   end
 
-  def args arg, optarg, rest_arg, block_arg
+  def block_var ary, splat, block
+    ary ||= s(:array)
+
+    if splat then
+      if splat == s(:splat) then
+        ary << splat
+      else
+        ary << s(:splat, splat)
+      end
+    end
+
+    if block then
+      block[-1] = :"&#{block[-1]}"
+      ary << block
+    end
+
+    result = if ary.length > 2 or ary.splat then
+               s(:masgn, ary)
+             else
+               ary.last
+             end
+
+    result
+  end
+
+  def args arg, optarg, rest_arg, block_arg, post_arg = nil
     arg ||= s(:args)
 
     result = arg
@@ -162,15 +178,53 @@ class RubyParser < Racc::Parser
     end
 
     result << rest_arg  if rest_arg
+
     result << :"&#{block_arg.last}" if block_arg
     result << optarg    if optarg # TODO? huh - processed above as well
+    post_arg[1..-1].each {|pa| result << pa } if post_arg
+
+    result
+  end
+
+  def args19 vals # TODO: migrate to args once 1.8 tests pass as well
+    result = s(:args)
+    block  = nil
+
+    vals.each do |val|
+      case val
+      when Sexp then
+        case val.first
+        when :args then
+          val[1..-1].each do |name|
+            result << name
+          end
+        when :block_arg then
+          result << :"&#{val.last}"
+        when :block then
+         block = val
+          val[1..-1].each do |lasgn| # FIX clean sexp iter
+            raise "wtf? #{val.inspect}" unless lasgn[0] == :lasgn
+            result << lasgn[1]
+          end
+        else
+          raise "unhandled sexp: #{val.inspect}"
+        end
+      when Symbol then
+        result << val
+      when ",", nil then
+        # ignore
+      else
+        raise "unhandled val: #{val.inspect} in #{vals.inspect}"
+      end
+    end
+
+    result << block if block
 
     result
   end
 
   def aryset receiver, index
-    index[0] = :arglist if index[0] == :array
-    s(:attrasgn, receiver, :"[]=", index)
+    s(:attrasgn, receiver, :"[]=", *index[1..-1])
   end
 
   def assignable(lhs, value = nil)
@@ -217,9 +271,9 @@ class RubyParser < Racc::Parser
     return result
   end
 
-  def block_append(head, tail, strip_tail_block=false)
-    return head unless tail
-    return tail unless head
+  def block_append(head, tail)
+    return head if tail.nil?
+    return tail if head.nil?
 
     case head[0]
     when :lit, :str then
@@ -229,16 +283,10 @@ class RubyParser < Racc::Parser
     line = [head.line, tail.line].compact.min
 
     head = remove_begin(head)
-    head = s(:block, head) unless head[0] == :block
-
-    if strip_tail_block and Sexp === tail and tail[0] == :block then
-      head.push(*tail.values)
-    else
-      head << tail
-    end
+    head = s(:block, head) unless head.node_type == :block
 
     head.line = line
-    head
+    head << tail
   end
 
   def cond node
@@ -295,20 +343,11 @@ class RubyParser < Racc::Parser
       end
     end
 
-    return s(:call, lhs, :"=~", s(:arglist, rhs)).line(lhs.line)
+    return new_call(lhs, :"=~", argl(rhs)).line(lhs.line)
   end
 
   def gettable(id)
-    raise "no: #{id.inspect}" if Sexp === id
-    id = id.to_sym if Sexp   === id # HACK
-    id = id.to_sym if String === id # HACK
-
-    return s(:self)                  if id == :self
-    return s(:nil)                   if id == :nil
-    return s(:true)                  if id == :true
-    return s(:false)                 if id == :false
-    return s(:str, self.file)        if id == :"__FILE__"
-    return s(:lit, lexer.src.current_line) if id == :"__LINE__"
+    id = id.to_sym if String === id
 
     result = case id.to_s
              when /^@@/ then
@@ -323,25 +362,38 @@ class RubyParser < Racc::Parser
                type = env[id]
                if type then
                  s(type, id)
-               elsif env.dynamic? and :dvar == env[id] then
-                 s(:lvar, id)
                else
-                 s(:call, nil, id, s(:arglist))
+                 new_call(nil, id)
                end
              end
 
-    return result if result
+    raise "identifier #{id.inspect} is not valid" unless result
 
-    raise "identifier #{id.inspect} is not valid"
+    result
   end
 
-  def initialize
-    super
-    self.lexer = RubyLexer.new
+  ##
+  # Canonicalize conditionals. Eg:
+  #
+  #   not x ? a : b
+  #
+  # becomes:
+  #
+  #   x ? b : a
+
+  attr_accessor :canonicalize_conditions
+
+  def initialize(options = {})
+    super()
+
+    v = self.class.name[/1[89]/]
+    self.lexer = RubyLexer.new v && v.to_i
     self.lexer.parser = self
     @env = Environment.new
     @comments = []
 
+    @canonicalize_conditions = true
+
     self.reset
   end
 
@@ -456,14 +508,37 @@ class RubyParser < Racc::Parser
     return result
   end
 
+  def argl x
+    x = s(:arglist, x) if x and x[0] != :arglist
+    x
+  end
+
+  def backref_assign_error ref
+    # TODO: need a test for this... obviously
+    case ref.first
+    when :nth_ref then
+      raise SyntaxError, "Can't set variable %p" % ref.last
+    when :back_ref then
+      raise SyntaxError, "Can't set back reference %p" % ref.last
+    else
+      raise "Unknown backref type: #{ref.inspect}"
+    end
+  end
+
   def new_call recv, meth, args = nil
     result = s(:call, recv, meth)
     result.line = recv.line if recv
 
+    # TODO: need a test with f(&b) to produce block_pass
+    # TODO: need a test with f(&b) { } to produce warning
+
     args ||= s(:arglist)
     args[0] = :arglist if args.first == :array
     args = s(:arglist, args) unless args.first == :arglist
-    result << args
+
+    # HACK quick hack to make this work quickly... easy to clean up above
+    result.concat args[1..-1]
+
     result
   end
 
@@ -476,6 +551,11 @@ class RubyParser < Racc::Parser
       body = body.delete_at 3
     end
 
+    result[2..-1].each do |node|
+      block = node.block(:delete)
+      node.concat block[1..-1] if block
+    end
+
     # else
     body = nil if body == s(:block)
     result << body
@@ -486,8 +566,17 @@ class RubyParser < Racc::Parser
 
   def new_class val
     line, path, superclass, body = val[1], val[2], val[3], val[5]
-    scope = s(:scope, body).compact
-    result = s(:class, path, superclass, scope)
+
+    result = s(:class, path, superclass)
+
+    if body then
+      if body.first == :block then
+        result.push(*body[1..-1])
+      else
+        result.push body
+      end
+    end
+
     result.line = line
     result.comments = self.comments.pop
     result
@@ -500,15 +589,20 @@ class RubyParser < Racc::Parser
   end
 
   def new_defn val
-    (line, bol), name, args, body = val[2], val[1], val[3], val[4]
+    (_, line), name, args, body = val[0], val[1], val[3], val[4]
     body ||= s(:nil)
 
-    body ||= s(:block)
-    body = s(:block, body) unless body.first == :block
+    result = s(:defn, name.to_sym, args)
+
+    if body then
+      if body.first == :block then
+        result.push(*body[1..-1])
+      else
+        result.push body
+      end
+    end
 
-    result = s(:defn, name.to_sym, args, s(:scope, body))
     result.line = line
-    result.line -= 1 if bol
     result.comments = self.comments.pop
     result
   end
@@ -516,10 +610,16 @@ class RubyParser < Racc::Parser
   def new_defs val
     recv, name, args, body = val[1], val[4], val[6], val[7]
 
-    body ||= s(:block)
-    body = s(:block, body) unless body.first == :block
+    result = s(:defs, recv, name.to_sym, args)
+
+    if body then
+      if body.first == :block then
+        result.push(*body[1..-1])
+      else
+        result.push body
+      end
+    end
 
-    result = s(:defs, recv, name.to_sym, args, s(:scope, body))
     result.line = recv.line
     result.comments = self.comments.pop
     result
@@ -534,7 +634,7 @@ class RubyParser < Racc::Parser
   def new_if c, t, f
     l = [c.line, t && t.line, f && f.line].compact.min
     c = cond c
-    c, t, f = c.last, f, t if c[0] == :not
+    c, t, f = c.last, f, t if c[0] == :not and canonicalize_conditions
     s(:if, c, t, f).line(l)
   end
 
@@ -559,7 +659,7 @@ class RubyParser < Racc::Parser
   def new_module val
     line, path, body = val[1], val[2], val[4]
     body = s(:scope, body).compact
-    result = s(:module, path, body)
+    result = s(:module, path, *body[1..-1])
     result.line = line
     result.comments = self.comments.pop
     result
@@ -578,8 +678,7 @@ class RubyParser < Racc::Parser
                s(:op_asgn_and, self.gettable(name), lhs)
              else
                # TODO: why [2] ?
-               lhs[2] = new_call(self.gettable(name), asgn_op,
-                                 s(:arglist, arg))
+               lhs[2] = new_call(self.gettable(name), asgn_op, argl(arg))
                lhs
              end
     result.line = lhs.line
@@ -631,10 +730,28 @@ class RubyParser < Racc::Parser
     node
   end
 
+  def new_resbody cond, body
+    if body && body.first == :block then
+      body.shift # remove block and splat it in directly
+    else
+      body = [body]
+    end
+    s(:resbody, cond, *body)
+  end
+
   def new_sclass val
     recv, in_def, in_single, body = val[3], val[4], val[6], val[7]
-    scope = s(:scope, body).compact
-    result = s(:sclass, recv, scope)
+
+    result = s(:sclass, recv)
+
+    if body then
+      if body.first == :block then
+        result.push(*body[1..-1])
+      else
+        result.push body
+      end
+    end
+
     result.line = val[2]
     self.in_def = in_def
     self.in_single = in_single
@@ -659,25 +776,34 @@ class RubyParser < Racc::Parser
   end
 
   def new_until block, expr, pre
-    expr = (expr.first == :not ? expr.last : s(:not, expr)).line(expr.line)
-    new_while block, expr, pre
+    new_until_or_while :until, block, expr, pre
   end
 
-  def new_while block, expr, pre
+  def new_until_or_while type, block, expr, pre
+    other = type == :until ? :while : :until
     line = [block && block.line, expr.line].compact.min
     block, pre = block.last, false if block && block[0] == :begin
 
     expr = cond expr
-    result = if expr.first == :not then
-               s(:until, expr.last, block, pre)
+
+    result = unless expr.first == :not and canonicalize_conditions then
+               s(type,  expr,      block, pre)
              else
-               s(:while, expr, block, pre)
+               s(other, expr.last, block, pre)
              end
 
     result.line = line
     result
   end
 
+  def new_when cond, body
+    s(:when, cond, body)
+  end
+
+  def new_while block, expr, pre
+    new_until_or_while :while, block, expr, pre
+  end
+
   def new_xstring str
     if str then
       case str[0]
@@ -722,12 +848,11 @@ class RubyParser < Racc::Parser
     rhs = value_expr rhs
 
     case lhs[0]
-    when :gasgn, :iasgn, :lasgn, :dasgn, :dasgn_curr,
-      :masgn, :cdecl, :cvdecl, :cvasgn then
+    when :gasgn, :iasgn, :lasgn, :masgn, :cdecl, :cvdecl, :cvasgn then
       lhs << rhs
     when :attrasgn, :call then
       args = lhs.pop unless Symbol === lhs.last
-      lhs << arg_add(args, rhs)
+      lhs.concat arg_add(args, rhs)[1..-1]
     when :const then
       lhs[0] = :cdecl
       lhs << rhs
@@ -742,7 +867,7 @@ class RubyParser < Racc::Parser
     raise "bad val: #{str.inspect}" unless String === str
 
     self.file = file
-    self.lexer.src = str
+    self.lexer.src = str.dup
 
     @yydebug = ENV.has_key? 'DEBUG'
 
@@ -808,192 +933,207 @@ class RubyParser < Racc::Parser
     # do nothing for now
   end
 
-  alias :old_yyerror :yyerror
   def yyerror msg
     # for now do nothing with the msg
-    old_yyerror
+    super
   end
-end
 
-class Keyword
-  class KWtable
-    attr_accessor :name, :state, :id0, :id1
-    def initialize(name, id=[], state=nil)
-      @name  = name
-      @id0, @id1 = id
-      @state = state
+  class Keyword
+    class KWtable
+      attr_accessor :name, :state, :id0, :id1
+      def initialize(name, id=[], state=nil)
+        @name  = name
+        @id0, @id1 = id
+        @state = state
+      end
     end
-  end
 
-  ##
-  # :stopdoc:
-  #
-  # :expr_beg    = ignore newline, +/- is a sign.
-  # :expr_end    = newline significant, +/- is a operator.
-  # :expr_arg    = newline significant, +/- is a operator.
-  # :expr_cmdarg = newline significant, +/- is a operator.
-  # :expr_endarg = newline significant, +/- is a operator.
-  # :expr_mid    = newline significant, +/- is a operator.
-  # :expr_fname  = ignore newline, no reserved words.
-  # :expr_dot    = right after . or ::, no reserved words.
-  # :expr_class  = immediate after class, no here document.
-
-  wordlist = [
-              ["end",      [:kEND,      :kEND        ], :expr_end   ],
-              ["else",     [:kELSE,     :kELSE       ], :expr_beg   ],
-              ["case",     [:kCASE,     :kCASE       ], :expr_beg   ],
-              ["ensure",   [:kENSURE,   :kENSURE     ], :expr_beg   ],
-              ["module",   [:kMODULE,   :kMODULE     ], :expr_beg   ],
-              ["elsif",    [:kELSIF,    :kELSIF      ], :expr_beg   ],
-              ["def",      [:kDEF,      :kDEF        ], :expr_fname ],
-              ["rescue",   [:kRESCUE,   :kRESCUE_MOD ], :expr_mid   ],
-              ["not",      [:kNOT,      :kNOT        ], :expr_beg   ],
-              ["then",     [:kTHEN,     :kTHEN       ], :expr_beg   ],
-              ["yield",    [:kYIELD,    :kYIELD      ], :expr_arg   ],
-              ["for",      [:kFOR,      :kFOR        ], :expr_beg   ],
-              ["self",     [:kSELF,     :kSELF       ], :expr_end   ],
-              ["false",    [:kFALSE,    :kFALSE      ], :expr_end   ],
-              ["retry",    [:kRETRY,    :kRETRY      ], :expr_end   ],
-              ["return",   [:kRETURN,   :kRETURN     ], :expr_mid   ],
-              ["true",     [:kTRUE,     :kTRUE       ], :expr_end   ],
-              ["if",       [:kIF,       :kIF_MOD     ], :expr_beg   ],
-              ["defined?", [:kDEFINED,  :kDEFINED    ], :expr_arg   ],
-              ["super",    [:kSUPER,    :kSUPER      ], :expr_arg   ],
-              ["undef",    [:kUNDEF,    :kUNDEF      ], :expr_fname ],
-              ["break",    [:kBREAK,    :kBREAK      ], :expr_mid   ],
-              ["in",       [:kIN,       :kIN         ], :expr_beg   ],
-              ["do",       [:kDO,       :kDO         ], :expr_beg   ],
-              ["nil",      [:kNIL,      :kNIL        ], :expr_end   ],
-              ["until",    [:kUNTIL,    :kUNTIL_MOD  ], :expr_beg   ],
-              ["unless",   [:kUNLESS,   :kUNLESS_MOD ], :expr_beg   ],
-              ["or",       [:kOR,       :kOR         ], :expr_beg   ],
-              ["next",     [:kNEXT,     :kNEXT       ], :expr_mid   ],
-              ["when",     [:kWHEN,     :kWHEN       ], :expr_beg   ],
-              ["redo",     [:kREDO,     :kREDO       ], :expr_end   ],
-              ["and",      [:kAND,      :kAND        ], :expr_beg   ],
-              ["begin",    [:kBEGIN,    :kBEGIN      ], :expr_beg   ],
-              ["__LINE__", [:k__LINE__, :k__LINE__   ], :expr_end   ],
-              ["class",    [:kCLASS,    :kCLASS      ], :expr_class ],
-              ["__FILE__", [:k__FILE__, :k__FILE__   ], :expr_end   ],
-              ["END",      [:klEND,     :klEND       ], :expr_end   ],
-              ["BEGIN",    [:klBEGIN,   :klBEGIN     ], :expr_end   ],
-              ["while",    [:kWHILE,    :kWHILE_MOD  ], :expr_beg   ],
-              ["alias",    [:kALIAS,    :kALIAS      ], :expr_fname ],
-             ].map { |args| KWtable.new(*args) }
-
-  # :startdoc:
-
-  WORDLIST = Hash[*wordlist.map { |o| [o.name, o] }.flatten] unless
-    defined? WORDLIST
-
-  def self.keyword str
-    WORDLIST[str]
+    ##
+    # :stopdoc:
+    #
+    # :expr_beg    = ignore newline, +/- is a sign.
+    # :expr_end    = newline significant, +/- is a operator.
+    # :expr_arg    = newline significant, +/- is a operator.
+    # :expr_cmdarg = newline significant, +/- is a operator.
+    # :expr_endarg = newline significant, +/- is a operator.
+    # :expr_mid    = newline significant, +/- is a operator.
+    # :expr_fname  = ignore newline, no reserved words.
+    # :expr_dot    = right after . or ::, no reserved words.
+    # :expr_class  = immediate after class, no here document.
+
+    wordlist = [
+                ["end",      [:kEND,      :kEND        ], :expr_end   ],
+                ["else",     [:kELSE,     :kELSE       ], :expr_beg   ],
+                ["case",     [:kCASE,     :kCASE       ], :expr_beg   ],
+                ["ensure",   [:kENSURE,   :kENSURE     ], :expr_beg   ],
+                ["module",   [:kMODULE,   :kMODULE     ], :expr_beg   ],
+                ["elsif",    [:kELSIF,    :kELSIF      ], :expr_beg   ],
+                ["def",      [:kDEF,      :kDEF        ], :expr_fname ],
+                ["rescue",   [:kRESCUE,   :kRESCUE_MOD ], :expr_mid   ],
+                ["not",      [:kNOT,      :kNOT        ], :expr_beg   ],
+                ["then",     [:kTHEN,     :kTHEN       ], :expr_beg   ],
+                ["yield",    [:kYIELD,    :kYIELD      ], :expr_arg   ],
+                ["for",      [:kFOR,      :kFOR        ], :expr_beg   ],
+                ["self",     [:kSELF,     :kSELF       ], :expr_end   ],
+                ["false",    [:kFALSE,    :kFALSE      ], :expr_end   ],
+                ["retry",    [:kRETRY,    :kRETRY      ], :expr_end   ],
+                ["return",   [:kRETURN,   :kRETURN     ], :expr_mid   ],
+                ["true",     [:kTRUE,     :kTRUE       ], :expr_end   ],
+                ["if",       [:kIF,       :kIF_MOD     ], :expr_beg   ],
+                ["defined?", [:kDEFINED,  :kDEFINED    ], :expr_arg   ],
+                ["super",    [:kSUPER,    :kSUPER      ], :expr_arg   ],
+                ["undef",    [:kUNDEF,    :kUNDEF      ], :expr_fname ],
+                ["break",    [:kBREAK,    :kBREAK      ], :expr_mid   ],
+                ["in",       [:kIN,       :kIN         ], :expr_beg   ],
+                ["do",       [:kDO,       :kDO         ], :expr_beg   ],
+                ["nil",      [:kNIL,      :kNIL        ], :expr_end   ],
+                ["until",    [:kUNTIL,    :kUNTIL_MOD  ], :expr_beg   ],
+                ["unless",   [:kUNLESS,   :kUNLESS_MOD ], :expr_beg   ],
+                ["or",       [:kOR,       :kOR         ], :expr_beg   ],
+                ["next",     [:kNEXT,     :kNEXT       ], :expr_mid   ],
+                ["when",     [:kWHEN,     :kWHEN       ], :expr_beg   ],
+                ["redo",     [:kREDO,     :kREDO       ], :expr_end   ],
+                ["and",      [:kAND,      :kAND        ], :expr_beg   ],
+                ["begin",    [:kBEGIN,    :kBEGIN      ], :expr_beg   ],
+                ["__LINE__", [:k__LINE__, :k__LINE__   ], :expr_end   ],
+                ["class",    [:kCLASS,    :kCLASS      ], :expr_class ],
+                ["__FILE__", [:k__FILE__, :k__FILE__   ], :expr_end   ],
+                ["END",      [:klEND,     :klEND       ], :expr_end   ],
+                ["BEGIN",    [:klBEGIN,   :klBEGIN     ], :expr_end   ],
+                ["while",    [:kWHILE,    :kWHILE_MOD  ], :expr_beg   ],
+                ["alias",    [:kALIAS,    :kALIAS      ], :expr_fname ],
+               ].map { |args| KWtable.new(*args) }
+
+    # :startdoc:
+
+    WORDLIST = Hash[*wordlist.map { |o| [o.name, o] }.flatten] unless
+      defined? WORDLIST
+
+    def self.keyword str
+      WORDLIST[str]
+    end
   end
-end
 
-class Environment
-  attr_reader :env, :dyn
+  class Environment
+    attr_reader :env, :dyn
 
-  def [] k
-    self.all[k]
-  end
+    def [] k
+      self.all[k]
+    end
 
-  def []= k, v
-    raise "no" if v == true
-    self.current[k] = v
-  end
+    def []= k, v
+      raise "no" if v == true
+      self.current[k] = v
+    end
 
-  def all
-    idx = @dyn.index(false) || 0
-    @env[0..idx].reverse.inject { |env, scope| env.merge scope }
-  end
+    def all
+      idx = @dyn.index(false) || 0
+      @env[0..idx].reverse.inject { |env, scope| env.merge scope }
+    end
 
-  def current
-    @env.first
-  end
+    def current
+      @env.first
+    end
 
-  def dynamic
-    idx = @dyn.index false
-    @env[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
-  end
+    def dynamic
+      idx = @dyn.index false
+      @env[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
+    end
 
-  def dynamic?
-    @dyn[0] != false
-  end
+    def dynamic?
+      @dyn[0] != false
+    end
 
-  def extend dyn = false
-    @dyn.unshift dyn
-    @env.unshift({})
-    @use.unshift({})
-  end
+    def extend dyn = false
+      @dyn.unshift dyn
+      @env.unshift({})
+      @use.unshift({})
+    end
 
-  def initialize dyn = false
-    @dyn = []
-    @env = []
-    @use = []
-    self.reset
-  end
+    def initialize dyn = false
+      @dyn = []
+      @env = []
+      @use = []
+      self.reset
+    end
 
-  def reset
-    @dyn.clear
-    @env.clear
-    @use.clear
-    self.extend
-  end
+    def reset
+      @dyn.clear
+      @env.clear
+      @use.clear
+      self.extend
+    end
 
-  def unextend
-    @dyn.shift
-    @env.shift
-    @use.shift
-    raise "You went too far unextending env" if @env.empty?
-  end
+    def unextend
+      @dyn.shift
+      @env.shift
+      @use.shift
+      raise "You went too far unextending env" if @env.empty?
+    end
 
-  def use id
-    @env.each_with_index do |env, i|
-      if env[id] then
-        @use[i][id] = true
+    def use id
+      @env.each_with_index do |env, i|
+        if env[id] then
+          @use[i][id] = true
+        end
       end
     end
-  end
 
-  def used? id
-    idx = @dyn.index false # REFACTOR
-    u = @use[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
-    u[id]
+    def used? id
+      idx = @dyn.index false # REFACTOR
+      u = @use[0...idx].reverse.inject { |env, scope| env.merge scope } || {}
+      u[id]
+    end
   end
-end
 
-class StackState
-  attr_reader :stack
+  class StackState
+    attr_reader :stack
 
-  def initialize(name)
-    @name = name
-    @stack = [false]
-  end
+    def initialize(name)
+      @name = name
+      @stack = [false]
+    end
 
-  def inspect
-    "StackState(#{@name}, #{@stack.inspect})"
-  end
+    def inspect
+      "StackState(#{@name}, #{@stack.inspect})"
+    end
 
-  def is_in_state
-    @stack.last
-  end
+    def is_in_state
+      @stack.last
+    end
 
-  def lexpop
-    raise if @stack.size == 0
-    a = @stack.pop
-    b = @stack.pop
-    @stack.push(a || b)
-  end
+    def lexpop
+      raise if @stack.size == 0
+      a = @stack.pop
+      b = @stack.pop
+      @stack.push(a || b)
+    end
+
+    def pop
+      r = @stack.pop
+      @stack.push false if @stack.size == 0
+      r
+    end
 
-  def pop
-    r = @stack.pop
-    @stack.push false if @stack.size == 0
-    r
+    def push val
+      @stack.push val
+    end
   end
+end
 
-  def push val
-    @stack.push val
+class Ruby19Parser < Racc::Parser
+  include RubyParserStuff
+end
+
+class Ruby18Parser < Racc::Parser
+  include RubyParserStuff
+end
+
+class RubyParser < Ruby18Parser
+  def initialize
+    super
+    warn "WA\RNING: Deprecated: RubyParser. Use Ruby18Parser or Ruby19Parser"
+    warn "  from #{caller.first}"
   end
 end
 
@@ -1022,6 +1162,14 @@ class Sexp
     self.value.to_sym
   end
 
+  def add x
+    raise "no" # TODO: need a test to trigger this
+  end
+
+  def add_all x
+    raise "no" # TODO: need a test to trigger this
+  end
+
   alias :node_type :sexp_type
   alias :values :sexp_body # TODO: retire
 end