atomy 0.1.1

data/lib/macros.rb

@@ -0,0 +1,317 @@
+class MethodFail < ArgumentError
+  def initialize(mn)
+    @method_name = mn
+  end
+
+  def message
+    "method #{@method_name.to_s} did not understand " +
+      "its arguments (non-exhaustive patterns)"
+  end
+end
+
+module Atomy
+  OPERATORS = {}
+  STATE = {}
+
+  module Macro
+    def self.set_op_info(ops, assoc, prec)
+      ops.each do |o|
+        info = OPERATORS[o] ||= {}
+        info[:assoc] = assoc
+        info[:prec] = prec
+      end
+    end
+
+    class Environment
+      @@salt = 0
+      @@macros = {}
+      @@let = Hash.new { |h, k| h[k] = [] }
+      @@quoters = {}
+      @@line = 0
+
+      class << self
+        attr_accessor :quoters
+
+        def macros
+          @@macros
+        end
+
+        def let
+          @@let
+        end
+
+        def line
+          @@line
+        end
+
+        def line=(x)
+          @@line = x
+        end
+
+        def quoter(name, &blk)
+          @@quoters[name] = blk
+        end
+
+        def quote(name, contents, flags)
+          if a = @@quoters[name.to_sym]
+            a.call(contents, flags)
+          else
+            raise "unknown quoter #{name.inspect}"
+          end
+        end
+
+        def names(num = 0, &block)
+          num = block.arity if block
+
+          as = []
+          num.times do
+            as << Atomy::AST::Variable.new(0, "s:" + @@salt.to_s)
+            @@salt += 1
+          end
+
+          if block
+            block.call(*as)
+          else
+            as
+          end
+        end
+      end
+    end
+
+    def self.register(name, args, body, let = false)
+      ns = Atomy::Namespace.get(Thread.current[:atomy_define_in])
+      meth = ns ? Atomy.namespaced(ns.name, name) : name
+      meth = (intern meth).to_sym
+
+      if let && Environment.respond_to?(meth)
+        Environment.let[name] << Environment.method(meth)
+      end
+
+      methods = Environment.macros
+      method = [[Patterns::Any.new, args], body.resolve]
+      if ms = methods[meth]
+        Atomy.insert_method(method, ms)
+      else
+        methods[meth] = [method]
+      end
+
+      Atomy.add_method(
+        Environment.singleton_class,
+        meth,
+        methods[meth],
+        nil,
+        :public,
+        true
+      )
+
+      meth
+    end
+
+    def self.intern(name)
+      "atomy-macro:" + name
+    end
+
+    # take a node and return its expansion
+    def self.expand(node)
+      name = node.method_name
+
+      return node unless name
+
+      methods = []
+      if name && ns = Atomy::Namespace.get
+        ([ns.name] + ns.using).each do |n|
+          methods << intern(Atomy.namespaced(n, name)).to_sym
+        end
+      end
+
+      methods << intern(name).to_sym
+
+      expanded = nil
+      methods.each do |meth|
+        next unless Environment.respond_to?(meth)
+
+        expanded = expand_node(node, meth)
+        break if expanded
+      end
+
+      expanded || node
+    end
+
+    def self.expand_node(node, meth)
+      Environment.line ||= node.line
+
+      begin
+        case node
+        when AST::BinarySend
+          expand_res Environment.send(
+            meth,
+            nil,
+            node.lhs,
+            node.rhs
+          )
+        when AST::Send
+          if node.arguments.last.kind_of?(AST::Unary) && \
+              node.arguments.last.operator == "&"
+            block = AST::BlockPass.new(node.line, node.arguments.pop.receiver)
+          else
+            block = node.block
+          end
+
+          expand_res Environment.send(
+            meth,
+            block,
+            node.receiver,
+            *node.arguments
+          )
+        when AST::Unary
+          expand_res Environment.send(
+            meth,
+            nil,
+            node.receiver
+          )
+        when AST::Variable
+          expand_res Environment.send(
+            meth
+          )
+        else
+          # just stopping
+          nil
+        end
+      rescue MethodFail, ArgumentError => e
+        # expand normally if the macro doesn't seem to be a match
+        raise unless e.instance_variable_get("@method_name") == meth
+        nil
+      ensure
+        Environment.line = nil
+      end
+    end
+
+    # helper method for #expand
+    def self.expand_res(node)
+      expand(node.to_node)
+    end
+
+    # @!x
+    #  to:
+    # @`(!~x)
+    #
+    # @!?x
+    #  to:
+    # @(`!?~x)
+    def self.unary_chain(n)
+      d = n.dup
+      x = d
+      while x.kind_of?(Atomy::AST::Unary)
+        if x.receiver.kind_of?(Atomy::AST::Unary)
+          y = x.receiver.dup
+          x.receiver = y
+          x = y
+        else
+          unless x.receiver.kind_of?(Atomy::AST::Primitive)
+            x.receiver = Atomy::AST::Unquote.new(
+              x.receiver.line,
+              x.receiver
+            )
+          end
+          break
+        end
+      end
+
+      Atomy::AST::QuasiQuote.new(d.line, d)
+    end
+
+    # x(a) y(b)
+    #  to:
+    # `(x(~a)) y(b)
+    #
+    # x(a) y(b) z(c)
+    #  to:
+    # `(x(~a) y(~b)) z(c)
+    #
+    # x(&a) b(c) should bind the proc-arg
+    def self.send_chain(n)
+      return n if n.block
+
+      d = n.dup
+      x = d
+      while x.kind_of?(Atomy::AST::Send)
+        as = []
+        x.arguments.each do |a|
+          if a.kind_of?(Atomy::AST::Unary) && a.operator == "&"
+            x.block = Atomy::AST::Unquote.new(
+              a.line,
+              a.receiver
+            )
+          else
+            as << Atomy::AST::Unquote.new(
+              a.line,
+              a
+            )
+          end
+        end
+
+        x.arguments = as
+
+        if x.receiver.kind_of?(Atomy::AST::Send) && !x.receiver.block
+          y = x.receiver.dup
+          x.receiver = y
+          x = y
+        else
+          unless x.receiver.kind_of?(Atomy::AST::Primitive)
+            x.receiver = Atomy::AST::Unquote.new(
+              x.receiver.line,
+              x.receiver
+            )
+          end
+          break
+        end
+      end
+
+      Atomy::AST::QuasiQuote.new(d.line, d)
+    end
+
+    def self.macro_pattern(n)
+      if n.kind_of?(Atomy::AST::Send) && !n.block
+        n = send_chain(n)
+      end
+
+      if n.kind_of?(Atomy::AST::Unary) && n.operator != "&" && n.operator != "*"
+        n = unary_chain(n)
+      end
+
+      # TODO: this is too powerful. `foo = 'Object` pattern breaks.
+      n = n.recursively do |sub|
+        case sub
+        when Atomy::AST::Constant
+          Atomy::AST::ScopedConstant.new(
+            sub.line,
+            Atomy::AST::ScopedConstant.new(
+              sub.line,
+              Atomy::AST::Constant.new(
+                sub.line,
+                "Atomy"
+              ),
+              "AST"
+            ),
+            sub.identifier
+          )
+        else
+          sub
+        end
+      end
+
+      case n
+      when Atomy::AST::Primitive
+        if n.value == :self
+          Atomy::Patterns::Quote.new(
+            Atomy::AST::Primitive.new(n.line, :self)
+          )
+        else
+          n.to_pattern
+        end
+      else
+        n.to_pattern
+      end
+    end
+  end
+end

