Translate Java's @Override into Dart's @override.

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 'java_core.dart';
@@ skipping 88 matching lines @@
   /**
    * The token representing the keyword 'static', or `null` if the keyword was not found.
    */
   Token staticKeyword;
 
   /**
    * The token representing the keyword 'var', or `null` if the keyword was not found.
    */
   Token varKeyword;
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     bool needsSpace = _appendKeyword(builder, false, abstractKeyword);
     needsSpace = _appendKeyword(builder, needsSpace, constKeyword);
     needsSpace = _appendKeyword(builder, needsSpace, externalKeyword);
     needsSpace = _appendKeyword(builder, needsSpace, factoryKeyword);
     needsSpace = _appendKeyword(builder, needsSpace, finalKeyword);
     needsSpace = _appendKeyword(builder, needsSpace, staticKeyword);
     _appendKeyword(builder, needsSpace, varKeyword);
     return builder.toString();
@@ skipping 42 matching lines @@
    * Initialize a newly created dispatcher to parse a single node that will replace the given node.
    *
    * @param parser the parser used to parse the replacement for the node
    * @param oldNode the node that is to be replaced
    */
   IncrementalParseDispatcher(Parser parser, AstNode oldNode) {
     this._parser = parser;
     this._oldNode = oldNode;
   }
 
