anchor.diff:        } else {
           preciseThisLocal = paramLocals[0];
         }
  -    }
  -
  -    closures.collectContexts(member);
  -    if (member is Constructor) {
  -      for (Field field in member.enclosingClass.fields) {
  -        if (field.isInstanceMember && field.initializer != null) {
  -          closures.collectContexts(field.initializer!,
  -              container: member.function);
  -        }
  -      }
  -    }
  -    closures.buildContexts();
  -
  -    allocateContext(member.function!);
  -    captureParameters();
  -
  -    if (member is Constructor) {
  -      Class cls = member.enclosingClass;
  -      ClassInfo info = translator.classInfo[cls]!;
  -      for (TypeParameter typeParam in cls.typeParameters) {
  -        b.local_get(thisLocal!);
  -        b.local_get(typeLocals[typeParam]!);
  -        b.struct_set(info.struct, translator.typeParameterIndex[typeParam]!);
  -      }
  -      for (Field field in cls.fields) {
  -        if (field.isInstanceMember &&
  -            field.initializer != null &&
  -            field.type is! VoidType) {
  -          int fieldIndex = translator.fieldIndex[field]!;
  -          b.local_get(thisLocal!);
  -          wrap(
  -              field.initializer!, info.struct.fields[fieldIndex].type.unpacked);
  -          b.struct_set(info.struct, fieldIndex);
  -        }
  -      }
  -      for (Initializer initializer in member.initializers) {
  -        visitInitializer(initializer);
  -      }
  -    }
  -
  -    Statement? body = member.function!.body;
  -    if (body != null) {
  -      visitStatement(body);
  -    }
  -    _implicitReturn();
  -    b.end();
  -  }
  -
  -  /// Generate code for the body of a lambda.
  -  w.DefinedFunction generateLambda(Lambda lambda, Closures closures) {
  -    FunctionNode functionNode = lambda.functionNode;
  -    if (functionNode.asyncMarker == AsyncMarker.Async &&
  -        lambda.function == function) {
  -      w.DefinedFunction inner =
  -          translator.functions.addAsyncInnerFunctionFor(function);
  -      generateAsyncWrapper(functionNode, inner);
  -      return CodeGenerator(translator, inner, reference)
  -          .generateLambda(lambda, closures);
  -    }
  -
  -    this.closures = closures;
  -
  -    int paramIndex = 1;
  -    for (TypeParameter typeParam in functionNode.typeParameters) {
  -      typeLocals[typeParam] = paramLocals[paramIndex++];
  -    }
  -    for (VariableDeclaration param in functionNode.positionalParameters) {
  -      locals[param] = paramLocals[paramIndex++];
  -    }
  -    for (VariableDeclaration param in functionNode.namedParameters) {
  -      locals[param] = paramLocals[paramIndex++];
  -    }
  -
  +      return 1;
  +    }
  +    return 0;
  +  }
  +
  +  /// Initialize locals pointing to every context in the context chain of a
  +  /// closure, plus the locals containing `this` if `this` is captured by the
  +  /// closure.
  +  void _initializeContextLocals(FunctionNode functionNode) {
       Context? context = closures.contexts[functionNode]?.parent;
       if (context != null) {
         b.local_get(paramLocals[0]);
  
positive.code:         ? member.enclosingClass.typeParameters
          : member.function!.typeParameters;
      for (int i = 0; i < typeParameters.length; i++) {
        typeLocals[typeParameters[i]] = paramLocals[typeParameterOffset + i];
      }
  
      // For all parameters whose Wasm type has been forced to `externref` due to
  
negative.code: 
    void generateBody(Member member) {
      ParameterInfo paramInfo = translator.paramInfoFor(reference);
      int parameterOffset = _initializeThis(member);
      int implicitParams = parameterOffset + paramInfo.typeParamCount;
      List<VariableDeclaration> positional =
          member.function!.positionalParameters;
      for (int i = 0; i < positional.length; i++) {
  