anchor.diff:    }
   
     Statement visitFunctionDeclaration(FunctionDeclaration node) {
  -    new CopyPropagator().visitFunctionDefinition(node.definition);
  +    new CopyPropagator().rewrite(node.definition);
       node.next = visitStatement(node.next);
       node.variable = copyPropagateVariable(node.variable);
       return node;
     }
   
     Statement visitExpressionStatement(ExpressionStatement node) {
  +    node.next = visitStatement(node.next);
       visitExpression(node.expression);
  -    node.next = visitStatement(node.next);
       return node;
     }
   
     void visitFunctionExpression(FunctionExpression node) {
  -    new CopyPropagator().visitFunctionDefinition(node.definition);
  +    new CopyPropagator().rewrite(node.definition);
     }
   
   }
  
positive.code:   /// Like [move], except w is the key instead of v.
    Map<Variable, Assign> inverseMove = <Variable, Assign>{};
  
    void rewrite(FunctionDefinition function) {
      visitFunctionDefinition(function);
    }
  
    void visitFunctionDefinition(FunctionDefinition function) {
      function.body = visitStatement(function.body);
  
      // Try to propagate moving assignments into function parameters.
  
negative.code:     visitVariable(node.variable);
  
      // If this is a moving assignment w := v, with this being the only use of v,
      // try to propagate it backwards.  Do not propagate assignments where w
      // is from an outer function scope.
      if (node.definition is Variable) {
        Variable def = node.definition;
        if (def.readCount == 1 &&
            node.variable.host.element == functionElement) {
          move[node.definition] = node;
          inverseMove[node.variable] = node;
        }
  