atomy 0.1.1 → 0.6.3

data/lib/atomy/locals.rb

@@ -0,0 +1,75 @@
+require "rubinius/compiler"
+
+module Atomy
+  class LocalState
+    include CodeTools::Compiler::LocalVariables
+
+    attr_accessor :parent
+
+    def search_local(name)
+      if variable = variables[name]
+        variable.nested_reference
+      elsif @parent && reference = @parent.search_local(name)
+        reference.depth += 1
+        reference
+      end
+    end
+
+    def new_local(name)
+      variable = CodeTools::Compiler::LocalVariable.new(allocate_slot)
+      variables[name] = variable
+    end
+  end
+
+  class EvalLocalState < LocalState
+    def initialize(variable_scope)
+      @variable_scope = variable_scope
+    end
+
+    # Returns a cached reference to a variable or searches all
+    # surrounding scopes for a variable. If no variable is found,
+    # it returns nil and a nested scope will create the variable
+    # in itself.
+    def search_local(name)
+      if variable = variables[name]
+        return variable.nested_reference
+      end
+
+      if variable = search_scopes(name)
+        variables[name] = variable
+        return variable.nested_reference
+      end
+    end
+
+    def new_local(name)
+      variable = CodeTools::Compiler::EvalLocalVariable.new(name)
+      variables[name] = variable
+    end
+
+    def local_count
+      0
+    end
+
+    def local_names
+      []
+    end
+
+    private
+
+    def search_scopes(name)
+      depth = 1
+      scope = @variable_scope
+
+      while scope
+        if !scope.method.for_eval? && (slot = scope.method.local_slot(name))
+          return CodeTools::Compiler::NestedLocalVariable.new(depth, slot)
+        elsif scope.eval_local_defined?(name, false)
+          return CodeTools::Compiler::EvalLocalVariable.new(name)
+        end
+
+        depth += 1
+        scope = scope.parent
+      end
+    end
+  end
+end

data/lib/atomy/message_structure.rb

