bud 0.9.4 → 0.9.9

data/lib/bud/rebl.rb

@@ -4,7 +4,9 @@ require 'rubygems'
 require 'bud'
 require 'abbrev'
 require 'tempfile'
-TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic", "sync", "store"]
+
+TABLE_TYPES = ["table", "scratch", "channel", "loopback", "periodic",
+               "sync", "store", "interface", "interfaces"]
 
 # The class to which rebl adds user-specified rules and declarations.
 class ReblBase
@@ -93,10 +95,13 @@ class ReblShell
 
   # One step of the rebl shell loop: processes one rebl shell line from stdin
   # and returns.  May raise an Exception.
-  def self.rebl_loop(lib,noreadline=false)
+  def self.rebl_loop(lib, noreadline=false)
     begin
-      line = Readline::readline('rebl> ') unless noreadline
-      line = gets if noreadline
+      if noreadline
+        line = gets
+      else
+        line = Readline::readline('rebl> ')
+      end
       do_exit if line.nil?
       line.strip!
       return if line.empty?
@@ -110,7 +115,7 @@ class ReblShell
         else
           puts "invalid command or ambiguous command prefix"
         end
-      elsif TABLE_TYPES.include? split_line[0]
+      elsif is_collection? split_line[0]
         # Collection
         lib.add_collection(line)
       else
@@ -186,6 +191,12 @@ class ReblShell
     puts "\n" + @@exit_message
     exit!
   end
+
+  # Checks if a given string refers to a collection type (one of the builtin
+  # collection types or a wrapper_name for a lattice).
+  def self.is_collection?(c)
+    TABLE_TYPES.include?(c) || Bud::Lattice.lattice_kinds.has_key?(c.to_sym)
+  end
 end
 
 
@@ -196,8 +207,8 @@ class LibRebl
   attr_accessor :rules, :state
   attr_reader :ip, :port, :rebl_class_inst
   @@builtin_tables = [:stdio, :periodics_tbl, :halt, :localtick,
-                      :t_depends, :t_cycle, :t_provides, :t_rules,
-                      :t_stratum, :t_underspecified,
+                      :t_depends, :t_cycle, :t_provides, :t_rule_stratum,
+                      :t_rules, :t_stratum, :t_underspecified,
                       :t_table_info, :t_table_schema, :rebl_breakpoint]
   @@classid = 0
 
@@ -233,11 +244,14 @@ class LibRebl
   def dump(c)
     if c.nil?
       puts "Error: dump must be passed a collection name"
-    elsif not @rebl_class_inst.tables.has_key? c.to_sym
-      puts "Error: non-existent collection \"#{c}\""
-    else
+    elsif @rebl_class_inst.tables.has_key? c.to_sym
       tups = @rebl_class_inst.tables[c.to_sym].to_a.sort
       puts(tups.empty? ? "(empty)" : tups.sort.map{|t| "#{t}"}.join("\n"))
+    elsif @rebl_class_inst.lattices.has_key? c.to_sym
+      val = @rebl_class_inst.lattices[c.to_sym].current_value
+      puts val.inspect
+    else
+      puts "Error: non-existent collection \"#{c}\""
     end
   end
 
@@ -334,11 +348,15 @@ class LibRebl
                                        end)
       @rebl_class_inst.dbm_tables.merge! @old_inst.dbm_tables
       @rebl_class_inst.zk_tables.merge! @old_inst.zk_tables
+      @rebl_class_inst.lattices.merge! @old_inst.lattices
 
       # Fix the bud instance pointers from copied tables.
       @rebl_class_inst.tables.each_value do |v|
         v.bud_instance = @rebl_class_inst
       end
+      @rebl_class_inst.lattices.each_value do |v|
+        v.bud_instance = @rebl_class_inst
+      end
     end
 
     # Run lazily in background, shutting down old instance.

data/lib/bud/rewrite.rb

@@ -1,27 +1,26 @@
 require 'rubygems'
-require 'ruby2ruby'
-require 'set'
 
 class RuleRewriter < Ruby2Ruby # :nodoc: all
-  attr_accessor :rule_indx, :rules, :depends
+  attr_accessor :rule_idx, :rules, :depends
 
