bud 0.0.8 → 0.1.0.pre1

data/lib/bud/rewrite.rb

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'ruby2ruby'
 
 class RuleRewriter < Ruby2Ruby # :nodoc: all
   attr_accessor :rule_indx, :rules, :depends
@@ -7,12 +8,12 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     @bud_instance = bud_instance
     @ops = {:<< => 1, :< => 1, :<= => 1}
     @monotonic_whitelist = {
-      :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1, :~ => 1,
-      :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
-      :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
-      :schema => 1, :cols => 1, :key_cols => 1, :val_cols => 1,
-      :payloads => 1, :tabname => 1, :+@ => 1
-    }
+          :== => 1, :+ => 1, :<= => 1, :- => 1, :< => 1, :> => 1,
+          :* => 1, :pairs => 1, :matches => 1, :combos => 1, :flatten => 1,
+          :lefts => 1, :rights => 1, :map => 1, :flat_map => 1, :pro => 1,
+          :cols => 1,  :key_cols => 1, :val_cols => 1, :payloads => 1, :~ => 1,
+          :lambda => 1, :tabname => 1
+      }
     @temp_ops = {:-@ => 1, :~ => 1, :+@ => 1}
     @tables = {}
     @nm = false
@@ -23,33 +24,60 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
     super()
   end
 
-  def call_is_attr_deref?(recv, op)
-    if recv.first == :call and @bud_instance.tables.has_key? recv[2]
-      cols = @bud_instance.tables[recv[2]].cols
-      return true if cols and cols.include? op
+  $not_id = [:not_coll_id]
+  def resolve(obj, prefix, name)
+    qn = prefix ? prefix + "." + name.to_s : name.to_s
+    return [:collection, qn, obj.tables[name]]  if obj.tables.has_key? name
+
+    # does name refer to an import name?
+    iobj = obj.import_instance name
+    return [:import, qn, iobj] if iobj and iobj.respond_to? :tables
+
+    return $not_id
+  end
+
+  def exp_id_type(recv, name, args) # call only if sexp type is :call
+    return $not_id unless args.size == 1
+    ty = $not_id
+    if recv
+      if recv.first == :call
+        # possibly nested reference.
+        rty, rqn, robj = exp_id_type(recv[1], recv[2], recv[3]) # rty, rqn, .. = receiver's type, qual name etc.
+        ty = resolve(robj, rqn, name) if rty == :import
+      end
+    else
+      # plain, un-prefixed name. See if it refers to a collection or import spec
+      ty = resolve(@bud_instance, nil, name)
     end
-    return false
+    ty
   end
 
   def process_call(exp)
     recv, op, args = exp
-    if recv.nil? and args == s(:arglist) and @collect
-      do_table(exp)
-    elsif @ops[op] and @context[1] == :block and @context.length == 4
+    if @ops[op] and @context[1] == :block and @context.length == 4
       # NB: context.length is 4 when see a method call at the top-level of a
       # :defn block -- this is where we expect Bloom statements to appear
       do_rule(exp)
     else
-      if op == :notin
-        # a <= b.m1.m2.notin(c, ... ) ..
-        # b contributes positively to a, but c contributes negatively.
-        notintab = args[1][2].to_s # args == (:arglist (:call, nil, :c, ...))
-        @tables[notintab] = true
-      elsif recv and recv.class == Sexp
+      ty = :not_coll_id
+      ty, qn, obj = exp_id_type(recv, op, args) # qn = qualified name, obj is the corresponding object
+      if ty == :collection
+        @tables[qn] = @nm if @collect
+      #elsif ty == :import .. do nothing
+      elsif ty == :not_coll_id
+        # check if receiver is a collection, and further if the current exp represents a field lookup
+        op_is_field_name = false
+        if recv and recv.first == :call
+          rty, _, robj = exp_id_type(recv[1], recv[2], recv[3])
+          if rty == :collection
+            cols = robj.cols
+            op_is_field_name =  true if cols and cols.include?(op)
+          end
+        end
         # for CALM analysis, mark deletion rules as non-monotonic
         @nm = true if op == :-@
         # don't worry about monotone ops, table names, table.attr calls, or accessors of iterator variables
-        unless @monotonic_whitelist[op] or @bud_instance.tables.has_key? op or call_is_attr_deref?(recv, op) or recv.first == :lvar
+        unless @monotonic_whitelist[op] or op_is_field_name or (recv and recv.first == :lvar) or op.to_s.start_with?("__")
           @nm = true
         end
       end
