anchor.diff:        {RhsFilter rhsFilter}) {
       for (int i = m - 1; i >= 0; i--) {
         if (tp == methods[i].returnType) {
  -        methods[i].emitCall(depth + 1, rhsFilter: rhsFilter);
  +        bool isRecursiveCall = (currentMethod == methods[i]);
  +        if (isRecursiveCall && !methods[i].recursionAllowed) {
  +          continue;
  +        }
  +        methods[i].emitCall(depth + 1,
  +            rhsFilter: rhsFilter, isRecursiveCall: isRecursiveCall);
           return true;
         }
       }
  
positive.code: 
    void emitMethods(List<Method> methods) {
      for (int i = 0; i < methods.length; i++) {
        Method method = methods[i];
        currentMethod = i;
        methods[i].emit();
        currentMethod = null;
      }
    }
  
    // Randomly overwrite some methods from the parent classes.
    void emitVirtualMethods() {
      final currentClassTmp = currentClass;
      int parentClass = classParents[currentClass];
      final vcm = <int, List<int>>{};
      // Chase randomly up in class hierarchy.
      while (parentClass >= 0) {
  
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();
          }
  