+  @override
   AstNode visitAdjacentStrings(AdjacentStrings node) {
     if (node.strings.contains(_oldNode)) {
       return _parser.parseStringLiteral();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitAnnotation(Annotation node) {
     if (identical(_oldNode, node.name)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.constructorName)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.arguments)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitArgumentList(ArgumentList node) {
     if (node.arguments.contains(_oldNode)) {
       return _parser.parseArgument();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitAsExpression(AsExpression node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseBitwiseOrExpression();
     } else if (identical(_oldNode, node.type)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitAssertStatement(AssertStatement node) {
     if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitAssignmentExpression(AssignmentExpression node) {
     if (identical(_oldNode, node.leftHandSide)) {
       // TODO(brianwilkerson) If the assignment is part of a cascade section, then we don't have a
       // single parse method that will work. Otherwise, we can parse a conditional expression, but
       // need to ensure that the resulting expression is assignable.
       // return parser.parseConditionalExpression();
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.rightHandSide)) {
       if (_isCascadeAllowedInAssignment(node)) {
         return _parser.parseExpression2();
       }
       return _parser.parseExpressionWithoutCascade();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitBinaryExpression(BinaryExpression node) {
     if (identical(_oldNode, node.leftOperand)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.rightOperand)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitBlock(Block node) {
     if (node.statements.contains(_oldNode)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitBlockFunctionBody(BlockFunctionBody node) {
     if (identical(_oldNode, node.block)) {
       return _parser.parseBlock();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitBooleanLiteral(BooleanLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitBreakStatement(BreakStatement node) {
     if (identical(_oldNode, node.label)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitCascadeExpression(CascadeExpression node) {
     if (identical(_oldNode, node.target)) {
       return _parser.parseConditionalExpression();
     } else if (node.cascadeSections.contains(_oldNode)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitCatchClause(CatchClause node) {
     if (identical(_oldNode, node.exceptionType)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.exceptionParameter)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.stackTraceParameter)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseBlock();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitClassDeclaration(ClassDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.extendsClause)) {
       return _parser.parseExtendsClause();
     } else if (identical(_oldNode, node.withClause)) {
       return _parser.parseWithClause();
     } else if (identical(_oldNode, node.implementsClause)) {
       return _parser.parseImplementsClause();
     } else if (node.members.contains(_oldNode)) {
       ClassMember member = _parser.parseClassMember(node.name.name);
       if (member == null) {
         throw new InsufficientContextException();
       }
       return member;
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitClassTypeAlias(ClassTypeAlias node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.superclass)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.withClause)) {
       return _parser.parseWithClause();
     } else if (identical(_oldNode, node.implementsClause)) {
       return _parser.parseImplementsClause();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitComment(Comment node) {
     throw new InsufficientContextException();
   }
 
+  @override
   AstNode visitCommentReference(CommentReference node) {
     if (identical(_oldNode, node.identifier)) {
       return _parser.parsePrefixedIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitCompilationUnit(CompilationUnit node) {
     throw new InsufficientContextException();
   }
 
+  @override
   AstNode visitConditionalExpression(ConditionalExpression node) {
     if (identical(_oldNode, node.condition)) {
       return _parser.parseLogicalOrExpression();
     } else if (identical(_oldNode, node.thenExpression)) {
       return _parser.parseExpressionWithoutCascade();
     } else if (identical(_oldNode, node.elseExpression)) {
       return _parser.parseExpressionWithoutCascade();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitConstructorDeclaration(ConstructorDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.name)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     } else if (identical(_oldNode, node.redirectedConstructor)) {
       throw new InsufficientContextException();
     } else if (node.initializers.contains(_oldNode)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.body)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     if (identical(_oldNode, node.fieldName)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.expression)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitConstructorName(ConstructorName node) {
     if (identical(_oldNode, node.type)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitContinueStatement(ContinueStatement node) {
     if (identical(_oldNode, node.label)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitDeclaredIdentifier(DeclaredIdentifier node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.type)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitDefaultFormalParameter(DefaultFormalParameter node) {
     if (identical(_oldNode, node.parameter)) {
       return _parser.parseNormalFormalParameter();
     } else if (identical(_oldNode, node.defaultValue)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitDoStatement(DoStatement node) {
     if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     } else if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitDoubleLiteral(DoubleLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitEmptyFunctionBody(EmptyFunctionBody node) => _notAChild(node);
 
+  @override
   AstNode visitEmptyStatement(EmptyStatement node) => _notAChild(node);
 
+  @override
   AstNode visitExportDirective(ExportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (node.combinators.contains(_oldNode)) {
       throw new IncrementalParseException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitExpressionFunctionBody(ExpressionFunctionBody node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitExpressionStatement(ExpressionStatement node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitExtendsClause(ExtendsClause node) {
     if (identical(_oldNode, node.superclass)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFieldDeclaration(FieldDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.fields)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFieldFormalParameter(FieldFormalParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.type)) {
       return _parser.parseTypeName();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitForEachStatement(ForEachStatement node) {
     if (identical(_oldNode, node.loopVariable)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFormalParameterList(FormalParameterList node) {
     // We don't know which kind of parameter to parse.
     throw new InsufficientContextException();
   }
 
+  @override
   AstNode visitForStatement(ForStatement node) {
     if (identical(_oldNode, node.variables)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.initialization)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     } else if (node.updaters.contains(_oldNode)) {
       return _parser.parseExpression2();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionDeclaration(FunctionDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.functionExpression)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     if (identical(_oldNode, node.functionDeclaration)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionExpression(FunctionExpression node) {
     if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     } else if (identical(_oldNode, node.body)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     if (identical(_oldNode, node.function)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.argumentList)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionTypeAlias(FunctionTypeAlias node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       return _parser.parseReturnType();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.parameters)) {
       return _parser.parseFormalParameterList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitHideCombinator(HideCombinator node) {
     if (node.hiddenNames.contains(_oldNode)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitIfStatement(IfStatement node) {
     if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     } else if (identical(_oldNode, node.thenStatement)) {
       return _parser.parseStatement2();
     } else if (identical(_oldNode, node.elseStatement)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitImplementsClause(ImplementsClause node) {
     if (node.interfaces.contains(node)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitImportDirective(ImportDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     } else if (identical(_oldNode, node.prefix)) {
       return _parser.parseSimpleIdentifier();
     } else if (node.combinators.contains(_oldNode)) {
       throw new IncrementalParseException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitIndexExpression(IndexExpression node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.index)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (identical(_oldNode, node.constructorName)) {
       return _parser.parseConstructorName();
     } else if (identical(_oldNode, node.argumentList)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitIntegerLiteral(IntegerLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitInterpolationExpression(InterpolationExpression node) {
     if (identical(_oldNode, node.expression)) {
       if (node.leftBracket == null) {
         throw new InsufficientContextException();
       }
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitInterpolationString(InterpolationString node) {
     throw new InsufficientContextException();
   }
 
+  @override
   AstNode visitIsExpression(IsExpression node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseBitwiseOrExpression();
     } else if (identical(_oldNode, node.type)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitLabel(Label node) {
     if (identical(_oldNode, node.label)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitLabeledStatement(LabeledStatement node) {
     if (node.labels.contains(_oldNode)) {
       return _parser.parseLabel();
     } else if (identical(_oldNode, node.statement)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitLibraryDirective(LibraryDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseLibraryIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitLibraryIdentifier(LibraryIdentifier node) {
     if (node.components.contains(_oldNode)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitListLiteral(ListLiteral node) {
     if (identical(_oldNode, node.typeArguments)) {
       return _parser.parseTypeArgumentList();
     } else if (node.elements.contains(_oldNode)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitMapLiteral(MapLiteral node) {
     if (identical(_oldNode, node.typeArguments)) {
       return _parser.parseTypeArgumentList();
     } else if (node.entries.contains(_oldNode)) {
       return _parser.parseMapLiteralEntry();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitMapLiteralEntry(MapLiteralEntry node) {
     if (identical(_oldNode, node.key)) {
       return _parser.parseExpression2();
     } else if (identical(_oldNode, node.value)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitMethodDeclaration(MethodDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.returnType)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.name)) {
       if (node.operatorKeyword != null) {
         throw new InsufficientContextException();
       }
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.body)) {
       //return parser.parseFunctionBody();
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitMethodInvocation(MethodInvocation node) {
     if (identical(_oldNode, node.target)) {
       throw new IncrementalParseException();
     } else if (identical(_oldNode, node.methodName)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.argumentList)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitNamedExpression(NamedExpression node) {
     if (identical(_oldNode, node.name)) {
       return _parser.parseLabel();
     } else if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitNativeClause(NativeClause node) {
     if (identical(_oldNode, node.name)) {
       return _parser.parseStringLiteral();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitNativeFunctionBody(NativeFunctionBody node) {
     if (identical(_oldNode, node.stringLiteral)) {
       return _parser.parseStringLiteral();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitNullLiteral(NullLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitParenthesizedExpression(ParenthesizedExpression node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPartDirective(PartDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.uri)) {
       return _parser.parseStringLiteral();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPartOfDirective(PartOfDirective node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.libraryName)) {
       return _parser.parseLibraryIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPostfixExpression(PostfixExpression node) {
     if (identical(_oldNode, node.operand)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPrefixedIdentifier(PrefixedIdentifier node) {
     if (identical(_oldNode, node.prefix)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.identifier)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPrefixExpression(PrefixExpression node) {
     if (identical(_oldNode, node.operand)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitPropertyAccess(PropertyAccess node) {
     if (identical(_oldNode, node.target)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.propertyName)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     if (identical(_oldNode, node.constructorName)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.argumentList)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitRethrowExpression(RethrowExpression node) => _notAChild(node);
 
+  @override
   AstNode visitReturnStatement(ReturnStatement node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitScriptTag(ScriptTag node) => _notAChild(node);
 
+  @override
   AstNode visitShowCombinator(ShowCombinator node) {
     if (node.shownNames.contains(_oldNode)) {
       return _parser.parseSimpleIdentifier();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.type)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.identifier)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSimpleIdentifier(SimpleIdentifier node) => _notAChild(node);
 
+  @override
   AstNode visitSimpleStringLiteral(SimpleStringLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitStringInterpolation(StringInterpolation node) {
     if (node.elements.contains(_oldNode)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     if (identical(_oldNode, node.constructorName)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.argumentList)) {
       return _parser.parseArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSuperExpression(SuperExpression node) => _notAChild(node);
 
+  @override
   AstNode visitSwitchCase(SwitchCase node) {
     if (node.labels.contains(_oldNode)) {
       return _parser.parseLabel();
     } else if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     } else if (node.statements.contains(_oldNode)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSwitchDefault(SwitchDefault node) {
     if (node.labels.contains(_oldNode)) {
       return _parser.parseLabel();
     } else if (node.statements.contains(_oldNode)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSwitchStatement(SwitchStatement node) {
     if (identical(_oldNode, node.expression)) {
       return _parser.parseExpression2();
     } else if (node.members.contains(_oldNode)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitSymbolLiteral(SymbolLiteral node) => _notAChild(node);
 
+  @override
   AstNode visitThisExpression(ThisExpression node) => _notAChild(node);
 
+  @override
   AstNode visitThrowExpression(ThrowExpression node) {
     if (identical(_oldNode, node.expression)) {
       if (_isCascadeAllowedInThrow(node)) {
         return _parser.parseExpression2();
       }
       return _parser.parseExpressionWithoutCascade();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.variables)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTryStatement(TryStatement node) {
     if (identical(_oldNode, node.body)) {
       return _parser.parseBlock();
     } else if (node.catchClauses.contains(_oldNode)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.finallyBlock)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTypeArgumentList(TypeArgumentList node) {
     if (node.arguments.contains(_oldNode)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTypeName(TypeName node) {
     if (identical(_oldNode, node.name)) {
       return _parser.parsePrefixedIdentifier();
     } else if (identical(_oldNode, node.typeArguments)) {
       return _parser.parseTypeArgumentList();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTypeParameter(TypeParameter node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.bound)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitTypeParameterList(TypeParameterList node) {
     if (node.typeParameters.contains(node)) {
       return _parser.parseTypeParameter();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitVariableDeclaration(VariableDeclaration node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
       throw new InsufficientContextException();
     } else if (identical(_oldNode, node.initializer)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitVariableDeclarationList(VariableDeclarationList node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (node.variables.contains(_oldNode)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     if (identical(_oldNode, node.variables)) {
       throw new InsufficientContextException();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitWhileStatement(WhileStatement node) {
     if (identical(_oldNode, node.condition)) {
       return _parser.parseExpression2();
     } else if (identical(_oldNode, node.body)) {
       return _parser.parseStatement2();
     }
     return _notAChild(node);
   }
 
+  @override
   AstNode visitWithClause(WithClause node) {
     if (node.mixinTypes.contains(node)) {
       return _parser.parseTypeName();
     }
     return _notAChild(node);
   }
 
   /**
    * Return `true` if the given assignment expression can have a cascade expression on the
    * right-hand side.
@@ skipping 6119 matching lines @@
  */
 class Parser_SyntheticKeywordToken extends KeywordToken {
   /**
    * Initialize a newly created token to represent the given keyword.
    *
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset) : super(keyword, offset);
 
+  @override
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 
+  @override
   int get length => 0;
 }
 
 /**
  * The enumeration `ParserErrorCode` defines the error codes used for errors detected by the
  * parser. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  */
 class ParserErrorCode extends Enum<ParserErrorCode> implements ErrorCode {
@@ skipping 435 matching lines @@
     this.correction8 = correction;
   }
 
   /**
    * Initialize a newly created error code to have the given message and a severity of ERROR.
    *
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con3(String name, int ordinal, String message) : this.con1(name, ordinal, ErrorSeverity.ERROR, message);
 
+  @override
   String get correction => correction8;
 
+  @override
   ErrorSeverity get errorSeverity => _severity;
 
+  @override
   String get message => _message;
 
+  @override
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
 
 /**
  * Instances of the class `ResolutionCopier` copies resolution information from one AST
  * structure to another as long as the structures of the corresponding children of a pair of nodes
  * are the same.
  */
 class ResolutionCopier implements AstVisitor<bool> {
   /**
    * 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);
   }
 
   /**
    * The AST node with which the node being visited is to be compared. This is only valid at the
    * beginning of each visit method (until [isEqualNodes] is invoked).
    */
   AstNode _toNode;
 
+  @override
   bool visitAdjacentStrings(AdjacentStrings node) {
     AdjacentStrings toNode = this._toNode as AdjacentStrings;
     return _isEqualNodeLists(node.strings, toNode.strings);
   }
 
+  @override
   bool visitAnnotation(Annotation node) {
     Annotation toNode = this._toNode as Annotation;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.atSign, toNode.atSign), _isEqualNodes(node.name, toNode.name)), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.constructorName, toNode.constructorName)), _isEqualNodes(node.arguments, toNode.arguments))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     ArgumentDefinitionTest toNode = this._toNode as ArgumentDefinitionTest;
     if (javaBooleanAnd(_isEqualTokens(node.question, toNode.question), _isEqualNodes(node.identifier, toNode.identifier))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitArgumentList(ArgumentList node) {
     ArgumentList toNode = this._toNode as ArgumentList;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftParenthesis, toNode.leftParenthesis), _isEqualNodeLists(node.arguments, toNode.arguments)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis));
   }
 
+  @override
   bool visitAsExpression(AsExpression node) {
     AsExpression toNode = this._toNode as AsExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.expression, toNode.expression), _isEqualTokens(node.asOperator, toNode.asOperator)), _isEqualNodes(node.type, toNode.type))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitAssertStatement(AssertStatement node) {
     AssertStatement toNode = this._toNode as AssertStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.condition, toNode.condition)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     AssignmentExpression toNode = this._toNode as AssignmentExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.leftHandSide, toNode.leftHandSide), _isEqualTokens(node.operator, toNode.operator)), _isEqualNodes(node.rightHandSide, toNode.rightHandSide))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitBinaryExpression(BinaryExpression node) {
     BinaryExpression toNode = this._toNode as BinaryExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.leftOperand, toNode.leftOperand), _isEqualTokens(node.operator, toNode.operator)), _isEqualNodes(node.rightOperand, toNode.rightOperand))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitBlock(Block node) {
     Block toNode = this._toNode as Block;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftBracket, toNode.leftBracket), _isEqualNodeLists(node.statements, toNode.statements)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitBlockFunctionBody(BlockFunctionBody node) {
     BlockFunctionBody toNode = this._toNode as BlockFunctionBody;
     return _isEqualNodes(node.block, toNode.block);
   }
 
+  @override
   bool visitBooleanLiteral(BooleanLiteral node) {
     BooleanLiteral toNode = this._toNode as BooleanLiteral;
     if (javaBooleanAnd(_isEqualTokens(node.literal, toNode.literal), identical(node.value, toNode.value))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitBreakStatement(BreakStatement node) {
     BreakStatement toNode = this._toNode as BreakStatement;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.label, toNode.label)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitCascadeExpression(CascadeExpression node) {
     CascadeExpression toNode = this._toNode as CascadeExpression;
     if (javaBooleanAnd(_isEqualNodes(node.target, toNode.target), _isEqualNodeLists(node.cascadeSections, toNode.cascadeSections))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitCatchClause(CatchClause node) {
     CatchClause toNode = this._toNode as CatchClause;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.onKeyword, toNode.onKeyword), _isEqualNodes(node.exceptionType, toNode.exceptionType)), _isEqualTokens(node.catchKeyword, toNode.catchKeyword)), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.exceptionParameter, toNode.exceptionParameter)), _isEqualTokens(node.comma, toNode.comma)), _isEqualNodes(node.stackTraceParameter, toNode.stackTraceParameter)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualNodes(node.body, toNode.body));
   }
 
+  @override
   bool visitClassDeclaration(ClassDeclaration node) {
     ClassDeclaration toNode = this._toNode as ClassDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.abstractKeyword, toNode.abstractKeyword)), _isEqualTokens(node.classKeyword, toNode.classKeyword)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.typeParameters, toNode.typeParameters)), _isEqualNodes(node.extendsClause, toNode.extendsClause)), _isEqualNodes(node.withClause, toNode.withClause)), _isEqualNodes(node.implementsClause, toNode.implementsClause)), _isEqualTokens(node.leftBracket, toNode.leftBracket)), _isEqualNodeLists(node.members, toNode.members)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitClassTypeAlias(ClassTypeAlias node) {
     ClassTypeAlias toNode = this._toNode as ClassTypeAlias;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.typeParameters, toNode.typeParameters)), _isEqualTokens(node.equals, toNode.equals)), _isEqualTokens(node.abstractKeyword, toNode.abstractKeyword)), _isEqualNodes(node.superclass, toNode.superclass)), _isEqualNodes(node.withClause, toNode.withClause)), _isEqualNodes(node.implementsClause, toNode.implementsClause)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitComment(Comment node) {
     Comment toNode = this._toNode as Comment;
     return _isEqualNodeLists(node.references, toNode.references);
   }
 
+  @override
   bool visitCommentReference(CommentReference node) {
     CommentReference toNode = this._toNode as CommentReference;
     return javaBooleanAnd(_isEqualTokens(node.newKeyword, toNode.newKeyword), _isEqualNodes(node.identifier, toNode.identifier));
   }
 
+  @override
   bool visitCompilationUnit(CompilationUnit node) {
     CompilationUnit toNode = this._toNode as CompilationUnit;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.beginToken, toNode.beginToken), _isEqualNodes(node.scriptTag, toNode.scriptTag)), _isEqualNodeLists(node.directives, toNode.directives)), _isEqualNodeLists(node.declarations, toNode.declarations)), _isEqualTokens(node.endToken, toNode.endToken))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitConditionalExpression(ConditionalExpression node) {
     ConditionalExpression toNode = this._toNode as ConditionalExpression;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.condition, toNode.condition), _isEqualTokens(node.question, toNode.question)), _isEqualNodes(node.thenExpression, toNode.thenExpression)), _isEqualTokens(node.colon, toNode.colon)), _isEqualNodes(node.elseExpression, toNode.elseExpression))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorDeclaration toNode = this._toNode as ConstructorDeclaration;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.externalKeyword, toNode.externalKeyword)), _isEqualTokens(node.constKeyword, toNode.constKeyword)), _isEqualTokens(node.factoryKeyword, toNode.factoryKeyword)), _isEqualNodes(node.returnType, toNode.returnType)), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.parameters, toNode.parameters)), _isEqualTokens(node.separator, toNode.separator)), _isEqualNodeLists(node.initializers, toNode.initializers)), _isEqualNodes(node.redirectedConstructor, toNode.redirectedConstructor)), _isEqualNodes(node.body, toNode.body))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     ConstructorFieldInitializer toNode = this._toNode as ConstructorFieldInitializer;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.fieldName, toNode.fieldName)), _isEqualTokens(node.equals, toNode.equals)), _isEqualNodes(node.expression, toNode.expression));
   }
 
+  @override
   bool visitConstructorName(ConstructorName node) {
     ConstructorName toNode = this._toNode as ConstructorName;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.type, toNode.type), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.name, toNode.name))) {
       toNode.staticElement = node.staticElement;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitContinueStatement(ContinueStatement node) {
     ContinueStatement toNode = this._toNode as ContinueStatement;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.label, toNode.label)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitDeclaredIdentifier(DeclaredIdentifier node) {
     DeclaredIdentifier toNode = this._toNode as DeclaredIdentifier;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.type, toNode.type)), _isEqualNodes(node.identifier, toNode.identifier));
   }
 
+  @override
   bool visitDefaultFormalParameter(DefaultFormalParameter node) {
     DefaultFormalParameter toNode = this._toNode as DefaultFormalParameter;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.parameter, toNode.parameter), identical(node.kind, toNode.kind)), _isEqualTokens(node.separator, toNode.separator)), _isEqualNodes(node.defaultValue, toNode.defaultValue));
   }
 
+  @override
   bool visitDoStatement(DoStatement node) {
     DoStatement toNode = this._toNode as DoStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.doKeyword, toNode.doKeyword), _isEqualNodes(node.body, toNode.body)), _isEqualTokens(node.whileKeyword, toNode.whileKeyword)), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.condition, toNode.condition)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitDoubleLiteral(DoubleLiteral node) {
     DoubleLiteral toNode = this._toNode as DoubleLiteral;
     if (javaBooleanAnd(_isEqualTokens(node.literal, toNode.literal), node.value == toNode.value)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitEmptyFunctionBody(EmptyFunctionBody node) {
     EmptyFunctionBody toNode = this._toNode as EmptyFunctionBody;
     return _isEqualTokens(node.semicolon, toNode.semicolon);
   }
 
+  @override
   bool visitEmptyStatement(EmptyStatement node) {
     EmptyStatement toNode = this._toNode as EmptyStatement;
     return _isEqualTokens(node.semicolon, toNode.semicolon);
   }
 
+  @override
   bool visitExportDirective(ExportDirective node) {
     ExportDirective toNode = this._toNode as ExportDirective;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.uri, toNode.uri)), _isEqualNodeLists(node.combinators, toNode.combinators)), _isEqualTokens(node.semicolon, toNode.semicolon))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitExpressionFunctionBody(ExpressionFunctionBody node) {
     ExpressionFunctionBody toNode = this._toNode as ExpressionFunctionBody;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.functionDefinition, toNode.functionDefinition), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitExpressionStatement(ExpressionStatement node) {
     ExpressionStatement toNode = this._toNode as ExpressionStatement;
     return javaBooleanAnd(_isEqualNodes(node.expression, toNode.expression), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitExtendsClause(ExtendsClause node) {
     ExtendsClause toNode = this._toNode as ExtendsClause;
     return javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.superclass, toNode.superclass));
   }
 
+  @override
   bool visitFieldDeclaration(FieldDeclaration node) {
     FieldDeclaration toNode = this._toNode as FieldDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.staticKeyword, toNode.staticKeyword)), _isEqualNodes(node.fields, toNode.fields)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitFieldFormalParameter(FieldFormalParameter node) {
     FieldFormalParameter toNode = this._toNode as FieldFormalParameter;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.type, toNode.type)), _isEqualTokens(node.thisToken, toNode.thisToken)), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.identifier, toNode.identifier));
   }
 
+  @override
   bool visitForEachStatement(ForEachStatement node) {
     ForEachStatement toNode = this._toNode as ForEachStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.forKeyword, toNode.forKeyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.loopVariable, toNode.loopVariable)), _isEqualTokens(node.inKeyword, toNode.inKeyword)), _isEqualNodes(node.iterator, toNode.iterator)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualNodes(node.body, toNode.body));
   }
 
+  @override
   bool visitFormalParameterList(FormalParameterList node) {
     FormalParameterList toNode = this._toNode as FormalParameterList;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftParenthesis, toNode.leftParenthesis), _isEqualNodeLists(node.parameters, toNode.parameters)), _isEqualTokens(node.leftDelimiter, toNode.leftDelimiter)), _isEqualTokens(node.rightDelimiter, toNode.rightDelimiter)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis));
   }
 
+  @override
   bool visitForStatement(ForStatement node) {
     ForStatement toNode = this._toNode as ForStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.forKeyword, toNode.forKeyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.variables, toNode.variables)), _isEqualNodes(node.initialization, toNode.initialization)), _isEqualTokens(node.leftSeparator, toNode.leftSeparator)), _isEqualNodes(node.condition, toNode.condition)), _isEqualTokens(node.rightSeparator, toNode.rightSeparator)), _isEqualNodeLists(node.updaters, toNode.updaters)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualNodes(node.body, toNode.body));
   }
 
+  @override
   bool visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionDeclaration toNode = this._toNode as FunctionDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.externalKeyword, toNode.externalKeyword)), _isEqualNodes(node.returnType, toNode.returnType)), _isEqualTokens(node.propertyKeyword, toNode.propertyKeyword)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.functionExpression, toNode.functionExpression));
   }
 
+  @override
   bool visitFunctionDeclarationStatement(FunctionDeclarationStatement node) {
     FunctionDeclarationStatement toNode = this._toNode as FunctionDeclarationStatement;
     return _isEqualNodes(node.functionDeclaration, toNode.functionDeclaration);
   }
 
+  @override
   bool visitFunctionExpression(FunctionExpression node) {
     FunctionExpression toNode = this._toNode as FunctionExpression;
     if (javaBooleanAnd(_isEqualNodes(node.parameters, toNode.parameters), _isEqualNodes(node.body, toNode.body))) {
       toNode.element = node.element;
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     FunctionExpressionInvocation toNode = this._toNode as FunctionExpressionInvocation;
     if (javaBooleanAnd(_isEqualNodes(node.function, toNode.function), _isEqualNodes(node.argumentList, toNode.argumentList))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAlias toNode = this._toNode as FunctionTypeAlias;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.returnType, toNode.returnType)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.typeParameters, toNode.typeParameters)), _isEqualNodes(node.parameters, toNode.parameters)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     FunctionTypedFormalParameter toNode = this._toNode as FunctionTypedFormalParameter;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualNodes(node.returnType, toNode.returnType)), _isEqualNodes(node.identifier, toNode.identifier)), _isEqualNodes(node.parameters, toNode.parameters));
   }
 