@@ -62,6 +90,18 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
 
   def collect_rhs(exp)
     @collect = true
+    # rewrite constant array expressions to lambdas
+    if exp[0] and exp[0] == :arglist
+      # the <= case
+      if exp[1] and exp[1][0] == :array
+        exp = s(exp[0], s(:iter, s(:call, nil, :lambda, s(:arglist)), nil, exp[1]))
+      # the superator case
+      elsif exp[1] and exp[1][0] == :call \
+        and exp[1][1] and exp[1][1][0] and exp[1][1][0] == :array \
+        and exp[1][2] and (exp[1][2] == :+@ or exp[1][2] == :-@ or exp[1][2] == :~@)
+        exp = s(exp[0], s(exp[1][0], s(:iter, s(:call, nil, :lambda, s(:arglist)), nil, exp[1][1]), exp[1][2], exp[1][3]))
+      end
+    end
     rhs = process exp
     @collect = false
     return rhs
@@ -82,38 +122,36 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       op = op.to_s
     end
 
-    @rules << [@rule_indx, lhs, op, rule_txt, rule_txt_orig]
+    @rules << [@bud_instance, @rule_indx, lhs, op, rule_txt, rule_txt_orig]
     @tables.each_pair do |t, non_monotonic|
-      @depends << [@rule_indx, lhs, op, t, non_monotonic]
+      @depends << [@bud_instance, @rule_indx, lhs, op, t, non_monotonic]
     end
 
     reset_instance_vars
     @rule_indx += 1
   end
 
-  def do_table(exp)
-    t = exp[1].to_s
-    # If we're called on a "table-like" part of the AST that doesn't correspond
-    # to an extant table, ignore it.
-    @tables[t] = @nm if @bud_instance.tables.has_key? t.to_sym and not @tables[t]
-    drain(exp)
-    return t
-  end
-
   def do_rule(exp)
     lhs = process exp[0]
     op = exp[1]
-    pro_rules = map2pro(exp[2])
+    rhs_ast = map2pro(exp[2])
+
+    # Remove the outer s(:arglist) from the rhs AST. An AST subtree rooted with
+    # s(:arglist) is not really sensible and it causes Ruby2Ruby < 1.3.1 to
+    # misbehave (for example, s(:arglist, s(:hash, ...)) is misparsed.
+    raise Bud::CompileError unless rhs_ast.sexp_type == :arglist
+    #rhs_ast = rhs_ast[1]
+
     if @bud_instance.options[:no_attr_rewrite]
-      rhs = collect_rhs(pro_rules)
+      rhs = collect_rhs(rhs_ast)
       rhs_pos = rhs
     else
       # need a deep copy of the rules so we can keep a version without AttrName
       # Rewrite
-      pro_rules2 = Marshal.load(Marshal.dump(pro_rules))
-      rhs = collect_rhs(pro_rules)
+      rhs_ast_dup = Marshal.load(Marshal.dump(rhs_ast))
+      rhs = collect_rhs(rhs_ast)
       reset_instance_vars
-      rhs_pos = collect_rhs(AttrNameRewriter.new(@bud_instance).process(pro_rules2))
+      rhs_pos = collect_rhs(AttrNameRewriter.new(@bud_instance).process(rhs_ast_dup))
     end
     record_rule(lhs, op, rhs_pos, rhs)
     drain(exp)
@@ -123,12 +161,18 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   # to do this precisely (issue #225), so we just replace map calls liberally
   # and define Enumerable#pro as an alias for "map".
   def map2pro(exp)
+    # the non-superator case
     if exp[1] and exp[1][0] and exp[1][0] == :iter \
       and exp[1][1] and exp[1][1][1] and exp[1][1][1][0] == :call
       if exp[1][1][2] == :map
         exp[1][1][2] = :pro
       end
-    end
+    # the superator case
+    elsif exp[1] and exp[1][0] == :call and (exp[1][2] == :~@ or exp[1][2] == :+@ or exp[1][2] == :-@)
+      if exp[1][1] and exp[1][1][1] and exp[1][1][1][2] == :map
+        exp[1][1][1][2] = :pro
+      end
+    end  
     exp
   end
 
@@ -168,11 +212,18 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
         else
           raise Bud::CompileError, "nested redefinition of block variable \"#{exp[2][1]}\" not allowed" if @iterhash[exp[2][1]]
         end
