anchor.diff:      if (leftIndex >= 0) {
         expect(leftToken, isNotNull);
       }
  -    expect(_incrementalScanner.leftToken, same(leftToken), reason: "Invalid left token");
  +    expect(
  +        _incrementalScanner.leftToken,
  +        same(leftToken),
  +        reason: "Invalid left token");
       if (rightIndex >= 0) {
         expect(rightToken, isNotNull);
       }
  -    expect(_incrementalScanner.rightToken, same(rightToken), reason: "Invalid right token");
  +    expect(
  +        _incrementalScanner.rightToken,
  +        same(rightToken),
  +        reason: "Invalid right token");
     }
   
     /**
  -   * Given a description of the original and modified contents, perform an incremental scan of the
  -   * two pieces of text. Verify that the incremental scan produced the same tokens as those that
  -   * would be produced by a full scan of the new contents.
  +   * Given a description of the original and modified contents, perform an
  +   * incremental scan of the two pieces of text. Verify that the incremental
  +   * scan produced the same tokens as those that would be produced by a full
  +   * scan of the new contents.
      *
  -   * @param prefix the unchanged text before the edit region
  -   * @param removed the text that was removed from the original contents
  -   * @param added the text that was added to the modified contents
  -   * @param suffix the unchanged text after the edit region
  +   * The original content is the concatenation of the [prefix], [removed] and
  +   * [suffix] fragments. The modeified content is the concatenation of the
  +   * [prefix], [added] and [suffix] fragments.
      */
     void _scan(String prefix, String removed, String added, String suffix) {
       //
  
positive.code:     // Scan the original contents.
      //
      GatheringErrorListener originalListener = new GatheringErrorListener();
      Scanner originalScanner = new Scanner(source, new CharSequenceReader(originalContents), originalListener);
      _originalTokens = originalScanner.tokenize();
      expect(_originalTokens, isNotNull);
      //
      // Scan the modified contents.
      //
      GatheringErrorListener modifiedListener = new GatheringErrorListener();
      Scanner modifiedScanner = new Scanner(source, new CharSequenceReader(modifiedContents), modifiedListener);
      Token modifiedTokens = modifiedScanner.tokenize();
      expect(modifiedTokens, isNotNull);
      //
      // Incrementally scan the modified contents.
      //
      GatheringErrorListener incrementalListener = new GatheringErrorListener();
      _incrementalScanner = new IncrementalScanner(source, new CharSequenceReader(modifiedContents), incrementalListener);
      _incrementalTokens = _incrementalScanner.rescan(_originalTokens, replaceStart, removed.length, added.length);
      //
      // Validate that the results of the incremental scan are the same as the full scan of the
      // modified source.
      //
      Token incrementalToken = _incrementalTokens;
      expect(incrementalToken, isNotNull);
      while (incrementalToken.type != TokenType.EOF && modifiedTokens.type != TokenType.EOF) {
        expect(incrementalToken.type, same(modifiedTokens.type), reason: "Wrong type for token");
        expect(incrementalToken.offset, modifiedTokens.offset, reason: "Wrong offset for token");
        expect(incrementalToken.length, modifiedTokens.length, reason: "Wrong length for token");
        expect(incrementalToken.lexeme, modifiedTokens.lexeme, reason: "Wrong lexeme for token");
        incrementalToken = incrementalToken.next;
        modifiedTokens = modifiedTokens.next;
      }
      expect(incrementalToken.type, same(TokenType.EOF), reason: "Too many tokens");
      expect(modifiedTokens.type, same(TokenType.EOF), reason: "Not enough tokens");
      // TODO(brianwilkerson) Verify that the errors are correct?
    }
  }
  
negative.code: 
  class IncrementalScannerTest extends EngineTestCase {
    /**
     * The first token from the token stream resulting from parsing the original
     * source, or `null` if [scan] has not been invoked.
     */
    Token _originalTokens;
  
    /**
     * The scanner used to perform incremental scanning, or `null` if [scan] has
     * not been invoked.
     */
    IncrementalScanner _incrementalScanner;
  
    /**
     * The first token from the token stream resulting from performing an
     * incremental scan, or `null` if [scan] has not been invoked.
     */
    Token _incrementalTokens;
  
    void fail_insert_beginning() {
      // This is currently reporting the changed range as being from 0 to 5, but
      // that would force us to re-parse both classes, which is clearly sub-optimal.
      //
      // "class B {}"
      // "class A {} class B {}"
      _scan("", "", "class A {} ", "class B {}");
      _assertTokens(-1, 4, ["class", "A", "{", "}", "class", "B", "{", "}"]);
      expect(_incrementalScanner.hasNonWhitespaceChange, isTrue);
    }
  
    void test_delete_identifier_beginning() {
      // "abs + b;"
  