+  @override
   bool visitHideCombinator(HideCombinator node) {
     HideCombinator toNode = this._toNode as HideCombinator;
     return javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodeLists(node.hiddenNames, toNode.hiddenNames));
   }
 
+  @override
   bool visitIfStatement(IfStatement node) {
     IfStatement toNode = this._toNode as IfStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.ifKeyword, toNode.ifKeyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.condition, toNode.condition)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualNodes(node.thenStatement, toNode.thenStatement)), _isEqualTokens(node.elseKeyword, toNode.elseKeyword)), _isEqualNodes(node.elseStatement, toNode.elseStatement));
   }
 
+  @override
   bool visitImplementsClause(ImplementsClause node) {
     ImplementsClause toNode = this._toNode as ImplementsClause;
     return javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodeLists(node.interfaces, toNode.interfaces));
   }
 
+  @override
   bool visitImportDirective(ImportDirective node) {
     ImportDirective toNode = this._toNode as ImportDirective;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.uri, toNode.uri)), _isEqualTokens(node.asToken, toNode.asToken)), _isEqualNodes(node.prefix, toNode.prefix)), _isEqualNodeLists(node.combinators, toNode.combinators)), _isEqualTokens(node.semicolon, toNode.semicolon))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitIndexExpression(IndexExpression node) {
     IndexExpression toNode = this._toNode as IndexExpression;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.target, toNode.target), _isEqualTokens(node.leftBracket, toNode.leftBracket)), _isEqualNodes(node.index, toNode.index)), _isEqualTokens(node.rightBracket, toNode.rightBracket))) {
       toNode.auxiliaryElements = node.auxiliaryElements;
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitInstanceCreationExpression(InstanceCreationExpression node) {
     InstanceCreationExpression toNode = this._toNode as InstanceCreationExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.constructorName, toNode.constructorName)), _isEqualNodes(node.argumentList, toNode.argumentList))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitIntegerLiteral(IntegerLiteral node) {
     IntegerLiteral toNode = this._toNode as IntegerLiteral;
     if (javaBooleanAnd(_isEqualTokens(node.literal, toNode.literal), identical(node.value, toNode.value))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitInterpolationExpression(InterpolationExpression node) {
     InterpolationExpression toNode = this._toNode as InterpolationExpression;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftBracket, toNode.leftBracket), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitInterpolationString(InterpolationString node) {
     InterpolationString toNode = this._toNode as InterpolationString;
     return javaBooleanAnd(_isEqualTokens(node.contents, toNode.contents), node.value == toNode.value);
   }
 
+  @override
   bool visitIsExpression(IsExpression node) {
     IsExpression toNode = this._toNode as IsExpression;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.expression, toNode.expression), _isEqualTokens(node.isOperator, toNode.isOperator)), _isEqualTokens(node.notOperator, toNode.notOperator)), _isEqualNodes(node.type, toNode.type))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitLabel(Label node) {
     Label toNode = this._toNode as Label;
     return javaBooleanAnd(_isEqualNodes(node.label, toNode.label), _isEqualTokens(node.colon, toNode.colon));
   }
 
