 # Unify two types, if possible, into a single type. If `assign` is true, then
 # this behaves asymmetrically for pointer types and automatic promotions of
 # primitive types.
-unify = (types, lty, rty, assign) ->
+unify = (types, lty, rty, assigning) ->
   # Unify is reflexive.
   return lty if lty is rty
   # If the left side is dynamic, the entire expression is dynamic.
   return unless lty and rty
   # Two pointer types are unifiable iff their bases are size compatible.
   if lty instanceof PointerType and rty instanceof PointerType
-    if assign
+    if assigning
       # Assigning a narrower pointer to a wider one may mess up due to
       # alignment, since all views are aligned.
       if rty.base and rty.baseAlignment() < lty.baseAlignment()

    ty1 = ty2
    ty2 = tmp

  @computedType = if (op is '+' or op is '-') and ty1 instanceof PointerType
    unless ty2 in integral
      error this, "invalid operand type `#{ty2}' for pointer arithmetic"
    ty1
  else if op is '-' and ty1 instanceof PointerType and ty2 instanceof PointerType
    unless unify o.types, ty1.base, ty2.base
      printWarn "pointer subtraction on incompatible pointer types `#{ty1}' and `#{ty2}'"
    i32ty
  else if op is '%'
    i32ty
  else if op in COMPARE
    if ty1 instanceof PointerType and ty2 instanceof PointerType and
       not unify o.types, ty1, ty2
      printWarn "comparison between incompatible pointer types `#{ty1}' and `#{ty2}'"
    i32ty
  else if op in BITWISE
    i32ty
  else if op in ARITH and ty1 in numeric and ty2 in numeric
    f64ty

# Gather return expressions.
returnExpressions = (body) ->

      new Call FREE, [@first]
    else if op is 'sizeof'
      new Literal @first.size
    else if op is '&'
      if @computedType.base instanceof StructType
        # If we're taking the pointer of a struct, we don't need to do anything
        # since structs are kept as pointers.
        @first
      else
        # Otherwise we must be doing a dereference, so transform it now and
        # get out the index expression, which must be the address.
        @first.unwrapAll().transformNode(o).properties[0].index
    else if op is '*'
      # This is only called when this deref is _not_ the base of a struct
      # access, as in struct accesses, dereferencing is the same as not
