anchor.diff:    /// ;
     /// ```
     Token parsePart(Token token) {
  -    // TODO(brianwilkerson) Accept the last consumed token.
  -    assert(optional('part', token));
  -    Token partKeyword = token;
  -    listener.beginPart(token);
  -    token = parseLiteralStringOrRecoverExpression(token);
  +    Token partKeyword = token.next;
  +    assert(optional('part', partKeyword));
  +    listener.beginPart(partKeyword);
  +    token = parseLiteralStringOrRecoverExpression(partKeyword);
       token = ensureSemicolon(token);
       listener.endPart(partKeyword, token);
       return token;
  
positive.code:   /// ;
    /// ```
    Token parseImport(Token token) {
      // TODO(brianwilkerson) Accept the last consumed token.
      assert(optional('import', token));
      Token importKeyword = token;
      listener.beginImport(importKeyword);
      token = parseLiteralStringOrRecoverExpression(token);
      Token afterUri = token;
      token = parseConditionalUris(token);
      token = parseImportPrefixOpt(token);
  
negative.code:       directiveState?.checkScriptTag(this, token.next);
        return parseScript(token);
      }
      token = parseMetadataStar(token);
      if (token.next.isTopLevelKeyword) {
        return parseTopLevelKeywordDeclaration(null, token, directiveState);
      }
      Token start = token.next;
      // Skip modifiers to find a top level keyword or identifier
      while (token.next.isModifier) {
        token = token.next;
      }
      Token next = token.next;
      if (next.isTopLevelKeyword) {
        Token abstractToken;
        Token modifier = start;
        while (modifier != next) {
          if (optional('abstract', modifier) &&
              optional('class', next) &&
              abstractToken == null) {
            abstractToken = modifier;
          } else {
            // Recovery
            reportTopLevelModifierError(modifier, next);
          }
          modifier = modifier.next;
        }
        return parseTopLevelKeywordDeclaration(
            abstractToken, token, directiveState);
      } else if (next.isIdentifier || next.keyword != null) {
        // TODO(danrubel): improve parseTopLevelMember
        // so that we don't parse modifiers twice.
        directiveState?.checkDeclaration();
        return parseTopLevelMember(start);
      } else if (start != next) {
        directiveState?.checkDeclaration();
        // Handle the edge case where a modifier is being used as an identifier
        return parseTopLevelMember(start);
      }
      // Ignore any preceding modifiers and just report the unexpected token
      reportRecoverableErrorWithToken(next, fasta.templateExpectedDeclaration);
      listener.handleInvalidTopLevelDeclaration(next);
      return next;
    }
  
    // Report an error for the given modifier preceding a top level keyword
  