atomy 0.1.1 → 0.6.3

data/lib/macros.rb

@@ -1,317 +0,0 @@
-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

@@ -1,261 +0,0 @@
-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