ruby-internal 0.6.0

data/lib/internal/node.rb

@@ -0,0 +1,3 @@
+require 'internal/node/node'
+require 'internal/node/to_a'
+require 'internal/node/pp'

data/lib/internal/node/as_code.rb

@@ -0,0 +1,233 @@
+require 'internal/node'
+require 'internal/node/as_expression'
+require 'internal/object/as_code'
+require 'rbconfig'
+
+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 then
+      vardefs = a[0]
+      while vardefs.class == Node::DASGN_CURR do
+        vardefs = vardefs.value
+      end
+      if not vardefs then
+        # ignore variable definitions
+        a.shift
+      end
+    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
+    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.args then
+        a = node.args.to_a.map { |n| n.as_expression }
+        "#{a.join(', ')}\n" +
+        "#{'  '*indent}#{node.body.as_code(indent+1)}"
+      else
+        node.body ? "\n#{'  '*indent}#{node.body.as_code(indent+1)}" : ''
+      end
+    else
+      # TODO: assuming node.args is false...
+      node.body ? node.body.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

data/lib/internal/node/as_expression.rb

@@ -0,0 +1,619 @@
+require 'internal/node'
+require 'internal/node/to_a'
+require 'rbconfig'
+
+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 will 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(:TRUE) do |node|
+    "true"
+  end
+
+  define_expression(:FALSE) do |node|
+    "false"
+  end
+
+  define_expression(:NIL) 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 is unset for MASGN
+    node.value ? "#{node.vid} = #{node.value.as_expression}" : "#{node.vid}"
+  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(:OP_ASGN1) do |node|
+    # TODO
+    raise "Not implemented"
+  end
+
+  define_expression(:OP_ASGN2) do |node|
+    recv = node.recv.as_expression
+    attr = node.next.vid # TODO: we assume it's the same as aid
+    op = case node.next.mid
+    when false then '||'
+    when nil then '&&'
+    else node.next.mid
+    end
+    value = node.value.as_expression
+    "#{recv}.#{attr} #{op}= #{value}"
+  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|
+    # TODO: shouldn't COLON2 have args if it's a method?
+    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|
+    iter = node.iter.as_expression
+    body = node.body ? (node.body.as_expression + " ") : ""
+    "#{iter} { #{body} }"
+  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.body 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.body 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.args then
+        a = node.args.to_a.map { |n| n.as_expression }
+        "#{a.join(', ')}; #{node.resq.as_expression}"
+      else
+        node.body ? "; #{node.body.as_expression}" : ''
+      end
+    else
+      # TODO: assuming node.args is false...
+      node.body ? node.body.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|
+    if defined? node.mid then
+      # < 1.8.5
+      "undef #{node.mid}"
+    else
+      # >= 1.8.5
+      "undef #{node.body.as_expression}"
+    end
+  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
+