-  OP_LIST = Set.new([:<<, :<, :<=])
-  TEMP_OP_LIST = Set.new([:-@, :~, :+@])
-  MONOTONE_WHITELIST = Set.new([:==, :+, :<=, :-, :<, :>, :*, :~,
-                                :pairs, :matches, :combos, :flatten,
-                                :lefts, :rights, :map, :flat_map, :pro,
-                                :cols, :key_cols, :val_cols, :payloads, :lambda,
-                                :tabname, :ip_port, :port, :ip, :int_ip_port])
+  OP_LIST = [:<<, :<, :<=].to_set
+  TEMP_OP_LIST = [:-@, :~, :+@].to_set
+  MONOTONE_WHITELIST = [:==, :+, :<=, :-, :<, :>, :*, :~, :+@,
+                        :pairs, :matches, :combos, :flatten, :new,
+                        :lefts, :rights, :map, :flat_map, :pro, :merge,
+                        :schema, :cols, :key_cols, :val_cols, :payloads, :lambda,
+                        :tabname, :current_value].to_set
 
-  def initialize(seed, bud_instance)
+  def initialize(bud_instance, rule_idx)
     @bud_instance = bud_instance
     @tables = {}
     @nm = false
-    @rule_indx = seed
+    @rule_idx = rule_idx
     @collect = false
     @rules = []
     @depends = []
-    @nm_funcs_called = false
+    @iter_stack = []
+    @refs_in_body = Set.new
     super()
   end
 
@@ -29,6 +28,7 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   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
+    return [:lattice, qn, obj.lattices[name]] if obj.lattices.has_key? name
 
     # does name refer to an import name?
     iobj = obj.import_instance name
@@ -38,12 +38,13 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   end
 
   def exp_id_type(recv, name, args) # call only if sexp type is :call
-    return $not_id unless args.size == 1
+    return $not_id unless args.empty?
     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.
+        # possibly nested reference
+        # rty, rqn, .. = receiver's type, qual name etc.
+        rty, rqn, robj = exp_id_type(recv[1], recv[2], recv[3..-1])
         ty = resolve(robj, rqn, name) if rty == :import
       end
     else
@@ -56,27 +57,94 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   def call_to_id(exp)
     # convert a series of nested calls, a sexp of the form
     #   s(:call,
-    #       s(:call, s(:call, nil, :a, s(:arglist)), :b, s(:arglist)),
-    #         :bar ,
-    #         s(:arglist)))
+    #       s(:call, s(:call, nil, :a), :b),
+    #         :bar))
     # to the string "a.b.bar"
-    raise "Malformed exp: #{exp}" unless (exp[0] == :call)
-    _, recv, op, args = exp
+    raise Bud::CompileError, "malformed expression: #{exp}" unless exp.sexp_type == :call
+    _, recv, op = exp
     return recv.nil? ? op.to_s : call_to_id(recv) + "." + op.to_s
   end
 
+  # We want to distinguish between collection dependencies that occur in
+  # top-level expressions versus collections that are referenced inside rule
+  # bodies. We just want to set a flag when processing the :iter body, but
+  # annoyingly it seems that is hard to do without duplicating the
+  # implementation of process_iter().
+  #
+  # XXX: the whole RuleRewriter approach is wrong because it conflates
+  # converting ASTs to strings with doing analysis on ASTs. Those should be
+  # split into two separate passes.
+  def process_iter(exp)
+    # first field of exp is tag; shift it
+    exp.shift
+    iter = process exp.shift
+    args = exp.shift
+
+    @iter_stack.push(true)
+    body = exp.empty? ? nil : process(exp.shift)
+    @iter_stack.pop
+
+    do_process_iter(iter, args, body)
+  end
+
+  def do_process_iter(iter, args, body)
+    args = case args
+           when 0 then
+             " ||"
+           else
+             a = process(args)[1..-2]
+             a = " |#{a}|" unless a.empty?
+             a
+           end
+
+    b, e = if iter == "END" then
+             [ "{", "}" ]
+           else
+             [ "do", "end" ]
+           end
+
+    iter.sub!(/\(\)$/, '')
+
+    # REFACTOR: ugh
+    result = []
+    result << "#{iter} {"
+    result << args
+    if body then
+      result << " #{body.strip} "
+    else
+      result << ' '
+    end
+    result << "}"
+    result = result.join
+    return result if result !~ /\n/ and result.size < LINE_LENGTH
+
+    result = []
+    result << "#{iter} #{b}"
+    result << args
+    result << "\n"
+    if body then
+      result << indent(body.strip)
+      result << "\n"
+    end
+    result << e
+    result.join
+  end
+
   def process_call(exp)