data/lib/method.rb

@@ -0,0 +1,261 @@
+module Atomy
+  def self.segments(args)
+    req = []
+    dfs = []
+    spl = nil
+    blk = nil
+    args.each do |a|
+      case a
+      when Patterns::BlockPass
+        blk = a
+      when Patterns::Splat
+        spl = a
+      when Patterns::Default
+        dfs << a
+      else
+        req << a
+      end
+    end
+    [req, dfs, spl, blk]
+  end
+
+  def self.match_self?(pat)
+    case pat
+    when Patterns::Match
+      pat.value != :self
+    when Patterns::Constant
+      false
+    when Patterns::Named
+      match_self?(pat.pattern)
+    else
+      true
+    end
+  end
+
+  def self.build_method(name, branches, is_macro = false, file = :dynamic, line = 1)
+    g = Rubinius::Generator.new
+    g.name = name.to_sym
+    g.file = file.to_sym
+    g.set_line Integer(line)
+
+    done = g.new_label
+    mismatch = g.new_label
+
+    g.push_state Rubinius::AST::ClosedScope.new(line)
+
+    g.state.push_name name
+
+    block_offset = is_macro ? 1 : 0
+
+    total = 0
+    min_reqs = nil
+    reqs = 0
+    defs = 0
+    names = []
+    splatted = false
+
+    resolved = branches.collect do |pats, meth|
+      segs = segments(pats[1])
+
+      min_reqs ||= segs[0].size
+      min_reqs = [min_reqs, segs[0].size].min
+      reqs = [reqs, segs[0].size].max
+      defs = [defs, segs[1].size].max
+      total = [reqs + defs, total].max
+
+      names += pats[0].local_names
+      pats[1].each do |p|
+        names += p.local_names
+      end
+
+      splatted = true if segs[2]
+
+      [pats[0], segs, meth]
+    end
+
+    names.uniq!
+
+    if splatted
+      g.splat_index = block_offset + reqs + defs
+    end
+
+    total += block_offset
+
+    total.times do |n|
+      names.unshift("arg:" + n.to_s)
+    end
+
+    locals = {}
+    names.each do |n|
+      locals[n] = g.state.scope.new_local(n).reference
+    end
+
+    g.local_names = names
+    g.total_args = total
+    g.required_args = min_reqs
+    g.local_count = total + g.local_names.size
+
+    g.push_self
+    resolved.each do |recv, (reqs, defs, splat, block), meth|
+      skip = g.new_label
+      argmis = g.new_label
+
+      if reqs.size > min_reqs
+        g.passed_arg((reqs.size + block_offset) - 1)
+        g.gif skip
+      end
+
+      if match_self?(recv)
+        g.dup
+        recv.matches?(g)
+        g.gif skip
+      end
+
+      if splat
+        g.push_local(g.splat_index)
+        splat.pattern.deconstruct(g)
+      end
+
+      if recv.bindings > 0
+        g.dup
+        recv.deconstruct(g, locals)
+      end
+
+      if block
+        if is_macro
+          g.push_local(0)
+          block.pattern.deconstruct(g, locals)
+        else
+          g.push_block_arg
+          block.deconstruct(g, locals)
+        end
+      end
+
+      reqs.each_with_index do |a, i|
+        g.push_local(i + block_offset)
+
+        if a.bindings > 0
+          g.dup
+          a.matches?(g)
+          g.gif argmis
+          a.deconstruct(g, locals)
+        else
+          a.matches?(g)
+          g.gif skip
+        end
+      end
+
+      defs.each_with_index do |d, i|
+        passed = g.new_label
+        decons = g.new_label
+
+        num = reqs.size + i + block_offset
+        g.passed_arg num
+        g.git passed
+
+        d.default.compile(g)
+        g.set_local num
+        g.goto decons
+
+        passed.set!
+        g.push_local num
+
+        decons.set!
+        d.deconstruct(g)
+      end
+
+      meth.compile(g)
+      g.goto done
+
+      argmis.set!
+      g.pop
+
+      skip.set!
+    end
+
+    g.invoke_primitive :vm_check_super_callable, 0
+    g.gif mismatch
+
+    g.push_block
+    if g.state.super?
+      g.zsuper g.state.super.name
+    else
+      g.zsuper nil
+    end
+    g.goto done
+
+    mismatch.set!
+    g.push_self
+    g.push_cpath_top
+    g.find_const :MethodFail
+    g.push_literal name
+    g.send :new, 1
+    g.allow_private
+    g.send :raise, 1
+
+    done.set!
+    g.state.pop_name
+    g.ret
+    g.close
+    g.pop_state
+    g.use_detected
+    g.encode
+
+    g.package Rubinius::CompiledMethod
+  end
+
+  def self.add_method(target, name, branches, static_scope, visibility = :public, is_macro = false)
+    cm = build_method(name, branches, is_macro)
+
+    unless static_scope
+      static_scope = Rubinius::StaticScope.new(
+        self,
+        Rubinius::StaticScope.new(Object)
+      )
+    end
+
+    cm.scope = static_scope
+
+    Rubinius.add_method name, cm, target, visibility
+  end
+
+  def self.compare_heads(xs, ys)
+    return 1 if xs.size > ys.size
+    return -1 if xs.size < ys.size
+
+    xs.zip(ys) do |x, y|
+      cmp = x <=> y
+      return cmp unless cmp == 0
+    end
+
+    0
+  end
+
+  def self.equivalent?(xs, ys)
+    xs.zip(ys) do |x, y|
+      return false unless x =~ y
+    end
+
+    true
+  end
+
+  def self.insert_method(new, branches)
+    (nr, na), nb = new
+    if nr.respond_to?(:<=>)
+      branches.each_with_index do |branch, i|
+        (r, a), b = branch
+        case compare_heads([nr] + na, [r] + a)
+        when 1
+          return branches.insert(i, new)
+        when 0
+          if equivalent?([nr] + na, [r] + a)
+            branches[i] = new
+            return branches
+          end
+        end
+      end
+    end
+
+    branches << new
+  end
+end