anchor.diff:      listener.beginSwitchCase(labelCount, expressionCount, begin);
       // Finally zero or more statements.
       int statementCount = 0;
  -    while (!identical(token.kind, EOF_TOKEN)) {
  +    while (!identical(token.next.kind, EOF_TOKEN)) {
         String value = peek.stringValue;
         if ((identical(value, 'case')) ||
             (identical(value, 'default')) ||
  -          ((identical(value, '}')) && (identical(token, peek)))) {
  +          ((identical(value, '}')) && (identical(token.next, peek)))) {
           // A label just before "}" will be handled as a statement error.
           break;
         } else {
  -        Token startToken = token;
  -        token = parseStatementOpt(token).next;
  -        if (identical(token, startToken)) {
  +        Token startToken = token.next;
  +        token = parseStatementOpt(startToken);
  +        Token next = token.next;
  +        if (identical(next, startToken)) {
             // No progress was made, so we report the current token as being
             // invalid and move forward.
             reportRecoverableError(
  -              token, fasta.templateUnexpectedToken.withArguments(token));
  -          token = token.next;
  +              next, fasta.templateUnexpectedToken.withArguments(next));
  +          token = next;
           }
           ++statementCount;
         }
  -      peek = peekPastLabels(token);
  +      peek = peekPastLabels(token.next);
       }
       listener.endSwitchCase(labelCount, expressionCount, defaultKeyword,
  -        colonAfterDefault, statementCount, begin, token);
  +        colonAfterDefault, statementCount, begin, token.next);
       return token;
     }
   
  
positive.code:   /// ;
    /// ```
    Token parseSwitchCase(Token token) {
      // TODO(brianwilkerson) Accept the last consumed token.
      // TODO(brianwilkerson) Return the last consumed token.
      Token begin = token;
      Token defaultKeyword = null;
      Token colonAfterDefault = null;
      int expressionCount = 0;
      int labelCount = 0;
      Token peek = peekPastLabels(token);
      while (true) {
        // Loop until we find something that can't be part of a switch case.
        String value = peek.stringValue;
        if (identical(value, 'default')) {
          while (!identical(token, peek)) {
            token = parseLabel(token).next;
            labelCount++;
          }
          defaultKeyword = token;
          colonAfterDefault = token.next;
          token = expect(':', colonAfterDefault);
          peek = token;
          break;
        } else if (identical(value, 'case')) {
          while (!identical(token, peek)) {
            token = parseLabel(token).next;
            labelCount++;
          }
          Token caseKeyword = token;
          listener.beginCaseExpression(token);
          token = parseExpression(token.next);
          listener.endCaseExpression(token);
          Token colonToken = token;
          token = expect(':', token);
          listener.handleCaseMatch(caseKeyword, colonToken);
          expressionCount++;
          peek = peekPastLabels(token);
        } else {
          if (expressionCount == 0) {
            // TODO(ahe): This is probably easy to recover from.
            reportUnrecoverableError(
                token, fasta.templateExpectedButGot.withArguments("case"));
          }
          break;
        }
  
negative.code:   Token parseSwitchBlock(Token token) {
      Token begin = token = token.next;
      listener.beginSwitchBlock(begin);
      expect('{', token);
      int caseCount = 0;
      while (!identical(token.next.kind, EOF_TOKEN)) {
        if (optional('}', token.next)) {
          break;
        }
        token = parseSwitchCase(token);
        ++caseCount;
      }
      token = token.next;
      listener.endSwitchBlock(caseCount, begin, token);
      expect('}', token);
      return token;
  