-    recv, op, args = exp
-    if OP_LIST.include?(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
+    tag, recv, op, *args = exp
+    if OP_LIST.include?(op) and @context[1] == :defn and @context.length == 2
+      # NB: context.length is 2 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)
     elsif op == :notin
       # Special case. In the rule "z <= x.notin(y)", z depends positively on x,
       # but negatively on y. See further explanation in the "else" section for
       # why this is a special case.
-      notintab = call_to_id(args[1])   # args expected to be of the form (:arglist (:call nil :y ...))
-      @tables[notintab.to_s] = true    # "true" denotes non-monotonic dependency
+      if args.first.sexp_type != :call
+        raise Bud::CompileError, "illegal argument to notin: #{args.first}"
+      end
+      notintab = call_to_id(args[0])   # args expected to be of the form (:call nil :y ...)
+      @tables[notintab] = true    # "true" denotes non-monotonic dependency
       super
     else
       # Parse a call of the form a.b.c.foo
@@ -88,15 +156,16 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       # a.b.c.notin(d.e.f), we register a non-monotonic dependency of lhs on
       # "d.e.f", not with "a.b.c"
       ty, qn, _ = exp_id_type(recv, op, args) # qn = qualified name
-      if ty == :collection
+      if ty == :collection or ty == :lattice
         (@tables[qn] = @nm if @collect) unless @tables[qn]
+        @refs_in_body << qn unless @iter_stack.empty?
       #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])
+          rty, _, robj = exp_id_type(recv[1], recv[2], recv[3..-1])
           if rty == :collection
             cols = robj.cols
             op_is_field_name = true if cols and cols.include?(op)
@@ -104,18 +173,14 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
         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
         if recv
-          # Don't worry about monotone ops, table names, table.attr calls, or
-          # accessors of iterator variables
           unless RuleRewriter.is_monotone(op) or op_is_field_name or
                  recv.first == :lvar or op.to_s.start_with?("__")
             @nm = true
           end
-        else
-          # Function called (implicit receiver = Bud instance) in a user-defined
-          # code block. Check if it is non-monotonic (like budtime, that
-          # produces a new value every time it is called)
-          @nm_funcs_called = true unless RuleRewriter.is_monotone(op)
         end
       end
       if TEMP_OP_LIST.include? op
@@ -126,25 +191,37 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   end
 
   def self.is_monotone(op)
-    MONOTONE_WHITELIST.include?(op)
+    MONOTONE_WHITELIST.include?(op) ||
+      is_morphism(op) ||
+      Bud::Lattice.global_mfuncs.include?(op)
+  end
+
+  def self.is_morphism(op)
+    Bud::Lattice.global_morphs.include?(op)
   end
 
-  # Rewrite top-level rhs array literals to lambdas. During wiring, these are
-  # turned into coll_expr collections.
+  # Rewrite top-level rhs literal expressions into lambdas. During wiring, these
+  # are turned into coll_expr collections. For normal relational Bloom, the only
+  # literal we expect to see is an array literal, but lattices can be
+  # initialized with other kinds of literals (e.g., integers for lmax).
   def lambda_rewrite(rhs)
     # the <= case
-    if rhs[0] == :array
-      return s(:iter, s(:call, nil, :lambda, s(:arglist)), nil, rhs)
+    if is_rhs_literal(rhs[0])
+      return s(:iter, s(:call, nil, :lambda), s(:args), rhs)
     # the superator case
     elsif rhs[0] == :call \
-      and rhs[1] and rhs[1][0] and rhs[1][0] == :array \
+      and rhs[1] and rhs[1][0] and is_rhs_literal(rhs[1][0]) \
       and rhs[2] and (rhs[2] == :+@ or rhs[2] == :-@ or rhs[2] == :~@)
-      return s(rhs[0], s(:iter, s(:call, nil, :lambda, s(:arglist)), nil, rhs[1]), rhs[2], rhs[3])
+      return s(rhs[0], s(:iter, s(:call, nil, :lambda), s(:args), rhs[1]), rhs[2], *rhs[3..-1])
     else
       return rhs
     end
   end
 
+  def is_rhs_literal(e)
+    [:array, :hash, :lit].include? e
+  end
+
   def collect_rhs(exp)
     exp = lambda_rewrite(exp)
 
@@ -155,13 +232,13 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
   end
 
   def reset_instance_vars
+    @refs_in_body = Set.new
     @tables = {}
     @nm = false
-    @nm_funcs_called = false
     @temp_op = nil
   end
 
-  def record_rule(lhs, op, rhs_pos, rhs)
+  def record_rule(lhs, op, rhs_pos, rhs, unsafe_funcs_called)
     rule_txt_orig = "#{lhs} #{op} (#{rhs})"
     rule_txt = "#{lhs} #{op} (#{rhs_pos})"
     if op == :<
@@ -170,27 +247,26 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       op = op.to_s
     end
 
-    @rules << [@bud_instance, @rule_indx, lhs, op, rule_txt, rule_txt_orig, @nm_funcs_called]
+    @rules << [@bud_instance, @rule_idx, lhs, op, rule_txt,
+               rule_txt_orig, unsafe_funcs_called]
     @tables.each_pair do |t, nm|
-      @depends << [@bud_instance, @rule_indx, lhs, op, t, nm]
+      in_rule_body = @refs_in_body.include? t
+      @depends << [@bud_instance, @rule_idx, lhs, op, t, nm, in_rule_body]
     end
 
     reset_instance_vars
-    @rule_indx += 1
+    @rule_idx += 1
   end
 
   def do_rule(exp)
-    lhs = process exp[0]
-    op = exp[1]
-    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]
+    tag, lhs, op, rhs_ast = exp
+    lhs = process(lhs)
 
