anchor.diff:    }
   
     ast.Node visitInvokeStatic(InvokeStatic node) {
  -    ast.Identifier name = new ast.Identifier(
  -        new StringToken.fromString(IDENTIFIER_INFO, node.target.name, -1));
  +    ast.Identifier name = makeIdentifier(node.target.name);
       ast.Send send =
  -        new ast.Send(null, name, makeArgumentList(node.arguments));
  +        new ast.Send(null, name, translateArguments(node.arguments));
       treeElements[send] = node.target;
       return send;
     }
  
positive.code:     // Reset the variable index.  This function is not reentrant.
      Variable.counter = 0;
      this.treeElements = treeElements;
      ast.Identifier name = new ast.Identifier(
          new StringToken.fromString(IDENTIFIER_INFO, element.name, -1));
  
      ast.NodeList parameters = new ast.NodeList(
          new BeginGroupToken(OPEN_PAREN_INFO, -1),
          const Link<ast.Node>(),
          new SymbolToken(CLOSE_PAREN_INFO, -1),
          ',');
      ast.Node body = expr.accept(this);
  
      if (!variables.isEmpty) {
  
negative.code:         ast.Modifiers.EMPTY, null, null);
    }
  
    /**
     * Translate a list of arguments to an AST NodeList.
     */
    ast.NodeList translateArguments(List<Expression> args) {
      List<ast.Expression> arguments =
          args.map((e) => e.accept(this)).toList(growable: false);
      return makeArgumentList(arguments);
    }
  
    /**
     * Concatenate a pair of AST expressions or statements into a single Block
     * statement.
     */
    ast.Node concatenate(ast.Node first, ast.Node second) {
      // This is a convenient but very inefficient way to accumulate statements.
      // The Block and NodeList nodes are not mutable so we can't simply use a
      // Block or NodeList as an accumulator.  Using a List<Node> requires
  