     # Use transform here to get a struct literal out, since we have to compute
     # the offset for the field. We have to manually set the types, kind of
     # gross.
-    access = new Access(new Literal fname)
+    access = new Access new Literal fname
     access.computedField = field
     propValue = new Value ptr, [access]
     propValue.computedType = field.type

  new Value ty.view, [new Index new Op '>>', offsetOp, new Literal shiftBy ty.size]

# Generate an inline memcpy.
inlineMemcpy = (dest, src, n, ret, o) ->
  scope = o.scope
  stmts = []
  # Store the pointer to the struct we're copying to.
  destPtr = new Value new Literal scope.freeVariable 'dest'
  stmts.push new Assign destPtr, dest
  # Store the pointer to the struct we're copying from.
  srcPtr = new Value new Literal scope.freeVariable 'src'
  stmts.push new Assign srcPtr, src
  # Loop over the bytes and copy.
  endVal = new Op '+', destPtr, new Literal n
  loopBody = new Assign new Value(HEAP, [new Index new Op '++', destPtr, null, true]),
                        new Value(HEAP, [new Index new Op '++', srcPtr, null, true])
  memcpy = new While new Op('<', destPtr, endVal)
  memcpy.addBody new Block [loopBody]
  stmts.push memcpy
  stmts.push ret
  new Value new Parens new Block stmts

# Reflect a heap-allocated struct as a JavaScript object literal.

  lval = @variable
  ty = @computedType
  return unless lval instanceof Deref and ty instanceof StructType
  inlineMemcpy lval.expr, @value, ty, o

# Typed new and delete are transformed to malloc and free, and pointer
# arithmetic also needs to be transformed.