+    rhs_ast = MapRewriter.new.process(rhs_ast)
     rhs_ast = RenameRewriter.new(@bud_instance).process(rhs_ast)
+    rhs_ast = LatticeRefRewriter.new(@bud_instance).process(rhs_ast)
+    ufr = UnsafeFuncRewriter.new(@bud_instance)
+    rhs_ast = ufr.process(rhs_ast)
 
     if @bud_instance.options[:no_attr_rewrite]
       rhs = collect_rhs(rhs_ast)
@@ -203,35 +279,37 @@ class RuleRewriter < Ruby2Ruby # :nodoc: all
       reset_instance_vars
       rhs_pos = collect_rhs(AttrNameRewriter.new(@bud_instance).process(rhs_ast_dup))
     end
-    record_rule(lhs, op, rhs_pos, rhs)
+    record_rule(lhs, op, rhs_pos, rhs, ufr.unsafe_func_called)
     drain(exp)
   end
 
-  # We want to rewrite "map" calls on BudCollections to "pro" calls. It is hard
-  # 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
-    # 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
-
   def drain(exp)
     exp.shift until exp.empty?
     return ""
   end
 end
 
+# We want to rewrite "map" calls on BudCollections to "pro" calls. It is hard
+# to do this precisely (issue #225), so we just replace map calls liberally
+# and define Enumerable#pro as an alias for "map".
+class MapRewriter < SexpProcessor
+  def initialize
+    super
+    self.require_empty = false
+    self.expected = Sexp
+  end
+
+  def process_call(exp)
+    tag, recv, op, *args = exp
+
+    if op == :map and args.empty?
+      op = :pro
+    end
+
+    s(tag, process(recv), op, *(args.map{|a| process(a)}))
+  end
+end
+
 # Look for rename statements and define the necessary scratch collections
 class RenameRewriter < SexpProcessor
   def initialize(bud_instance)
@@ -252,14 +330,135 @@ class RenameRewriter < SexpProcessor
   end
 
   def process_call(exp)
-    call, recv, op, args = exp
+    tag, recv, op, *args = exp
 
     if op == :rename
-      arglist, namelit, schemahash = args
+      raise Bud::CompileError, "reduce takes two arguments" unless args.size == 2
+      namelit, schemahash = args
       register_scratch(namelit[1], schemahash)
     end
 