-      elsif exp[2] and exp[2][0] == :masgn and not @collnames.empty? # join iter
-        next unless exp[2][1] and exp[2][1][0] == :array
-        @collnames.each_with_index do |c, i|
-          next unless exp[2][1][i+1] and exp[2][1][i+1][0] == :lasgn
-          @iterhash[exp[2][1][i+1][1]] = c
+      elsif exp[2] and exp[2][0] == :masgn and not @collnames.empty? # join or reduce iter
+        return unless exp[2][1] and exp[2][1][0] == :array
+        if exp[1][2] == :reduce
+          unless @collnames.length == 1
+            raise Bud::Error, "reduce should only one associated collection, but has #{@collnames.inspect}"
+          end
+          @iterhash[exp[2][1][2][1]] = @collnames.first
+        else #join
+          @collnames.each_with_index do |c, i|
+            next unless exp[2][1][i+1] and exp[2][1][i+1][0] == :lasgn
+            @iterhash[exp[2][1][i+1][1]] = c
+          end
         end
       end
     end
@@ -180,9 +231,23 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
     exp
   end
 
+  def register_scratch(name, schemahash)
+    # define a scratch with the name and schema in this rename block
+    hash, key_array, val_array = schemahash
+    key_array ||= []
+    val_array ||= []
+    key_cols = key_array.map{|i| i[1] if i.class <= Sexp}.compact
+    val_cols = val_array.map{|i| i[1] if i.class <= Sexp}.compact
+    @bud_instance.scratch(name, key_cols=>val_cols)
+  end
+
   def gather_collection_names(exp)
     if exp[0] == :call and exp[1].nil?
       @collnames << exp[2]
+    elsif exp[2] and exp[2] == :rename
+      arglist, namelit, schemahash = exp[3]
+      # and add name to @collnames
+      @collnames << namelit[1]
     else
       exp.each { |e| gather_collection_names(e) if e and e.class <= Sexp }
     end
@@ -191,6 +256,10 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
   def process_call(exp)
     call, recv, op, args = exp
 
+    if op == :rename
+      arglist, namelit, schemahash = args
+      register_scratch(namelit[1], schemahash)
+    end
     if recv and recv.class == Sexp and recv.first == :lvar and recv[1] and @iterhash[recv[1]]
       if @bud_instance.respond_to?(@iterhash[recv[1]])
         if @bud_instance.send(@iterhash[recv[1]]).class <= Bud::BudCollection
@@ -211,131 +280,6 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
   end
 end
 
