Rename method

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.parser;
 
 import "dart:math" as math;
@@ skipping 2310 matching lines @@
 
   /**
    * Initialize a newly created parser.
    *
    * @param source the source being parsed
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during the parse
    */
   Parser(this._source, this._errorListener);
 
-  /**
-   * Advance to the next token in the token stream, making it the new current token.
-   *
-   * @return the token that was current before this method was invoked
-   */
-  Token get andAdvance {
-    Token token = _currentToken;
-    _advance();
-    return token;
-  }
-
   void set currentToken(Token currentToken) {
     this._currentToken = currentToken;
   }
 
   /**
+   * Advance to the next token in the token stream, making it the new current
+   * token and return the token that was current before this method was invoked.
+   */
+  Token getAndAdvance() {
+    Token token = _currentToken;
+    _advance();
+    return token;
+  }
+
+  /**
    * Return `true` if the current token is the first token of a return type that is followed
    * by an identifier, possibly followed by a list of type parameters, followed by a
    * left-parenthesis. This is used by parseTypeAlias to determine whether or not to parse a return
    * type.
    *
    * @return `true` if we can successfully parse the rest of a type alias if we first parse a
    *         return type.
    */
   bool get hasReturnTypeInTypeAlias {
     Token next = _skipReturnType(_currentToken);
@@ skipping 48 matching lines @@
    * </pre>
    *
    * @return the annotation that was parsed
    */
   Annotation parseAnnotation() {
     Token atSign = _expect(TokenType.AT);
     Identifier name = parsePrefixedIdentifier();
     Token period = null;
     SimpleIdentifier constructorName = null;
     if (_matches(TokenType.PERIOD)) {
-      period = andAdvance;
+      period = getAndAdvance();
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList arguments = null;
     if (_matches(TokenType.OPEN_PAREN)) {
       arguments = parseArgumentList();
     }
     return new Annotation(atSign, name, period, constructorName, arguments);
   }
 
   /**
@@ skipping 33 matching lines @@
    *     namedArgument (',' namedArgument)*
    *   | expressionList (',' namedArgument)*
    * </pre>
    *
    * @return the argument list that was parsed
    */
   ArgumentList parseArgumentList() {
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     List<Expression> arguments = new List<Expression>();
     if (_matches(TokenType.CLOSE_PAREN)) {
-      return new ArgumentList(leftParenthesis, arguments, andAdvance);
+      return new ArgumentList(leftParenthesis, arguments, getAndAdvance());
     }
     //
     // Even though unnamed arguments must all appear before any named arguments,
     // we allow them to appear in any order so that we can recover faster.
     //
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
       Expression argument = parseArgument();
       arguments.add(argument);
@@ skipping 36 matching lines @@
    *     bitwiseXorExpression ('|' bitwiseXorExpression)*
    *   | 'super' ('|' bitwiseXorExpression)+
    * </pre>
    *
    * @return the bitwise or expression that was parsed
    */
   Expression parseBitwiseOrExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _tokenMatches(_peek(), TokenType.BAR)) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseBitwiseXorExpression();
     }
     while (_matches(TokenType.BAR)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseBitwiseXorExpression());
     }
     return expression;
   }
 
   /**
    * Parse a block.
    *
    * <pre>
@@ skipping 138 matching lines @@
       if (_matchesKeyword(Keyword.CLASS)) {
         _reportErrorForCurrentToken(ParserErrorCode.CLASS_IN_CLASS);
         // TODO(brianwilkerson) We don't currently have any way to capture the
         // class that was parsed.
         _parseClassDeclaration(commentAndMetadata, null);
         return null;
       } else if (_matchesKeyword(Keyword.ABSTRACT) && _tokenMatchesKeyword(_peek(), Keyword.CLASS)) {
         _reportErrorForToken(ParserErrorCode.CLASS_IN_CLASS, _peek());
         // TODO(brianwilkerson) We don't currently have any way to capture the
         // class that was parsed.
-        _parseClassDeclaration(commentAndMetadata, andAdvance);
+        _parseClassDeclaration(commentAndMetadata, getAndAdvance());
         return null;
       } else if (_isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the
         // 'operator' keyword.
         //
         _validateModifiersForOperator(modifiers);
         return _parseOperator(
             commentAndMetadata,
             modifiers.externalKeyword,
@@ skipping 47 matching lines @@
       return null;
     } else if (_tokenMatches(_peek(), TokenType.PERIOD) &&
         _tokenMatchesIdentifier(_peekAt(2)) &&
         _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
       return _parseConstructor(
           commentAndMetadata,
           modifiers.externalKeyword,
           _validateModifiersForConstructor(modifiers),
           modifiers.factoryKeyword,
           parseSimpleIdentifier(),
-          andAdvance,
+          getAndAdvance(),
           parseSimpleIdentifier(),
           parseFormalParameterList());
     } else if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
       SimpleIdentifier methodName = parseSimpleIdentifier();
       FormalParameterList parameters = parseFormalParameterList();
       if (_matches(TokenType.COLON) ||
           modifiers.factoryKeyword != null ||
           methodName.name == className) {
         return _parseConstructor(
             commentAndMetadata,
@@ skipping 24 matching lines @@
       }
       return _parseInitializedIdentifierList(
           commentAndMetadata,
           modifiers.staticKeyword,
           _validateModifiersForField(modifiers),
           null);
     } else if (_matchesKeyword(Keyword.TYPEDEF)) {
       _reportErrorForCurrentToken(ParserErrorCode.TYPEDEF_IN_CLASS);
       // TODO(brianwilkerson) We don't currently have any way to capture the
       // function type alias that was parsed.
-      _parseFunctionTypeAlias(commentAndMetadata, andAdvance);
+      _parseFunctionTypeAlias(commentAndMetadata, getAndAdvance());
       return null;
     }
     TypeName type = parseTypeName();
     if (_matchesKeyword(Keyword.GET) && _tokenMatchesIdentifier(_peek())) {
       _validateModifiersForGetterOrSetterOrMethod(modifiers);
       return _parseGetter(
           commentAndMetadata,
           modifiers.externalKeyword,
           modifiers.staticKeyword,
           type);
@@ skipping 102 matching lines @@
    * `null`.
    *
    * <pre>
    * combinator ::=
    *     'show' identifier (',' identifier)*
    *   | 'hide' identifier (',' identifier)*
    * </pre>
    */
   Combinator parseCombinator() {
     if (_matchesString(_SHOW) || _matchesString(_HIDE)) {
-      Token keyword = andAdvance;
+      Token keyword = getAndAdvance();
       List<SimpleIdentifier> names = _parseIdentifierList();
       if (keyword.lexeme == _SHOW) {
         return new ShowCombinator(keyword, names);
       } else {
         return new HideCombinator(keyword, names);
       }
     }
     return null;
   }
 