@@ -0,0 +1,277 @@
+module Atomy
+  class MessageStructure
+    class DefaultArgument
+      attr_reader :node, :default
+
+      def initialize(node, default)
+        @node = node
+        @default = default
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && \
+          other.node == @node && \
+          other.default == @default
+      end
+    end
+
+    class BlockArgument
+      attr_reader :body, :arguments, :proc_argument
+
+      def initialize(body, arguments = [], proc_argument = nil)
+        @body = body
+        @arguments = arguments
+        @proc_argument = proc_argument
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && \
+          other.body == @body && \
+          other.arguments == @arguments && \
+          other.proc_argument == @proc_argument
+      end
+    end
+
+    class UnknownMessageStructure < RuntimeError
+      def initialize(node)
+        @node = node
+      end
+
+      def to_s
+        "unknown message structure: #{@node}"
+      end
+    end
+
+    def initialize(node)
+      @node = node
+    end
+
+    def name
+      # don't treat sole constant as message send
+      raise unknown_message if @node.is_a?(Atomy::Grammar::AST::Constant)
+
+      name_from(@node)
+    end
+
+    def arguments
+      pre, defaults, post, splat = arguments_from(argument_list_from(@node))
+      pre
+    end
+
+    def splat_argument
+      pre, defaults, post, splat = arguments_from(argument_list_from(@node))
+      splat
+    end
+
+    def receiver
+      receiver_from(@node)
+    end
+
+    def proc_argument
+      proc_argument_from(@node)
+    end
+
+    def block
+      block_from(@node)
+    end
+
+    def default_arguments
+      pre, defaults, post, splat = arguments_from(argument_list_from(@node))
+      defaults
+    end
+
+    def post_arguments
+      pre, defaults, post, splat = arguments_from(argument_list_from(@node))
+      post
+    end
+
+    private
+
+    def unknown_message
+      UnknownMessageStructure.new(@node)
+    end
+
+    def name_from(node)
+      case node
+      when Grammar::AST::Word, Grammar::AST::Constant
+        return node.text
+      when Grammar::AST::Apply
+        return name_from(node.node)
+      when Grammar::AST::Infix
+        return node.operator
+      when Grammar::AST::Postfix
+        case node.operator
+        when :"!", :"?"
+          case node.node
+          when Grammar::AST::Word, Grammar::AST::Constant
+            return :"#{node.node.text}#{node.operator}"
+          end
+        end
+      when Grammar::AST::Prefix
+        return :"#{node.operator}@"
+      when Grammar::AST::Compose
+        case node.right
+        when Grammar::AST::Prefix # proc argument
+          return name_from(node.left)
+        when Grammar::AST::Word, Grammar::AST::Constant, Grammar::AST::Apply # has a receiver
+          return name_from(node.right)
+        when Grammar::AST::Postfix
+          case node.right.operator
+          when :"!", :"?"
+            return name_from(node.right)
+          end
+        when Grammar::AST::Block # block literal argument
+          case node.left
+          when Grammar::AST::Compose
+            case node.left.right
+            when Grammar::AST::List # block args; skip
+              return name_from(node.left.left)
+            else
+              return name_from(node.left)
+            end
+          else
+            return name_from(node.left)
+          end
+        when Grammar::AST::List # foo[bar]
+          return :[]
+        end
+      end
+
+      raise unknown_message
+    end
+
+    def arguments_from(list)
+      pre = []
+      defaults = []
+      post = []
+      splat = nil
+
+      list.each do |a|
+        if a.is_a?(Grammar::AST::Infix) && a.operator == :"="
+          if splat || !post.empty?
+            raise unknown_message
+          end
+
+          defaults << DefaultArgument.new(a.left, a.right)
+        elsif a.is_a?(Grammar::AST::Prefix) && a.operator == :"*"
+          if splat || !post.empty?
+            raise unknown_message
+          end
+
+          splat = a.node
+        elsif splat || !defaults.empty?
+          post << a
+        else
+          pre << a
+        end
+      end
+
+      [pre, defaults, post, splat]
+    end
+
+    def argument_list_from(node)
+      case node
+      when Grammar::AST::Apply
+        return node.arguments
+      when Grammar::AST::Infix
+        return [node.right]
+      when Grammar::AST::Compose
+        case node.right
+        when Grammar::AST::Prefix # proc argument
+          return argument_list_from(node.left)
+        when Grammar::AST::Word, Grammar::AST::Constant, Grammar::AST::Apply # has a receiver
+          return argument_list_from(node.right)
+        when Grammar::AST::Block # block literal argument
+          case node.left
+          when Grammar::AST::Compose
+            case node.left.right
+            when Grammar::AST::List # block args; skip
+              return argument_list_from(node.left.left)
+            else
+              return argument_list_from(node.left)
+            end
+          else
+            return argument_list_from(node.left)
+          end
+        when Grammar::AST::List # foo[bar]
+          return node.right.nodes
+        end
+      end
+
+      []
+    end
+
+    def proc_argument_from(node)
+      case node
+      when Grammar::AST::Compose
+        case node.right
+        when Grammar::AST::Prefix
+          if node.right.operator == :"&" # proc argument
+            return node.right.node
+          end
+        end
+      end
+    end
+
+    def receiver_from(node)
+      case node
+      when Grammar::AST::Infix
+        return node.left
+      when Grammar::AST::Compose
+        case node.right
+        when Grammar::AST::Word, Grammar::AST::Constant, Grammar::AST::Apply
+          return node.left
+        when Grammar::AST::Postfix
+          case node.right.operator
+          when :"!", :"?"
+            return node.left
+          end
+        when Grammar::AST::Block # block literal argument
+          case node.left
+          when Grammar::AST::Compose
+            case node.left.right
+            when Grammar::AST::List # block args; skip
+              return receiver_from(node.left.left)
+            else
+              return receiver_from(node.left)
+            end
+          else
+            return receiver_from(node.left)
+          end
+        when Grammar::AST::List
+          return node.left
+        when Grammar::AST::Prefix
+          if node.right.operator == :"&" # proc argument
+            return receiver_from(node.left)
+          end
+        end
+      when Grammar::AST::Prefix
+        return node.node
+      end
+    end
+    
+    def block_from(node)
+      case node
+      when Grammar::AST::Compose
+        blk = nil
+
+        case node.right
+        when Grammar::AST::Block
+          blk = BlockArgument.new(node.right.nodes)
+        else
+          return
+        end
+
+        case node.left
+        when Grammar::AST::Compose
+          case node.left.right
+          when Grammar::AST::List
+            return BlockArgument.new(blk.body, node.left.right.nodes)
+          end
+        end
+
+        return blk
+      end
+    end
+  end
+end