+  @override
   bool visitLabeledStatement(LabeledStatement node) {
     LabeledStatement toNode = this._toNode as LabeledStatement;
     return javaBooleanAnd(_isEqualNodeLists(node.labels, toNode.labels), _isEqualNodes(node.statement, toNode.statement));
   }
 
+  @override
   bool visitLibraryDirective(LibraryDirective node) {
     LibraryDirective toNode = this._toNode as LibraryDirective;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.libraryToken, toNode.libraryToken)), _isEqualNodes(node.name, toNode.name)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitLibraryIdentifier(LibraryIdentifier node) {
     LibraryIdentifier toNode = this._toNode as LibraryIdentifier;
     if (_isEqualNodeLists(node.components, toNode.components)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitListLiteral(ListLiteral node) {
     ListLiteral toNode = this._toNode as ListLiteral;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.constKeyword, toNode.constKeyword), _isEqualNodes(node.typeArguments, toNode.typeArguments)), _isEqualTokens(node.leftBracket, toNode.leftBracket)), _isEqualNodeLists(node.elements, toNode.elements)), _isEqualTokens(node.rightBracket, toNode.rightBracket))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitMapLiteral(MapLiteral node) {
     MapLiteral toNode = this._toNode as MapLiteral;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.constKeyword, toNode.constKeyword), _isEqualNodes(node.typeArguments, toNode.typeArguments)), _isEqualTokens(node.leftBracket, toNode.leftBracket)), _isEqualNodeLists(node.entries, toNode.entries)), _isEqualTokens(node.rightBracket, toNode.rightBracket))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitMapLiteralEntry(MapLiteralEntry node) {
     MapLiteralEntry toNode = this._toNode as MapLiteralEntry;
     return javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.key, toNode.key), _isEqualTokens(node.separator, toNode.separator)), _isEqualNodes(node.value, toNode.value));
   }
 