@@ skipping 34 matching lines @@
    *     directive
    *   | topLevelDeclaration
    * </pre>
    *
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseCompilationUnit2() {
     Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (_matches(TokenType.SCRIPT_TAG)) {
-      scriptTag = new ScriptTag(andAdvance);
+      scriptTag = new ScriptTag(getAndAdvance());
     }
     //
     // Even though all directives must appear before declarations and must occur
     // in a given order, we allow directives and declarations to occur in any
     // order so that we can recover better.
     //
     bool libraryDirectiveFound = false;
     bool partOfDirectiveFound = false;
     bool partDirectiveFound = false;
     bool directiveFoundAfterDeclaration = false;
@@ skipping 104 matching lines @@
    *     logicalOrExpression ('?' expressionWithoutCascade ':' expressionWithoutCascade)?
    * </pre>
    *
    * @return the conditional expression that was parsed
    */
   Expression parseConditionalExpression() {
     Expression condition = parseLogicalOrExpression();
     if (!_matches(TokenType.QUESTION)) {
       return condition;
     }
-    Token question = andAdvance;
+    Token question = getAndAdvance();
     Expression thenExpression = parseExpressionWithoutCascade();
     Token colon = _expect(TokenType.COLON);
     Expression elseExpression = parseExpressionWithoutCascade();
     return new ConditionalExpression(
         condition,
         question,
         thenExpression,
         colon,
         elseExpression);
   }
 
   /**
    * Parse the name of a constructor.
    *
    * <pre>
    * constructorName:
    *     type ('.' identifier)?
    * </pre>
    *
    * @return the constructor name that was parsed
    */
   ConstructorName parseConstructorName() {
     TypeName type = parseTypeName();
     Token period = null;
     SimpleIdentifier name = null;
     if (_matches(TokenType.PERIOD)) {
-      period = andAdvance;
+      period = getAndAdvance();
       name = parseSimpleIdentifier();
     }
     return new ConstructorName(type, period, name);
   }
 
   /**
    * Parse the script tag and directives in a compilation unit, starting with the given token, until
    * the first non-directive is encountered. The remainder of the compilation unit will not be
    * parsed. Specifically, if there are directives later in the file, they will not be parsed.
    *
@@ skipping 62 matching lines @@
       List<Expression> cascadeSections = new List<Expression>();
       while (tokenType == TokenType.PERIOD_PERIOD) {
         Expression section = _parseCascadeSection();
         if (section != null) {
           cascadeSections.add(section);
         }
         tokenType = _currentToken.type;
       }
       return new CascadeExpression(expression, cascadeSections);
     } else if (tokenType.isAssignmentOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       _ensureAssignable(expression);
       return new AssignmentExpression(expression, operator, parseExpression2());
     }
     return expression;
   }
 
   /**
    * Parse an expression that does not contain any cascades.
    *
    * <pre>
@@ skipping 12 matching lines @@
       return _parseRethrowExpression();
     }
     //
     // assignableExpression is a subset of conditionalExpression, so we can
     // parse a conditional expression and then determine whether it is followed
     // by an assignmentOperator, checking for conformance to the restricted
     // grammar after making that determination.
     //
     Expression expression = parseConditionalExpression();
     if (_currentToken.type.isAssignmentOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       _ensureAssignable(expression);
       expression = new AssignmentExpression(
           expression,
           operator,
           parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
@@ skipping 38 matching lines @@
    * @return the formal parameters that were parsed
    */
   FormalParameterList parseFormalParameterList() {
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     if (_matches(TokenType.CLOSE_PAREN)) {
       return new FormalParameterList(
           leftParenthesis,
           null,
           null,
           null,
-          andAdvance);
+          getAndAdvance());
     }
     //
     // Even though it is invalid to have default parameters outside of brackets,
     // required parameters inside of brackets, or multiple groups of default and
     // named parameters, we allow all of these cases so that we can recover
     // better.
     //
     List<FormalParameter> parameters = new List<FormalParameter>();
     List<FormalParameter> normalParameters = new List<FormalParameter>();
     List<FormalParameter> positionalParameters = new List<FormalParameter>();
@@ skipping 35 matching lines @@
         wasOptionalParameter = true;
         if (leftSquareBracket != null && !reportedMuliplePositionalGroups) {
           _reportErrorForCurrentToken(
               ParserErrorCode.MULTIPLE_POSITIONAL_PARAMETER_GROUPS);
           reportedMuliplePositionalGroups = true;
         }
         if (leftCurlyBracket != null && !reportedMixedGroups) {
           _reportErrorForCurrentToken(ParserErrorCode.MIXED_PARAMETER_GROUPS);
           reportedMixedGroups = true;
         }
-        leftSquareBracket = andAdvance;
+        leftSquareBracket = getAndAdvance();
         currentParameters = positionalParameters;
         kind = ParameterKind.POSITIONAL;
       } else if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
         wasOptionalParameter = true;
         if (leftCurlyBracket != null && !reportedMulipleNamedGroups) {
           _reportErrorForCurrentToken(
               ParserErrorCode.MULTIPLE_NAMED_PARAMETER_GROUPS);
           reportedMulipleNamedGroups = true;
         }
         if (leftSquareBracket != null && !reportedMixedGroups) {
           _reportErrorForCurrentToken(ParserErrorCode.MIXED_PARAMETER_GROUPS);
           reportedMixedGroups = true;
         }
-        leftCurlyBracket = andAdvance;
+        leftCurlyBracket = getAndAdvance();
         currentParameters = namedParameters;
         kind = ParameterKind.NAMED;
       }
       //
       // Parse and record the parameter.
       //
       FormalParameter parameter = _parseFormalParameter(kind);
       parameters.add(parameter);
       currentParameters.add(parameter);
       if (kind == ParameterKind.REQUIRED && wasOptionalParameter) {
         _reportErrorForNode(
             ParserErrorCode.NORMAL_BEFORE_OPTIONAL_PARAMETERS,
             parameter);
       }
       //
       // Handle the end of parameter groups.
       //
       // TODO(brianwilkerson) Improve the detection and reporting of missing and
       // mismatched delimiters.
       if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
-        rightSquareBracket = andAdvance;
+        rightSquareBracket = getAndAdvance();
         currentParameters = normalParameters;
         if (leftSquareBracket == null) {
           if (leftCurlyBracket != null) {
             _reportErrorForCurrentToken(
                 ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP,
                 ["}"]);
             rightCurlyBracket = rightSquareBracket;
             rightSquareBracket = null;
           } else {
             _reportErrorForCurrentToken(
                 ParserErrorCode.UNEXPECTED_TERMINATOR_FOR_PARAMETER_GROUP,
                 ["["]);
           }
         }
         kind = ParameterKind.REQUIRED;
       } else if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