-    return s(call, process(recv), op, process(args))
+    return s(tag, process(recv), op, *(args.map{|a| process(a)}))
+  end
+end
+
+# Check for whether the rule invokes any "unsafe" functions (functions that
+# might return a different value every time they are called, e.g., budtime). The
+# test for "unsafe" functions is pretty naive: any function call with a nil
+# receiver is treated as unsafe unless it is belongs to a list of "safe"
+# functions (below) or it denotes a lattice identifier. In the latter case, the
+# rule is akin to an implicit join with the lattice, so we only rescan it on
+# deltas to the lattice (see "rescan_on_merge" in LatticeWrapper).
+#
+# Although this is called a rewriter, it doesn't modify the input AST.
+class UnsafeFuncRewriter < SexpProcessor
+  SAFE_FUNC_LIST = [:int_ip_port, :ip_port, :ip, :port].to_set
+
+  attr_reader :unsafe_func_called
+
+  def initialize(bud_instance)
+    super()
+    self.require_empty = false
+    self.expected = Sexp
+    @bud_instance = bud_instance
+    @unsafe_func_called = false
+    @elem_stack = []
+  end
+
+  def process_call(exp)
+    tag, recv, op, *args = exp
+
+    # We assume that unsafe funcs have a nil receiver (Bud instance is implicit
+    # receiver).
+    if recv.nil? and @elem_stack.size > 0
+      unless is_safe_func(op) || is_collection_name?(op)
+        @unsafe_func_called = true
+      end
+    end
+
+    return s(tag, process(recv), op, *(args.map{|a| process(a)}))
+  end
+
+  def process_iter(exp)
+    tag, recv, iter_args, body = exp
+    if (iter_args == 0)
+      iter_args = s(:args)
+    end
+    new_body = push_and_process(body)
+    return s(tag, process(recv), process(iter_args), new_body)
+  end
+
+  def push_and_process(exp)
+    obj_id = exp.object_id
+    @elem_stack.push(obj_id)
+    rv = process(exp)
+    raise Bud::Error unless @elem_stack.pop == obj_id
+    return rv
+  end
+
+  def is_collection_name?(op)
+    @bud_instance.tables.has_key?(op.to_sym) || @bud_instance.lattices.has_key?(op.to_sym)
+  end
+
+  def is_safe_func(op)
+    SAFE_FUNC_LIST.include? op
+  end
+end
+
+# Rewrite references to lattice identifiers that appear in rule bodies. A
+# reference to a lattice identifier returns the associated lattice wrapper. When
+# the identifier appears at the top-level of the rule RHS, that is fine (since
+# we want the wrapper to do wiring). But for references that appear inside rule
+# bodies, we want to instead fetch the current value associated with the lattice
+# wrapper.
+class LatticeRefRewriter < SexpProcessor
+  def initialize(bud_instance)
+    super()
+    self.require_empty = false
+    self.expected = Sexp
+    @bud_instance = bud_instance
+    @elem_stack = []
+  end
+
+  def process_iter(exp)
+    tag, recv, iter_args, body = exp
+    new_body = push_and_process(body)
+    if (iter_args == 0)
+      iter_args = s(:args)
+    end
+    return s(tag, process(recv), process(iter_args), new_body)
+  end
+
+  def process_array(exp)
+    new_body = exp.sexp_body.map {|t| push_and_process(t)}
+    return s(:array, *new_body)
+  end
+
+  def process_hash(exp)
+    new_body = exp.sexp_body.map {|t| push_and_process(t)}
+    return s(:hash, *new_body)
+  end
+
+  def process_call(exp)
+    tag, recv, op, *args = exp
+
+    if recv.nil? and args.empty? and is_lattice?(op) and @elem_stack.size > 0
+      return s(:call, exp, :current_value)
+    else
+      return s(tag, process(recv), op, *(args.map{|a| process(a)}))
+    end
+  end
+
+  def push_and_process(exp)
+    obj_id = exp.object_id
+    @elem_stack.push(obj_id)
+    rv = process(exp)
+    raise Bud::Error unless @elem_stack.pop == obj_id
+    return rv
+  end
+
+  def is_lattice?(op)
+    @bud_instance.lattices.has_key? op.to_sym
   end
 end
 
@@ -278,32 +477,43 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
   # iter vars
   def process_iter(exp)
     if exp[1] and exp[1][0] == :call
+      return exp unless exp[2]
       gather_collection_names(exp[1])
+      meth_name = exp[1][2]
 
       # now find iter vars and match up