data/lib/atomy/method.rb

@@ -0,0 +1,343 @@
+# dispatch strategy:
+#
+#   1 foo([a, b]) := a + 1
+#   2 foo([c]) := 4
+#
+# defines:
+#
+#   Integer#foo           (arity 1) : 1 concrete arg
+#   Integer#foo-branch-1  (arity 2) : 2 bindings
+#   Integer#foo-branch-2  (arity 1) : 1 binding
+#
+# so, doing 1.foo([1, 2]) will execute:
+#
+# Integer#foo:
+#   - locals tuple: [arg:0]
+#   - invoke Pattern#matches? with var scope
+#     - if true, invoke Integer#foo-match-1(*Pattern#bindings(scope))
+#     - if false, invoke Pattern#matches? with var scope
+#       - if true, invoke Integer#foo-match-2(*Pattern#bindings(scope))
+#       - if false, raise Atomy::MessageMismatch
+#
+
+require "atomy/compiler"
+require "atomy/locals"
+
+module Atomy
+  class InconsistentArgumentForms < RuntimeError
+    def to_s
+      "inconsistent method argument forms"
+    end
+  end
+
+  class Method
+    class Branch
+      attr_reader :body, :receiver, :arguments, :default_arguments,
+        :splat_argument, :post_arguments, :proc_argument
+
+      attr_accessor :name
+
+      def initialize(receiver = nil, arguments = [], default_arguments = [],
+                     splat_argument = nil, post_arguments = [],
+                     proc_argument = nil, &body)
+        @body = body.block
+        @receiver = receiver
+        @arguments = arguments
+        @default_arguments = default_arguments
+        @splat_argument = splat_argument
+        @post_arguments = post_arguments
+        @proc_argument = proc_argument
+      end
+
+      def pre_arguments_count
+        @arguments.size
+      end
+
+      def default_arguments_count
+        @default_arguments.size
+      end
+
+      def post_arguments_count
+        @post_arguments.size
+      end
+
+      def splat_index
+        @arguments.size + @default_arguments.size if @splat_argument
+      end
+
+      def for_method!
+        @method = true
+        self
+      end
+
+      def method?
+        @method
+      end
+
+      def as_method
+        Rubinius::BlockEnvironment::AsMethod.new(@body)
+      end
+    end
+
+    attr_reader :name, :branches
+
+    def initialize(name)
+      @name = name
+      @branches = []
+    end
+
+    @@tick = 0
+
+    def add_branch(branch)
+      @branches << branch
+
+      if branch.method?
+        @@tick += 1
+        branch.name = :"#{@name}:branch:#{@@tick}"
+      end
+
+      branch
+    end
+
+    def build
+      Atomy::Compiler.package(:__wrapper__) do |gen|
+        gen.name = @name
+
+        pre, default, splat, post = argument_form
+        gen.total_args = pre + default + post
+        gen.required_args = pre + post
+        gen.splat_index = splat
+        gen.post_args = post
+
+        arg = 0
+        pre.times do
+          gen.state.scope.new_local(:"arg:#{arg}")
+          arg += 1
+        end
+
+        default.times do
+          gen.state.scope.new_local(:"arg:#{arg}")
+          arg += 1
+        end
+
+        if gen.splat_index
+          gen.state.scope.new_local(:"arg:splat")
+        end
+
+        post.times do
+          gen.state.scope.new_local(:"arg:#{arg}")
+          arg += 1
+        end
+
+        done = gen.new_label
+
+        build_branches(gen, done)
+
+        try_super(gen, done) unless @name == :initialize
+        raise_mismatch(gen)
+
+        gen.push_nil
+
+        done.set!
+      end.tap do |cm|
+        cm.scope = Rubinius::ConstantScope.new(Object)
+      end
+    end
+
+    private
+
+    def uniform_argument_forms?
+      return true if @branches.empty?
+
+      return false unless @branches.collect(&:pre_arguments_count).uniq.size == 1
+      return false unless @branches.collect(&:splat_index).uniq.size == 1
+      return false unless @branches.collect(&:post_arguments_count).uniq.size == 1
+
+      # permit varying default argument counts; as long as the rest are the
+      # same it's unambiguous
+
+      true
+    end
+
+    def argument_form
+      return [0, 0, nil, 0] if @branches.empty?
+
+      raise InconsistentArgumentForms unless uniform_argument_forms?
+
+      [
+        @branches.collect(&:pre_arguments_count).first,
+        @branches.collect(&:default_arguments_count).max,
+        @branches.collect(&:splat_index).first,
+        @branches.collect(&:post_arguments_count).first,
+      ]
+    end
+
+    def build_branches(gen, done)
+      @branches.each do |b|
+        skip = gen.new_label
+
+        # check for too few arguments
+        gen.passed_arg(b.pre_arguments_count - 1)
+        gen.gif(skip)
+
+        # check for too many arguments
+        unless b.splat_index
+          gen.passed_arg(b.pre_arguments_count + b.default_arguments_count + b.post_arguments_count)
+          gen.git(skip)
+        end
+
+        if b.receiver
+          gen.push_self
+          b.receiver.inline_matches?(gen)
+          gen.gif(skip)
+        end
+
+        arg = 0
+        b.arguments.each do |pat|
+          gen.push_local(arg)
+          pat.inline_matches?(gen)
+          gen.gif(skip)
+
+          arg += 1
+        end
+
+        b.default_arguments.each do |pat|
+          skip_check = gen.new_label
+
+          gen.push_local(arg)
+          gen.goto_if_undefined(skip_check)
+
+          gen.push_local(arg)
+          pat.inline_matches?(gen)
+          gen.gif(skip)
+
+          skip_check.set!
+
+          arg += 1
+        end
+
+        if b.splat_argument
+          gen.push_local(b.splat_index)
+          b.splat_argument.inline_matches?(gen)
+          gen.gif(skip)
+
+          arg += 1
+        end
+
+        b.post_arguments.each do |pat|
+          gen.push_local(arg)
+          pat.inline_matches?(gen)
+          gen.gif(skip)
+
+          arg += 1
+        end
+
+        if b.proc_argument
+          gen.push_proc
+          b.proc_argument.inline_matches?(gen)
+          gen.gif(skip)
+        end
+
+        branch_args = 0
+        method_arg = 0
+
+        if pat = b.receiver
+          gen.push_literal(pat)
+          gen.push_self
+          branch_args += 2
+        end
+
+        b.arguments.each do |pat|
+          gen.push_literal(pat)
+          gen.push_local(method_arg)
+          method_arg += 1
+          branch_args += 2
+        end
+
+        b.default_arguments.each do |pat|
+          gen.push_literal(pat)
+          gen.push_local(method_arg)
+          method_arg += 1
+          branch_args += 2
+        end
+
+        if pat = b.splat_argument
+          gen.push_literal(pat)
+          gen.push_local(b.splat_index)
+          method_arg += 1
+          branch_args += 2
+        end
+
+        b.post_arguments.each do |pat|
+          gen.push_literal(pat)
+          gen.push_local(method_arg)
+          method_arg += 1
+          branch_args += 2
+        end
+
+        if pat = b.proc_argument
+          gen.push_literal(pat)
+          gen.push_proc
+          branch_args += 2
+        end
+
+        if b.name
+          gen.push_self
+          gen.move_down(branch_args)
+
+          gen.send(b.name, branch_args, true)
+        else
+          gen.push_literal(b.as_method)
+          gen.move_down(branch_args)
+
+          gen.push_literal(@name)
+          gen.move_down(branch_args)
+
+          gen.push_literal(b.body.constant_scope.module)
+          gen.move_down(branch_args)
+
+          gen.push_self
+          gen.move_down(branch_args)
+
+          gen.make_array(branch_args)
+
+          gen.push_nil
+
+          gen.send(:invoke, 5)
+        end
+
+        gen.goto(done)
+
+        skip.set!
+      end
+    end
+
+    def try_super(gen, done)
+      no_super = gen.new_label
+
+      gen.invoke_primitive(:vm_check_super_callable, 0)
+      gen.gif(no_super)
+
+      gen.push_proc
+      if gen.state.super?
+        gen.zsuper(g.state.super.name)
+      else
+        gen.zsuper(nil)
+      end
+
+      gen.goto(done)
+
+      no_super.set!
+    end
+
+    def raise_mismatch(gen)
+      gen.push_cpath_top
+      gen.find_const(:Atomy)
+      gen.find_const(:MessageMismatch)
+      gen.push_literal(@name)
+      gen.push_self
+      gen.send(:new, 2)
+      gen.raise_exc
+    end
+  end
+end