nodewrap 0.5.0

data/lib/as_code.rb

@@ -0,0 +1,347 @@
+require 'nodewrap'
+require 'rbconfig'
+require 'as_expression'
+
+if defined?(VM::InstructionSequence) then
+  require 'bytedecoder'
+
+  class VM
+    class InstructionSequence
+      def as_code(indent=0)
+        env = Nodewrap::ByteDecoder::Environment.new(local_table())
+        opt_pc = self.opt_pc
+        self.bytedecode(env, opt_pc)
+        expressions = env.expressions + env.stack
+        if expressions.length == 0 then
+          return nil
+        elsif expressions.length == 1 and
+           expressions[0].is_a?(Nodewrap::ByteDecoder::Expression::Literal) and
+           expressions[0].value == nil then
+          return nil
+        else
+          expressions.map! { |e| "#{'  '*indent}#{e}" }
+          return expressions.join("\n")
+        end
+      end
+    end
+  end
+end
+
+class Node
+  public
+
+  def as_code(indent=0, *args)
+    return as_code_impl(self, indent, *args)
+  end
+
+  private
+
+  def as_code_impl(node, indent, *args)
+    # default -- most code is just an expression
+    expression = node.as_expression(*args)
+    if not expression.nil? then
+      return "#{'  '*indent}#{expression}"
+    else
+      return nil
+    end
+  end
+
+  class << self
+    def define_code(klass, &block)
+      if const_defined?(klass) then
+        const_get(klass).instance_eval { define_method(:as_code_impl, &block) }
+      end
+    end
+  end
+
+  define_code(:IF) do |node, indent|
+    if node.body.class == Node::BLOCK or
+       node.else.class == Node::BLOCK then
+      s = "#{'  '*indent}if #{node.cond.as_expression} then\n"
+      s << "#{'  '*indent}#{node.body.as_code(indent+1)}\n"
+      if node.else then
+        s << "#{'  '*indent}else\n"
+        s << "#{'  '*indent}#{node.else.as_code(indent+1)}\n"
+      end
+      s << "#{'  '*indent}end"
+      s
+    else
+      "#{'  '*indent}#{node.as_expression}"
+    end
+  end
+
+  define_code(:BLOCK) do |node, indent|
+    a = node.to_a
+    if a[0].class == Node::DASGN_CURR and not a[0].value
+      # ignore variable definitions
+      a.shift
+    end
+    lines = a.map { |n| n.as_code(indent) }
+    lines.reject! { |e| e.nil? }
+    if lines.size == 0 then
+      "#{'  '*indent}nil"
+    else
+      lines.join("\n")
+    end
+  end
+
+  define_code(:ITER) do |node, indent|
+    "#{'  '*indent}#{node.iter.as_expression} {\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}}"
+  end
+
+  define_code(:WHILE) do |node, indent|
+    if node.state == 1 then
+      "#{'  '*indent}while #{node.cond.as_expression} do\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end while #{node.cond.as_expression}"
+    end
+  end
+
+  define_code(:UNTIL) do |node, indent|
+    if node.state == 1 then
+      "#{'  '*indent}until #{node.cond.as_expression} do\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end until #{node.cond.as_expression}"
+    end
+  end
+
+  define_code(:BEGIN) do |node, indent|
+    if node.body.class == Node::RESCUE or
+       node.body.class == Node::ENSURE then
+      s = "#{'  '*indent}begin\n" +
+      "#{node.body.as_code(indent+1, true)}\n" +
+      "#{'  '*indent}end"
+    elsif node.body then
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+      "#{'  '*indent}end"
+    else
+      "#{'  '*indent}begin\n" +
+      "#{'  '*indent}end\n"
+    end
+  end
+
+  def self.begin_end(indent, have_begin)
+    s = ''
+    if not have_begin then
+      s << "#{'  '*indent}begin\n"
+      indent += 1
+    end
+    yield s, indent, true
+    if not have_begin then
+      indent -= 1
+      s << "\n#{'  '*indent}end"
+    end
+    return s
+  end
+
+  define_code(:ENSURE) do |node, indent, *args|
+    begin_ensure = args[0] || false
+    s = ''
+    Node.begin_end(indent, begin_ensure) do |s, indent, begin_ensure|
+      if node.head then
+        s << "#{node.head.as_code(indent)}\n"
+      end
+      s << "#{'  '*(indent-1)}ensure\n"
+      s << "#{node.ensr.as_code(indent)}"
+    end
+  end
+
+  define_code(:RESCUE) do |node, indent, *args|
+    begin_rescue = args[0] || false
+    Node.begin_end(indent, begin_rescue) do |s, indent, begin_rescue|
+      if node.head then
+        if begin_rescue then
+          s << "#{node.head.as_code(indent)}\n"
+          s << "#{'  '*(indent-1)}rescue #{node.resq.as_code(indent+1, begin_rescue)}"
+        else
+          s << "#{node.head.as_expression} rescue #{node.resq.as_expression(begin_rescue)}"
+        end
+      else
+        s << "rescue #{node.resq.as_expression(begin_rescue)}"
+      end
+    end
+  end
+
+  define_code(:RESBODY) do |node, indent, *args|
+    begin_rescue = args[0] || false
+    if begin_rescue then
+      if node.ensr then
+        a = node.ensr.to_a.map { |n| n.as_expression }
+        "#{a.join(', ')}\n" +
+        "#{'  '*indent}#{node.resq.as_code(indent+1)}"
+      else
+        node.resq ? "\n#{'  '*indent}#{node.resq.as_code(indent+1)}" : ''
+      end
+    else
+      # TODO: assuming node.ensr is false...
+      node.resq ? node.resq.as_code : ''
+    end
+  end
+
+  define_code(:NEWLINE) do |node, indent|
+    node.next.as_code(indent)
+  end
+
+  define_code(:CASE) do |node, indent|
+    "#{'  '*indent}case #{node.head.as_expression}\n" +
+    "#{node.body.as_code(indent)}end"
+  end
+
+  define_code(:WHEN) do |node, indent|
+    args = node.head.to_a.map { |n| n.as_expression }
+    s = "#{'  '*indent}when #{args.join(', ')}\n"
+    if node.body then
+      s << "#{'  '*indent}#{node.body.as_code(indent+1)}; "
+    end
+    if node.next then
+      s << node.next.as_code
+    end
+    s
+  end
+
+  define_code(:CLASS) do |node, indent|
+    s_super = node.super ? " < #{node.super.as_expression}" : ''
+    if node.respond_to?(:cpath) then
+      path = node.cpath.as_expression
+    else
+      path = node.cname
+    end
+    "#{'  '*indent}class #{path}#{s_super}\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:SCLASS) do |node, indent|
+    "#{'  '*indent}class << #{node.recv.as_expression}\n" +
+    "#{'  '*indent}#{node.body.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:DEFN) do |node, indent|
+    # TODO: what to do about noex?
+    "#{'  '*indent}def #{node.mid}\n" +
+    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:DEFS) do |node, indent|
+    "#{'  '*indent}def #{node.recv.as_expression}.#{node.mid}\n" +
+    "#{'  '*indent}#{node.next.as_code(indent+1)}\n" +
+    "#{'  '*indent}end"
+  end
+
+  define_code(:SCOPE) do |node, indent|
+    case node.next
+    when nil then ''
+    when Node::ARGS then "#{'  '*indent}nil"
+    when Node::BLOCK_ARG then "#{'  '*indent}nil"
+    else node.next.as_code(indent)
+    end
+  end
+end
+
+module MethodAsCode
+  def as_code(indent=0, name=nil)
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_code(indent+1)
+    else
+      # pre-YARV
+      body_expression = self.body ? self.body.as_code(indent+1) : ''
+    end
+    name ||= sig.name
+    s = "#{'  '*indent}def #{name}(#{sig.param_list})\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+
+class Method
+  include MethodAsCode
+end
+
+class UnboundMethod
+  include MethodAsCode
+end
+
+class Proc
+  def as_code(indent=0)
+    sig = self.signature
+    body_expression = self.body ? self.body.as_code(indent+1) : nil
+    s = "#{'  '*indent}proc do"
+    if not sig.args.unspecified then
+      s += " #{sig}"
+    end
+    s += "\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+
+class Module
+  # TODO: it would be nice if we could go back and find the AST
+  # for the class instead of recreating the code from the class's
+  # current state.
+  def as_code(indent=0)
+    imethods = self.instance_methods - self.superclass.instance_methods
+    cmethods = self.instance_methods - self.superclass.instance_methods
+    constants = self.constants - self.superclass.constants
+    name = self.name.gsub(/.*::/, '')
+
+    # TODO: included modules?
+    if self.class == Class then
+      s = "#{'  '*indent}class #{name} < #{self.superclass}\n"
+    else
+      s = "#{'  '*indent}module #{name}\n"
+    end
+
+    constants.each do |constant|
+      s += "#{'  '*indent} #{constant}=#{self.const_get(constant).as_code}\n"
+    end
+
+    # TODO: protected/private
+    imethods.each do |method|
+      s += self.instance_method(method).as_code(indent+1)
+      s += "\n"
+    end
+
+    cmethods.each do |method|
+      s += self.instance_method(method).as_code(indent+1, "self.#{method}")
+      s += "\n"
+    end
+
+    # TODO: singleton class constants
+    # TODO: class variables
+    # TODO: singleton instance variables
+
+    s += "#{'  '*indent}end"
+
+    return s
+  end
+end
+
+class Object
+  def as_code(indent=0)
+    # TODO: this won't work for many objects
+    "#{'  '*indent}#{self.inspect}"
+  end
+end
+