-      if exp[2] and exp[2][0] == :lasgn and @collnames.size == 1 #single-table iter
-        raise Bud::CompileError, "nested redefinition of block variable \"#{exp[2][1]}\" not allowed" if @iterhash[exp[2][1]]
-        @iterhash[exp[2][1]] = @collnames[0]
-      elsif exp[2] and exp[2][0] == :lasgn and @collnames.size > 1 and exp[1] # join iter with lefts/rights
-        case exp[1][2]
+      if exp[2][0] == :args and @collnames.size == 1 # single-table iter
+        if @iterhash[exp[2][1]]
+          raise Bud::CompileError, "redefinition of block variable \"#{exp[2][1]}\" not allowed"
+        end
+
+        # XXX: The BudChannel#payloads method assigns the correct schema to
+        # tuples that pass through it (i.e., it omits the location specifier);
+        # hence we don't want to apply the location rewrite to the code block
+        # that is passed to payloads(). This is a dirty hack.
+        unless meth_name == :payloads
+          @iterhash[exp[2][1]] = @collnames[0]
+        end
+      elsif exp[2][0] == :args and not @collnames.empty? # join iter with lefts/rights
+        case meth_name
         when :lefts
           @iterhash[exp[2][1]] = @collnames[0]
         when :rights
           @iterhash[exp[2][1]] = @collnames[1]
-        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 or reduce iter
-        return unless exp[2][1] and exp[2][1][0] == :array
-        if exp[1][2] == :reduce
+        when :reduce
           unless @collnames.length == 1
-            raise Bud::Error, "reduce should only have one associated collection, but has #{@collnames.inspect}"
+            raise Bud::CompileError, "reduce should only have 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
+          @iterhash[exp[2][1]] = @collnames[0]
+        else
+          # join
+          if @iterhash[exp[2][1]]
+            raise Bud::CompileError, "redefinition of block variable \"#{exp[2][1]}\" not allowed"
+          end
+
+          @collnames.each_with_index do |c,i|
+            next unless exp[2][i+1]
+            @iterhash[exp[2][i+1]] = c
           end
         end
       end
@@ -313,36 +523,43 @@ class AttrNameRewriter < SexpProcessor # :nodoc: all
   end
 
   def gather_collection_names(exp)
-    if exp[0] == :call and exp[1].nil?
+    # We expect a reference to a collection name to look like a function call
+    # (nil receiver) with no arguments.
+    if exp.sexp_type == :call and exp[1].nil? and exp.length == 3
       @collnames << exp[2]
-    elsif exp[2] and exp[2] == :rename
-      arglist, namelit, schemahash = exp[3]
+    elsif exp.sexp_type == :call and exp[2] == :rename
+      namelit = exp[3]
       @collnames << namelit[1]
+    elsif exp.sexp_type == :call and [:group, :argagg].include?(exp[2])
+      # For grouping and argagg expressions, only look at the receiver (the
+      # collection we're grouping on); otherwise, we might mistakenly think some
+      # of the arguments to the grouping operation are collection names.
+      gather_collection_names(exp[1])
     else
-      exp.each { |e| gather_collection_names(e) if e and e.class <= Sexp }
+      exp.each { |e| gather_collection_names(e) if e.class <= Sexp }
     end
   end
 
   def process_call(exp)
-    call, recv, op, args = exp
+    call, recv, op, *args = exp
 
-    if recv and recv.class == Sexp and recv.first == :lvar and recv[1] and @iterhash[recv[1]]
+    if recv.class == Sexp and recv.sexp_type == :lvar and @iterhash[recv[1]]
       if @bud_instance.respond_to?(@iterhash[recv[1]])
         if @bud_instance.send(@iterhash[recv[1]]).class <= Bud::BudCollection
           cols = @bud_instance.send(@iterhash[recv[1]]).cols
           if op != :[] and @bud_instance.send(@iterhash[recv[1]]).respond_to?(op)
-            # if the op is an attribute name in the schema, col is its index
-            col = cols.index(op) unless cols.nil?
-            unless col.nil?
+            # if the op is an attribute name in the schema, col_idx is its index
+            col_idx = cols.index(op) unless cols.nil?
+            unless col_idx.nil?
               op = :[]
-              args = s(:arglist, s(:lit, col))
+              args = [s(:lit, col_idx)]
             end
           end
         end
-        return s(call, recv, op, args)
+        return s(call, recv, op, *args)
       end
     end