-        rightCurlyBracket = andAdvance;
+        rightCurlyBracket = getAndAdvance();
         currentParameters = normalParameters;
         if (leftCurlyBracket == null) {
           if (leftSquareBracket != null) {
             _reportErrorForCurrentToken(
                 ParserErrorCode.WRONG_TERMINATOR_FOR_PARAMETER_GROUP,
                 ["]"]);
             rightSquareBracket = rightCurlyBracket;
             rightCurlyBracket = null;
           } else {
             _reportErrorForCurrentToken(
@@ skipping 116 matching lines @@
    * <pre>
    * logicalOrExpression ::=
    *     logicalAndExpression ('||' logicalAndExpression)*
    * </pre>
    *
    * @return the logical or expression that was parsed
    */
   Expression parseLogicalOrExpression() {
     Expression expression = _parseLogicalAndExpression();
     while (_matches(TokenType.BAR_BAR)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseLogicalAndExpression());
     }
     return expression;
   }
 
   /**
    * Parse a map literal entry.
    *
    * <pre>
@@ skipping 30 matching lines @@
    *     declaredIdentifier
    *   | metadata identifier
    * </pre>
    */
   NormalFormalParameter parseNormalFormalParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     FinalConstVarOrType holder = _parseFinalConstVarOrType(true);
     Token thisKeyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
-      thisKeyword = andAdvance;
+      thisKeyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
     SimpleIdentifier identifier = parseSimpleIdentifier();
     if (_matches(TokenType.OPEN_PAREN)) {
       FormalParameterList parameters = parseFormalParameterList();
       if (thisKeyword == null) {
         if (holder.keyword != null) {
           _reportErrorForToken(
               ParserErrorCode.FUNCTION_TYPED_PARAMETER_VAR,
               holder.keyword);
@@ skipping 54 matching lines @@
    *     identifier ('.' identifier)?
    * </pre>
    *
    * @return the prefixed identifier that was parsed
    */
   Identifier parsePrefixedIdentifier() {
     SimpleIdentifier qualifier = parseSimpleIdentifier();
     if (!_matches(TokenType.PERIOD)) {
       return qualifier;
     }
-    Token period = andAdvance;
+    Token period = getAndAdvance();
     SimpleIdentifier qualified = parseSimpleIdentifier();
     return new PrefixedIdentifier(qualifier, period, qualified);
   }
 
   /**
    * Parse a return type.
    *
    * <pre>
    * returnType ::=
    *     'void'
    *   | type
    * </pre>
    *
    * @return the return type that was parsed
    */
   TypeName parseReturnType() {
     if (_matchesKeyword(Keyword.VOID)) {
-      return new TypeName(new SimpleIdentifier(andAdvance), null);
+      return new TypeName(new SimpleIdentifier(getAndAdvance()), null);
     } else {
       return parseTypeName();
     }
   }
 
   /**
    * Parse a simple identifier.
    *
    * <pre>
    * identifier ::=
    *     IDENTIFIER
    * </pre>
    *
    * @return the simple identifier that was parsed
    */
   SimpleIdentifier parseSimpleIdentifier() {
     if (_matchesIdentifier()) {
-      return new SimpleIdentifier(andAdvance);
+      return new SimpleIdentifier(getAndAdvance());
     }
     _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
     return _createSyntheticIdentifier();
   }
 
   /**
    * Parse a statement, starting with the given token.
    *
    * @param token the first token of the statement
    * @return the statement that was parsed, or `null` if the tokens do not represent a
@@ skipping 59 matching lines @@
    * stringLiteral ::=
    *     MULTI_LINE_STRING+
    *   | SINGLE_LINE_STRING+
    * </pre>
    *
    * @return the string literal that was parsed
    */
   StringLiteral parseStringLiteral() {
     List<StringLiteral> strings = new List<StringLiteral>();
     while (_matches(TokenType.STRING)) {
-      Token string = andAdvance;
+      Token string = getAndAdvance();
       if (_matches(TokenType.STRING_INTERPOLATION_EXPRESSION) ||
           _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER)) {
         strings.add(_parseStringInterpolation(string));
       } else {
         strings.add(
             new SimpleStringLiteral(
                 string,
                 _computeStringValue(string.lexeme, true, true)));
       }
     }
@@ skipping 38 matching lines @@
    * type ::=
    *     qualified typeArguments?
    * </pre>
    *
    * @return the type name that was parsed
    */
   TypeName parseTypeName() {
     Identifier typeName;
     if (_matchesKeyword(Keyword.VAR)) {
       _reportErrorForCurrentToken(ParserErrorCode.VAR_AS_TYPE_NAME);
-      typeName = new SimpleIdentifier(andAdvance);
+      typeName = new SimpleIdentifier(getAndAdvance());
     } else if (_matchesIdentifier()) {
       typeName = parsePrefixedIdentifier();
     } else {
       typeName = _createSyntheticIdentifier();
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TYPE_NAME);
     }
     TypeArgumentList typeArguments = null;
     if (_matches(TokenType.LT)) {
       typeArguments = parseTypeArgumentList();
     }
     return new TypeName(typeName, typeArguments);
   }
 
   /**
    * Parse a type parameter.
    *
    * <pre>
    * typeParameter ::=
    *     metadata name ('extends' bound)?
    * </pre>
    *
    * @return the type parameter that was parsed
    */
   TypeParameter parseTypeParameter() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name = parseSimpleIdentifier();
     if (_matchesKeyword(Keyword.EXTENDS)) {
-      Token keyword = andAdvance;
+      Token keyword = getAndAdvance();
       TypeName bound = parseTypeName();
       return new TypeParameter(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           name,
           keyword,
           bound);
     }
     return new TypeParameter(
         commentAndMetadata.comment,
@@ skipping 275 matching lines @@
    * the next token. Otherwise report an error and return the current token
    * without advancing.
    *
    * Note that the method [_expectGt] should be used if the argument to this
    * method would be [TokenType.GT].
    *
    * The [type] is the type of token that is expected.
    */
   Token _expect(TokenType type) {
     if (_matches(type)) {
-      return andAdvance;
+      return getAndAdvance();
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     if (type == TokenType.SEMICOLON) {
       if (_tokenMatches(_currentToken.next, TokenType.SEMICOLON)) {
         _reportErrorForCurrentToken(
             ParserErrorCode.UNEXPECTED_TOKEN,
             [_currentToken.lexeme]);
         _advance();
-        return andAdvance;
+        return getAndAdvance();
       }
       _reportErrorForToken(
           ParserErrorCode.EXPECTED_TOKEN,
           _currentToken.previous,
           [type.lexeme]);
     } else {
       _reportErrorForCurrentToken(
           ParserErrorCode.EXPECTED_TOKEN,
           [type.lexeme]);
     }
     return _currentToken;
   }
 
   /**
    * If the current token has the type [TokenType.GT], return it after advancing to the next
    * token. Otherwise report an error and return the current token without advancing.
    *
    * @return the token that matched the given type
    */
   Token _expectGt() {
     if (_matchesGt()) {
-      return andAdvance;
+      return getAndAdvance();
     }
     _reportErrorForCurrentToken(
         ParserErrorCode.EXPECTED_TOKEN,
         [TokenType.GT.lexeme]);
     return _currentToken;
   }
 
   /**
    * If the current token is a keyword matching the given string, return it after advancing to the
    * next token. Otherwise report an error and return the current token without advancing.
    *
    * @param keyword the keyword that is expected
    * @return the token that matched the given type
    */
   Token _expectKeyword(Keyword keyword) {
     if (_matchesKeyword(keyword)) {
-      return andAdvance;
+      return getAndAdvance();
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     _reportErrorForCurrentToken(
         ParserErrorCode.EXPECTED_TOKEN,
         [keyword.syntax]);
     return _currentToken;
   }
 
   /**
    * If [currentToken] is a semicolon, returns it; otherwise reports error and creates a
    * synthetic one.
    *
    * TODO(scheglov) consider pushing this into [expect]
    */
   Token _expectSemicolon() {
     if (_matches(TokenType.SEMICOLON)) {
-      return andAdvance;
+      return getAndAdvance();
     } else {
       _reportErrorForToken(
           ParserErrorCode.EXPECTED_TOKEN,
           _currentToken.previous,
           [";"]);
       return _createSyntheticToken(TokenType.SEMICOLON);
     }
   }
 
   /**
@@ skipping 468 matching lines @@
    *     multiplicativeExpression (additiveOperator multiplicativeExpression)*
    *   | 'super' (additiveOperator multiplicativeExpression)+
    * </pre>
    *
    * @return the additive expression that was parsed
    */
   Expression _parseAdditiveExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _currentToken.next.type.isAdditiveOperator) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseMultiplicativeExpression();
     }
     while (_currentToken.type.isAdditiveOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseMultiplicativeExpression());
     }
     return expression;
   }
 
   /**
    * Parse an assert statement.
    *
    * <pre>
@@ skipping 43 matching lines @@
    *   | 'super' assignableSelector
    *   | identifier
    * </pre>
    *
    * @param primaryAllowed `true` if the expression is allowed to be a primary without any
    *          assignable selector
    * @return the assignable expression that was parsed
    */
   Expression _parseAssignableExpression(bool primaryAllowed) {
     if (_matchesKeyword(Keyword.SUPER)) {
-      return _parseAssignableSelector(new SuperExpression(andAdvance), false);
+      return _parseAssignableSelector(new SuperExpression(getAndAdvance()), false);
     }
     //
     // A primary expression can start with an identifier. We resolve the
     // ambiguity by determining whether the primary consists of anything other
     // than an identifier and/or is followed by an assignableSelector.
     //
     Expression expression = _parsePrimaryExpression();
     bool isOptional = primaryAllowed || expression is SimpleIdentifier;
     while (true) {
       while (_matches(TokenType.OPEN_PAREN)) {
@@ skipping 50 matching lines @@
    *   | '.' identifier
    * </pre>
    *
    * @param prefix the expression preceding the selector
    * @param optional `true` if the selector is optional
    * @return the assignable selector that was parsed, or the original prefix if there was no
    *         assignable selector
    */
   Expression _parseAssignableSelector(Expression prefix, bool optional) {
     if (_matches(TokenType.OPEN_SQUARE_BRACKET)) {
-      Token leftBracket = andAdvance;
+      Token leftBracket = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         return new IndexExpression.forTarget(
             prefix,
             leftBracket,
             index,
             rightBracket);
       } finally {
         _inInitializer = wasInInitializer;
       }
     } else if (_matches(TokenType.PERIOD)) {
-      Token period = andAdvance;
+      Token period = getAndAdvance();
       return new PropertyAccess(prefix, period, parseSimpleIdentifier());
     } else {
       if (!optional) {
         // Report the missing selector.
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR);
       }
       return prefix;
     }
   }
 
   /**
    * Parse a await expression.
    *
    * <pre>
    * awaitExpression ::=
    *     'await' unaryExpression
    * </pre>
    *
    * @return the await expression that was parsed
    */
   AwaitExpression _parseAwaitExpression() {
-    Token awaitToken = andAdvance;
+    Token awaitToken = getAndAdvance();
     Expression expression = _parseUnaryExpression();
     return new AwaitExpression(awaitToken, expression);
   }
 
   /**
    * Parse a bitwise and expression.
    *
    * <pre>
    * bitwiseAndExpression ::=
    *     shiftExpression ('&' shiftExpression)*
    *   | 'super' ('&' shiftExpression)+
    * </pre>
    *
    * @return the bitwise and expression that was parsed
    */
   Expression _parseBitwiseAndExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _tokenMatches(_peek(), TokenType.AMPERSAND)) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseShiftExpression();
     }
     while (_matches(TokenType.AMPERSAND)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseShiftExpression());
     }
     return expression;
   }
 
   /**
    * Parse a bitwise exclusive-or expression.
    *
    * <pre>
    * bitwiseXorExpression ::=
    *     bitwiseAndExpression ('^' bitwiseAndExpression)*
    *   | 'super' ('^' bitwiseAndExpression)+
    * </pre>
    *
    * @return the bitwise exclusive-or expression that was parsed
    */
   Expression _parseBitwiseXorExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _tokenMatches(_peek(), TokenType.CARET)) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseBitwiseAndExpression();
     }
     while (_matches(TokenType.CARET)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseBitwiseAndExpression());
     }
     return expression;
   }
 
   /**
    * Parse a break statement.
    *
    * <pre>
@@ skipping 33 matching lines @@
    *
    * @return the expression representing the cascaded method invocation
    */
   Expression _parseCascadeSection() {
     Token period = _expect(TokenType.PERIOD_PERIOD);
     Expression expression = null;
     SimpleIdentifier functionName = null;
     if (_matchesIdentifier()) {
       functionName = parseSimpleIdentifier();
     } else if (_currentToken.type == TokenType.OPEN_SQUARE_BRACKET) {
-      Token leftBracket = andAdvance;
+      Token leftBracket = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression index = parseExpression2();
         Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
         expression =
             new IndexExpression.forCascade(period, leftBracket, index, rightBracket);
         period = null;
       } finally {
         _inInitializer = wasInInitializer;
@@ skipping 47 matching lines @@
                 propertyAccess.propertyName,
                 parseArgumentList());
           } else {
             expression =
                 new FunctionExpressionInvocation(expression, parseArgumentList());
           }
         }
       }
     }
     if (_currentToken.type.isAssignmentOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       _ensureAssignable(expression);
       expression = new AssignmentExpression(
           expression,
           operator,
           parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
@@ skipping 216 matching lines @@
       _reportErrorForCurrentToken(
           ParserErrorCode.EXPECTED_TOKEN,
           [Keyword.WITH.syntax]);
     }
     ImplementsClause implementsClause = null;
     if (_matchesKeyword(Keyword.IMPLEMENTS)) {
       implementsClause = parseImplementsClause();
     }
     Token semicolon;
     if (_matches(TokenType.SEMICOLON)) {
-      semicolon = andAdvance;
+      semicolon = getAndAdvance();
     } else {
       if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
         _reportErrorForCurrentToken(
             ParserErrorCode.EXPECTED_TOKEN,
             [TokenType.SEMICOLON.lexeme]);
-        Token leftBracket = andAdvance;
+        Token leftBracket = getAndAdvance();
         _parseClassMembers(className.name, _getEndToken(leftBracket));
         _expect(TokenType.CLOSE_CURLY_BRACKET);
       } else {
         _reportErrorForToken(
             ParserErrorCode.EXPECTED_TOKEN,
             _currentToken.previous,
             [TokenType.SEMICOLON.lexeme]);
       }
       semicolon = _createSyntheticToken(TokenType.SEMICOLON);
     }