+  @override
   bool visitMethodDeclaration(MethodDeclaration node) {
     MethodDeclaration toNode = this._toNode as MethodDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.externalKeyword, toNode.externalKeyword)), _isEqualTokens(node.modifierKeyword, toNode.modifierKeyword)), _isEqualNodes(node.returnType, toNode.returnType)), _isEqualTokens(node.propertyKeyword, toNode.propertyKeyword)), _isEqualTokens(node.propertyKeyword, toNode.propertyKeyword)), _isEqualNodes(node.name, toNode.name)), _isEqualNodes(node.parameters, toNode.parameters)), _isEqualNodes(node.body, toNode.body));
   }
 
+  @override
   bool visitMethodInvocation(MethodInvocation node) {
     MethodInvocation toNode = this._toNode as MethodInvocation;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.target, toNode.target), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.methodName, toNode.methodName)), _isEqualNodes(node.argumentList, toNode.argumentList))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitNamedExpression(NamedExpression node) {
     NamedExpression toNode = this._toNode as NamedExpression;
     if (javaBooleanAnd(_isEqualNodes(node.name, toNode.name), _isEqualNodes(node.expression, toNode.expression))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitNativeClause(NativeClause node) {
     NativeClause toNode = this._toNode as NativeClause;
     return javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.name, toNode.name));
   }
 
