anchor.diff:          // Call methods are presently always already overriden, so we
           // shouldn't override them here.
           if (rollDice(8) && !(classMethods[parentClass][j] is CallMethod)) {
  -          currentClass = parentClass;
  -          currentMethod = j;
  +          currentClassIndex = parentClass;
  +          currentMethod = classMethods[parentClass][j];
  +          currentMethodIndex = j;
             classMethods[parentClass][j].emit();
  -          vcm[parentClass].add(currentMethod);
  +          vcm[parentClass].add(currentMethodIndex);
  +          currentClassIndex = null;
             currentMethod = null;
  -          currentClass = null;
  +          currentMethodIndex = null;
           }
         }
         if (coinFlip() || classParents.length > parentClass) {
  
positive.code: // Version of DartFuzz. Increase this each time changes are made
  // to preserve the property that a given version of DartFuzz yields
  // the same fuzzed program for a deterministic random seed.
  const String version = '1.75';
  
  // Restriction on statements and expressions.
  const int stmtDepth = 1;
  
negative.code: 
  /// Base class for all methods in the program generated by DartFuzz.
  abstract class Method {
    Method(this.name, this.parameters, this.fuzzer)
        : recursionAllowed = fuzzer.coinFlip() {
      if (recursionAllowed) {
        // Add the recursion depth parameter.
        parameters.add(DartType.INT);
      }
    }
  
    String get recursionDepthParamName => '${paramName}${parameters.length - 1}';
    DartType get returnType => parameters[0];
  
    void emitCallParameters(int depth, bool isRecursiveCall,
        {RhsFilter rhsFilter}) {
      if (isRecursiveCall && !recursionAllowed) {
        throw StateError('Did not expect a recursive call in $name');
      }
      fuzzer.emitParenWrapped(() => fuzzer.emitCommaSeparated((int i) {
            // If this function can be called recursively, the last parameter is the
            // recursion depth parameter.
            if (i == parameters.length - 1 && recursionAllowed) {
              if (isRecursiveCall) {
                // This is a recursive call, so we increase the recursion depth
                // parameter.
                fuzzer.emit('$recursionDepthParamName + 1');
              } else {
                // This isn't a recursive call. Our recursion depth is 0.
                fuzzer.emit('0');
              }
            } else {
              fuzzer.emitExpr(depth, parameters[i], rhsFilter: rhsFilter);
            }
          }, parameters.length, start: 1));
    }
  
    void emitRecursionBaseCase() {
      fuzzer.emitIfStatement(() {
        fuzzer.emit("$recursionDepthParamName >= ");
        fuzzer.emitSmallPositiveInt();
      }, () {
        fuzzer.emitReturn(terminal: true);
        return false;
      });
    }
  
    void emitFunctionBody() {
      if (!recursionAllowed && fuzzer.rollDice(10)) {
        // Emit a method using "=>" syntax.
        fuzzer.emit(' => ');
        fuzzer.emitExpr(0, returnType, includeSemicolon: true);
      } else {
        fuzzer.emitBraceWrapped(() {
          assert(fuzzer.localVars.isEmpty);
          if (recursionAllowed) {
            emitRecursionBaseCase();
          }
          if (fuzzer.emitStatements(0)) {
            fuzzer.emitReturn();
          }
  