data/lib/as_expression.rb

@@ -0,0 +1,657 @@
+require 'nodewrap'
+require 'methodsig'
+require 'procsig'
+require 'node_to_a'
+require 'rbconfig'
+
+if defined?(VM::InstructionSequence) then
+  require 'bytedecoder'
+
+  class VM
+    class InstructionSequence
+      def as_expression
+        env = Nodewrap::ByteDecoder::Environment.new(local_table())
+        opt_pc = self.opt_pc
+        self.bytedecode(env, opt_pc)
+        expressions = env.expressions + env.stack
+        if expressions.length == 0 then
+          return nil
+        elsif expressions.length == 1 and
+           expressions[0].is_a?(Nodewrap::ByteDecoder::Expression::Literal) and
+           expressions[0].value == nil then
+          return nil
+        else
+          return expressions.join('; ')
+        end
+      end
+    end
+  end
+end
+
+class Node
+  public
+
+  # Return an string describing this node as a single expression.  By
+  # default, this just returns the name of the node's type, but some
+  # node types override this method to produce more meaningful output.
+  def as_expression(*args)
+    return as_expression_impl(self, *args)
+  end
+
+  # Return a string as with as_expression, but surround it with parens
+  # if it is a composite expression, so that it can be used to form more
+  # complex expressions.
+  def as_paren_expression(*args)
+    expr = self.as_expression(*args)
+    if not OMIT_PARENS[self.class] then
+      expr = "(#{expr})"
+    end
+    return expr
+  end
+
+  private
+
+  # default
+  def as_expression_impl(node)
+    return "<#{node.nd_type.to_s}>"
+  end
+
+  class << self
+    def define_expression(klass, &block)
+      if const_defined?(klass) then
+        const_get(klass).instance_eval { define_method(:as_expression_impl, &block) }
+      end
+    end
+  end
+
+  define_expression(:LIT) do |node|
+    # TODO: #inspect might not give an eval-able expression
+    node.lit.inspect
+  end
+
+  define_expression(:FCALL) do |node|
+    # args with either be an ARRAY or ARGSCAT
+    args = node.args
+    "#{node.mid}(#{args ? args.as_expression(false) : ''})"
+  end
+
+  define_expression(:VCALL) do |node|
+    node.mid.to_s
+  end
+
+  arithmetic_expressions = [
+    :+, :-, :*, :/, :<, :>, :<=, :>=, :==, :===, :<=>, :<<, :>>, :&, :|,
+    :^, :%, '!'.intern, '!='.intern
+  ]
+
+  # TODO: there should be a way to detect if the expressions need to be
+  # in parens
+  define_expression(:CALL) do |node|
+    recv_expr = node.recv.as_paren_expression
+
+    case node.mid
+    when *arithmetic_expressions
+      args = node.args
+      "#{recv_expr} #{node.mid} #{args ? args.as_paren_expression(false) : ''}"
+    when :[]
+      args = node.args
+      "#{recv_expr}[#{args ? args.as_expression(false) : ''}]"
+    else
+      args = node.args
+      "#{recv_expr}.#{node.mid}(#{args ? args.as_expression(false) : ''})"
+    end
+  end
+
+  define_expression(:ZSUPER) do |node|
+    "super"
+  end
+
+  define_expression(:SUPER) do |node|
+    "super(#{node.args ? node.args.as_expression(false) : ''})"
+  end
+
+  define_expression(:REDO) do |node|
+    "redo"
+  end
+
+  define_expression(:RETRY) do |node|
+    "retry"
+  end
+
+  define_expression(:NOT) do |node|
+    "not #{node.body.as_expression}"
+  end
+
+  define_expression(:AND) do |node|
+    "#{node.first.as_expression} and #{node.second.as_expression}"
+  end
+
+  define_expression(:OR) do |node|
+    "#{node.first.as_expression} or #{node.second.as_expression}"
+  end
+
+  class ARRAY < Node
+    def as_expression_impl(node, brackets = true)
+      s = brackets ? '[' : ''
+      s << (node.to_a.map { |n| n.as_expression }.join(', '))
+      s << (brackets ? ']' : '')
+      s
+    end
+  end
+
+  class ARGSCAT < Node
+    def as_expression_impl(node, brackets = true)
+      s = brackets ? '[' : ''
+      s << node.head.as_expression(false)
+      s << ", "
+      s << "*#{node.body.as_expression}"
+      s << (brackets ? ']' : '')
+      s
+    end
+  end
+
+  class ZARRAY < Node
+    def as_expression_impl(node, brackets = true)
+      brackets ? '[]' : ''
+    end
+  end
+
+  class BLOCK < Node
+    def as_expression_impl(node)
+      a = node.to_a
+      if a.size == 1 then
+        return 'nil'
+      end
+      d = a[0]
+      while d.class == Node::DASGN_CURR do
+        d = d.value
+      end
+      a.shift if not d
+      expressions = a.map { |n| n.as_expression }
+      expressions.reject! { |e| e.nil? }
+      if expressions.nitems == 0 then
+        return 'nil'
+      else
+        return expressions.join('; ')
+      end
+    end
+  end
+
+  define_expression(:HASH) do |node|
+    if not node.head then
+      "{}"
+    else
+      a = node.head.to_a
+      elems = []
+      i = 0
+      while i < a.size do
+        elems << "(#{a[i].as_expression})=>(#{a[i+1].as_expression})"
+        i += 2
+      end
+      "{#{elems.join(', ')}}"
+    end
+  end
+
+  define_expression(:IF) do |node|
+    if Node.const_defined?(:NEWLINE) then
+      bodynode = node.body.class == Node::NEWLINE ? node.body.next : node.body
+      elsenode = node.else.class == Node::NEWLINE ? node.else.next : node.else
+    else
+      bodynode = node.body
+      elsenode = node.else
+    end
+    if elsenode then
+      "#{node.cond.as_paren_expression} ? " +
+      "#{bodynode.as_paren_expression} : " +
+      "#{elsenode.as_paren_expression}"
+    else
+      "#{bodynode.as_paren_expression} if " +
+      "#{node.cond.as_paren_expression}"
+    end
+  end
+
+  define_expression(:TRUENODE) do |node|
+    "true"
+  end
+
+  define_expression(:FALSENODE) do |node|
+    "false"
+  end
+
+  define_expression(:NILNODE) do |node|
+    "nil"
+  end
+
+  define_expression(:SELF) do |node|
+    "self"
+  end
+
+  define_expression(:DOT2) do |node|
+    "#{node.beg.as_paren_expression}..#{node.end.as_paren_expression}"
+  end
+
+  define_expression(:DOT3) do |node|
+    "#{node.beg.as_paren_expression}...#{node.end.as_paren_expression}"
+  end
+
+  define_expression(:GVAR) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:IVAR) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:CVAR) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:DVAR) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:NTH_REF) do |node|
+    "$#{node.nth}"
+  end
+
+  define_expression(:BACK_REF) do |node|
+    "$`"
+  end
+
+  define_expression(:DASGN_CURR) do |node|
+    node.value ? "#{node.vid} = #{node.value.as_expression}" : ''
+  end
+
+  define_expression(:DASGN) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:IASGN) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:LASGN) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:MASGN) do |node|
+    lhs = node.head.to_a.map { |n| n.as_expression }
+    rhs = node.value.to_a.map { |n| n.as_expression }
+    "#{lhs.join(', ')} = #{rhs.join(', ')}"
+  end
+
+  define_expression(:CDECL) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:CVDECL) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:CVASGN) do |node|
+    "#{node.vid} = #{node.value.as_expression}"
+  end
+
+  define_expression(:ATTRASGN) do |node|
+    case node.mid
+    when :[]=
+      args = node.args.to_a
+      attrs = args[1..-2].map { |n| n.as_expression }
+      value = args[-1].as_expression
+      "#{node.recv.as_paren_expression}[#{attrs.join(', ')}] = #{value}"
+    else
+      "#{node.recv.as_paren_expression}.#{node.mid}#{node.args.as_expression(false)}"
+    end
+  end
+
+  define_expression(:CONST) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:COLON2) do |node|
+    if node.head then
+      "#{node.head.as_expression}::#{node.mid}"
+    else
+      node.mid.to_s
+    end
+  end
+
+  define_expression(:COLON3) do |node|
+    "::#{node.mid}"
+  end
+
+  define_expression(:LVAR) do |node|
+    "#{node.vid}"
+  end
+
+  define_expression(:NEWLINE) do |node|
+    node.next.as_expression
+  end
+
+  define_expression(:STR) do |node|
+    "\"#{node.lit.inspect[1..-2]}\""
+  end
+
+  define_expression(:REGX) do |node|
+    # TODO: cflag
+    "/#{node.lit.inspect[1..-2]}/"
+  end
+
+  define_expression(:REGX_ONCE) do |node|
+    # TODO: cflag
+    "/#{node.lit.inspect[1..-2]}/o"
+  end
+
+  define_expression(:XSTR) do |node|
+    "`#{node.lit.inspect[1..-2]}`"
+  end
+
+  define_expression(:DSTR) do |node|
+    a = node.next.to_a
+    s = "\"#{node.lit.inspect[1..-2]}"
+    a.each do |elem|
+      case elem
+      when Node::STR then s += elem.lit
+      else s += elem.as_expression
+      end
+    end
+    s += "\""
+    s
+  end
+
+  define_expression(:DREGX) do |node|
+    a = node.next.to_a
+    s = "/#{node.lit.inspect[1..-2]}"
+    a.each do |elem|
+      case elem
+      when Node::STR then s += elem.lit
+      else s += elem.as_expression
+      end
+    end
+    s += "/"
+    # TODO: cflag
+    s
+  end
+
+  define_expression(:DREGX_ONCE) do |node|
+    a = node.next.to_a
+    s = "/#{node.lit.inspect[1..-2]}"
+    a.each do |elem|
+      case elem
+      when Node::STR then s += elem.lit
+      else s += elem.as_expression
+      end
+    end
+    s += "/o"
+    # TODO: cflag
+    s
+  end
+
+  define_expression(:DXSTR) do |node|
+    a = node.next.to_a
+    s = "`#{node.lit.inspect[1..-2]}"
+    a.each do |elem|
+      case elem
+      when Node::STR then s += elem.lit
+      else s += elem.as_expression
+      end
+    end
+    s += "`"
+    s
+  end
+
+  major = Config::CONFIG['MAJOR'].to_i
+  minor = Config::CONFIG['MINOR'].to_i
+  teeny = Config::CONFIG['TEENY'].to_i
+  ruby_version_code = major * 100 + minor * 10 + teeny
+
+  if ruby_version_code >= 180 then
+
+    define_expression(:EVSTR) do |node|
+      "\#\{#{node.body.as_expression}\}"
+    end
+
+  else
+
+    define_expression(:EVSTR) do |node|
+      "\#\{#{node.lit}\}"
+    end
+
+  end
+
+  define_expression(:ITER) do |node|
+    "#{node.iter.as_expression} { #{node.body.as_expression} }"
+  end
+
+  define_expression(:WHILE) do |node|
+    if node.state == 1 then
+      "while #{node.cond.as_expression} do; #{node.body.as_expression}; end"
+    else
+      "begin; #{node.body.as_expression}; end while #{node.cond.as_expression}"
+    end
+  end
+
+  define_expression(:UNTIL) do |node|
+    if node.state == 1 then
+      "until #{node.cond.as_expression} do; #{node.body.as_expression}; end"
+    else
+      "begin; #{node.body.as_expression}; end until #{node.cond.as_expression}"
+    end
+  end
+
+  define_expression(:BREAK) do |node|
+    s = "break"
+    if node.stts then
+      s += " #{node.stts.as_expression}"
+    end
+    s
+  end
+
+  define_expression(:RETURN) do |node|
+    s = "return"
+    if node.stts then
+      s += " #{node.stts.as_expression}"
+    end
+    s
+  end
+
+  define_expression(:YIELD) do |node|
+    s = "yield"
+    if node.stts then
+      s += " #{node.stts.as_expression}"
+    end
+    s
+  end
+
+  define_expression(:BEGIN) do |node|
+    if node.body.class == Node::RESCUE or
+       node.body.class == Node::ENSURE then
+      "begin; #{node.body.as_expression(true)}; end"
+    elsif node.body then
+      "begin; #{node.body.as_expression}; end"
+    else
+      "begin; end"
+    end
+  end
+
+  define_expression(:ENSURE) do |node, *args|
+    begin_ensure = args[0] || false
+    if node.head then
+      if begin_ensure then
+        "#{node.head.as_expression} ensure #{node.ensr.as_expression}"
+      else
+        "begin; #{node.head.as_expression} ensure #{node.ensr.as_expression}; end"
+      end
+    else
+      if begin_ensure then
+        "ensure #{node.ensr.as_expression}"
+      else
+        "begin; ensure #{node.ensr.as_expression}; end"
+      end
+    end
+  end
+
+  define_expression(:RESCUE) do |node, *args|
+    begin_rescue = args[0] || false
+    if node.head then
+      if begin_rescue then
+        "#{node.head.as_expression}; rescue #{node.resq.as_expression(begin_rescue)}"
+      else
+        if not node.resq or not node.resq.resq then
+          "begin; #{node.head.as_expression}; rescue; end"
+        else
+          "#{node.head.as_paren_expression} rescue #{node.resq.as_expression(begin_rescue)}"
+        end
+      end
+    else
+      if not node.resq or not node.resq.resq then
+        "begin; rescue; end"
+      else
+        "rescue #{node.resq.as_expression(begin_rescue)}"
+      end
+    end
+  end
+
+  define_expression(:RESBODY) do |node, *args|
+    begin_rescue = args[0] || false
+    if begin_rescue then
+      if node.ensr then
+        a = node.ensr.to_a.map { |n| n.as_expression }
+        "#{a.join(', ')}; #{node.resq.as_expression}"
+      else
+        node.resq ? "; #{node.resq.as_expression}" : ''
+      end
+    else
+      # TODO: assuming node.ensr is false...
+      node.resq ? node.resq.as_expression : ''
+    end
+  end
+
+  define_expression(:CASE) do |node|
+    "case #{node.head.as_expression}; #{node.body.as_expression}end"
+  end
+
+  define_expression(:WHEN) do |node|
+    args = node.head.to_a.map { |n| n.as_expression }
+    s = ''
+    if node.body then
+      s = "when #{args.join(', ')} then #{node.body.as_expression}; "
+    else
+      s = "when #{args.join(', ')}; "
+    end
+    if node.next then
+      s += node.next.as_expression
+    end
+    s
+  end
+
+  define_expression(:ALIAS) do |node|
+    "alias #{node.new} #{node.old}"
+  end
+
+  define_expression(:VALIAS) do |node|
+    "alias #{node.new} #{node.old}"
+  end
+
+  define_expression(:UNDEF) do |node|
+    "alias #{node.mid}"
+  end
+
+  define_expression(:CLASS) do |node|
+    s_super = node.super ? " < #{node.super.as_expression}" : ''
+    if node.respond_to?(:cpath) then
+      path = node.cpath.as_expression
+    else
+      path = node.cname
+    end
+    "class #{path}#{s_super}; #{node.body.as_expression}; end"
+  end
+
+  define_expression(:SCLASS) do |node|
+    "class << #{node.recv.as_expression}; #{node.body.as_expression}; end"
+  end
+
+  define_expression(:SCOPE) do |node|
+    case node.next
+    when nil then ''
+    when Node::ARGS then 'nil'
+    when Node::BLOCK_ARG then 'nil'
+    else node.next.as_expression
+    end
+  end
+
+  define_expression(:DEFN) do |node|
+    # TODO: what to do about noex?
+    "def #{node.mid}; #{node.next.as_expression}; end"
+  end
+
+  define_expression(:DEFS) do |node|
+    "def #{node.recv.as_expression}.#{node.mid}; #{node.next.as_expression}; end"
+  end
+
+  define_expression(:DEFINED) do |node|
+    "defined?(#{node.head.as_expression})"
+  end
+
+  define_expression(:ARGS) do |node|
+    nil
+  end
+
+  define_expression(:BLOCK_ARG) do |node|
+    nil
+  end
+
+  # TODO: MATCH3
+
+  OMIT_PARENS = {
+    LVAR   => true,
+    GVAR   => true,
+    IVAR   => true,
+    CVAR   => true,
+    DVAR   => true,
+    LIT    => true,
+    ARRAY  => true,
+    ZARRAY => true,
+    HASH   => true,
+  }
+end
+
+module MethodAsExpression
+  # It doesn't entirely make sense to have Method#as_expression, because
+  # a method definition isn't an expression.  We have one anyway, to be
+  # consistent with Proc.
+  def as_expression
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_expression
+    else
+      # pre-YARV
+      body_expression = self.body.as_expression
+    end
+    if body_expression then
+      return "def #{sig.name}(#{sig.param_list}); #{body_expression}; end"
+    else
+      return "def #{sig.name}(#{sig.param_list}); end"
+    end
+  end
+end
+
+class Method
+  include MethodAsExpression
+end
+
+class UnboundMethod
+  include MethodAsExpression
+end
+
+class Proc
+  def as_expression
+    sig = self.signature
+    body_expression = self.body ? self.body.as_expression : nil
+    s = sig.args.unspecified ? "" : sig.to_s + ' '
+    b = body_expression ? body_expression + ' ' : ''
+    return "proc { #{s}#{b}}"
+  end
+end
+