+  @override
   bool visitNativeFunctionBody(NativeFunctionBody node) {
     NativeFunctionBody toNode = this._toNode as NativeFunctionBody;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.nativeToken, toNode.nativeToken), _isEqualNodes(node.stringLiteral, toNode.stringLiteral)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitNullLiteral(NullLiteral node) {
     NullLiteral toNode = this._toNode as NullLiteral;
     if (_isEqualTokens(node.literal, toNode.literal)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitParenthesizedExpression(ParenthesizedExpression node) {
     ParenthesizedExpression toNode = this._toNode as ParenthesizedExpression;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftParenthesis, toNode.leftParenthesis), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPartDirective(PartDirective node) {
     PartDirective toNode = this._toNode as PartDirective;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.partToken, toNode.partToken)), _isEqualNodes(node.uri, toNode.uri)), _isEqualTokens(node.semicolon, toNode.semicolon))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPartOfDirective(PartOfDirective node) {
     PartOfDirective toNode = this._toNode as PartOfDirective;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.partToken, toNode.partToken)), _isEqualTokens(node.ofToken, toNode.ofToken)), _isEqualNodes(node.libraryName, toNode.libraryName)), _isEqualTokens(node.semicolon, toNode.semicolon))) {
       toNode.element = node.element;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPostfixExpression(PostfixExpression node) {
     PostfixExpression toNode = this._toNode as PostfixExpression;
     if (javaBooleanAnd(_isEqualNodes(node.operand, toNode.operand), _isEqualTokens(node.operator, toNode.operator))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPrefixedIdentifier(PrefixedIdentifier node) {
     PrefixedIdentifier toNode = this._toNode as PrefixedIdentifier;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.prefix, toNode.prefix), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.identifier, toNode.identifier))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPrefixExpression(PrefixExpression node) {
     PrefixExpression toNode = this._toNode as PrefixExpression;
     if (javaBooleanAnd(_isEqualTokens(node.operator, toNode.operator), _isEqualNodes(node.operand, toNode.operand))) {
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitPropertyAccess(PropertyAccess node) {
     PropertyAccess toNode = this._toNode as PropertyAccess;
     if (javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.target, toNode.target), _isEqualTokens(node.operator, toNode.operator)), _isEqualNodes(node.propertyName, toNode.propertyName))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     RedirectingConstructorInvocation toNode = this._toNode as RedirectingConstructorInvocation;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.constructorName, toNode.constructorName)), _isEqualNodes(node.argumentList, toNode.argumentList))) {
       toNode.staticElement = node.staticElement;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitRethrowExpression(RethrowExpression node) {
     RethrowExpression toNode = this._toNode as RethrowExpression;
     if (_isEqualTokens(node.keyword, toNode.keyword)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitReturnStatement(ReturnStatement node) {
     ReturnStatement toNode = this._toNode as ReturnStatement;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitScriptTag(ScriptTag node) {
     ScriptTag toNode = this._toNode as ScriptTag;
     return _isEqualTokens(node.scriptTag, toNode.scriptTag);
   }
 
+  @override
   bool visitShowCombinator(ShowCombinator node) {
     ShowCombinator toNode = this._toNode as ShowCombinator;
     return javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodeLists(node.shownNames, toNode.shownNames));
   }
 
+  @override
   bool visitSimpleFormalParameter(SimpleFormalParameter node) {
     SimpleFormalParameter toNode = this._toNode as SimpleFormalParameter;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.type, toNode.type)), _isEqualNodes(node.identifier, toNode.identifier));
   }
 