-    return s(call, process(recv), op, process(args))
+    return s(call, process(recv), op, *(args.map{|a| process(a)}))
   end
 end
 
@@ -354,7 +571,7 @@ class TempExpander < SexpProcessor # :nodoc: all
   attr_reader :tmp_tables
   attr_accessor :did_work
 
-  KEYWORD = :temp
+  TEMP_KEYWORD = :temp
 
   def initialize
     super()
@@ -365,71 +582,63 @@ class TempExpander < SexpProcessor # :nodoc: all
   end
 
   def process_defn(exp)
-    tag, name, args, scope = exp
-    if name.to_s =~ /^__bloom__.+/
-      block = scope[1]
-
-      block.each_with_index do |n,i|
-        if i == 0
-          raise Bud::CompileError if n != :block
-          next
-        end
-
-        # temp declarations are misparsed if the RHS contains certain constructs
-        # (e.g., group, "do |f| ... end" rather than "{|f| ... }").  Rewrite to
-        # correct the misparsing.
-        if n.sexp_type == :iter
-          iter_body = n.sexp_body
-          new_n = fix_temp_decl(iter_body)
-          unless new_n.nil?
-            block[i] = n = new_n
-            @did_work = true
-          end
-        end
-
-        _, recv, meth, meth_args = n
-        if meth == KEYWORD and recv.nil?
-          block[i] = rewrite_me(n)
+    tag, name, args, *body = exp
+    return exp unless name.to_s =~ /^__bloom__.+/
+
+    body.each_with_index do |n,i|
+      # temp declarations are misparsed if the RHS contains certain constructs
+      # (e.g., group, "do |f| ... end" rather than "{|f| ... }").  Rewrite to
+      # correct the misparsing.
+      if n.sexp_type == :iter
+        iter_body = n.sexp_body
+        new_n = fix_temp_decl(iter_body)
+        unless new_n.nil?
+          body[i] = n = new_n
           @did_work = true
         end
       end
+
+      _, recv, meth, meth_args = n
+      if meth == TEMP_KEYWORD and recv.nil?
+        body[i] = rewrite_temp(n)
+        @did_work = true
+      end
     end
-    s(tag, name, args, scope)
+    s(tag, name, args, *body)
   end
 
   private
   def fix_temp_decl(iter_body)
     if iter_body.first.sexp_type == :call
       call_node = iter_body.first
+      _, recv, meth, *meth_args = call_node
 
-      _, recv, meth, meth_args = call_node
-      if meth == KEYWORD and recv.nil?
-        _, lhs, op, rhs = meth_args.sexp_body.first
-
-        old_rhs_body = rhs.sexp_body
-        new_rhs_body = [:iter]
-        new_rhs_body += old_rhs_body
-        new_rhs_body += iter_body[1..-1]
-        rhs[1] = Sexp.from_array(new_rhs_body)
+      if meth == TEMP_KEYWORD and recv.nil?
+        _, lhs, op, rhs = meth_args.first
+        new_rhs = s(:iter, rhs, *(iter_body[1..-1]))
+        meth_args.first[3] = new_rhs
         return call_node
       end
     end
     return nil
   end
 
-  def rewrite_me(exp)
-    _, recv, meth, args = exp
+  def rewrite_temp(exp)
+    _, recv, meth, *args = exp
 
-    raise Bud::CompileError unless recv == nil
-    nest_call = args.sexp_body.first
+    raise Bud::CompileError unless recv.nil?
+    nest_call = args.first
     raise Bud::CompileError unless nest_call.sexp_type == :call
 
-    nest_recv, nest_op, nest_args = nest_call.sexp_body
-    raise Bud::CompileError unless nest_recv.sexp_type == :lit
+    nest_recv, nest_op, *nest_args = nest_call.sexp_body
+    unless nest_recv.sexp_type == :lit
+      recv_src = Ruby2Ruby.new.process(Marshal.load(Marshal.dump(nest_recv)))
+      raise Bud::CompileError, "argument to temp must be a symbol: #{recv_src}"
+    end
 
     tmp_name = nest_recv.sexp_body.first
     @tmp_tables << tmp_name
-    new_recv = s(:call, nil, tmp_name, s(:arglist))
-    return s(:call, new_recv, nest_op, nest_args)
+    new_recv = s(:call, nil, tmp_name)
+    return s(:call, new_recv, nest_op, *nest_args)
   end
 end