anchor.diff:      List<UnlinkedExecutableBuilder> oldExecutables = executables;
       List<UnlinkedLabelBuilder> oldLabels = labels;
       List<UnlinkedVariableBuilder> oldVariables = variables;
  +    Map<int, int> oldLocalClosureIndexMap = _localClosureIndexMap;
       executables = <UnlinkedExecutableBuilder>[];
       labels = <UnlinkedLabelBuilder>[];
       variables = <UnlinkedVariableBuilder>[];
  +    _localClosureIndexMap = <int, int>{};
       if (initializers != null) {
         for (ConstructorInitializer initializer in initializers) {
           initializer.accept(this);
         }
       }
       body.accept(this);
  +    if (serializeBodyExpr) {
  +      if (body is Expression) {
  +        b.bodyExpr = serializeConstExpr(_localClosureIndexMap, body);
  +      } else {
  +        // TODO(paulberry): serialize other types of function bodies.
  +      }
  +    }
       b.localFunctions = executables;
       b.localLabels = labels;
       b.localVariables = variables;
  +    Map<int, int> localClosureIndexMap = _localClosureIndexMap;
       executables = oldExecutables;
       labels = oldLabels;
       variables = oldVariables;
  +    _localClosureIndexMap = oldLocalClosureIndexMap;
  +    return localClosureIndexMap;
     }
   
     /**
  
positive.code:     b.documentationComment = serializeDocumentation(node.documentationComment);
      b.annotations = serializeAnnotations(node.metadata);
      b.codeRange = serializeCodeRange(node);
      Map<int, int> localClosureIndexMap = _withLocalClosureIndexMap(() {
        serializeFunctionBody(b, node.initializers, node.body);
      });
      if (node.constKeyword != null) {
        Set<String> constructorParameterNames =
            node.parameters.parameters.map((p) => p.identifier.name).toSet();
  
negative.code:    *
     * If [initializers] is non-`null`, closures occurring inside the initializers
     * are serialized first.
     *
     * If [serializeBodyExpr] is `true`, then the function definition is stored
     * in [UnlinkedExecutableBuilder.bodyExpr].
     *
     * The return value is a map whose keys are the offsets of local function
     * nodes representing closures inside [initializers] and [body], and whose
     * values are the indices of those local functions relative to their siblings.
     */
    Map<int, int> serializeFunctionBody(
        UnlinkedExecutableBuilder b,
        List<ConstructorInitializer> initializers,
        AstNode body,
        bool serializeBodyExpr) {
      if (body is BlockFunctionBody || body is ExpressionFunctionBody) {
        for (UnlinkedParamBuilder parameter in b.parameters) {
          parameter.visibleOffset = body.offset;
  