+  @override
   bool visitSimpleIdentifier(SimpleIdentifier node) {
     SimpleIdentifier toNode = this._toNode as SimpleIdentifier;
     if (_isEqualTokens(node.token, toNode.token)) {
       toNode.staticElement = node.staticElement;
       toNode.staticType = node.staticType;
       toNode.propagatedElement = node.propagatedElement;
       toNode.propagatedType = node.propagatedType;
       toNode.auxiliaryElements = node.auxiliaryElements;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitSimpleStringLiteral(SimpleStringLiteral node) {
     SimpleStringLiteral toNode = this._toNode as SimpleStringLiteral;
     if (javaBooleanAnd(_isEqualTokens(node.literal, toNode.literal), identical(node.value, toNode.value))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitStringInterpolation(StringInterpolation node) {
     StringInterpolation toNode = this._toNode as StringInterpolation;
     if (_isEqualNodeLists(node.elements, toNode.elements)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation toNode = this._toNode as SuperConstructorInvocation;
     if (javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.period, toNode.period)), _isEqualNodes(node.constructorName, toNode.constructorName)), _isEqualNodes(node.argumentList, toNode.argumentList))) {
       toNode.staticElement = node.staticElement;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitSuperExpression(SuperExpression node) {
     SuperExpression toNode = this._toNode as SuperExpression;
     if (_isEqualTokens(node.keyword, toNode.keyword)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitSwitchCase(SwitchCase node) {
     SwitchCase toNode = this._toNode as SwitchCase;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodeLists(node.labels, toNode.labels), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.colon, toNode.colon)), _isEqualNodeLists(node.statements, toNode.statements));
   }
 
+  @override
   bool visitSwitchDefault(SwitchDefault node) {
     SwitchDefault toNode = this._toNode as SwitchDefault;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodeLists(node.labels, toNode.labels), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualTokens(node.colon, toNode.colon)), _isEqualNodeLists(node.statements, toNode.statements));
   }
 