@@ skipping 368 matching lines @@
               null,
               _validateModifiersForTopLevelVariable(modifiers),
               returnType),
           _expect(TokenType.SEMICOLON));
     } else if (!_matchesIdentifier()) {
       // TODO(brianwilkerson) Generalize this error. We could also be parsing a
       // top-level variable at this point.
       _reportErrorForToken(ParserErrorCode.EXPECTED_EXECUTABLE, _currentToken);
       Token semicolon;
       if (_matches(TokenType.SEMICOLON)) {
-        semicolon = andAdvance;
+        semicolon = getAndAdvance();
       } else {
         semicolon = _createSyntheticToken(TokenType.SEMICOLON);
       }
       List<VariableDeclaration> variables = new List<VariableDeclaration>();
       variables.add(
           new VariableDeclaration(null, null, _createSyntheticIdentifier(), null, null));
       return new TopLevelVariableDeclaration(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           new VariableDeclarationList(null, null, null, returnType, variables),
@@ skipping 42 matching lines @@
   }
 
   ConstructorDeclaration
       _parseConstructor(CommentAndMetadata commentAndMetadata, Token externalKeyword,
       Token constKeyword, Token factoryKeyword, SimpleIdentifier returnType,
       Token period, SimpleIdentifier name, FormalParameterList parameters) {
     bool bodyAllowed = externalKeyword == null;
     Token separator = null;
     List<ConstructorInitializer> initializers = null;
     if (_matches(TokenType.COLON)) {
-      separator = andAdvance;
+      separator = getAndAdvance();
       initializers = new List<ConstructorInitializer>();
       do {
         if (_matchesKeyword(Keyword.THIS)) {
           if (_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
             bodyAllowed = false;
             initializers.add(_parseRedirectingConstructorInvocation());
           } else if (_tokenMatches(_peek(), TokenType.PERIOD) &&
               _tokenMatches(_peekAt(3), TokenType.OPEN_PAREN)) {
             bodyAllowed = false;
             initializers.add(_parseRedirectingConstructorInvocation());
@@ skipping 11 matching lines @@
       } while (_optional(TokenType.COMMA));
       if (factoryKeyword != null) {
         _reportErrorForToken(
             ParserErrorCode.FACTORY_WITH_INITIALIZERS,
             factoryKeyword);
       }
     }
     ConstructorName redirectedConstructor = null;
     FunctionBody body;
     if (_matches(TokenType.EQ)) {
-      separator = andAdvance;
+      separator = getAndAdvance();
       redirectedConstructor = parseConstructorName();
       body = new EmptyFunctionBody(_expect(TokenType.SEMICOLON));
       if (factoryKeyword == null) {
         _reportErrorForNode(
             ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR,
             redirectedConstructor);
       }
     } else {
       body =
           _parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
@@ skipping 42 matching lines @@
    * fieldInitializer:
    *     ('this' '.')? identifier '=' conditionalExpression cascadeSection*
    * </pre>
    *
    * @return the field initializer that was parsed
    */
   ConstructorFieldInitializer _parseConstructorFieldInitializer() {
     Token keyword = null;
     Token period = null;
     if (_matchesKeyword(Keyword.THIS)) {
-      keyword = andAdvance;
+      keyword = getAndAdvance();
       period = _expect(TokenType.PERIOD);
     }
     SimpleIdentifier fieldName = parseSimpleIdentifier();
     Token equals = null;
     if (_matches(TokenType.EQ)) {
-      equals = andAdvance;
+      equals = getAndAdvance();
     } else if (!_matchesKeyword(Keyword.THIS) &&
         !_matchesKeyword(Keyword.SUPER) &&
         !_matches(TokenType.OPEN_CURLY_BRACKET) &&
         !_matches(TokenType.FUNCTION)) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER);
       equals = _createSyntheticToken(TokenType.EQ);
     } else {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER);
@@ skipping 101 matching lines @@
    * compilationUnit ::=
    *     scriptTag? directive*
    * </pre>
    *
    * @return the compilation unit that was parsed
    */
   CompilationUnit _parseDirectives() {
     Token firstToken = _currentToken;
     ScriptTag scriptTag = null;
     if (_matches(TokenType.SCRIPT_TAG)) {
-      scriptTag = new ScriptTag(andAdvance);
+      scriptTag = new ScriptTag(getAndAdvance());
     }
     List<Directive> directives = new List<Directive>();
     while (!_matches(TokenType.EOF)) {
       CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
       if ((_matchesKeyword(Keyword.IMPORT) ||
           _matchesKeyword(Keyword.EXPORT) ||
           _matchesKeyword(Keyword.LIBRARY) ||
           _matchesKeyword(Keyword.PART)) &&
           !_tokenMatches(_peek(), TokenType.PERIOD) &&
           !_tokenMatches(_peek(), TokenType.LT) &&
@@ skipping 99 matching lines @@
   /**
    * Parse an empty statement.
    *
    * <pre>
    * emptyStatement ::=
    *     ';'
    * </pre>
    *
    * @return the empty statement that was parsed
    */
-  Statement _parseEmptyStatement() => new EmptyStatement(andAdvance);
+  Statement _parseEmptyStatement() => new EmptyStatement(getAndAdvance());
 
   EnumConstantDeclaration _parseEnumConstantDeclaration() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name;
     if (_matchesIdentifier()) {
       name = parseSimpleIdentifier();
     } else {
       name = _createSyntheticIdentifier();
     }
     return new EnumConstantDeclaration(
@@ skipping 62 matching lines @@
    *     relationalExpression (equalityOperator relationalExpression)?
    *   | 'super' equalityOperator relationalExpression
    * </pre>
    *
    * @return the equality expression that was parsed
    */
   Expression _parseEqualityExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _currentToken.next.type.isEqualityOperator) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseRelationalExpression();
     }
     bool leftEqualityExpression = false;
     while (_currentToken.type.isEqualityOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       if (leftEqualityExpression) {
         _reportErrorForNode(
             ParserErrorCode.EQUALITY_CANNOT_BE_EQUALITY_OPERAND,
             expression);
       }
       expression =
           new BinaryExpression(expression, operator, _parseRelationalExpression());
       leftEqualityExpression = true;
     }
     return expression;
@@ skipping 54 matching lines @@
    *   | type
    * </pre>
    *
    * @param optional `true` if the keyword and type are optional
    * @return the 'final', 'const', 'var' or type that was parsed
    */
   FinalConstVarOrType _parseFinalConstVarOrType(bool optional) {
     Token keyword = null;
     TypeName type = null;
     if (_matchesKeyword(Keyword.FINAL) || _matchesKeyword(Keyword.CONST)) {
-      keyword = andAdvance;
+      keyword = getAndAdvance();
       if (_isTypedIdentifier(_currentToken)) {
         type = parseTypeName();
       }
     } else if (_matchesKeyword(Keyword.VAR)) {
-      keyword = andAdvance;
+      keyword = getAndAdvance();
     } else {
       if (_isTypedIdentifier(_currentToken)) {
         type = parseReturnType();
       } else if (!optional) {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE);
       }
     }
     return new FinalConstVarOrType(keyword, type);
   }
@@ skipping 10 matching lines @@
    *     normalFormalParameter (':' expression)?
    * </pre>
    *
    * @param kind the kind of parameter being expected based on the presence or absence of group
    *          delimiters
    * @return the formal parameter that was parsed
    */
   FormalParameter _parseFormalParameter(ParameterKind kind) {
     NormalFormalParameter parameter = parseNormalFormalParameter();
     if (_matches(TokenType.EQ)) {
-      Token seperator = andAdvance;
+      Token seperator = getAndAdvance();
       Expression defaultValue = parseExpression2();
       if (kind == ParameterKind.NAMED) {
         _reportErrorForToken(
             ParserErrorCode.WRONG_SEPARATOR_FOR_NAMED_PARAMETER,
             seperator);
       } else if (kind == ParameterKind.REQUIRED) {
         _reportErrorForNode(
             ParserErrorCode.POSITIONAL_PARAMETER_OUTSIDE_GROUP,
             parameter);
       }
       return new DefaultFormalParameter(
           parameter,
           kind,
           seperator,
           defaultValue);
     } else if (_matches(TokenType.COLON)) {
-      Token seperator = andAdvance;
+      Token seperator = getAndAdvance();
       Expression defaultValue = parseExpression2();
       if (kind == ParameterKind.POSITIONAL) {
         _reportErrorForToken(
             ParserErrorCode.WRONG_SEPARATOR_FOR_POSITIONAL_PARAMETER,
             seperator);
       } else if (kind == ParameterKind.REQUIRED) {
         _reportErrorForNode(
             ParserErrorCode.NAMED_PARAMETER_OUTSIDE_GROUP,
             parameter);
       }
@@ skipping 26 matching lines @@
    * </pre>
    *
    * @return the for statement that was parsed
    */
   Statement _parseForStatement() {
     bool wasInLoop = _inLoop;
     _inLoop = true;
     try {
       Token awaitKeyword = null;
       if (_matchesString(_AWAIT)) {
-        awaitKeyword = andAdvance;
+        awaitKeyword = getAndAdvance();
       }
       Token forKeyword = _expectKeyword(Keyword.FOR);
       Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
       VariableDeclarationList variableList = null;
       Expression initialization = null;
       if (!_matches(TokenType.SEMICOLON)) {
         CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
         if (_matchesIdentifier() && (_tokenMatchesKeyword(_peek(), Keyword.IN) || _tokenMatches(_peek(), TokenType.COLON))) {
           List<VariableDeclaration> variables = new List<VariableDeclaration>();
           SimpleIdentifier variableName = parseSimpleIdentifier();
@@ skipping 44 matching lines @@
                   variable.name);
             } else {
               if (!commentAndMetadata.metadata.isEmpty) {
                 // TODO(jwren) metadata isn't allowed before the identifier in
                 // "identifier in expression", add warning if commentAndMetadata
                 // has content
               }
               identifier = variable.name;
             }
           }
-          Token inKeyword = andAdvance;
+          Token inKeyword = getAndAdvance();
           Expression iterator = parseExpression2();
           Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
           Statement body = parseStatement2();
           if (loopVariable == null) {
             return new ForEachStatement.con2(
                 awaitKeyword,
                 forKeyword,
                 leftParenthesis,
                 identifier,
                 inKeyword,
@@ skipping 72 matching lines @@
     bool wasInSwitch = _inSwitch;
     _inAsync = false;
     _inGenerator = false;
     _inLoop = false;
     _inSwitch = false;
     try {
       if (_matches(TokenType.SEMICOLON)) {
         if (!mayBeEmpty) {
           _reportErrorForCurrentToken(emptyErrorCode);
         }
-        return new EmptyFunctionBody(andAdvance);
+        return new EmptyFunctionBody(getAndAdvance());
       } else if (_matchesString(_NATIVE)) {
-        Token nativeToken = andAdvance;
+        Token nativeToken = getAndAdvance();
         StringLiteral stringLiteral = null;
         if (_matches(TokenType.STRING)) {
           stringLiteral = parseStringLiteral();
         }
         return new NativeFunctionBody(
             nativeToken,
             stringLiteral,
             _expect(TokenType.SEMICOLON));
       }
       Token keyword = null;
       Token star = null;
       if (_parseAsync) {
         if (_matchesString(ASYNC)) {
-          keyword = andAdvance;
+          keyword = getAndAdvance();
           if (_matches(TokenType.STAR)) {
-            star = andAdvance;
+            star = getAndAdvance();
             _inGenerator = true;
           }
           _inAsync = true;
         } else if (_matchesString(SYNC)) {
-          keyword = andAdvance;
+          keyword = getAndAdvance();
           if (_matches(TokenType.STAR)) {
-            star = andAdvance;
+            star = getAndAdvance();
             _inGenerator = true;
           }
         }
       }
       if (_matches(TokenType.FUNCTION)) {
         if (keyword != null) {
           if (!_tokenMatchesString(keyword, ASYNC)) {
             _reportErrorForToken(ParserErrorCode.INVALID_SYNC, keyword);
             keyword = null;
           } else if (star != null) {
             _reportErrorForToken(
                 ParserErrorCode.INVALID_STAR_AFTER_ASYNC,
                 star);
           }
         }
-        Token functionDefinition = andAdvance;
+        Token functionDefinition = getAndAdvance();
         if (_matchesKeyword(Keyword.RETURN)) {
           _reportErrorForToken(
               ParserErrorCode.UNEXPECTED_TOKEN,
-              andAdvance);
+              getAndAdvance());
         }
         Expression expression = parseExpression2();
         Token semicolon = null;
         if (!inExpression) {
           semicolon = _expect(TokenType.SEMICOLON);
         }
         if (!_parseFunctionBodies) {
           return new EmptyFunctionBody(
               _createSyntheticToken(TokenType.SEMICOLON));
         }
@@ skipping 46 matching lines @@
    * @param isStatement `true` if the function declaration is being parsed as a statement
    * @return the function declaration that was parsed
    */
   FunctionDeclaration
       _parseFunctionDeclaration(CommentAndMetadata commentAndMetadata,
       Token externalKeyword, TypeName returnType) {
     Token keyword = null;
     bool isGetter = false;
     if (_matchesKeyword(Keyword.GET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
-      keyword = andAdvance;
+      keyword = getAndAdvance();
       isGetter = true;
     } else if (_matchesKeyword(Keyword.SET) &&
         !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
-      keyword = andAdvance;
+      keyword = getAndAdvance();
     }
     SimpleIdentifier name = parseSimpleIdentifier();
     FormalParameterList parameters = null;
     if (!isGetter) {
       if (_matches(TokenType.OPEN_PAREN)) {
         parameters = parseFormalParameterList();
         _validateFormalParameterList(parameters);
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.MISSING_FUNCTION_PARAMETERS);
@@ skipping 235 matching lines @@
    */
   Statement _parseIfStatement() {
     Token ifKeyword = _expectKeyword(Keyword.IF);
     Token leftParenthesis = _expect(TokenType.OPEN_PAREN);
     Expression condition = parseExpression2();
     Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
     Statement thenStatement = parseStatement2();
     Token elseKeyword = null;
     Statement elseStatement = null;
     if (_matchesKeyword(Keyword.ELSE)) {
-      elseKeyword = andAdvance;
+      elseKeyword = getAndAdvance();
       elseStatement = parseStatement2();
     }
     return new IfStatement(
         ifKeyword,
         leftParenthesis,
         condition,
         rightParenthesis,
         thenStatement,
         elseKeyword,
         elseStatement);
@@ skipping 11 matching lines @@
    * @return the import directive that was parsed
    */
   ImportDirective _parseImportDirective(CommentAndMetadata commentAndMetadata) {
     Token importKeyword = _expectKeyword(Keyword.IMPORT);
     StringLiteral libraryUri = _parseUri();
     Token deferredToken = null;
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (_matchesKeyword(Keyword.DEFERRED)) {
       if (_parseDeferredLibraries) {
-        deferredToken = andAdvance;
+        deferredToken = getAndAdvance();
       } else {
         _reportErrorForCurrentToken(
             ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED);
         _advance();
       }
     }
     if (_matchesKeyword(Keyword.AS)) {
-      asToken = andAdvance;
+      asToken = getAndAdvance();
       prefix = parseSimpleIdentifier();
     } else if (deferredToken != null) {
       _reportErrorForCurrentToken(
           ParserErrorCode.MISSING_PREFIX_IN_DEFERRED_IMPORT);
     }
     List<Combinator> combinators = _parseCombinators();
     Token semicolon = _expectSemicolon();
     return new ImportDirective(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
@@ skipping 153 matching lines @@
           rightBracket);
     }
     // open
     Token leftBracket = _expect(TokenType.OPEN_SQUARE_BRACKET);
     if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
       return new ListLiteral(
           modifier,
           typeArguments,
           leftBracket,
           null,
-          andAdvance);
+          getAndAdvance());
     }
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
       List<Expression> elements = new List<Expression>();
       elements.add(parseExpression2());
       while (_optional(TokenType.COMMA)) {
         if (_matches(TokenType.CLOSE_SQUARE_BRACKET)) {
           return new ListLiteral(
               modifier,
               typeArguments,
               leftBracket,
               elements,
-              andAdvance);
+              getAndAdvance());
         }
         elements.add(parseExpression2());
       }
       Token rightBracket = _expect(TokenType.CLOSE_SQUARE_BRACKET);
       return new ListLiteral(
           modifier,
           typeArguments,
           leftBracket,
           elements,
           rightBracket);
@@ skipping 41 matching lines @@
    * <pre>
    * logicalAndExpression ::=
    *     equalityExpression ('&&' equalityExpression)*
    * </pre>
    *
    * @return the logical and expression that was parsed
    */
   Expression _parseLogicalAndExpression() {
     Expression expression = _parseEqualityExpression();
     while (_matches(TokenType.AMPERSAND_AMPERSAND)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseEqualityExpression());
     }
     return expression;
   }
 
   /**
    * Parse a map literal.
    *
    * <pre>
    * mapLiteral ::=
    *     'const'? typeArguments? '{' (mapLiteralEntry (',' mapLiteralEntry)* ','?)? '}'
    * </pre>
    *
    * @param modifier the 'const' modifier appearing before the literal, or `null` if there is
    *          no modifier
    * @param typeArguments the type arguments that were declared, or `null` if there are no
    *          type arguments
    * @return the map literal that was parsed
    */
   MapLiteral _parseMapLiteral(Token modifier, TypeArgumentList typeArguments) {
     Token leftBracket = _expect(TokenType.OPEN_CURLY_BRACKET);
     List<MapLiteralEntry> entries = new List<MapLiteralEntry>();
     if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
       return new MapLiteral(
           modifier,
           typeArguments,
           leftBracket,
           entries,
-          andAdvance);
+          getAndAdvance());
     }
     bool wasInInitializer = _inInitializer;
     _inInitializer = false;
     try {
       entries.add(parseMapLiteralEntry());
       while (_optional(TokenType.COMMA)) {
         if (_matches(TokenType.CLOSE_CURLY_BRACKET)) {
           return new MapLiteral(
               modifier,
               typeArguments,
               leftBracket,
               entries,
-              andAdvance);
+              getAndAdvance());
         }
         entries.add(parseMapLiteralEntry());
       }
       Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
       return new MapLiteral(
           modifier,
           typeArguments,
           leftBracket,
           entries,
           rightBracket);
@@ skipping 117 matching lines @@
           _tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
         return modifiers;
       }
       if (_matchesKeyword(Keyword.ABSTRACT)) {
         if (modifiers.abstractKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.abstractKeyword = andAdvance;
+          modifiers.abstractKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.CONST)) {
         if (modifiers.constKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.constKeyword = andAdvance;
+          modifiers.constKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.EXTERNAL) &&
           !_tokenMatches(_peek(), TokenType.PERIOD) &&
           !_tokenMatches(_peek(), TokenType.LT)) {
         if (modifiers.externalKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.externalKeyword = andAdvance;
+          modifiers.externalKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.FACTORY) &&
           !_tokenMatches(_peek(), TokenType.PERIOD) &&
           !_tokenMatches(_peek(), TokenType.LT)) {
         if (modifiers.factoryKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.factoryKeyword = andAdvance;
+          modifiers.factoryKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.FINAL)) {
         if (modifiers.finalKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.finalKeyword = andAdvance;
+          modifiers.finalKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.STATIC) &&
           !_tokenMatches(_peek(), TokenType.PERIOD) &&
           !_tokenMatches(_peek(), TokenType.LT)) {
         if (modifiers.staticKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.staticKeyword = andAdvance;
+          modifiers.staticKeyword = getAndAdvance();
         }
       } else if (_matchesKeyword(Keyword.VAR)) {
         if (modifiers.varKeyword != null) {
           _reportErrorForCurrentToken(
               ParserErrorCode.DUPLICATED_MODIFIER,
               [_currentToken.lexeme]);
           _advance();
         } else {
-          modifiers.varKeyword = andAdvance;
+          modifiers.varKeyword = getAndAdvance();
         }
       } else {
         progress = false;
       }
     }
     return modifiers;
   }
 
   /**
    * Parse a multiplicative expression.
    *
    * <pre>
    * multiplicativeExpression ::=
    *     unaryExpression (multiplicativeOperator unaryExpression)*
    *   | 'super' (multiplicativeOperator unaryExpression)+
    * </pre>
    *
    * @return the multiplicative expression that was parsed
    */
   Expression _parseMultiplicativeExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _currentToken.next.type.isMultiplicativeOperator) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseUnaryExpression();
     }
     while (_currentToken.type.isMultiplicativeOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseUnaryExpression());
     }
     return expression;
   }
 
   /**
    * Parse a class native clause.
    *
    * <pre>
    * classNativeClause ::=
    *     'native' name
    * </pre>
    *
    * @return the class native clause that was parsed
    */
   NativeClause _parseNativeClause() {
-    Token keyword = andAdvance;
+    Token keyword = getAndAdvance();
     StringLiteral name = parseStringLiteral();
     return new NativeClause(keyword, name);
   }
 
   /**
    * Parse a new expression.
    *
    * <pre>
    * newExpression ::=
    *     instanceCreationExpression
@@ skipping 204 matching lines @@
    *          declaration
    * @param externalKeyword the 'external' token
    * @param the return type that has already been parsed, or `null` if there was no return
    *          type
    * @return the operator declaration that was parsed
    */
   MethodDeclaration _parseOperator(CommentAndMetadata commentAndMetadata,
       Token externalKeyword, TypeName returnType) {
     Token operatorKeyword;
     if (_matchesKeyword(Keyword.OPERATOR)) {
-      operatorKeyword = andAdvance;
+      operatorKeyword = getAndAdvance();
     } else {
       _reportErrorForToken(
           ParserErrorCode.MISSING_KEYWORD_OPERATOR,
           _currentToken);
       operatorKeyword = _createSyntheticKeyword(Keyword.OPERATOR);
     }
     if (!_currentToken.isUserDefinableOperator) {
       _reportErrorForCurrentToken(
           ParserErrorCode.NON_USER_DEFINABLE_OPERATOR,
           [_currentToken.lexeme]);
     }
-    SimpleIdentifier name = new SimpleIdentifier(andAdvance);
+    SimpleIdentifier name = new SimpleIdentifier(getAndAdvance());
     if (_matches(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((_tokenMatches(previous, TokenType.EQ_EQ) ||
           _tokenMatches(previous, TokenType.BANG_EQ)) &&
           _currentToken.offset == previous.offset + 2) {
         _reportErrorForCurrentToken(
             ParserErrorCode.INVALID_OPERATOR,
             ["${previous.lexeme}${_currentToken.lexeme}"]);
         _advance();
       }
@@ skipping 52 matching lines @@
    * partOfDirective ::=
    *     metadata 'part' 'of' identifier ';'
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the directive
    * @return the part or part-of directive that was parsed
    */
   Directive _parsePartDirective(CommentAndMetadata commentAndMetadata) {
     Token partKeyword = _expectKeyword(Keyword.PART);
     if (_matchesString(_OF)) {
-      Token ofKeyword = andAdvance;
+      Token ofKeyword = getAndAdvance();
       LibraryIdentifier libraryName = _parseLibraryName(
           ParserErrorCode.MISSING_NAME_IN_PART_OF_DIRECTIVE,
           ofKeyword);
       Token semicolon = _expect(TokenType.SEMICOLON);
       return new PartOfDirective(
           commentAndMetadata.comment,
           commentAndMetadata.metadata,
           partKeyword,
           ofKeyword,
           libraryName,
@@ skipping 47 matching lines @@
         }
       } while (_matches(TokenType.OPEN_SQUARE_BRACKET) ||
           _matches(TokenType.PERIOD) ||
           _matches(TokenType.OPEN_PAREN));
       return operand;
     }
     if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
     _ensureAssignable(operand);
-    Token operator = andAdvance;
+    Token operator = getAndAdvance();
     return new PostfixExpression(operand, operator);
   }
 
   /**
    * Parse a primary expression.
    *
    * <pre>
    * primary ::=
    *     thisExpression
    *   | 'super' assignableSelector
@@ skipping 12 matching lines @@
    *   | stringLiteral
    *   | symbolLiteral
    *   | mapLiteral
    *   | listLiteral
    * </pre>
    *
    * @return the primary expression that was parsed
    */
   Expression _parsePrimaryExpression() {
     if (_matchesKeyword(Keyword.THIS)) {
-      return new ThisExpression(andAdvance);
+      return new ThisExpression(getAndAdvance());
     } else if (_matchesKeyword(Keyword.SUPER)) {
-      return _parseAssignableSelector(new SuperExpression(andAdvance), false);
+      return _parseAssignableSelector(new SuperExpression(getAndAdvance()), false);
     } else if (_matchesKeyword(Keyword.NULL)) {
-      return new NullLiteral(andAdvance);
+      return new NullLiteral(getAndAdvance());
     } else if (_matchesKeyword(Keyword.FALSE)) {
-      return new BooleanLiteral(andAdvance, false);
+      return new BooleanLiteral(getAndAdvance(), false);
     } else if (_matchesKeyword(Keyword.TRUE)) {
-      return new BooleanLiteral(andAdvance, true);
+      return new BooleanLiteral(getAndAdvance(), true);
     } else if (_matches(TokenType.DOUBLE)) {
-      Token token = andAdvance;
+      Token token = getAndAdvance();
       double value = 0.0;
       try {
         value = double.parse(token.lexeme);
       } on FormatException catch (exception) {
         // The invalid format should have been reported by the scanner.
       }
       return new DoubleLiteral(token, value);
     } else if (_matches(TokenType.HEXADECIMAL)) {
-      Token token = andAdvance;
+      Token token = getAndAdvance();
       int value = null;
       try {
         value = int.parse(token.lexeme.substring(2), radix: 16);
       } on FormatException catch (exception) {
         // The invalid format should have been reported by the scanner.
       }
       return new IntegerLiteral(token, value);
     } else if (_matches(TokenType.INT)) {
-      Token token = andAdvance;
+      Token token = getAndAdvance();
       int value = null;
       try {
         value = int.parse(token.lexeme);
       } on FormatException catch (exception) {
         // The invalid format should have been reported by the scanner.
       }
       return new IntegerLiteral(token, value);
     } else if (_matches(TokenType.STRING)) {
       return parseStringLiteral();
     } else if (_matches(TokenType.OPEN_CURLY_BRACKET)) {
@@ skipping 15 matching lines @@
 //            }
       return parsePrefixedIdentifier();
     } else if (_matchesKeyword(Keyword.NEW)) {
       return _parseNewExpression();
     } else if (_matchesKeyword(Keyword.CONST)) {
       return _parseConstExpression();
     } else if (_matches(TokenType.OPEN_PAREN)) {
       if (_isFunctionExpression(_currentToken)) {
         return parseFunctionExpression();
       }
-      Token leftParenthesis = andAdvance;
+      Token leftParenthesis = getAndAdvance();
       bool wasInInitializer = _inInitializer;
       _inInitializer = false;
       try {
         Expression expression = parseExpression2();
         Token rightParenthesis = _expect(TokenType.CLOSE_PAREN);
         return new ParenthesizedExpression(
             leftParenthesis,
             expression,
             rightParenthesis);
       } finally {
@@ skipping 35 matching lines @@
    *     'this' ('.' identifier)? arguments
    * </pre>
    *
    * @return the redirecting constructor invocation that was parsed
    */
   RedirectingConstructorInvocation _parseRedirectingConstructorInvocation() {
     Token keyword = _expectKeyword(Keyword.THIS);
     Token period = null;
     SimpleIdentifier constructorName = null;
     if (_matches(TokenType.PERIOD)) {
-      period = andAdvance;
+      period = getAndAdvance();
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList argumentList = parseArgumentList();
     return new RedirectingConstructorInvocation(
         keyword,
         period,
         constructorName,
         argumentList);
   }
 
   /**
    * Parse a relational expression.
    *
    * <pre>
    * relationalExpression ::=
    *     bitwiseOrExpression ('is' '!'? type | 'as' type | relationalOperator bitwiseOrExpression)?
    *   | 'super' relationalOperator bitwiseOrExpression
    * </pre>
    *
    * @return the relational expression that was parsed
    */
   Expression _parseRelationalExpression() {
     if (_matchesKeyword(Keyword.SUPER) &&
         _currentToken.next.type.isRelationalOperator) {
-      Expression expression = new SuperExpression(andAdvance);
-      Token operator = andAdvance;
+      Expression expression = new SuperExpression(getAndAdvance());
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, parseBitwiseOrExpression());
       return expression;
     }
     Expression expression = parseBitwiseOrExpression();
     if (_matchesKeyword(Keyword.AS)) {
-      Token asOperator = andAdvance;
+      Token asOperator = getAndAdvance();
       expression = new AsExpression(expression, asOperator, parseTypeName());
     } else if (_matchesKeyword(Keyword.IS)) {
-      Token isOperator = andAdvance;
+      Token isOperator = getAndAdvance();
       Token notOperator = null;
       if (_matches(TokenType.BANG)) {
-        notOperator = andAdvance;
+        notOperator = getAndAdvance();
       }
       expression =
           new IsExpression(expression, isOperator, notOperator, parseTypeName());
     } else if (_currentToken.type.isRelationalOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, parseBitwiseOrExpression());
     }
     return expression;
   }
 
   /**
    * Parse a rethrow expression.
    *
    * <pre>
@@ skipping 12 matching lines @@
    * <pre>
    * returnStatement ::=
    *     'return' expression? ';'
    * </pre>
    *
    * @return the return statement that was parsed
    */
   Statement _parseReturnStatement() {
     Token returnKeyword = _expectKeyword(Keyword.RETURN);
     if (_matches(TokenType.SEMICOLON)) {
-      return new ReturnStatement(returnKeyword, null, andAdvance);
+      return new ReturnStatement(returnKeyword, null, getAndAdvance());
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new ReturnStatement(returnKeyword, expression, semicolon);
   }
 
   /**
    * Parse a setter.
    *
    * <pre>
@@ skipping 46 matching lines @@
    *     additiveExpression (shiftOperator additiveExpression)*
    *   | 'super' (shiftOperator additiveExpression)+
    * </pre>
    *
    * @return the shift expression that was parsed
    */
   Expression _parseShiftExpression() {
     Expression expression;
     if (_matchesKeyword(Keyword.SUPER) &&
         _currentToken.next.type.isShiftOperator) {
-      expression = new SuperExpression(andAdvance);
+      expression = new SuperExpression(getAndAdvance());
     } else {
       expression = _parseAdditiveExpression();
     }
     while (_currentToken.type.isShiftOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       expression =
           new BinaryExpression(expression, operator, _parseAdditiveExpression());
     }
     return expression;
   }
 
   /**
    * Parse a list of statements within a switch statement.
    *
    * <pre>
@@ skipping 31 matching lines @@
     List<InterpolationElement> elements = new List<InterpolationElement>();
     bool hasMore =
         _matches(TokenType.STRING_INTERPOLATION_EXPRESSION) ||
         _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER);
     elements.add(
         new InterpolationString(
             string,
             _computeStringValue(string.lexeme, true, !hasMore)));
     while (hasMore) {
       if (_matches(TokenType.STRING_INTERPOLATION_EXPRESSION)) {
-        Token openToken = andAdvance;
+        Token openToken = getAndAdvance();
         bool wasInInitializer = _inInitializer;
         _inInitializer = false;
         try {
           Expression expression = parseExpression2();
           Token rightBracket = _expect(TokenType.CLOSE_CURLY_BRACKET);
           elements.add(
               new InterpolationExpression(openToken, expression, rightBracket));
         } finally {
           _inInitializer = wasInInitializer;
         }
       } else {
-        Token openToken = andAdvance;
+        Token openToken = getAndAdvance();
         Expression expression = null;
         if (_matchesKeyword(Keyword.THIS)) {
-          expression = new ThisExpression(andAdvance);
+          expression = new ThisExpression(getAndAdvance());
         } else {
           expression = parseSimpleIdentifier();
         }
         elements.add(new InterpolationExpression(openToken, expression, null));
       }
       if (_matches(TokenType.STRING)) {
-        string = andAdvance;
+        string = getAndAdvance();
         hasMore = _matches(TokenType.STRING_INTERPOLATION_EXPRESSION) ||
             _matches(TokenType.STRING_INTERPOLATION_IDENTIFIER);
         elements.add(
             new InterpolationString(
                 string,
                 _computeStringValue(string.lexeme, false, !hasMore)));
       } else {
         hasMore = false;
       }
     }
     return new StringInterpolation(elements);
   }
 
   /**
    * Parse a super constructor invocation.
    *
    * <pre>
    * superConstructorInvocation ::=
    *     'super' ('.' identifier)? arguments
    * </pre>
    *
    * @return the super constructor invocation that was parsed
    */
   SuperConstructorInvocation _parseSuperConstructorInvocation() {
     Token keyword = _expectKeyword(Keyword.SUPER);
     Token period = null;
     SimpleIdentifier constructorName = null;
     if (_matches(TokenType.PERIOD)) {
-      period = andAdvance;
+      period = getAndAdvance();
       constructorName = parseSimpleIdentifier();
     }
     ArgumentList argumentList = parseArgumentList();
     return new SuperConstructorInvocation(
         keyword,
         period,
         constructorName,
         argumentList);
   }
 
@@ skipping 37 matching lines @@
                 ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT,
                 identifier.token,
                 [label]);
           } else {
             definedLabels.add(label);
           }
           Token colon = _expect(TokenType.COLON);
           labels.add(new Label(identifier, colon));
         }
         if (_matchesKeyword(Keyword.CASE)) {
-          Token caseKeyword = andAdvance;
+          Token caseKeyword = getAndAdvance();
           Expression caseExpression = parseExpression2();
           Token colon = _expect(TokenType.COLON);
           members.add(
               new SwitchCase(
                   labels,
                   caseKeyword,
                   caseExpression,
                   colon,
                   _parseStatementList()));
           if (defaultKeyword != null) {
             _reportErrorForToken(
                 ParserErrorCode.SWITCH_HAS_CASE_AFTER_DEFAULT_CASE,
                 caseKeyword);
           }
         } else if (_matchesKeyword(Keyword.DEFAULT)) {
           if (defaultKeyword != null) {
             _reportErrorForToken(
                 ParserErrorCode.SWITCH_HAS_MULTIPLE_DEFAULT_CASES,
                 _peek());
           }
-          defaultKeyword = andAdvance;
+          defaultKeyword = getAndAdvance();
           Token colon = _expect(TokenType.COLON);
           members.add(
               new SwitchDefault(labels, defaultKeyword, colon, _parseStatementList()));
         } else {
           // We need to advance, otherwise we could end up in an infinite loop,
           // but this could be a lot smarter about recovering from the error.
           _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_CASE_OR_DEFAULT);
           while (!_matches(TokenType.EOF) &&
               !_matches(TokenType.CLOSE_CURLY_BRACKET) &&
               !_matchesKeyword(Keyword.CASE) &&
@@ skipping 20 matching lines @@
    * Parse a symbol literal.
    *
    * <pre>
    * symbolLiteral ::=
    *     '#' identifier ('.' identifier)*
    * </pre>
    *
    * @return the symbol literal that was parsed
    */
   SymbolLiteral _parseSymbolLiteral() {
-    Token poundSign = andAdvance;
+    Token poundSign = getAndAdvance();
     List<Token> components = new List<Token>();
     if (_matchesIdentifier()) {
-      components.add(andAdvance);
+      components.add(getAndAdvance());
       while (_matches(TokenType.PERIOD)) {
         _advance();
         if (_matchesIdentifier()) {
-          components.add(andAdvance);
+          components.add(getAndAdvance());
         } else {
           _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
           components.add(_createSyntheticToken(TokenType.IDENTIFIER));
           break;
         }
       }
     } else if (_currentToken.isOperator) {
-      components.add(andAdvance);
+      components.add(getAndAdvance());
     } else if (_tokenMatchesKeyword(_currentToken, Keyword.VOID)) {
-      components.add(andAdvance);
+      components.add(getAndAdvance());
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       components.add(_createSyntheticToken(TokenType.IDENTIFIER));
     }
     return new SymbolLiteral(poundSign, components);
   }
 
   /**
    * Parse a throw expression.
    *
@@ skipping 60 matching lines @@
    */
   Statement _parseTryStatement() {
     Token tryKeyword = _expectKeyword(Keyword.TRY);
     Block body = parseBlock();
     List<CatchClause> catchClauses = new List<CatchClause>();
     Block finallyClause = null;
     while (_matchesString(_ON) || _matchesKeyword(Keyword.CATCH)) {
       Token onKeyword = null;
       TypeName exceptionType = null;
       if (_matchesString(_ON)) {
-        onKeyword = andAdvance;
+        onKeyword = getAndAdvance();
         exceptionType = parseTypeName();
       }
       Token catchKeyword = null;
       Token leftParenthesis = null;
       SimpleIdentifier exceptionParameter = null;
       Token comma = null;
       SimpleIdentifier stackTraceParameter = null;
       Token rightParenthesis = null;
       if (_matchesKeyword(Keyword.CATCH)) {
-        catchKeyword = andAdvance;
+        catchKeyword = getAndAdvance();
         leftParenthesis = _expect(TokenType.OPEN_PAREN);
         exceptionParameter = parseSimpleIdentifier();
         if (_matches(TokenType.COMMA)) {
-          comma = andAdvance;
+          comma = getAndAdvance();
           stackTraceParameter = parseSimpleIdentifier();
         }
         rightParenthesis = _expect(TokenType.CLOSE_PAREN);
       }
       Block catchBody = parseBlock();
       catchClauses.add(
           new CatchClause(
               onKeyword,
               exceptionType,
               catchKeyword,
               leftParenthesis,
               exceptionParameter,
               comma,
               stackTraceParameter,
               rightParenthesis,
               catchBody));
     }
     Token finallyKeyword = null;
     if (_matchesKeyword(Keyword.FINALLY)) {
-      finallyKeyword = andAdvance;
+      finallyKeyword = getAndAdvance();
       finallyClause = parseBlock();
     } else {
       if (catchClauses.isEmpty) {
         _reportErrorForCurrentToken(ParserErrorCode.MISSING_CATCH_OR_FINALLY);
       }
     }
     return new TryStatement(
         tryKeyword,
         body,
         catchClauses,
@@ skipping 66 matching lines @@
    *   | '-' 'super'
    *   | incrementOperator assignableExpression
    * </pre>
    *
    * @return the unary expression that was parsed
    */
   Expression _parseUnaryExpression() {
     if (_matches(TokenType.MINUS) ||
         _matches(TokenType.BANG) ||
         _matches(TokenType.TILDE)) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
         if (_tokenMatches(_peek(), TokenType.OPEN_SQUARE_BRACKET) ||
             _tokenMatches(_peek(), TokenType.PERIOD)) {
           //     "prefixOperator unaryExpression"
           // --> "prefixOperator postfixExpression"
           // --> "prefixOperator primary                    selector*"
           // --> "prefixOperator 'super' assignableSelector selector*"
           return new PrefixExpression(operator, _parseUnaryExpression());
         }
-        return new PrefixExpression(operator, new SuperExpression(andAdvance));
+        return new PrefixExpression(operator, new SuperExpression(getAndAdvance()));
       }
       return new PrefixExpression(operator, _parseUnaryExpression());
     } else if (_currentToken.type.isIncrementOperator) {
-      Token operator = andAdvance;
+      Token operator = getAndAdvance();
       if (_matchesKeyword(Keyword.SUPER)) {
         if (_tokenMatches(_peek(), TokenType.OPEN_SQUARE_BRACKET) ||
             _tokenMatches(_peek(), TokenType.PERIOD)) {
           // --> "prefixOperator 'super' assignableSelector selector*"
           return new PrefixExpression(operator, _parseUnaryExpression());
         }
         //
         // Even though it is not valid to use an incrementing operator
         // ('++' or '--') before 'super', we can (and therefore must) interpret
         // "--super" as semantically equivalent to "-(-super)". Unfortunately,
         // we cannot do the same for "++super" because "+super" is also not
         // valid.
         //
         if (operator.type == TokenType.MINUS_MINUS) {
           int offset = operator.offset;
           Token firstOperator = new Token(TokenType.MINUS, offset);
           Token secondOperator = new Token(TokenType.MINUS, offset + 1);
           secondOperator.setNext(_currentToken);
           firstOperator.setNext(secondOperator);
           operator.previous.setNext(firstOperator);
           return new PrefixExpression(
               firstOperator,
-              new PrefixExpression(secondOperator, new SuperExpression(andAdvance)));
+              new PrefixExpression(secondOperator, new SuperExpression(getAndAdvance())));
         } else {
           // Invalid operator before 'super'
           _reportErrorForCurrentToken(
               ParserErrorCode.INVALID_OPERATOR_FOR_SUPER,
               [operator.lexeme]);
           return new PrefixExpression(
               operator,
-              new SuperExpression(andAdvance));
+              new SuperExpression(getAndAdvance()));
         }
       }
       return new PrefixExpression(operator, _parseAssignableExpression(false));
     } else if (_matches(TokenType.PLUS)) {
       _reportErrorForCurrentToken(ParserErrorCode.MISSING_IDENTIFIER);
       return _createSyntheticIdentifier();
     } else if (_matchesString(_AWAIT)) {
       return _parseAwaitExpression();
     }
     return _parsePostfixExpression();
@@ skipping 60 matching lines @@
    * </pre>
    *
    * @return the variable declaration that was parsed
    */
   VariableDeclaration _parseVariableDeclaration() {
     CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
     SimpleIdentifier name = parseSimpleIdentifier();
     Token equals = null;
     Expression initializer = null;
     if (_matches(TokenType.EQ)) {
-      equals = andAdvance;
+      equals = getAndAdvance();
       initializer = parseExpression2();
     }
     return new VariableDeclaration(
         commentAndMetadata.comment,
         commentAndMetadata.metadata,
         name,
         equals,
         initializer);
   }
 
@@ skipping 139 matching lines @@
    * Parse a yield statement.
    *
    * <pre>
    * yieldStatement ::=
    *     'yield' '*'? expression ';'
    * </pre>
    *
    * @return the yield statement that was parsed
    */
   YieldStatement _parseYieldStatement() {
-    Token yieldToken = andAdvance;
+    Token yieldToken = getAndAdvance();
     Token star = null;
     if (_matches(TokenType.STAR)) {
-      star = andAdvance;
+      star = getAndAdvance();
     }
     Expression expression = parseExpression2();
     Token semicolon = _expect(TokenType.SEMICOLON);
     return new YieldStatement(yieldToken, star, expression, semicolon);
   }
 
   /**
    * Return the token that is immediately after the current token. This is equivalent to
    * [peekAt].
    *
@@ skipping 3245 matching lines @@
    * Copy resolution data from one node to another.
    *
    * @param fromNode the node from which resolution information will be copied
    * @param toNode the node to which resolution information will be copied
    */
   static void copyResolutionData(AstNode fromNode, AstNode toNode) {
     ResolutionCopier copier = new ResolutionCopier();
     copier._isEqualNodes(fromNode, toNode);
   }
 }