-# Given a table of renames from x => y, replace all calls to "x" with calls to
-# "y" instead. We don't try to handle shadowing due to block variables: if a
-# block references a block variable that shadows an identifier in the rename
-# table, it should appear as an :lvar node rather than a :call, so we should be
-# okay.
-class CallRewriter < SexpProcessor # :nodoc: all
-  def initialize(rename_tbl)
-    super()
-    self.require_empty = false
-    self.expected = Sexp
-    @rename_tbl = rename_tbl
-  end
-
-  def process_call(exp)
-    tag, recv, meth_name, args = exp
-
-    if @rename_tbl.has_key? meth_name
-      meth_name = @rename_tbl[meth_name] # No need to deep-copy Symbol
-    end
-
-    recv = process(recv)
-    args = process(args)
-
-    s(tag, recv, meth_name, args)
-  end
-end
-
-# Rewrite qualified references to collections defined by an imported module. In
-# the AST, this looks like a tree of :call nodes. For example, a.b.c looks like:
-#
-#   (:call, (:call, (:call, nil, :a, args), :b, args), :c, args)
-#
-# If the import table contains [a][b], we want to rewrite this into a single
-# call to a__b__c, which matches how the corresponding Bloom collection will
-# be name-mangled. Note that we don't currently check that a__b__c (or a.b.c)
-# corresponds to an extant Bloom collection.
-class NestedRefRewriter < SexpProcessor # :nodoc: all
-  attr_accessor :did_work
-
-  def initialize(mod)
-    super()
-    self.require_empty = false
-    self.expected = Sexp
-
-    @import_tbl = NestedRefRewriter.build_import_table(mod)
-    @did_work = false
-  end
-
-  # If module Y imports Z as "z" and X includes Y, X can contain a reference
-  # to "z.foo". Hence, when expanding nested references in X, we want to merge
-  # the import tables of X and any modules that X includes; however, we can
-  # skip the Bud module, as well as any modules generated via the import
-  # system.
-  def self.build_import_table(mod)
-    child_tbl = mod.bud_import_table.clone
-    mod.modules.each do |m|
-      next if m == Bud
-      next if m.instance_variable_get('@bud_imported_module')
-
-      child_tbl = NestedRefRewriter.merge_import_table(child_tbl,
-                                                       m.bud_import_table)
-    end
-    child_tbl
-  end
-
-  def self.merge_import_table(old, new)
-    old ||= {}
-    old.merge(new) do |key, old_val, new_val|
-      NestedRefRewriter.merge_import_table(old_val, new_val)
-    end
-  end
-
-  def process_call(exp)
-    return exp if @import_tbl.empty?
-    tag, recv, meth_name, args = exp
-
-    catch :skip do
-      recv_stack = make_recv_stack(recv)
-      throw :skip unless recv_stack.length > 0
-
-      lookup_tbl = @import_tbl
-      new_meth_name = ""
-      until recv_stack.empty?
-        m = recv_stack.pop
-        throw :skip unless lookup_tbl.has_key? m
-
-        new_meth_name += "#{m}__"
-        lookup_tbl = lookup_tbl[m]
-      end
-
-      # Okay, apply the rewrite
-      @did_work = true
-      new_meth_name += meth_name.to_s
-      recv = nil
-      meth_name = new_meth_name.to_sym
-    end
-
-    recv = process(recv)
-    args = process(args)
-
-    s(tag, recv, meth_name, args)
-  end
-
-  private
-  def make_recv_stack(r)
-    rv = []
-
-    while true
-      break if r.nil?
-      # We can exit early if we see something unexpected
-      throw :skip unless r.sexp_type == :call
-
-      recv, meth_name, args = r.sexp_body
-      unless args.sexp_type == :arglist and args.sexp_body.length == 0
-        throw :skip
-      end
-
-      rv << meth_name
-      r = recv
-    end
-
-    return rv
-  end
-end
-
 # Look for temp declarations and remove the "temp" keyword, yielding code that
 # we can safely eval. We also record the set of "temp" collections we've seen,
 # and provide a helper method that returns the AST of a state block that
@@ -570,275 +514,3 @@ class DefnRenamer < SexpProcessor # :nodoc: all
   end
 end
 
