anchor.diff:  
     /// A stack of collectors for breaks.
     final List<JumpCollector> breakCollectors;
  +  /// A stack of collectors for continues.
  +  final List<JumpCollector> continueCollectors;
   
     ConstExpBuilder constantBuilder;
   
  
positive.code:     return join;
    }
  
    /// Invoke a recursive join-point continuation.
    ///
    /// Given the continuation and a list of open contexts that should contain
    /// recursive invocations, plug each context with an invocation of the
    /// continuation.
    void invokeRecursiveJoin(ir.Continuation join, List<IrBuilder> contexts) {
      for (IrBuilder context in contexts) {
        // Passing `this` as one of the contexts will not do the right thing
        // (this.environment has already been mutated).
        assert(context != this);
        List<ir.Primitive> args =
            context.environment.index2value.sublist(0, join.parameters.length);
        context.add(new ir.InvokeContinuation(join, args, recursive: true));
        context.current = null;
      }
    }
  
  
negative.code:       }
      }
      compiler.internalError(node, "'break' target not found");
      return null;
    }
  
    // Build(ContinueStatement L, C) = C[InvokeContinuation(...)]
    //
    // The continuation and arguments are filled in later after translating
    // the body containing the continue.
    ir.Primitive visitContinueStatement(ast.ContinueStatement node) {
      assert(isOpen);
      JumpTarget target = elements.getTargetOf(node);
      for (JumpCollector collector in continueCollectors) {
        if (target == collector.target) {
          collector.addJump(this);
          return null;
        }
      }
      compiler.internalError(node, "'continue' target not found");
      return null;
    }
  
  