anchor.diff:            optional("{", token) ||
             optional("=>", token)) {
           // A method.
  -        identifiers = identifiers.prepend(token);
  +        identifiers = identifiers.prepend(previous);
           return identifiers;
         } else if (optional("=", token) ||
             optional(";", token) ||
             optional(",", token)) {
           // A field or abstract getter.
  -        identifiers = identifiers.prepend(token);
  +        identifiers = identifiers.prepend(previous);
           return identifiers;
         } else if (optional('native', token) &&
             (token.next.kind == STRING_TOKEN || optional(';', token.next))) {
           // Skip.
  +        previous = token;
           token = token.next;
           if (token.kind == STRING_TOKEN) {
  +          previous = token;
             token = token.next;
           }
           continue;
  
positive.code:     token = token.next;
      listener.beginTopLevelMember(token);
  
      Link<Token> identifiers = findMemberName(token);
      if (identifiers.isEmpty) {
        return reportUnrecoverableErrorWithToken(
            token, fasta.templateExpectedDeclaration);
      }
      Token afterName = identifiers.head;
      identifiers = identifiers.tail;
  
      if (identifiers.isEmpty) {
        return reportUnrecoverableErrorWithToken(
            token, fasta.templateExpectedDeclaration);
      }
      Token name = identifiers.head;
      identifiers = identifiers.tail;
      Token getOrSet;
      if (!identifiers.isEmpty) {
        String value = identifiers.head.stringValue;
        if ((identical(value, 'get')) || (identical(value, 'set'))) {
          getOrSet = identifiers.head;
          identifiers = identifiers.tail;
        }
      }
      Token type;
      if (!identifiers.isEmpty) {
        if (isValidTypeReference(identifiers.head)) {
          type = identifiers.head;
          identifiers = identifiers.tail;
        }
      }
  
negative.code:           // Handle the edge case where a built-in keyword is being used
            // as the identifier, as in "abstract<T>() => 0;"
            if (optional('<', token.next)) {
              Token beforeIdentifier = previous;
              Token identifier = token;
              if (token.next is BeginToken) {
                previous = token;
                token = token.next;
                Token closeBrace = closeBraceTokenFor(token);
                if (closeBrace == null) {
                  // Handle the edge case where the user is defining the less
                  // than operator, as in "bool operator <(other) => false;"
                  if (optional('operator', identifier)) {
                    previous = beforeIdentifier;
                    token = identifier;
                  } else {
                    previous = reportUnmatchedToken(token);
                    token = previous.next;
                  }
                } else {
                  token = closeBrace;
                  // TODO(brianwilkerson): Remove the invocation of `previous`
                  // when `closeBraceTokenFor` returns the token before the
                  // closing brace.
                  previous = token.previous;
                }
              }
            }
          }
          previous = token;
          token = token.next;
        }
        while (isGeneralizedFunctionType(token)) {
          previous = token;
          token = token.next;
          if (optional('<', token)) {
            if (token is BeginToken) {
              Token closeBrace = closeBraceTokenFor(token);
              if (closeBrace == null) {
                previous = reportUnmatchedToken(token);
                token = previous.next;
              } else {
                previous = closeBrace;
                token = previous.next;
              }
            }
          }
  