-module ModuleRewriter # :nodoc: all
-  # Do the heavy-lifting to import the Bloom module "mod" into the class/module
-  # "import_site", bound to "local_name" at the import site. We implement this
-  # by converting the imported module into an AST and rewriting the AST like so:
-  #
-  #   (a) statements in the module that reference sub-modules are rewritten to
-  #       reference the mangled name of the submodule
-  #   (b) the module name is mangled to include the local bind name and the
-  #       import site
-  #   (c) instance method names are mangled to include the local bind name
-  #   (d) collection names are mangled to include the local bind name
-  #   (e) statements in the module are rewritten to reference the mangled names
-  #
-  # We then convert the rewritten AST back into Ruby source code using Ruby2Ruby
-  # and eval() it to define a new module. We return the name of that newly
-  # defined module; the caller can then use "include" to load the module into
-  # the import site. Note that additional rewrites are needed to ensure that
-  # code in the import site that accesses module contents does the right thing;
-  # see Bud#rewrite_local_methods.
-
-  @@with_id = 0 # upon initialize
-  def self.with_id
-    @@with_id
-  end
-
-  def self.incr_with_id
-    @@with_id += 1
-  end
-
-  def self.do_import(import_site, mod, local_name)
-    # ast_process_withs modifies its argument as a side-effect
-    # and returns a matching ast.
-    # hence we run it before the other rewrites.
-    ast = ast_process_withs(mod)
-    ast = ast_flatten_nested_refs(ast, mod)
-    ast = ast_process_temps(ast, mod)
-
-    ast, new_mod_name = ast_rename_module(ast, import_site, mod, local_name)
-    rename_tbl = {}
-    ast = ast_rename_methods(ast, local_name, rename_tbl)
-    ast = ast_rename_state(ast, local_name, rename_tbl)
-    ast = ast_update_refs(ast, rename_tbl)
-
-    str = Ruby2Ruby.new.process(ast)
-    rv = import_site.module_eval str
-    raise Bud::CompileError unless rv.nil?
-
-    # Set an instance variable to allow modules produced by the import/rewrite
-    # process to be distinguished from "normal" Ruby modules.
-    mod = import_site.module_eval new_mod_name
-    raise Bud::CompileError unless mod.class == Module
-    mod.instance_variable_set("@bud_imported_module", true)
-
-    return new_mod_name
-  end
-
-  def self.get_module_ast(mod)
-    raw_ast = get_raw_parse_tree(mod)
-    unless raw_ast.first == :module
-      raise Bud::CompileError, "import must be used with a Module"
-    end
-
-    return Unifier.new.process(raw_ast)
-  end
-
-  # Returns the AST for the given module (as a tree of Sexps). ParseTree
-  # provides native support for doing this, but we choose to do it ourselves. In
-  # ParseTree <= 3.0.7, the support is buggy; in later versions of ParseTree,
-  # the AST is returned in a different format than we expect. In particular, we
-  # expect that the methods from any modules included in the target module will
-  # be "inlined" into the dumped AST; ParseTree > 3.0.7 adds an "include"
-  # statement to the AST instead. In the long run we should probably adapt the
-  # module rewrite system to work with ParseTree > 3.0.7 and get rid of this
-  # code, but that will require further changes.
-  def self.get_raw_parse_tree(klass)
-    pt = RawParseTree.new(false)
-    klassname = klass.name
-    klassname = klass.to_s if klassname.empty? #("anon_" + Process.pid.to_s + "_" + klass.object_id.to_s) if klassname.empty
-    klassname = klassname.to_sym
-
-    code = if Class === klass then
-      sc = klass.superclass
-      sc_name = ((sc.nil? or sc.name.empty?) ? "nil" : sc.name).intern
-      [:class, klassname, [:const, sc_name]]
-    else
-      [:module, klassname]
-    end
-
-    method_names = klass.private_instance_methods false
-    # protected methods are included in instance_methods, go figure!
-
-    # Get the set of classes/modules that define instance methods we want to
-    # include in the result
-    relatives = klass.modules + [klass]
-    relatives.each do |r|
-      method_names += r.instance_methods false
-    end
-
-    # For each distinct method name, use the implementation that appears the
-    # furthest down in the inheritance hierarchy.
-    relatives.reverse!
-    method_names.uniq.sort.each do |m|
-      relatives.each do |r|
-        t = pt.parse_tree_for_method(r, m.to_sym)
-        if t != [nil]
-          code << t
-          break
-        end
-      end
-    end
-
-    klass.singleton_methods(false).sort.each do |m|
-      code << pt.parse_tree_for_method(klass, m.to_sym, true)
-    end
-
-    return code
-  end
-
-  # If this module imports a submodule and binds it to :x, references to x.t1
-  # need to be flattened to the mangled name of x.t1.
-  def self.ast_flatten_nested_refs(ast, mod)
-    NestedRefRewriter.new(mod).process(ast)
-  end
-
-  # Handle temp collections defined in the module's Bloom blocks.
-  def self.ast_process_temps(ast, mod)
-    t = TempExpander.new
-    ast = t.process(ast)
-
-    new_meth = t.get_state_meth(mod)
-    if new_meth
-      # Insert the new extra state method into the module's AST
-      ast << new_meth
-    end
-    return ast
-  end
-
-  def self.ast_mangle_with(w,klass)
-    r2r = Ruby2Ruby.new
-
-    while st = w.get_state_meth(klass)
-      # generate the module
-      tmpmod = Module.new
-
-      # add a state block to define a temp for the collection name
-      state_src = r2r.process(st)
-      tmpmod.module_eval(state_src)
-
-      # add a bloom block
-      bloom_blk = s(:defn, :__bloom__rules, s(:args), s(:scope, s(:block)))
-      inblk = bloom_blk[3][1]
-
-      # add in the rule that was in the "with" definition
-      newdefn = w.with_defns.pop
-      inblk << newdefn unless newdefn.nil?
-
-      # add in all the rules from the body of the "with" block
-      newrules = w.with_rules.pop
-      newrules.each_with_index do |ast, i|
-        inblk << ast unless i == 0
-      end
-      bloom_src = r2r.process(bloom_blk)
-
-      # eval all that Ruby we generated and import new Module into our code
-      tmpmod.module_eval(bloom_src)
-      modname = "with__#{ModuleRewriter.with_id.to_s}"
-      klass.import tmpmod => modname.to_sym
-
-      ModuleRewriter.incr_with_id
-    end
-  end
-
-  def self.ast_process_withs(mod)
-      # strategy to handle withs:
-      # 1) run WithExpander#process to delete the "with" blocks and extract their contents
-      # 2) get the state and rules mangled appropriately into modules
-      # 3) run mod.import on each
-      # 4) call self.get_raw_parse_tree on the result to generate an AST
-
-      ast = get_module_ast(mod)
-      w = WithExpander.new
-      ast = w.process(ast)
-      mod_s, name_s, blocks = ast[0], ast[1], ast[2..-1]
-      tag, name, args, scope = blocks[0]
-
-      self.ast_mangle_with(w, mod)
-
-      retval = Unifier.new.process(self.get_raw_parse_tree(mod))
-      return retval
-      # return s(mod_s, name_s, *blocks)
-  end
-
-  # Rename the given module's name to be a mangle of import site, imported
-  # module, and local bind name. We also rename all the instance methods defined
-  # in the module to include the local bind name (including the special "state",
-  # "bootstrap", and "bloom" methods).
-  def self.ast_rename_module(ast, importer, importee, local_name)
-    mod_name = ast.sexp_body.first
-    raise Bud::CompileError if mod_name.to_s != importee.to_s
-
-    # If the importer or importee modules are nested inside an outer module,
-    # strip off the outer module name before using for name mangling purposes
-    importer_name = Module.get_class_name(importer)
-    importee_name = Module.get_class_name(importee)
-    new_name = "#{importer_name}__#{importee_name}__#{local_name}"
-    ast[1] = new_name.to_sym
-
-    # XXX: it would be nice to return a Module, rather than a string containing
-    # the Module's name. Unfortunately, I can't see how to do that.
-    return [ast, new_name]
-  end
-
-  def self.ast_rename_methods(ast, local_name, rename_tbl)
-    DefnRenamer.new(local_name, rename_tbl).process(ast)
-  end
-
-  # Mangle the names of all the collections defined in state blocks found in the
-  # given module's AST. Returns a table mapping old => new names.
-  def self.ast_rename_state(ast, local_name, rename_tbl)
-    # Find all the state blocks in the AST
-    raise Bud::CompileError unless ast.sexp_type == :module
-
-    ast.sexp_body.each do |b|
-      next unless b.class <= Sexp
-      next if b.sexp_type != :defn
-
-      def_name, args, scope = b.sexp_body
-      next unless /^__state\d+__/.match def_name.to_s
-
-      raise Bud::CompileError unless scope.sexp_type == :scope
-      state_block = scope.sexp_body.first
-      raise Bud::CompileError unless state_block.sexp_type == :block
-      next unless state_block.sexp_body
-
-      # Look for collection definition statements inside the block
-      state_block.sexp_body.each do |e|
-        raise Bud::CompileError unless e.sexp_type == :call
-
-        recv, meth_name, args = e.sexp_body
-        raise Bud::CompileError unless args.sexp_type == :arglist
-
-        if meth_name == :interface
-          tbl_name_node = args.sexp_body[1]
-        else
-          tbl_name_node = args.sexp_body[0]
-        end
-
-        if tbl_name_node.nil? or tbl_name_node.sexp_type != :lit
-          raise Bud::CompileError, "syntax error in state block"
-        end
-        tbl_name = tbl_name_node.sexp_body.first
-
-        new_tbl_name = "#{local_name}__#{tbl_name}".to_sym
-        rename_tbl[tbl_name] = new_tbl_name
-
-        tbl_name_node[1] = new_tbl_name
-      end
-    end
-
-    return ast
-  end
-
-  def self.ast_update_refs(ast, rename_tbl)
-    CallRewriter.new(rename_tbl).process(ast)
-  end
-
-  # Return a list of symbols containing the names of def blocks containing Bloom
-  # rules in the given module and all of its ancestors.
-  def self.get_rule_defs(mod)
-    mod.instance_methods.select {|m| m =~ /^__bloom__.+$/}
-  end
-end

data/lib/bud/server.rb

@@ -38,11 +38,12 @@ class Bud::BudServer < EM::Connection #:nodoc: all
 
     begin
       @bud.tick_internal if @bud.running_async
-    rescue Exception
+    rescue Exception => e
       # If we raise an exception here, EM dies, which causes problems (e.g.,
       # other Bud instances in the same process will crash). Ignoring the
       # error isn't best though -- we should do better (#74).
-      puts "Exception handling network messages: #{$!}"
+      puts "Exception handling network messages: #{e}"
+      puts e.backtrace
       puts "Inbound messages:"
       @bud.inbound.each do |chn_name, t|
         puts "    #{t.inspect} (channel: #{chn_name})"