+  @override
   bool visitSwitchStatement(SwitchStatement node) {
     SwitchStatement toNode = this._toNode as SwitchStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.expression, toNode.expression)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualTokens(node.leftBracket, toNode.leftBracket)), _isEqualNodeLists(node.members, toNode.members)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitSymbolLiteral(SymbolLiteral node) {
     SymbolLiteral toNode = this._toNode as SymbolLiteral;
     if (javaBooleanAnd(_isEqualTokens(node.poundSign, toNode.poundSign), _isEqualTokenLists(node.components, toNode.components))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitThisExpression(ThisExpression node) {
     ThisExpression toNode = this._toNode as ThisExpression;
     if (_isEqualTokens(node.keyword, toNode.keyword)) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitThrowExpression(ThrowExpression node) {
     ThrowExpression toNode = this._toNode as ThrowExpression;
     if (javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualNodes(node.expression, toNode.expression))) {
       toNode.propagatedType = node.propagatedType;
       toNode.staticType = node.staticType;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     TopLevelVariableDeclaration toNode = this._toNode as TopLevelVariableDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualNodes(node.variables, toNode.variables)), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitTryStatement(TryStatement node) {
     TryStatement toNode = this._toNode as TryStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.tryKeyword, toNode.tryKeyword), _isEqualNodes(node.body, toNode.body)), _isEqualNodeLists(node.catchClauses, toNode.catchClauses)), _isEqualTokens(node.finallyKeyword, toNode.finallyKeyword)), _isEqualNodes(node.finallyBlock, toNode.finallyBlock));
   }
 
+  @override
   bool visitTypeArgumentList(TypeArgumentList node) {
     TypeArgumentList toNode = this._toNode as TypeArgumentList;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftBracket, toNode.leftBracket), _isEqualNodeLists(node.arguments, toNode.arguments)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitTypeName(TypeName node) {
     TypeName toNode = this._toNode as TypeName;
     if (javaBooleanAnd(_isEqualNodes(node.name, toNode.name), _isEqualNodes(node.typeArguments, toNode.typeArguments))) {
       toNode.type = node.type;
       return true;
     }
     return false;
   }
 
+  @override
   bool visitTypeParameter(TypeParameter node) {
     TypeParameter toNode = this._toNode as TypeParameter;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualNodes(node.name, toNode.name)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.bound, toNode.bound));
   }
 
+  @override
   bool visitTypeParameterList(TypeParameterList node) {
     TypeParameterList toNode = this._toNode as TypeParameterList;
     return javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.leftBracket, toNode.leftBracket), _isEqualNodeLists(node.typeParameters, toNode.typeParameters)), _isEqualTokens(node.rightBracket, toNode.rightBracket));
   }
 
+  @override
   bool visitVariableDeclaration(VariableDeclaration node) {
     VariableDeclaration toNode = this._toNode as VariableDeclaration;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualNodes(node.name, toNode.name)), _isEqualTokens(node.equals, toNode.equals)), _isEqualNodes(node.initializer, toNode.initializer));
   }
 
+  @override
   bool visitVariableDeclarationList(VariableDeclarationList node) {
     VariableDeclarationList toNode = this._toNode as VariableDeclarationList;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualNodes(node.documentationComment, toNode.documentationComment), _isEqualNodeLists(node.metadata, toNode.metadata)), _isEqualTokens(node.keyword, toNode.keyword)), _isEqualNodes(node.type, toNode.type)), _isEqualNodeLists(node.variables, toNode.variables));
   }
 
+  @override
   bool visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     VariableDeclarationStatement toNode = this._toNode as VariableDeclarationStatement;
     return javaBooleanAnd(_isEqualNodes(node.variables, toNode.variables), _isEqualTokens(node.semicolon, toNode.semicolon));
   }
 
+  @override
   bool visitWhileStatement(WhileStatement node) {
     WhileStatement toNode = this._toNode as WhileStatement;
     return javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(javaBooleanAnd(_isEqualTokens(node.keyword, toNode.keyword), _isEqualTokens(node.leftParenthesis, toNode.leftParenthesis)), _isEqualNodes(node.condition, toNode.condition)), _isEqualTokens(node.rightParenthesis, toNode.rightParenthesis)), _isEqualNodes(node.body, toNode.body));
   }
 
+  @override
   bool visitWithClause(WithClause node) {
     WithClause toNode = this._toNode as WithClause;
     return javaBooleanAnd(_isEqualTokens(node.withKeyword, toNode.withKeyword), _isEqualNodeLists(node.mixinTypes, toNode.mixinTypes));
   }
 
   /**
    * Return `true` if the given lists of AST nodes have the same size and corresponding
    * elements are equal.
    *
    * @param first the first node being compared
@@ skipping 307 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }