Convert isX() methods to isX getter.

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

 // 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:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
@@ skipping 499 matching lines @@
    * primary (arguments* assignableSelector)+
    * | 'super' assignableSelector
    * | identifier
    * assignableSelector ::=
    * '\[' expression '\]'
    * | '.' identifier
    * </pre>
    * @param expression the expression being checked
    */
   void ensureAssignable(Expression expression) {
-    if (expression != null && !expression.isAssignable()) {
+    if (expression != null && !expression.isAssignable) {
       reportError7(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, []);
     }
   }
 
   /**
    * 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
    */
@@ skipping 119 matching lines @@
     if (next == null) {
       return false;
     }
     return matchesIdentifier2(next);
   }
 
   /**
    * Return `true` if the current token appears to be the beginning of a function declaration.
    * @return `true` if the current token appears to be the beginning of a function declaration
    */
-  bool isFunctionDeclaration() {
+  bool get isFunctionDeclaration {
     if (matches(Keyword.VOID)) {
       return true;
     }
     Token afterReturnType = skipTypeName(_currentToken);
     if (afterReturnType == null) {
       afterReturnType = _currentToken;
     }
     Token afterIdentifier = skipSimpleIdentifier(afterReturnType);
     if (afterIdentifier == null) {
       afterIdentifier = skipSimpleIdentifier(_currentToken);
@@ skipping 39 matching lines @@
    * | 'var'
    * | type
    * type ::=
    * qualified typeArguments?
    * initializedIdentifier ::=
    * identifier ('=' expression)?
    * </pre>
    * @return `true` if the current token is the first token in an initialized variable
    * declaration
    */
-  bool isInitializedVariableDeclaration() {
+  bool get isInitializedVariableDeclaration {
     if (matches(Keyword.FINAL) || matches(Keyword.VAR)) {
       return true;
     }
     if (matches(Keyword.CONST)) {
       return !matchesAny(peek(), [TokenType.LT, TokenType.OPEN_CURLY_BRACKET, TokenType.OPEN_SQUARE_BRACKET, TokenType.INDEX]);
     }
     Token token = skipTypeName(_currentToken);
     if (token == null) {
       return false;
     }
@@ skipping 35 matching lines @@
     }
     return nextChar == 0x5B;
   }
 
   /**
    * Return `true` if the given token appears to be the beginning of an operator declaration.
    * @param startToken the token that might be the start of an operator declaration
    * @return `true` if the given token appears to be the beginning of an operator declaration
    */
   bool isOperator(Token startToken) {
-    if (startToken.isOperator()) {
+    if (startToken.isOperator) {
       Token token = startToken.next;
-      while (token.isOperator()) {
+      while (token.isOperator) {
         token = token.next;
       }
       return matches4(token, TokenType.OPEN_PAREN);
     }
     return false;
   }
 
   /**
    * Return `true` if the current token appears to be the beginning of a switch member.
    * @return `true` if the current token appears to be the beginning of a switch member
    */
-  bool isSwitchMember() {
+  bool get isSwitchMember {
     Token token = _currentToken;
     while (matches4(token, TokenType.IDENTIFIER) && matches4(token.next, TokenType.COLON)) {
       token = token.next.next;
     }
     if (identical(token.type, TokenType.KEYWORD)) {
       Keyword keyword = ((token as KeywordToken)).keyword;
       return identical(keyword, Keyword.CASE) || identical(keyword, Keyword.DEFAULT);
     }
     return false;
   }
@@ skipping 120 matching lines @@
    * built-in identifiers (pseudo-keywords).
    * @return `true` if the current token is a valid identifier
    */
   bool matchesIdentifier() => matchesIdentifier2(_currentToken);
 
   /**
    * Return `true` if the given token is a valid identifier. Valid identifiers include
    * built-in identifiers (pseudo-keywords).
    * @return `true` if the given token is a valid identifier
    */
-  bool matchesIdentifier2(Token token) => matches4(token, TokenType.IDENTIFIER) || (matches4(token, TokenType.KEYWORD) && ((token as KeywordToken)).keyword.isPseudoKeyword());
+  bool matchesIdentifier2(Token token) => matches4(token, TokenType.IDENTIFIER) || (matches4(token, TokenType.KEYWORD) && ((token as KeywordToken)).keyword.isPseudoKeyword);
 
   /**
    * If the current token has the given type, then advance to the next token and return `true`. Otherwise, return `false` without advancing.
    * @param type the type of token that can optionally appear in the current location
    * @return `true` if the current token has the given type
    */
   bool optional(TokenType type) {
     if (matches5(type)) {
       advance();
       return true;
     }
     return false;
   }
 
   /**
    * Parse an additive expression.
    * <pre>
    * additiveExpression ::=
    * multiplicativeExpression (additiveOperator multiplicativeExpression)
    * | 'super' (additiveOperator multiplicativeExpression)+
    * </pre>
    * @return the additive expression that was parsed
    */
   Expression parseAdditiveExpression() {
     Expression expression;
-    if (matches(Keyword.SUPER) && _currentToken.next.type.isAdditiveOperator()) {
+    if (matches(Keyword.SUPER) && _currentToken.next.type.isAdditiveOperator) {
       expression = new SuperExpression.full(andAdvance);
     } else {
       expression = parseMultiplicativeExpression();
     }
-    while (_currentToken.type.isAdditiveOperator()) {
+    while (_currentToken.type.isAdditiveOperator) {
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseMultiplicativeExpression());
     }
     return expression;
   }
 
   /**
    * Parse an annotation.
    * <pre>
    * annotation ::=
@@ skipping 350 matching lines @@
       progress = false;
       Expression selector = parseAssignableSelector(expression, true);
       if (selector != expression) {
         expression = selector;
         progress = true;
         while (identical(_currentToken.type, TokenType.OPEN_PAREN)) {
           expression = new FunctionExpressionInvocation.full(expression, parseArgumentList());
         }
       }
     }
-    if (_currentToken.type.isAssignmentOperator()) {
+    if (_currentToken.type.isAssignmentOperator) {
       Token operator = andAdvance;
       ensureAssignable(expression);
       expression = new AssignmentExpression.full(expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
    * Parse a class declaration.
    * <pre>
@@ skipping 853 matching lines @@
    * Parse an equality expression.
    * <pre>
    * equalityExpression ::=
    * relationalExpression (equalityOperator relationalExpression)?
    * | 'super' equalityOperator relationalExpression
    * </pre>
    * @return the equality expression that was parsed
    */
   Expression parseEqualityExpression() {
     Expression expression;
-    if (matches(Keyword.SUPER) && _currentToken.next.type.isEqualityOperator()) {
+    if (matches(Keyword.SUPER) && _currentToken.next.type.isEqualityOperator) {
       expression = new SuperExpression.full(andAdvance);
     } else {
       expression = parseRelationalExpression();
     }
-    while (_currentToken.type.isEqualityOperator()) {
+    while (_currentToken.type.isEqualityOperator) {
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseRelationalExpression());
     }
     return expression;
   }
 
   /**
    * Parse an export directive.
    * <pre>
    * exportDirective ::=
@@ skipping 31 matching lines @@
     if (identical(tokenType, TokenType.PERIOD_PERIOD)) {
       List<Expression> cascadeSections = new List<Expression>();
       while (identical(tokenType, TokenType.PERIOD_PERIOD)) {
         Expression section = parseCascadeSection();
         if (section != null) {
           cascadeSections.add(section);
         }
         tokenType = _currentToken.type;
       }
       return new CascadeExpression.full(expression, cascadeSections);
-    } else if (tokenType.isAssignmentOperator()) {
+    } else if (tokenType.isAssignmentOperator) {
       Token operator = andAdvance;
       ensureAssignable(expression);
       return new AssignmentExpression.full(expression, operator, parseExpression2());
     }
     return expression;
   }
 
   /**
    * Parse a list of expressions.
    * <pre>
@@ skipping 21 matching lines @@
    * </pre>
    * @return the expression that was parsed
    */
   Expression parseExpressionWithoutCascade() {
     if (matches(Keyword.THROW)) {
       return parseThrowExpressionWithoutCascade();
     } else if (matches(Keyword.RETHROW)) {
       return parseRethrowExpression();
     }
     Expression expression = parseConditionalExpression();
-    if (_currentToken.type.isAssignmentOperator()) {
+    if (_currentToken.type.isAssignmentOperator) {
       Token operator = andAdvance;
       ensureAssignable(expression);
       expression = new AssignmentExpression.full(expression, operator, parseExpressionWithoutCascade());
     }
     return expression;
   }
 
   /**
    * Parse a class extends clause.
    * <pre>
@@ skipping 224 matching lines @@
       Token leftParenthesis = expect2(TokenType.OPEN_PAREN);
       VariableDeclarationList variableList = null;
       Expression initialization = null;
       if (!matches5(TokenType.SEMICOLON)) {
         CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
         if (matchesIdentifier() && matches3(peek(), Keyword.IN)) {
           List<VariableDeclaration> variables = new List<VariableDeclaration>();
           SimpleIdentifier variableName = parseSimpleIdentifier();
           variables.add(new VariableDeclaration.full(null, null, variableName, null, null));
           variableList = new VariableDeclarationList.full(commentAndMetadata.comment, commentAndMetadata.metadata, null, null, variables);
-        } else if (isInitializedVariableDeclaration()) {
+        } else if (isInitializedVariableDeclaration) {
           variableList = parseVariableDeclarationList(commentAndMetadata);
         } else {
           initialization = parseExpression2();
         }
         if (matches(Keyword.IN)) {
           DeclaredIdentifier loopVariable = null;
           if (variableList == null) {
             reportError7(ParserErrorCode.MISSING_VARIABLE_IN_FOR_EACH, []);
           } else {
             NodeList<VariableDeclaration> variables = variableList.variables;
@@ skipping 690 matching lines @@
    * 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 (matches(Keyword.SUPER) && _currentToken.next.type.isMultiplicativeOperator()) {
+    if (matches(Keyword.SUPER) && _currentToken.next.type.isMultiplicativeOperator) {
       expression = new SuperExpression.full(andAdvance);
     } else {
       expression = parseUnaryExpression();
     }
-    while (_currentToken.type.isMultiplicativeOperator()) {
+    while (_currentToken.type.isMultiplicativeOperator) {
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseUnaryExpression());
     }
     return expression;
   }
 
   /**
    * Parse a new expression.
    * <pre>
    * newExpression ::=
@@ skipping 27 matching lines @@
   Statement parseNonLabeledStatement() {
     CommentAndMetadata commentAndMetadata = parseCommentAndMetadata();
     if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
       if (matches4(peek(), TokenType.STRING)) {
         Token afterString = skipStringLiteral(_currentToken.next);
         if (afterString != null && identical(afterString.type, TokenType.COLON)) {
           return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
         }
       }
       return parseBlock();
-    } else if (matches5(TokenType.KEYWORD) && !((_currentToken as KeywordToken)).keyword.isPseudoKeyword()) {
+    } else if (matches5(TokenType.KEYWORD) && !((_currentToken as KeywordToken)).keyword.isPseudoKeyword) {
       Keyword keyword = ((_currentToken as KeywordToken)).keyword;
       if (identical(keyword, Keyword.ASSERT)) {
         return parseAssertStatement();
       } else if (identical(keyword, Keyword.BREAK)) {
         return parseBreakStatement();
       } else if (identical(keyword, Keyword.CONTINUE)) {
         return parseContinueStatement();
       } else if (identical(keyword, Keyword.DO)) {
         return parseDoStatement();
       } else if (identical(keyword, Keyword.FOR)) {
@@ skipping 43 matching lines @@
         }
         return parseVariableDeclarationStatement(commentAndMetadata);
       } else if (identical(keyword, Keyword.NEW) || identical(keyword, Keyword.TRUE) || identical(keyword, Keyword.FALSE) || identical(keyword, Keyword.NULL) || identical(keyword, Keyword.SUPER) || identical(keyword, Keyword.THIS)) {
         return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
       } else {
         reportError7(ParserErrorCode.MISSING_STATEMENT, []);
         return new EmptyStatement.full(createSyntheticToken2(TokenType.SEMICOLON));
       }
     } else if (matches5(TokenType.SEMICOLON)) {
       return parseEmptyStatement();
-    } else if (isInitializedVariableDeclaration()) {
+    } else if (isInitializedVariableDeclaration) {
       return parseVariableDeclarationStatement(commentAndMetadata);
-    } else if (isFunctionDeclaration()) {
+    } else if (isFunctionDeclaration) {
       return parseFunctionDeclarationStatement();
     } else if (matches5(TokenType.CLOSE_CURLY_BRACKET)) {
       reportError7(ParserErrorCode.MISSING_STATEMENT, []);
       return new EmptyStatement.full(createSyntheticToken2(TokenType.SEMICOLON));
     } else {
       return new ExpressionStatement.full(parseExpression2(), expect2(TokenType.SEMICOLON));
     }
   }
 
   /**
@@ skipping 55 matching lines @@
    * @return the operator declaration that was parsed
    */
   MethodDeclaration parseOperator(CommentAndMetadata commentAndMetadata, Token externalKeyword, TypeName returnType) {
     Token operatorKeyword;
     if (matches(Keyword.OPERATOR)) {
       operatorKeyword = andAdvance;
     } else {
       reportError8(ParserErrorCode.MISSING_KEYWORD_OPERATOR, _currentToken, []);
       operatorKeyword = createSyntheticToken(Keyword.OPERATOR);
     }
-    if (!_currentToken.isUserDefinableOperator()) {
+    if (!_currentToken.isUserDefinableOperator) {
       reportError7(ParserErrorCode.NON_USER_DEFINABLE_OPERATOR, [_currentToken.lexeme]);
     }
     SimpleIdentifier name = new SimpleIdentifier.full(andAdvance);
     if (matches5(TokenType.EQ)) {
       Token previous = _currentToken.previous;
       if ((matches4(previous, TokenType.EQ_EQ) || matches4(previous, TokenType.BANG_EQ)) && _currentToken.offset == previous.offset + 2) {
         reportError7(ParserErrorCode.INVALID_OPERATOR, ["${previous.lexeme}${_currentToken.lexeme}"]);
         advance();
       }
     }
@@ skipping 68 matching lines @@
             operand = new MethodInvocation.full(access.target, access.operator, access.propertyName, argumentList);
           } else {
             operand = new FunctionExpressionInvocation.full(operand, argumentList);
           }
         } else {
           operand = parseAssignableSelector(operand, true);
         }
       } while (matches5(TokenType.OPEN_SQUARE_BRACKET) || matches5(TokenType.PERIOD) || matches5(TokenType.OPEN_PAREN));
       return operand;
     }
-    if (!_currentToken.type.isIncrementOperator()) {
+    if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
     if (operand is FunctionExpressionInvocation) {
       reportError7(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, []);
     }
     Token operator = andAdvance;
     return new PostfixExpression.full(operand, operator);
   }
 
   /**
@@ skipping 129 matching lines @@
   /**
    * Parse a relational expression.
    * <pre>
    * relationalExpression ::=
    * shiftExpression ('is' '!'? type | 'as' type | relationalOperator shiftExpression)?
    * | 'super' relationalOperator shiftExpression
    * </pre>
    * @return the relational expression that was parsed
    */
   Expression parseRelationalExpression() {
-    if (matches(Keyword.SUPER) && _currentToken.next.type.isRelationalOperator()) {
+    if (matches(Keyword.SUPER) && _currentToken.next.type.isRelationalOperator) {
       Expression expression = new SuperExpression.full(andAdvance);
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseShiftExpression());
       return expression;
     }
     Expression expression = parseShiftExpression();
     if (matches(Keyword.AS)) {
       Token asOperator = andAdvance;
       expression = new AsExpression.full(expression, asOperator, parseTypeName());
     } else if (matches(Keyword.IS)) {
       Token isOperator = andAdvance;
       Token notOperator = null;
       if (matches5(TokenType.BANG)) {
         notOperator = andAdvance;
       }
       expression = new IsExpression.full(expression, isOperator, notOperator, parseTypeName());
-    } else if (_currentToken.type.isRelationalOperator()) {
+    } else if (_currentToken.type.isRelationalOperator) {
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseShiftExpression());
     }
     return expression;
   }
 
   /**
    * Parse a rethrow expression.
    * <pre>
    * rethrowExpression ::=
@@ skipping 70 matching lines @@
    * Parse a shift expression.
    * <pre>
    * shiftExpression ::=
    * additiveExpression (shiftOperator additiveExpression)
    * | 'super' (shiftOperator additiveExpression)+
    * </pre>
    * @return the shift expression that was parsed
    */
   Expression parseShiftExpression() {
     Expression expression;
-    if (matches(Keyword.SUPER) && _currentToken.next.type.isShiftOperator()) {
+    if (matches(Keyword.SUPER) && _currentToken.next.type.isShiftOperator) {
       expression = new SuperExpression.full(andAdvance);
     } else {
       expression = parseAdditiveExpression();
     }
-    while (_currentToken.type.isShiftOperator()) {
+    while (_currentToken.type.isShiftOperator) {
       Token operator = andAdvance;
       expression = new BinaryExpression.full(expression, operator, parseAdditiveExpression());
     }
     return expression;
   }
 
   /**
    * Parse a simple identifier.
    * <pre>
    * identifier ::=
@@ skipping 35 matching lines @@
    * Parse a list of statements within a switch statement.
    * <pre>
    * statements ::=
    * statement
    * </pre>
    * @return the statements that were parsed
    */
   List<Statement> parseStatements2() {
     List<Statement> statements = new List<Statement>();
     Token statementStart = _currentToken;
-    while (!matches5(TokenType.EOF) && !matches5(TokenType.CLOSE_CURLY_BRACKET) && !isSwitchMember()) {
+    while (!matches5(TokenType.EOF) && !matches5(TokenType.CLOSE_CURLY_BRACKET) && !isSwitchMember) {
       statements.add(parseStatement2());
       if (identical(_currentToken, statementStart)) {
         reportError8(ParserErrorCode.UNEXPECTED_TOKEN, _currentToken, [_currentToken.lexeme]);
         advance();
       }
       statementStart = _currentToken;
     }
     return statements;
   }
 
@@ skipping 373 matching lines @@
   Expression parseUnaryExpression() {
     if (matches5(TokenType.MINUS) || matches5(TokenType.BANG) || matches5(TokenType.TILDE)) {
       Token operator = andAdvance;
       if (matches(Keyword.SUPER)) {
         if (matches4(peek(), TokenType.OPEN_SQUARE_BRACKET) || matches4(peek(), TokenType.PERIOD)) {
           return new PrefixExpression.full(operator, parseUnaryExpression());
         }
         return new PrefixExpression.full(operator, new SuperExpression.full(andAdvance));
       }
       return new PrefixExpression.full(operator, parseUnaryExpression());
-    } else if (_currentToken.type.isIncrementOperator()) {
+    } else if (_currentToken.type.isIncrementOperator) {
       Token operator = andAdvance;
       if (matches(Keyword.SUPER)) {
         if (matches4(peek(), TokenType.OPEN_SQUARE_BRACKET) || matches4(peek(), TokenType.PERIOD)) {
           return new PrefixExpression.full(operator, parseUnaryExpression());
         }
         if (identical(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);
@@ skipping 353 matching lines @@
    *
    * This method must be kept in sync with [parseSimpleIdentifier].
    * <pre>
    * identifier ::=
    * IDENTIFIER
    * </pre>
    * @param startToken the token at which parsing is to begin
    * @return the token following the simple identifier that was parsed
    */
   Token skipSimpleIdentifier(Token startToken) {
-    if (matches4(startToken, TokenType.IDENTIFIER) || (matches4(startToken, TokenType.KEYWORD) && ((startToken as KeywordToken)).keyword.isPseudoKeyword())) {
+    if (matches4(startToken, TokenType.IDENTIFIER) || (matches4(startToken, TokenType.KEYWORD) && ((startToken as KeywordToken)).keyword.isPseudoKeyword)) {
       return startToken.next;
     }
     return null;
   }
 
   /**
    * Parse a string literal that contains interpolations, starting at the given token, without
    * actually creating a string literal or changing the current token. Return the token following
    * the string literal that was parsed, or `null` if the given token is not the first token
    * in a valid string literal.
@@ skipping 879 matching lines @@
     _writer.print(";");
     return null;
   }
   Object visitComment(Comment node) {
     Token token = node.beginToken;
     while (token != null) {
       bool firstLine = true;
       for (String line in StringUtils.split(token.lexeme, "\n")) {
         if (firstLine) {
           firstLine = false;
-          if (node.isDocumentation()) {
+          if (node.isDocumentation) {
             nl2();
           }
         } else {
           line = " ${line.trim()}";
           line = StringUtils.replace(line, "/*", "/ *");
         }
         _writer.print(line);
         nl2();
       }
       if (identical(token, node.endToken)) {
@@ skipping 239 matching lines @@
   }
   Object visitImportDirective(ImportDirective node) {
     _writer.print("import ");
     visit(node.uri);
     visit7(" as ", node.prefix);
     visitList7(" ", node.combinators, " ");
     _writer.print(';');
     return null;
   }
   Object visitIndexExpression(IndexExpression node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit(node.array);
     }
     _writer.print('[');
     visit(node.index);
     _writer.print(']');
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
@@ skipping 81 matching lines @@
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     visit(node.documentationComment);
     visit8(node.externalKeyword, " ");
     visit8(node.modifierKeyword, " ");
     visit6(node.returnType, " ");
     visit8(node.propertyKeyword, " ");
     visit8(node.operatorKeyword, " ");
     visit(node.name);
-    if (!node.isGetter()) {
+    if (!node.isGetter) {
       visit(node.parameters);
     }
     if (node.body is! EmptyFunctionBody) {
       _writer.print(' ');
     }
     visit(node.body);
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit6(node.target, ".");
     }
     visit(node.methodName);
     visit(node.argumentList);
     return null;
   }
   Object visitNamedExpression(NamedExpression node) {
     visit(node.name);
@@ skipping 38 matching lines @@
     _writer.print('.');
     visit(node.identifier);
     return null;
   }
   Object visitPrefixExpression(PrefixExpression node) {
     _writer.print(node.operator.lexeme);
     visit(node.operand);
     return null;
   }
   Object visitPropertyAccess(PropertyAccess node) {
-    if (node.isCascaded()) {
+    if (node.isCascaded) {
       _writer.print("..");
     } else {
       visit6(node.target, ".");
     }
     visit(node.propertyName);
     return null;
   }
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     _writer.print("this");
     visit7(".", node.constructorName);
@@ skipping 287 matching lines @@
         for (int i = 0; i < size; i++) {
           if (i > 0) {
             _writer.print(separator);
           }
           nodes[i].accept(this);
         }
       }
     }
   }
 }