ruby-internal 0.6.0

data/lib/internal/method/signature.rb

@@ -0,0 +1,442 @@
+require 'internal/method'
+require 'internal/node'
+require 'internal/node/as_expression'
+
+if defined?(RubyVM) then
+require 'internal/vm/bytedecoder'
+end
+
+module MethodSig
+  class Argument
+    attr_reader :name
+
+    def required?
+      return !optional?
+    end
+
+    def optional?
+      return rest? || block?
+    end
+
+    def rest?
+      return @is_rest
+    end
+
+    def block?
+      return @is_block
+    end
+
+    def default
+      return nil
+    end
+
+    def initialize(name, is_rest, is_block)
+      @name = name
+      @is_rest = is_rest
+      @is_block = is_block
+    end
+
+    def to_s
+      if @is_rest then
+        prefix = "*"
+      elsif @is_block then
+        prefix = "&"
+      end
+
+      if self.default then
+        suffix = "=#{default()}"
+      end
+
+      return "#{prefix}#{@name}#{suffix}"
+    end
+  end
+
+  class OptionalArgument < Argument
+    def optional?
+      return true
+    end
+  end
+
+  class NodeOptionalArgument < OptionalArgument
+    attr_reader :node_for_default
+    attr_reader :default
+
+    def initialize(name, default, node_for_default, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @default = default
+      @node_for_default = node_for_default
+    end
+  end
+
+  class YarvOptionalArgument < OptionalArgument
+    attr_reader :iseq
+    attr_reader :pc_start
+    attr_reader :local_idx
+
+    def initialize(name, iseq, pc_start, local_idx, is_rest, is_block)
+      super(name, is_rest, is_block)
+      @iseq = iseq
+      @pc_start = pc_start
+      @local_idx = local_idx
+      @default = nil
+    end
+
+    def inspect
+      default()
+      super
+    end
+
+    def default
+      return @default if @default
+
+      env = Nodewrap::ByteDecoder::Environment.new(@iseq.local_table())
+      local_table_idx = local_table_idx()
+      @iseq.bytedecode(env, @pc_start) do |instr|
+        RubyVM::Instruction::SETLOCAL === instr &&
+        instr.operands[0] == local_table_idx
+      end
+      expressions = env.expressions + env.stack
+
+      @default = expressions[0].rhs.to_s
+      return @default
+    end
+
+    def local_table_idx
+      return @iseq.local_table.size - @local_idx + 1
+    end
+  end
+
+  def local_vars
+    return self.body.local_vars
+  end
+
+  # Return the names of the arguments this method takes, in the order in
+  # which they appear in the argument list.
+  def argument_names
+    return self.body.argument_names
+  end
+
+  def args_node
+    return self.body.args_node
+  end
+  private :args_node
+
+  # If this method has a "rest" argument, that is, it has an argument
+  # that is preceded by an asterisk (*) in the argument list, then
+  # return its index, otherwise return nil.
+  def rest_arg
+    return self.body.rest_arg
+  end
+
+  # If this method has a "block" argument, that is, it has an argument
+  # that is preceded by an ampersand (&) in the argument list, then
+  # return its index, otherwise return nil.
+  def block_arg
+    return self.body.block_arg
+  end
+
+  def set_optional_args(args, args_node, names)
+    self.body.set_optional_args(args, args_node, names)
+  end
+  private :set_optional_args
+
+  # Return a hash mapping each argument name to a description of that
+  # argument.
+  def arguments
+    names = self.argument_names()
+    block_arg = self.block_arg()
+
+    args = {}
+    names.each do |name|
+      args[name] = Argument.new(name, false, false)
+    end
+
+    # Optional args
+    args_node = args_node()
+    set_optional_args(args, args_node, names)
+
+    # Rest arg
+    if self.rest_arg then
+      rest_name = names[rest_arg]
+      args[rest_name] = Argument.new(rest_name, true, false)
+    end
+
+    # Block arg
+    if block_arg then
+      block_name = names[block_arg]
+      args[block_name] = Argument.new(block_name, false, true)
+    end
+
+    return args
+  end
+
+  # An abstraction for a method signature.
+  class Signature
+    attr_reader :origin_class, :name, :arg_names, :args
+
+    def initialize(origin_class, name, arg_names, args)
+      @origin_class = origin_class
+      @name = name
+      @arg_names = arg_names
+      @args = args
+    end
+
+    def to_s
+      return "#{@origin_class}\##{@name}(#{param_list})"
+    end
+
+    def param_list
+      params = @arg_names.map{ |n| args[n].to_s }
+      return params.join(', ')
+    end
+  end
+
+  # An abstraction for a method origin.
+  class Origin
+    attr_reader :file, :line
+
+    def initialize(file, line)
+      @file = file
+      @line = line
+    end
+
+    def to_s
+      return "#{file}:#{line}"
+    end
+  end
+
+  # Return a Method::Origin representing where the method was defined.
+  def origin
+    block = body().next
+    return Origin.new(block.nd_file, block.nd_line)
+  end
+end
+
+class Method
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        attached_class(),
+        method_oid().to_s,
+        argument_names(),
+        arguments())
+  end
+end
+
+class UnboundMethod
+  include MethodSig
+
+  # Return a String representing the method's signature.
+  def signature
+    return Signature.new(
+        origin_class(),
+        method_oid().to_s,
+        argument_names(),
+        arguments())
+  end
+end
+
+class Node
+  # pre-YARV
+  class SCOPE
+    include MethodSig
+
+    def local_vars
+      return self.tbl || []
+    end
+
+    def argument_names
+      local_vars = self.local_vars
+      args = self.args_node
+      num_required_args = args.cnt
+      num_optional_args = 0
+      opt = args.opt
+      while opt do
+        num_optional_args += 1
+        opt = opt.next
+      end
+      num_args = \
+        num_required_args + \
+        num_optional_args + \
+        (rest_arg ? 1 : 0) + \
+        (block_arg ? 1 : 0)
+      return local_vars[0...num_args]
+    end
+
+    def args_node
+      if self.next.class == Node::ARGS then
+        return self.next
+      elsif self.next.head.class == Node::ARGS then
+        return self.next.head
+      else
+        raise "Could not find method arguments"
+      end
+    end
+
+    def rest_arg
+      args_node = args_node()
+      rest = args_node.rest()
+      if rest.class == Node::LASGN then
+        # subtract 2 to account for implicit vars
+        return rest.cnt - 2
+      elsif not rest
+        return nil
+      else
+        return rest > 0 ? rest - 2 : nil
+      end
+    end
+
+    def block_arg
+      block = self.next
+      if block.class == Node::BLOCK and
+         block.next.head.class == Node::BLOCK_ARG then
+        # subtract 2 to account for implicit vars
+        return block.next.head.cnt - 2
+      else
+        return nil
+      end
+    end
+
+    def set_optional_args(args, args_node, names)
+      opt = args_node.opt
+      while opt do
+        head = opt.head
+        if head.class == Node::LASGN then
+          args[head.vid] = NodeOptionalArgument.new(
+              head.vid, head.value.as_expression, head.value, false, false)
+        else
+          raise "Unexpected node type: #{opt.class}"
+        end
+        opt = opt.next
+      end
+    end
+  end
+
+  # Pre-YARV, I think
+  class BMETHOD
+    def local_vars
+      raise "TODO: Not implemented yet"
+    end
+
+    def argument_names
+      return self.cval.arguments.names
+    end
+
+    def arguments
+      return self.cval.arguments
+    end
+
+    def args_node
+      raise "TODO: Not implemented yet"
+    end
+
+    def rest_arg
+      raise "TODO: Not implemented yet"
+    end
+
+    def block_arg
+      raise "TODO: Not implemented yet"
+    end
+
+    def set_optional_args(args, args_node, names)
+      raise "TODO: Not implemented yet"
+    end
+  end
+
+  # YARV
+  class METHOD
+    include MethodSig
+
+    def local_vars
+      iseq = self.body
+      local_vars = iseq.local_table
+      return local_vars
+    end
+
+    def argument_names
+      local_vars = self.local_vars
+      iseq = self.body
+      opt_args = iseq.arg_opt_table
+      opt_args.pop # last arg is a pointer to the start of the code
+      num_args = \
+        iseq.argc + \
+        opt_args.size + \
+        (rest_arg ? 1 : 0) + \
+        (block_arg ? 1 : 0)
+      return local_vars[0...num_args]
+    end
+
+    def args_node
+      return nil
+    end
+
+    def rest_arg
+      arg_rest = self.body.arg_rest
+      return arg_rest >= 0 ? arg_rest : nil
+    end
+
+    def block_arg
+      arg_block = self.body.arg_block
+      return arg_block >= 0 ? arg_block : nil
+    end
+
+    def set_optional_args(args, args_node, names)
+      opt_table = self.body.arg_opt_table
+      opt_table.pop
+      first_opt_idx =
+        names.size -
+        opt_table.size -
+        (self.rest_arg ? 1 : 0) -
+        (self.block_arg ? 1 : 0)
+      opt_table.each_with_index do |pc, idx|
+        name = names[first_opt_idx + idx]
+        args[name] = YarvOptionalArgument.new(name, self.body, pc, idx, false, false)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  def foo(); end
+  puts method(:foo).signature
+
+  def foo(foo); end
+  puts method(:foo).signature
+
+  def foo(foo, bar); end
+  puts method(:foo).signature
+
+  def foo(foo=42, bar=10); end
+  puts method(:foo).signature
+
+  def foo(*args); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=42, *args, &block); end
+  puts method(:foo).signature
+  puts method(:foo).origin
+
+  def foo(foo, bar=obj.foo(1, 2, foo(10)), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=obj.foo(1 + 1), *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true ? false : 0, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=true, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=nil, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar={1=>2}, *args, &block); end
+  puts method(:foo).signature
+
+  def foo(foo, bar=[1,2], *args, &block); end
+  puts method(:foo).signature
+end
+

data/lib/internal/module.rb

@@ -0,0 +1 @@
+require 'internal/module/module'

data/lib/internal/module/as_code.rb

@@ -0,0 +1,45 @@
+require 'internal/node/as_code'
+require 'internal/module'
+
+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
+