pkg/kernel/lib/src/equivalence.dart

// Copyright (c) 2021, 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.

// NOTE: THIS FILE IS GENERATED. DO NOT EDIT.
//
// Run 'dart pkg/front_end/tool/generate_ast_equivalence.dart' to update.

// ignore_for_file: deprecated_member_use_from_same_package

import 'package:kernel/ast.dart';
import 'package:kernel/src/printer.dart';

import 'union_find.dart';

part 'equivalence_helpers.dart';

/// Visitor that uses a EquivalenceStrategy to compute AST node equivalence.
///
/// The visitor hold a current state that collects found inequivalences and
/// current assumptions. The current state has two modes. In the asserting mode,
/// the default, inequivalences are registered when found. In the non-asserting
/// mode, inequivalences are _not_ registered. The latter is used to compute
/// equivalences in sandboxed state, for instance to determine which elements
/// to pair when checking equivalence of two sets.
class EquivalenceVisitor implements Visitor1<bool, Node> {
  final EquivalenceStrategy strategy;

  new({this.strategy = const EquivalenceStrategy()});

  @override
  bool visitAuxiliaryConstant(AuxiliaryConstant node, Node other) {
    return strategy.checkAuxiliaryConstant(this, node, other);
  }

  @override
  bool visitNullConstant(NullConstant node, Node other) {
    return strategy.checkNullConstant(this, node, other);
  }

  @override
  bool visitBoolConstant(BoolConstant node, Node other) {
    return strategy.checkBoolConstant(this, node, other);
  }

  @override
  bool visitIntConstant(IntConstant node, Node other) {
    return strategy.checkIntConstant(this, node, other);
  }

  @override
  bool visitDoubleConstant(DoubleConstant node, Node other) {
    return strategy.checkDoubleConstant(this, node, other);
  }

  @override
  bool visitStringConstant(StringConstant node, Node other) {
    return strategy.checkStringConstant(this, node, other);
  }

  @override
  bool visitSymbolConstant(SymbolConstant node, Node other) {
    return strategy.checkSymbolConstant(this, node, other);
  }

  @override
  bool visitMapConstant(MapConstant node, Node other) {
    return strategy.checkMapConstant(this, node, other);
  }

  @override
  bool visitListConstant(ListConstant node, Node other) {
    return strategy.checkListConstant(this, node, other);
  }

  @override
  bool visitSetConstant(SetConstant node, Node other) {
    return strategy.checkSetConstant(this, node, other);
  }

  @override
  bool visitRecordConstant(RecordConstant node, Node other) {
    return strategy.checkRecordConstant(this, node, other);
  }

  @override
  bool visitInstanceConstant(InstanceConstant node, Node other) {
    return strategy.checkInstanceConstant(this, node, other);
  }

  @override
  bool visitInstantiationConstant(InstantiationConstant node, Node other) {
    return strategy.checkInstantiationConstant(this, node, other);
  }

  @override
  bool visitStaticTearOffConstant(StaticTearOffConstant node, Node other) {
    return strategy.checkStaticTearOffConstant(this, node, other);
  }

  @override
  bool visitConstructorTearOffConstant(
    ConstructorTearOffConstant node,
    Node other,
  ) {
    return strategy.checkConstructorTearOffConstant(this, node, other);
  }

  @override
  bool visitRedirectingFactoryTearOffConstant(
    RedirectingFactoryTearOffConstant node,
    Node other,
  ) {
    return strategy.checkRedirectingFactoryTearOffConstant(this, node, other);
  }

  @override
  bool visitTypedefTearOffConstant(TypedefTearOffConstant node, Node other) {
    return strategy.checkTypedefTearOffConstant(this, node, other);
  }

  @override
  bool visitTypeLiteralConstant(TypeLiteralConstant node, Node other) {
    return strategy.checkTypeLiteralConstant(this, node, other);
  }

  @override
  bool visitUnevaluatedConstant(UnevaluatedConstant node, Node other) {
    return strategy.checkUnevaluatedConstant(this, node, other);
  }

  @override
  bool visitComponent(Component node, Node other) {
    return strategy.checkComponent(this, node, other);
  }

  @override
  bool visitClass(Class node, Node other) {
    return strategy.checkClass(this, node, other);
  }

  @override
  bool visitExtension(Extension node, Node other) {
    return strategy.checkExtension(this, node, other);
  }

  @override
  bool visitExtensionTypeDeclaration(
    ExtensionTypeDeclaration node,
    Node other,
  ) {
    return strategy.checkExtensionTypeDeclaration(this, node, other);
  }

  @override
  bool visitLibrary(Library node, Node other) {
    return strategy.checkLibrary(this, node, other);
  }

  @override
  bool visitField(Field node, Node other) {
    return strategy.checkField(this, node, other);
  }

  @override
  bool visitConstructor(Constructor node, Node other) {
    return strategy.checkConstructor(this, node, other);
  }

  @override
  bool visitProcedure(Procedure node, Node other) {
    return strategy.checkProcedure(this, node, other);
  }

  @override
  bool visitTypedef(Typedef node, Node other) {
    return strategy.checkTypedef(this, node, other);
  }

  @override
  bool visitAuxiliaryExpression(AuxiliaryExpression node, Node other) {
    return strategy.checkAuxiliaryExpression(this, node, other);
  }

  @override
  bool visitInvalidExpression(InvalidExpression node, Node other) {
    return strategy.checkInvalidExpression(this, node, other);
  }

  @override
  bool visitVariableGet(VariableGet node, Node other) {
    return strategy.checkVariableGet(this, node, other);
  }

  @override
  bool visitVariableSet(VariableSet node, Node other) {
    return strategy.checkVariableSet(this, node, other);
  }

  @override
  bool visitRecordIndexGet(RecordIndexGet node, Node other) {
    return strategy.checkRecordIndexGet(this, node, other);
  }

  @override
  bool visitRecordNameGet(RecordNameGet node, Node other) {
    return strategy.checkRecordNameGet(this, node, other);
  }

  @override
  bool visitDynamicGet(DynamicGet node, Node other) {
    return strategy.checkDynamicGet(this, node, other);
  }

  @override
  bool visitInstanceGet(InstanceGet node, Node other) {
    return strategy.checkInstanceGet(this, node, other);
  }

  @override
  bool visitFunctionTearOff(FunctionTearOff node, Node other) {
    return strategy.checkFunctionTearOff(this, node, other);
  }

  @override
  bool visitInstanceTearOff(InstanceTearOff node, Node other) {
    return strategy.checkInstanceTearOff(this, node, other);
  }

  @override
  bool visitDynamicSet(DynamicSet node, Node other) {
    return strategy.checkDynamicSet(this, node, other);
  }

  @override
  bool visitInstanceSet(InstanceSet node, Node other) {
    return strategy.checkInstanceSet(this, node, other);
  }

  @override
  bool visitAbstractSuperPropertyGet(
    AbstractSuperPropertyGet node,
    Node other,
  ) {
    return strategy.checkAbstractSuperPropertyGet(this, node, other);
  }

  @override
  bool visitSuperPropertyGet(SuperPropertyGet node, Node other) {
    return strategy.checkSuperPropertyGet(this, node, other);
  }

  @override
  bool visitAbstractSuperPropertySet(
    AbstractSuperPropertySet node,
    Node other,
  ) {
    return strategy.checkAbstractSuperPropertySet(this, node, other);
  }

  @override
  bool visitSuperPropertySet(SuperPropertySet node, Node other) {
    return strategy.checkSuperPropertySet(this, node, other);
  }

  @override
  bool visitStaticGet(StaticGet node, Node other) {
    return strategy.checkStaticGet(this, node, other);
  }

  @override
  bool visitStaticTearOff(StaticTearOff node, Node other) {
    return strategy.checkStaticTearOff(this, node, other);
  }

  @override
  bool visitStaticSet(StaticSet node, Node other) {
    return strategy.checkStaticSet(this, node, other);
  }

  @override
  bool visitDynamicInvocation(DynamicInvocation node, Node other) {
    return strategy.checkDynamicInvocation(this, node, other);
  }

  @override
  bool visitInstanceInvocation(InstanceInvocation node, Node other) {
    return strategy.checkInstanceInvocation(this, node, other);
  }

  @override
  bool visitInstanceGetterInvocation(
    InstanceGetterInvocation node,
    Node other,
  ) {
    return strategy.checkInstanceGetterInvocation(this, node, other);
  }

  @override
  bool visitFunctionInvocation(FunctionInvocation node, Node other) {
    return strategy.checkFunctionInvocation(this, node, other);
  }

  @override
  bool visitLocalFunctionInvocation(LocalFunctionInvocation node, Node other) {
    return strategy.checkLocalFunctionInvocation(this, node, other);
  }

  @override
  bool visitAbstractSuperMethodInvocation(
    AbstractSuperMethodInvocation node,
    Node other,
  ) {
    return strategy.checkAbstractSuperMethodInvocation(this, node, other);
  }

  @override
  bool visitSuperMethodInvocation(SuperMethodInvocation node, Node other) {
    return strategy.checkSuperMethodInvocation(this, node, other);
  }

  @override
  bool visitStaticInvocation(StaticInvocation node, Node other) {
    return strategy.checkStaticInvocation(this, node, other);
  }

  @override
  bool visitConstructorInvocation(ConstructorInvocation node, Node other) {
    return strategy.checkConstructorInvocation(this, node, other);
  }

  @override
  bool visitEqualsNull(EqualsNull node, Node other) {
    return strategy.checkEqualsNull(this, node, other);
  }

  @override
  bool visitEqualsCall(EqualsCall node, Node other) {
    return strategy.checkEqualsCall(this, node, other);
  }

  @override
  bool visitRedirectingFactoryInvocation(
    RedirectingFactoryInvocation node,
    Node other,
  ) {
    return strategy.checkRedirectingFactoryInvocation(this, node, other);
  }

  @override
  bool visitInstantiation(Instantiation node, Node other) {
    return strategy.checkInstantiation(this, node, other);
  }

  @override
  bool visitNot(Not node, Node other) {
    return strategy.checkNot(this, node, other);
  }

  @override
  bool visitLogicalExpression(LogicalExpression node, Node other) {
    return strategy.checkLogicalExpression(this, node, other);
  }

  @override
  bool visitConditionalExpression(ConditionalExpression node, Node other) {
    return strategy.checkConditionalExpression(this, node, other);
  }

  @override
  bool visitStringConcatenation(StringConcatenation node, Node other) {
    return strategy.checkStringConcatenation(this, node, other);
  }

  @override
  bool visitListConcatenation(ListConcatenation node, Node other) {
    return strategy.checkListConcatenation(this, node, other);
  }

  @override
  bool visitSetConcatenation(SetConcatenation node, Node other) {
    return strategy.checkSetConcatenation(this, node, other);
  }

  @override
  bool visitMapConcatenation(MapConcatenation node, Node other) {
    return strategy.checkMapConcatenation(this, node, other);
  }

  @override
  bool visitInstanceCreation(InstanceCreation node, Node other) {
    return strategy.checkInstanceCreation(this, node, other);
  }

  @override
  bool visitFileUriExpression(FileUriExpression node, Node other) {
    return strategy.checkFileUriExpression(this, node, other);
  }

  @override
  bool visitIsExpression(IsExpression node, Node other) {
    return strategy.checkIsExpression(this, node, other);
  }

  @override
  bool visitAsExpression(AsExpression node, Node other) {
    return strategy.checkAsExpression(this, node, other);
  }

  @override
  bool visitNullCheck(NullCheck node, Node other) {
    return strategy.checkNullCheck(this, node, other);
  }

  @override
  bool visitStringLiteral(StringLiteral node, Node other) {
    return strategy.checkStringLiteral(this, node, other);
  }

  @override
  bool visitIntLiteral(IntLiteral node, Node other) {
    return strategy.checkIntLiteral(this, node, other);
  }

  @override
  bool visitDoubleLiteral(DoubleLiteral node, Node other) {
    return strategy.checkDoubleLiteral(this, node, other);
  }

  @override
  bool visitBoolLiteral(BoolLiteral node, Node other) {
    return strategy.checkBoolLiteral(this, node, other);
  }

  @override
  bool visitNullLiteral(NullLiteral node, Node other) {
    return strategy.checkNullLiteral(this, node, other);
  }

  @override
  bool visitSymbolLiteral(SymbolLiteral node, Node other) {
    return strategy.checkSymbolLiteral(this, node, other);
  }

  @override
  bool visitTypeLiteral(TypeLiteral node, Node other) {
    return strategy.checkTypeLiteral(this, node, other);
  }

  @override
  bool visitThisExpression(ThisExpression node, Node other) {
    return strategy.checkThisExpression(this, node, other);
  }

  @override
  bool visitRethrow(Rethrow node, Node other) {
    return strategy.checkRethrow(this, node, other);
  }

  @override
  bool visitThrow(Throw node, Node other) {
    return strategy.checkThrow(this, node, other);
  }

  @override
  bool visitListLiteral(ListLiteral node, Node other) {
    return strategy.checkListLiteral(this, node, other);
  }

  @override
  bool visitSetLiteral(SetLiteral node, Node other) {
    return strategy.checkSetLiteral(this, node, other);
  }

  @override
  bool visitMapLiteral(MapLiteral node, Node other) {
    return strategy.checkMapLiteral(this, node, other);
  }

  @override
  bool visitRecordLiteral(RecordLiteral node, Node other) {
    return strategy.checkRecordLiteral(this, node, other);
  }

  @override
  bool visitAwaitExpression(AwaitExpression node, Node other) {
    return strategy.checkAwaitExpression(this, node, other);
  }

  @override
  bool visitFunctionExpression(FunctionExpression node, Node other) {
    return strategy.checkFunctionExpression(this, node, other);
  }

  @override
  bool visitConstantExpression(ConstantExpression node, Node other) {
    return strategy.checkConstantExpression(this, node, other);
  }

  @override
  bool visitLet(Let node, Node other) {
    return strategy.checkLet(this, node, other);
  }

  @override
  bool visitBlockExpression(BlockExpression node, Node other) {
    return strategy.checkBlockExpression(this, node, other);
  }

  @override
  bool visitLoadLibrary(LoadLibrary node, Node other) {
    return strategy.checkLoadLibrary(this, node, other);
  }

  @override
  bool visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node, Node other) {
    return strategy.checkCheckLibraryIsLoaded(this, node, other);
  }

  @override
  bool visitConstructorTearOff(ConstructorTearOff node, Node other) {
    return strategy.checkConstructorTearOff(this, node, other);
  }

  @override
  bool visitRedirectingFactoryTearOff(
    RedirectingFactoryTearOff node,
    Node other,
  ) {
    return strategy.checkRedirectingFactoryTearOff(this, node, other);
  }

  @override
  bool visitTypedefTearOff(TypedefTearOff node, Node other) {
    return strategy.checkTypedefTearOff(this, node, other);
  }

  @override
  bool visitSwitchExpression(SwitchExpression node, Node other) {
    return strategy.checkSwitchExpression(this, node, other);
  }

  @override
  bool visitPatternAssignment(PatternAssignment node, Node other) {
    return strategy.checkPatternAssignment(this, node, other);
  }

  @override
  bool visitArguments(Arguments node, Node other) {
    return strategy.checkArguments(this, node, other);
  }

  @override
  bool visitNamedExpression(NamedExpression node, Node other) {
    return strategy.checkNamedExpression(this, node, other);
  }

  @override
  bool visitMapLiteralEntry(MapLiteralEntry node, Node other) {
    return strategy.checkMapLiteralEntry(this, node, other);
  }

  @override
  bool visitFunctionNode(FunctionNode node, Node other) {
    return strategy.checkFunctionNode(this, node, other);
  }

  @override
  bool visitAuxiliaryInitializer(AuxiliaryInitializer node, Node other) {
    return strategy.checkAuxiliaryInitializer(this, node, other);
  }

  @override
  bool visitInvalidInitializer(InvalidInitializer node, Node other) {
    return strategy.checkInvalidInitializer(this, node, other);
  }

  @override
  bool visitFieldInitializer(FieldInitializer node, Node other) {
    return strategy.checkFieldInitializer(this, node, other);
  }

  @override
  bool visitSuperInitializer(SuperInitializer node, Node other) {
    return strategy.checkSuperInitializer(this, node, other);
  }

  @override
  bool visitRedirectingInitializer(RedirectingInitializer node, Node other) {
    return strategy.checkRedirectingInitializer(this, node, other);
  }

  @override
  bool visitLocalInitializer(LocalInitializer node, Node other) {
    return strategy.checkLocalInitializer(this, node, other);
  }

  @override
  bool visitAssertInitializer(AssertInitializer node, Node other) {
    return strategy.checkAssertInitializer(this, node, other);
  }

  @override
  bool visitLibraryDependency(LibraryDependency node, Node other) {
    return strategy.checkLibraryDependency(this, node, other);
  }

  @override
  bool visitLibraryPart(LibraryPart node, Node other) {
    return strategy.checkLibraryPart(this, node, other);
  }

  @override
  bool visitCombinator(Combinator node, Node other) {
    return strategy.checkCombinator(this, node, other);
  }

  @override
  bool visitConstantPattern(ConstantPattern node, Node other) {
    return strategy.checkConstantPattern(this, node, other);
  }

  @override
  bool visitAndPattern(AndPattern node, Node other) {
    return strategy.checkAndPattern(this, node, other);
  }

  @override
  bool visitOrPattern(OrPattern node, Node other) {
    return strategy.checkOrPattern(this, node, other);
  }

  @override
  bool visitCastPattern(CastPattern node, Node other) {
    return strategy.checkCastPattern(this, node, other);
  }

  @override
  bool visitNullAssertPattern(NullAssertPattern node, Node other) {
    return strategy.checkNullAssertPattern(this, node, other);
  }

  @override
  bool visitNullCheckPattern(NullCheckPattern node, Node other) {
    return strategy.checkNullCheckPattern(this, node, other);
  }

  @override
  bool visitListPattern(ListPattern node, Node other) {
    return strategy.checkListPattern(this, node, other);
  }

  @override
  bool visitObjectPattern(ObjectPattern node, Node other) {
    return strategy.checkObjectPattern(this, node, other);
  }

  @override
  bool visitRelationalPattern(RelationalPattern node, Node other) {
    return strategy.checkRelationalPattern(this, node, other);
  }

  @override
  bool visitWildcardPattern(WildcardPattern node, Node other) {
    return strategy.checkWildcardPattern(this, node, other);
  }

  @override
  bool visitAssignedVariablePattern(AssignedVariablePattern node, Node other) {
    return strategy.checkAssignedVariablePattern(this, node, other);
  }

  @override
  bool visitMapPattern(MapPattern node, Node other) {
    return strategy.checkMapPattern(this, node, other);
  }

  @override
  bool visitNamedPattern(NamedPattern node, Node other) {
    return strategy.checkNamedPattern(this, node, other);
  }

  @override
  bool visitRecordPattern(RecordPattern node, Node other) {
    return strategy.checkRecordPattern(this, node, other);
  }

  @override
  bool visitVariablePattern(VariablePattern node, Node other) {
    return strategy.checkVariablePattern(this, node, other);
  }

  @override
  bool visitRestPattern(RestPattern node, Node other) {
    return strategy.checkRestPattern(this, node, other);
  }

  @override
  bool visitInvalidPattern(InvalidPattern node, Node other) {
    return strategy.checkInvalidPattern(this, node, other);
  }

  @override
  bool visitAuxiliaryPattern(AuxiliaryPattern node, Node other) {
    return strategy.checkAuxiliaryPattern(this, node, other);
  }

  @override
  bool visitMapPatternEntry(MapPatternEntry node, Node other) {
    return strategy.checkMapPatternEntry(this, node, other);
  }

  @override
  bool visitMapPatternRestEntry(MapPatternRestEntry node, Node other) {
    return strategy.checkMapPatternRestEntry(this, node, other);
  }

  @override
  bool visitPatternGuard(PatternGuard node, Node other) {
    return strategy.checkPatternGuard(this, node, other);
  }

  @override
  bool visitPatternSwitchCase(PatternSwitchCase node, Node other) {
    return strategy.checkPatternSwitchCase(this, node, other);
  }

  @override
  bool visitSwitchCase(SwitchCase node, Node other) {
    return strategy.checkSwitchCase(this, node, other);
  }

  @override
  bool visitPatternSwitchStatement(PatternSwitchStatement node, Node other) {
    return strategy.checkPatternSwitchStatement(this, node, other);
  }

  @override
  bool visitSwitchStatement(SwitchStatement node, Node other) {
    return strategy.checkSwitchStatement(this, node, other);
  }

  @override
  bool visitPatternVariableDeclaration(
    PatternVariableDeclaration node,
    Node other,
  ) {
    return strategy.checkPatternVariableDeclaration(this, node, other);
  }

  @override
  bool visitIfCaseStatement(IfCaseStatement node, Node other) {
    return strategy.checkIfCaseStatement(this, node, other);
  }

  @override
  bool visitAuxiliaryStatement(AuxiliaryStatement node, Node other) {
    return strategy.checkAuxiliaryStatement(this, node, other);
  }

  @override
  bool visitExpressionStatement(ExpressionStatement node, Node other) {
    return strategy.checkExpressionStatement(this, node, other);
  }

  @override
  bool visitBlock(Block node, Node other) {
    return strategy.checkBlock(this, node, other);
  }

  @override
  bool visitAssertBlock(AssertBlock node, Node other) {
    return strategy.checkAssertBlock(this, node, other);
  }

  @override
  bool visitEmptyStatement(EmptyStatement node, Node other) {
    return strategy.checkEmptyStatement(this, node, other);
  }

  @override
  bool visitAssertStatement(AssertStatement node, Node other) {
    return strategy.checkAssertStatement(this, node, other);
  }

  @override
  bool visitLabeledStatement(LabeledStatement node, Node other) {
    return strategy.checkLabeledStatement(this, node, other);
  }

  @override
  bool visitBreakStatement(BreakStatement node, Node other) {
    return strategy.checkBreakStatement(this, node, other);
  }

  @override
  bool visitWhileStatement(WhileStatement node, Node other) {
    return strategy.checkWhileStatement(this, node, other);
  }

  @override
  bool visitDoStatement(DoStatement node, Node other) {
    return strategy.checkDoStatement(this, node, other);
  }

  @override
  bool visitForStatement(ForStatement node, Node other) {
    return strategy.checkForStatement(this, node, other);
  }

  @override
  bool visitForInStatement(ForInStatement node, Node other) {
    return strategy.checkForInStatement(this, node, other);
  }

  @override
  bool visitContinueSwitchStatement(ContinueSwitchStatement node, Node other) {
    return strategy.checkContinueSwitchStatement(this, node, other);
  }

  @override
  bool visitIfStatement(IfStatement node, Node other) {
    return strategy.checkIfStatement(this, node, other);
  }

  @override
  bool visitReturnStatement(ReturnStatement node, Node other) {
    return strategy.checkReturnStatement(this, node, other);
  }

  @override
  bool visitTryCatch(TryCatch node, Node other) {
    return strategy.checkTryCatch(this, node, other);
  }

  @override
  bool visitTryFinally(TryFinally node, Node other) {
    return strategy.checkTryFinally(this, node, other);
  }

  @override
  bool visitYieldStatement(YieldStatement node, Node other) {
    return strategy.checkYieldStatement(this, node, other);
  }

  @override
  bool visitVariableStatement(VariableStatement node, Node other) {
    return strategy.checkVariableStatement(this, node, other);
  }

  @override
  bool visitFunctionDeclaration(FunctionDeclaration node, Node other) {
    return strategy.checkFunctionDeclaration(this, node, other);
  }

  @override
  bool visitSwitchExpressionCase(SwitchExpressionCase node, Node other) {
    return strategy.checkSwitchExpressionCase(this, node, other);
  }

  @override
  bool visitCatch(Catch node, Node other) {
    return strategy.checkCatch(this, node, other);
  }

  @override
  bool visitNominalParameter(NominalParameter node, Node other) {
    return strategy.checkNominalParameter(this, node, other);
  }

  @override
  bool visitTypeVariable(TypeVariable node, Node other) {
    return strategy.checkTypeVariable(this, node, other);
  }

  @override
  bool visitLocalVariable(LocalVariable node, Node other) {
    return strategy.checkLocalVariable(this, node, other);
  }

  @override
  bool visitLocalFunctionVariable(LocalFunctionVariable node, Node other) {
    return strategy.checkLocalFunctionVariable(this, node, other);
  }

  @override
  bool visitLateVariable(LateVariable node, Node other) {
    return strategy.checkLateVariable(this, node, other);
  }

  @override
  bool visitConstVariable(ConstVariable node, Node other) {
    return strategy.checkConstVariable(this, node, other);
  }

  @override
  bool visitSyntheticVariable(SyntheticVariable node, Node other) {
    return strategy.checkSyntheticVariable(this, node, other);
  }

  @override
  bool visitCatchVariable(CatchVariable node, Node other) {
    return strategy.checkCatchVariable(this, node, other);
  }

  @override
  bool visitPositionalParameter(PositionalParameter node, Node other) {
    return strategy.checkPositionalParameter(this, node, other);
  }

  @override
  bool visitNamedParameter(NamedParameter node, Node other) {
    return strategy.checkNamedParameter(this, node, other);
  }

  @override
  bool visitThisVariable(ThisVariable node, Node other) {
    return strategy.checkThisVariable(this, node, other);
  }

  @override
  bool visitVariableDeclaration(VariableDeclaration node, Node other) {
    return strategy.checkVariableDeclaration(this, node, other);
  }

  @override
  bool visitName(Name node, Node other) {
    return strategy.checkName(this, node, other);
  }

  @override
  bool visitStructuralParameter(StructuralParameter node, Node other) {
    return strategy.checkStructuralParameter(this, node, other);
  }

  @override
  bool visitSupertype(Supertype node, Node other) {
    return strategy.checkSupertype(this, node, other);
  }

  @override
  bool visitInterfaceType(InterfaceType node, Node other) {
    return strategy.checkInterfaceType(this, node, other);
  }

  @override
  bool visitExtensionType(ExtensionType node, Node other) {
    return strategy.checkExtensionType(this, node, other);
  }

  @override
  bool visitAuxiliaryType(AuxiliaryType node, Node other) {
    return strategy.checkAuxiliaryType(this, node, other);
  }

  @override
  bool visitFunctionTypeParameterType(
    FunctionTypeParameterType node,
    Node other,
  ) {
    return strategy.checkFunctionTypeParameterType(this, node, other);
  }

  @override
  bool visitClassTypeParameterType(ClassTypeParameterType node, Node other) {
    return strategy.checkClassTypeParameterType(this, node, other);
  }

  @override
  bool visitInvalidType(InvalidType node, Node other) {
    return strategy.checkInvalidType(this, node, other);
  }

  @override
  bool visitDynamicType(DynamicType node, Node other) {
    return strategy.checkDynamicType(this, node, other);
  }

  @override
  bool visitVoidType(VoidType node, Node other) {
    return strategy.checkVoidType(this, node, other);
  }

  @override
  bool visitNeverType(NeverType node, Node other) {
    return strategy.checkNeverType(this, node, other);
  }

  @override
  bool visitNullType(NullType node, Node other) {
    return strategy.checkNullType(this, node, other);
  }

  @override
  bool visitFunctionType(FunctionType node, Node other) {
    return strategy.checkFunctionType(this, node, other);
  }

  @override
  bool visitTypedefType(TypedefType node, Node other) {
    return strategy.checkTypedefType(this, node, other);
  }

  @override
  bool visitFutureOrType(FutureOrType node, Node other) {
    return strategy.checkFutureOrType(this, node, other);
  }

  @override
  bool visitIntersectionType(IntersectionType node, Node other) {
    return strategy.checkIntersectionType(this, node, other);
  }

  @override
  bool visitTypeParameterType(TypeParameterType node, Node other) {
    return strategy.checkTypeParameterType(this, node, other);
  }

  @override
  bool visitStructuralParameterType(StructuralParameterType node, Node other) {
    return strategy.checkStructuralParameterType(this, node, other);
  }

  @override
  bool visitRecordType(RecordType node, Node other) {
    return strategy.checkRecordType(this, node, other);
  }

  @override
  bool visitNamedType(NamedType node, Node other) {
    return strategy.checkNamedType(this, node, other);
  }

  @override
  bool visitClassReference(Class node, Node other) {
    return false;
  }

  @override
  bool visitExtensionReference(Extension node, Node other) {
    return false;
  }

  @override
  bool visitExtensionTypeDeclarationReference(
    ExtensionTypeDeclaration node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitFieldReference(Field node, Node other) {
    return false;
  }

  @override
  bool visitConstructorReference(Constructor node, Node other) {
    return false;
  }

  @override
  bool visitProcedureReference(Procedure node, Node other) {
    return false;
  }

  @override
  bool visitTypedefReference(Typedef node, Node other) {
    return false;
  }

  @override
  bool visitAuxiliaryConstantReference(AuxiliaryConstant node, Node other) {
    return false;
  }

  @override
  bool visitNullConstantReference(NullConstant node, Node other) {
    return false;
  }

  @override
  bool visitBoolConstantReference(BoolConstant node, Node other) {
    return false;
  }

  @override
  bool visitIntConstantReference(IntConstant node, Node other) {
    return false;
  }

  @override
  bool visitDoubleConstantReference(DoubleConstant node, Node other) {
    return false;
  }

  @override
  bool visitStringConstantReference(StringConstant node, Node other) {
    return false;
  }

  @override
  bool visitSymbolConstantReference(SymbolConstant node, Node other) {
    return false;
  }

  @override
  bool visitMapConstantReference(MapConstant node, Node other) {
    return false;
  }

  @override
  bool visitListConstantReference(ListConstant node, Node other) {
    return false;
  }

  @override
  bool visitSetConstantReference(SetConstant node, Node other) {
    return false;
  }

  @override
  bool visitRecordConstantReference(RecordConstant node, Node other) {
    return false;
  }

  @override
  bool visitInstanceConstantReference(InstanceConstant node, Node other) {
    return false;
  }

  @override
  bool visitInstantiationConstantReference(
    InstantiationConstant node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitStaticTearOffConstantReference(
    StaticTearOffConstant node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitConstructorTearOffConstantReference(
    ConstructorTearOffConstant node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitRedirectingFactoryTearOffConstantReference(
    RedirectingFactoryTearOffConstant node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitTypedefTearOffConstantReference(
    TypedefTearOffConstant node,
    Node other,
  ) {
    return false;
  }

  @override
  bool visitTypeLiteralConstantReference(TypeLiteralConstant node, Node other) {
    return false;
  }

  @override
  bool visitUnevaluatedConstantReference(UnevaluatedConstant node, Node other) {
    return false;
  }

  /// Returns `true` if [a] and [b] are identical or equal.
  bool _checkValues<T>(T? a, T? b) {
    return identical(a, b) || a == b;
  }

  /// Returns `true` if [a] and [b] are identical or equal and registers the
  /// inequivalence otherwise.
  bool checkValues<T>(T? a, T? b, String propertyName) {
    bool result = _checkValues(a, b);
    if (!result) {
      registerInequivalence(
        propertyName,
        'Values ${a} and ${b} are not equivalent',
      );
    }
    return result;
  }

  /// Returns `true` if [a] and [b] are identical or equal. Inequivalence is
  /// _not_ registered.
  bool matchValues<T>(T? a, T? b) {
    return _checkValues(a, b);
  }

  /// Cache of Constants compares and the results.
  /// This avoids potential exponential blowup when comparing ASTs
  /// that contain Constants.
  Map<Constant, Map<dynamic, bool>>? _constantCache;

  /// Returns `true` if [a] and [b] are equivalent.
  bool _checkNodes<T extends Node>(T? a, T? b) {
    if (identical(a, b)) return true;
    if (a == null || b == null) {
      return false;
    } else {
      if (a is Constant) {
        Map<Constant, Map<dynamic, bool>> cacheFrom = _constantCache ??= {};
        Map<dynamic, bool> cacheTo = cacheFrom[a] ??= {};
        bool? previousResult = cacheTo[b];
        if (previousResult != null) return previousResult;
        bool result = a.accept1(this, b);
        cacheTo[b] = result;
        return result;
      }
      return a.accept1(this, b);
    }
  }

  /// Returns `true` if [a] and [b] are equivalent, as defined by the current
  /// strategy, and registers the inequivalence otherwise.
  bool checkNodes<T extends Node>(T? a, T? b, [String propertyName = '']) {
    _checkingState.pushPropertyState(propertyName);
    bool result = _checkNodes(a, b);
    _checkingState.popState();
    if (!result) {
      registerInequivalence(
        propertyName,
        'Inequivalent nodes\n1: ${a}\n2: ${b}',
      );
    }
    return result;
  }

  /// Returns `true` if [a] and [b] are equivalent, either by existing
  /// assumption or as defined by their corresponding canonical names.
  /// Inequivalence is _not_ registered.
  bool matchNamedNodes(NamedNode? a, NamedNode? b) {
    return identical(a, b) ||
        a == null ||
        b == null ||
        checkAssumedReferences(a.reference, b.reference) ||
        new ReferenceName.fromNamedNode(a) ==
            new ReferenceName.fromNamedNode(b);
  }

  /// Returns `true` if [a] and [b] are currently assumed to be equivalent.
  bool checkAssumedReferences(Reference? a, Reference? b) {
    return _checkingState.checkAssumedReferences(a, b);
  }

  /// Assume that [a] and [b] are equivalent, if possible.
  ///
  /// Returns `true` if [a] and [b] could be assumed to be equivalent. This
  /// would not be the case if [a] xor [b] is `null`.
  bool assumeReferences(Reference? a, Reference? b) {
    return _checkingState.assumeReferences(a, b);
  }

  /// Returns `true` if [a] and [b] are equivalent, either by existing
  /// assumption or as defined by their corresponding canonical names.
  /// Inequivalence is _not_ registered.
  bool matchReferences(Reference? a, Reference? b) {
    return identical(a, b) ||
        checkAssumedReferences(a, b) ||
        ReferenceName.fromReference(a) == ReferenceName.fromReference(b);
  }

  /// Returns `true` if [a] and [b] are equivalent, either by their
  /// corresponding canonical names or by assumption. Inequivalence is _not_
  /// registered.
  bool _checkReferences(Reference? a, Reference? b) {
    if (identical(a, b)) {
      return true;
    } else if (a == null || b == null) {
      return false;
    } else if (matchReferences(a, b)) {
      return true;
    } else if (checkAssumedReferences(a, b)) {
      return true;
    } else {
      return false;
    }
  }

  /// Returns `true` if [a] and [b] are equivalent, either by their
  /// corresponding canonical names or by assumption, and registers the
  /// inequivalence otherwise.
  bool checkReferences(Reference? a, Reference? b, [String propertyName = '']) {
    bool result = _checkReferences(a, b);
    if (!result) {
      registerInequivalence(
        propertyName,
        'Inequivalent references:\n1: ${a}\n2: ${b}',
      );
    }
    return result;
  }

  /// Returns `true` if declarations [a] and [b] are currently assumed to be
  /// equivalent.
  bool checkAssumedDeclarations(dynamic a, dynamic b) {
    return _checkingState.checkAssumedDeclarations(a, b);
  }

  /// Assume that [a] and [b] are equivalent, if possible.
  ///
  /// Returns `true` if [a] and [b] could be assumed to be equivalent. This
  /// would not be the case if [a] is already assumed to be equivalent to
  /// another declaration.
  bool assumeDeclarations(dynamic a, dynamic b) {
    return _checkingState.assumeDeclarations(a, b);
  }

  bool matchDeclarations(dynamic a, dynamic b) {
    if (a is SwitchCase) {
      return b is SwitchCase;
    }
    if (a is LabeledStatement) {
      return b is LabeledStatement;
    }
    if (a is StructuralParameter) {
      return b is StructuralParameter && a.name == b.name;
    }
    return false;
  }

  bool _checkDeclarations(dynamic a, dynamic b) {
    if (identical(a, b)) {
      return true;
    } else if (a == null || b == null) {
      return false;
    } else if (checkAssumedDeclarations(a, b)) {
      return true;
    } else if (matchDeclarations(a, b)) {
      return assumeDeclarations(a, b);
    } else {
      return false;
    }
  }

  bool checkDeclarations(dynamic a, dynamic b, [String propertyName = '']) {
    bool result = _checkDeclarations(a, b);
    if (!result) {
      result = assumeDeclarations(a, b);
    }
    if (!result) {
      registerInequivalence(
        propertyName,
        'Declarations ${a} and ${b} are not equivalent',
      );
    }
    return result;
  }

  /// Returns `true` if lists [a] and [b] are equivalent, using
  /// [equivalentValues] to determine element-wise equivalence.
  ///
  /// If run in a checking state, the [propertyName] is used for registering
  /// inequivalences.
  bool checkLists<E>(
    List<E>? a,
    List<E>? b,
    bool Function(E, E, String) equivalentValues, [
    String propertyName = '',
  ]) {
    if (identical(a, b)) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) {
      registerInequivalence(
        '${propertyName}.length',
        'Lists ${a} and ${b} are not equivalent',
      );
      return false;
    }
    for (int i = 0; i < a.length; i++) {
      if (!equivalentValues(a[i], b[i], '${propertyName}[${i}]')) {
        return false;
      }
    }
    return true;
  }

  /// Returns `true` if sets [a] and [b] are equivalent, using
  /// [matchingValues] to determine which elements that should be checked for
  /// element-wise equivalence using [equivalentValues].
  ///
  /// If run in a checking state, the [propertyName] is used for registering
  /// inequivalences.
  bool checkSets<E>(
    Set<E>? a,
    Set<E>? b,
    bool Function(E, E) matchingValues,
    bool Function(E, E, String) equivalentValues, [
    String propertyName = '',
  ]) {
    if (identical(a, b)) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) {
      registerInequivalence(
        '${propertyName}.length',
        'Sets ${a} and ${b} are not equivalent',
      );
      return false;
    }
    b = b.toSet();
    for (E aValue in a) {
      bool hasFoundValue = false;
      E? foundValue;
      for (E bValue in b) {
        if (matchingValues(aValue, bValue)) {
          foundValue = bValue;
          hasFoundValue = true;
          if (!equivalentValues(aValue, bValue, '${propertyName}[${aValue}]')) {
            registerInequivalence(
              '${propertyName}[${aValue}]',
              'Elements ${aValue} and ${bValue} are not equivalent',
            );
            return false;
          }
          break;
        }
      }
      if (hasFoundValue) {
        b.remove(foundValue);
      } else {
        registerInequivalence(
          '${propertyName}[${aValue}]',
          'Sets ${a} and ${b} are not equivalent, no equivalent value '
              'found for $aValue',
        );
        return false;
      }
    }
    return true;
  }

  /// Returns `true` if maps [a] and [b] are equivalent, using
  /// [matchingKeys] to determine which entries that should be checked for
  /// entry-wise equivalence using [equivalentKeys] and [equivalentValues] to
  /// determine key and value equivalences, respectively.
  ///
  /// If run in a checking state, the [propertyName] is used for registering
  /// inequivalences.
  bool checkMaps<K, V>(
    Map<K, V>? a,
    Map<K, V>? b,
    bool Function(K, K) matchingKeys,
    bool Function(K, K, String) equivalentKeys,
    bool Function(V, V, String) equivalentValues, [
    String propertyName = '',
  ]) {
    if (identical(a, b)) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) {
      registerInequivalence(
        '${propertyName}.length',
        'Maps ${a} and ${b} are not equivalent',
      );
      return false;
    }
    Set<K> bKeys = b.keys.toSet();
    for (K aKey in a.keys) {
      bool hasFoundKey = false;
      K? foundKey;
      for (K bKey in bKeys) {
        if (matchingKeys(aKey, bKey)) {
          foundKey = bKey;
          hasFoundKey = true;
          if (!equivalentKeys(aKey, bKey, '${propertyName}[${aKey}]')) {
            registerInequivalence(
              '${propertyName}[${aKey}]',
              'Keys ${aKey} and ${bKey} are not equivalent',
            );
            return false;
          }
          break;
        }
      }
      if (hasFoundKey) {
        bKeys.remove(foundKey);
        if (!equivalentValues(
          a[aKey]!,
          b[foundKey]!,
          '${propertyName}[${aKey}]',
        )) {
          return false;
        }
      } else {
        registerInequivalence(
          '${propertyName}[${aKey}]',
          'Maps ${a} and ${b} are not equivalent, no equivalent key '
              'found for $aKey',
        );
        return false;
      }
    }
    return true;
  }

  /// The current state of the visitor.
  ///
  /// This holds the current assumptions, found inequivalences, and whether
  /// inequivalences are currently registered.
  CheckingState _checkingState = new CheckingState();

  /// Registers that the visitor enters nodes [a] and [b].
  void pushNodeState(Node a, Node b) {
    _checkingState.pushNodeState(a, b);
  }

  /// Register that the visitor leave the current node or property.
  void popState() {
    _checkingState.popState();
  }

  /// Returns the value used as the result for property inequivalences.
  ///
  /// When inequivalences are currently registered, this is `true`, so that the
  /// visitor will continue find inequivalences that are not directly related.
  ///
  /// An example is finding several child inequivalences on otherwise equivalent
  /// nodes, like finding inequivalences deeply in the members of the second
  /// library of a component even when inequivalences deeply in the members of
  /// the first library. Had the return value been `false`, signaling that the
  /// first libraries were inequivalent, which they technically are, given that
  /// the contain inequivalent subnodes, the visitor would have stopped short in
  /// checking the list of libraries, and the inequivalences in the second
  /// library would not have been found.
  ///
  /// When inequivalences are _not_ currently registered, i.e. we are only
  /// interested in the true/false value of the equivalence test, `false` is
  /// used as the result value to stop the equivalence checking short.
  bool get resultOnInequivalence => _checkingState.resultOnInequivalence;

  /// Registers an equivalence on the [propertyName] with a detailed description
  /// in [message].
  void registerInequivalence(String propertyName, String message) {
    _checkingState.registerInequivalence(propertyName, message);
  }

  /// Returns the inequivalences found by the visitor.
  EquivalenceResult toResult() => _checkingState.toResult();
}

/// Checks [a] and [b] be for equivalence using [strategy].
///
/// Returns an [EquivalenceResult] containing the found inequivalences.
EquivalenceResult checkEquivalence(
  Node a,
  Node b, {
  EquivalenceStrategy strategy = const EquivalenceStrategy(),
}) {
  EquivalenceVisitor visitor = new EquivalenceVisitor(strategy: strategy);
  visitor.checkNodes(a, b, 'root');
  return visitor.toResult();
}

/// Strategy used for determining equivalence of AST nodes.
///
/// The strategy has a method for determining the equivalence of each AST node
/// class, and a method for determining the equivalence of each property on each
/// AST node class.
///
/// The base implementation enforces a full structural equivalence.
///
/// Custom strategies can be made by extending this strategy and override
/// methods where exceptions to the structural equivalence are needed.
class EquivalenceStrategy {
  const new();

  bool checkAuxiliaryConstant(
    EquivalenceVisitor visitor,
    AuxiliaryConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryConstant) return false;
    if (other is! AuxiliaryConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkNullConstant(
    EquivalenceVisitor visitor,
    NullConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullConstant) return false;
    if (other is! NullConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNullConstant_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkBoolConstant(
    EquivalenceVisitor visitor,
    BoolConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! BoolConstant) return false;
    if (other is! BoolConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkBoolConstant_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIntConstant(
    EquivalenceVisitor visitor,
    IntConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IntConstant) return false;
    if (other is! IntConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIntConstant_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDoubleConstant(
    EquivalenceVisitor visitor,
    DoubleConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DoubleConstant) return false;
    if (other is! DoubleConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDoubleConstant_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStringConstant(
    EquivalenceVisitor visitor,
    StringConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StringConstant) return false;
    if (other is! StringConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStringConstant_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSymbolConstant(
    EquivalenceVisitor visitor,
    SymbolConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SymbolConstant) return false;
    if (other is! SymbolConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSymbolConstant_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSymbolConstant_libraryReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstantMapEntry(
    EquivalenceVisitor visitor,
    ConstantMapEntry? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstantMapEntry) return false;
    if (other is! ConstantMapEntry) return false;
    bool result = true;
    if (!checkConstantMapEntry_key(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantMapEntry_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkMapConstant(
    EquivalenceVisitor visitor,
    MapConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapConstant) return false;
    if (other is! MapConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapConstant_keyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapConstant_valueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapConstant_entries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkListConstant(
    EquivalenceVisitor visitor,
    ListConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ListConstant) return false;
    if (other is! ListConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkListConstant_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListConstant_entries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSetConstant(
    EquivalenceVisitor visitor,
    SetConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SetConstant) return false;
    if (other is! SetConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSetConstant_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetConstant_entries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordConstant(
    EquivalenceVisitor visitor,
    RecordConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordConstant) return false;
    if (other is! RecordConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordConstant_positional(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordConstant_named(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordConstant_recordType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceConstant(
    EquivalenceVisitor visitor,
    InstanceConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceConstant) return false;
    if (other is! InstanceConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceConstant_classReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceConstant_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceConstant_fieldValues(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstantiationConstant(
    EquivalenceVisitor visitor,
    InstantiationConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstantiationConstant) return false;
    if (other is! InstantiationConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstantiationConstant_tearOffConstant(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstantiationConstant_types(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStaticTearOffConstant(
    EquivalenceVisitor visitor,
    StaticTearOffConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StaticTearOffConstant) return false;
    if (other is! StaticTearOffConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStaticTearOffConstant_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstructorTearOffConstant(
    EquivalenceVisitor visitor,
    ConstructorTearOffConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstructorTearOffConstant) return false;
    if (other is! ConstructorTearOffConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstructorTearOffConstant_targetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRedirectingFactoryTearOffConstant(
    EquivalenceVisitor visitor,
    RedirectingFactoryTearOffConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RedirectingFactoryTearOffConstant) return false;
    if (other is! RedirectingFactoryTearOffConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRedirectingFactoryTearOffConstant_targetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypedefTearOffConstant(
    EquivalenceVisitor visitor,
    TypedefTearOffConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypedefTearOffConstant) return false;
    if (other is! TypedefTearOffConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypedefTearOffConstant_parameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefTearOffConstant_tearOffConstant(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefTearOffConstant_types(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypeLiteralConstant(
    EquivalenceVisitor visitor,
    TypeLiteralConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypeLiteralConstant) return false;
    if (other is! TypeLiteralConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypeLiteralConstant_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkUnevaluatedConstant(
    EquivalenceVisitor visitor,
    UnevaluatedConstant? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! UnevaluatedConstant) return false;
    if (other is! UnevaluatedConstant) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkUnevaluatedConstant_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSource(EquivalenceVisitor visitor, Source? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Source) return false;
    if (other is! Source) return false;
    bool result = true;
    if (!checkSource_lineStarts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSource_source(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSource_importUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSource_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSource_constantCoverageConstructors(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSource_cachedText(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkMetadataRepository(
    EquivalenceVisitor visitor,
    MetadataRepository? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MetadataRepository) return false;
    if (other is! MetadataRepository) return false;
    bool result = true;
    return result;
  }

  bool checkComponent(
    EquivalenceVisitor visitor,
    Component? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Component) return false;
    if (other is! Component) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkComponent_problemsAsJson(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_libraries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_uriToSource(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_metadata(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_mainMethodName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkClass(EquivalenceVisitor visitor, Class? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Class) return false;
    if (other is! Class) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkClass_startFileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_supertype(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_mixedInType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_implementedTypes(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_fields(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_constructors(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_procedures(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClass_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkExtensionMemberDescriptor(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ExtensionMemberDescriptor) return false;
    if (other is! ExtensionMemberDescriptor) return false;
    bool result = true;
    if (!checkExtensionMemberDescriptor_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionMemberDescriptor_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionMemberDescriptor_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionMemberDescriptor_memberReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionMemberDescriptor_tearOffReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkExtension(
    EquivalenceVisitor visitor,
    Extension? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Extension) return false;
    if (other is! Extension) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkExtension_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_onType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_memberDescriptors(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkExtensionTypeMemberDescriptor(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ExtensionTypeMemberDescriptor) return false;
    if (other is! ExtensionTypeMemberDescriptor) return false;
    bool result = true;
    if (!checkExtensionTypeMemberDescriptor_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeMemberDescriptor_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeMemberDescriptor_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeMemberDescriptor_memberReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeMemberDescriptor_tearOffReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkExtensionTypeDeclaration(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ExtensionTypeDeclaration) return false;
    if (other is! ExtensionTypeDeclaration) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkExtensionTypeDeclaration_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_declaredRepresentationType(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_representationName(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_procedures(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_memberDescriptors(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_implements(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeDeclaration_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLibrary(EquivalenceVisitor visitor, Library? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Library) return false;
    if (other is! Library) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLibrary_importUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_languageVersion(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_problemsAsJson(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_dependencies(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_additionalExports(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_parts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_typedefs(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_classes(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_extensions(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_extensionTypeDeclarations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_procedures(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_fields(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibrary_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariableContext(
    EquivalenceVisitor visitor,
    VariableContext? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariableContext) return false;
    if (other is! VariableContext) return false;
    bool result = true;
    if (!checkVariableContext_captureKind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableContext_variables(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkScope(EquivalenceVisitor visitor, Scope? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Scope) return false;
    if (other is! Scope) return false;
    bool result = true;
    if (!checkScope_contexts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkField(EquivalenceVisitor visitor, Field? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Field) return false;
    if (other is! Field) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkField_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_getterReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_setterReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_thisVariable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_fieldReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkField_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstructor(
    EquivalenceVisitor visitor,
    Constructor? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Constructor) return false;
    if (other is! Constructor) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstructor_startFileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_function(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_initializers(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructor_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkProcedure(
    EquivalenceVisitor visitor,
    Procedure? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Procedure) return false;
    if (other is! Procedure) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkProcedure_fileStartOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_function(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_stubKind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_stubTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_signatureType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkProcedure_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypedef(EquivalenceVisitor visitor, Typedef? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Typedef) return false;
    if (other is! Typedef) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypedef_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedef_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAuxiliaryExpression(
    EquivalenceVisitor visitor,
    AuxiliaryExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryExpression) return false;
    if (other is! AuxiliaryExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAuxiliaryExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInvalidExpression(
    EquivalenceVisitor visitor,
    InvalidExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InvalidExpression) return false;
    if (other is! InvalidExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInvalidExpression_message(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidExpression_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariableGet(
    EquivalenceVisitor visitor,
    VariableGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariableGet) return false;
    if (other is! VariableGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariableGet_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableGet_promotedType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariableSet(
    EquivalenceVisitor visitor,
    VariableSet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariableSet) return false;
    if (other is! VariableSet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariableSet_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableSet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableSet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordIndexGet(
    EquivalenceVisitor visitor,
    RecordIndexGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordIndexGet) return false;
    if (other is! RecordIndexGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordIndexGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordIndexGet_receiverType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordIndexGet_index(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordIndexGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordNameGet(
    EquivalenceVisitor visitor,
    RecordNameGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordNameGet) return false;
    if (other is! RecordNameGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordNameGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordNameGet_receiverType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordNameGet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordNameGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDynamicGet(
    EquivalenceVisitor visitor,
    DynamicGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DynamicGet) return false;
    if (other is! DynamicGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDynamicGet_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicGet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceGet(
    EquivalenceVisitor visitor,
    InstanceGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceGet) return false;
    if (other is! InstanceGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceGet_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGet_resultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGet_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFunctionTearOff(
    EquivalenceVisitor visitor,
    FunctionTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionTearOff) return false;
    if (other is! FunctionTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionTearOff_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceTearOff(
    EquivalenceVisitor visitor,
    InstanceTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceTearOff) return false;
    if (other is! InstanceTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceTearOff_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceTearOff_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceTearOff_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceTearOff_resultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceTearOff_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDynamicSet(
    EquivalenceVisitor visitor,
    DynamicSet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DynamicSet) return false;
    if (other is! DynamicSet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDynamicSet_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicSet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicSet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicSet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicSet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceSet(
    EquivalenceVisitor visitor,
    InstanceSet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceSet) return false;
    if (other is! InstanceSet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceSet_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceSet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceSet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceSet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceSet_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceSet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAbstractSuperPropertyGet(
    EquivalenceVisitor visitor,
    AbstractSuperPropertyGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AbstractSuperPropertyGet) return false;
    if (other is! AbstractSuperPropertyGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAbstractSuperPropertyGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertyGet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertyGet_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertyGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSuperPropertyGet(
    EquivalenceVisitor visitor,
    SuperPropertyGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SuperPropertyGet) return false;
    if (other is! SuperPropertyGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSuperPropertyGet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertyGet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertyGet_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertyGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAbstractSuperPropertySet(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AbstractSuperPropertySet) return false;
    if (other is! AbstractSuperPropertySet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAbstractSuperPropertySet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertySet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertySet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertySet_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperPropertySet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSuperPropertySet(
    EquivalenceVisitor visitor,
    SuperPropertySet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SuperPropertySet) return false;
    if (other is! SuperPropertySet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSuperPropertySet_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertySet_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertySet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertySet_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperPropertySet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStaticGet(
    EquivalenceVisitor visitor,
    StaticGet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StaticGet) return false;
    if (other is! StaticGet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStaticGet_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticGet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStaticTearOff(
    EquivalenceVisitor visitor,
    StaticTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StaticTearOff) return false;
    if (other is! StaticTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStaticTearOff_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStaticSet(
    EquivalenceVisitor visitor,
    StaticSet? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StaticSet) return false;
    if (other is! StaticSet) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStaticSet_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticSet_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticSet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDynamicInvocation(
    EquivalenceVisitor visitor,
    DynamicInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DynamicInvocation) return false;
    if (other is! DynamicInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDynamicInvocation_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicInvocation_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicInvocation_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDynamicInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceInvocation(
    EquivalenceVisitor visitor,
    InstanceInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceInvocation) return false;
    if (other is! InstanceInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceInvocation_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_resultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceGetterInvocation(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceGetterInvocation) return false;
    if (other is! InstanceGetterInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceGetterInvocation_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceGetterInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFunctionInvocation(
    EquivalenceVisitor visitor,
    FunctionInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionInvocation) return false;
    if (other is! FunctionInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionInvocation_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionInvocation_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLocalFunctionInvocation(
    EquivalenceVisitor visitor,
    LocalFunctionInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LocalFunctionInvocation) return false;
    if (other is! LocalFunctionInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLocalFunctionInvocation_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionInvocation_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAbstractSuperMethodInvocation(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AbstractSuperMethodInvocation) return false;
    if (other is! AbstractSuperMethodInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAbstractSuperMethodInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperMethodInvocation_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperMethodInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperMethodInvocation_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAbstractSuperMethodInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSuperMethodInvocation(
    EquivalenceVisitor visitor,
    SuperMethodInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SuperMethodInvocation) return false;
    if (other is! SuperMethodInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSuperMethodInvocation_receiver(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperMethodInvocation_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperMethodInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperMethodInvocation_interfaceTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperMethodInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStaticInvocation(
    EquivalenceVisitor visitor,
    StaticInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StaticInvocation) return false;
    if (other is! StaticInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStaticInvocation_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticInvocation_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStaticInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstructorInvocation(
    EquivalenceVisitor visitor,
    ConstructorInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstructorInvocation) return false;
    if (other is! ConstructorInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstructorInvocation_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructorInvocation_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructorInvocation_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructorInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkEqualsNull(
    EquivalenceVisitor visitor,
    EqualsNull? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! EqualsNull) return false;
    if (other is! EqualsNull) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkEqualsNull_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkEqualsNull_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkEqualsCall(
    EquivalenceVisitor visitor,
    EqualsCall? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! EqualsCall) return false;
    if (other is! EqualsCall) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkEqualsCall_left(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkEqualsCall_right(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkEqualsCall_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkEqualsCall_interfaceTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkEqualsCall_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRedirectingFactoryInvocation(
    EquivalenceVisitor visitor,
    RedirectingFactoryInvocation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RedirectingFactoryInvocation) return false;
    if (other is! RedirectingFactoryInvocation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRedirectingFactoryInvocation_redirectingFactoryTargetReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactoryInvocation_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactoryInvocation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstantiation(
    EquivalenceVisitor visitor,
    Instantiation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Instantiation) return false;
    if (other is! Instantiation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstantiation_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstantiation_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstantiation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNot(EquivalenceVisitor visitor, Not? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Not) return false;
    if (other is! Not) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNot_operand(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNot_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLogicalExpression(
    EquivalenceVisitor visitor,
    LogicalExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LogicalExpression) return false;
    if (other is! LogicalExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLogicalExpression_left(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLogicalExpression_operatorEnum(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLogicalExpression_right(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLogicalExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConditionalExpression(
    EquivalenceVisitor visitor,
    ConditionalExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConditionalExpression) return false;
    if (other is! ConditionalExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConditionalExpression_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConditionalExpression_then(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConditionalExpression_otherwise(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConditionalExpression_staticType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConditionalExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStringConcatenation(
    EquivalenceVisitor visitor,
    StringConcatenation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StringConcatenation) return false;
    if (other is! StringConcatenation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStringConcatenation_expressions(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStringConcatenation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkListConcatenation(
    EquivalenceVisitor visitor,
    ListConcatenation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ListConcatenation) return false;
    if (other is! ListConcatenation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkListConcatenation_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListConcatenation_lists(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListConcatenation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSetConcatenation(
    EquivalenceVisitor visitor,
    SetConcatenation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SetConcatenation) return false;
    if (other is! SetConcatenation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSetConcatenation_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetConcatenation_sets(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetConcatenation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapConcatenation(
    EquivalenceVisitor visitor,
    MapConcatenation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapConcatenation) return false;
    if (other is! MapConcatenation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapConcatenation_keyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapConcatenation_valueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapConcatenation_maps(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapConcatenation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInstanceCreation(
    EquivalenceVisitor visitor,
    InstanceCreation? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InstanceCreation) return false;
    if (other is! InstanceCreation) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInstanceCreation_classReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceCreation_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceCreation_fieldValues(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceCreation_asserts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceCreation_unusedArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInstanceCreation_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFileUriExpression(
    EquivalenceVisitor visitor,
    FileUriExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FileUriExpression) return false;
    if (other is! FileUriExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFileUriExpression_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFileUriExpression_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFileUriExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIsExpression(
    EquivalenceVisitor visitor,
    IsExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IsExpression) return false;
    if (other is! IsExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIsExpression_operand(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIsExpression_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIsExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAsExpression(
    EquivalenceVisitor visitor,
    AsExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AsExpression) return false;
    if (other is! AsExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAsExpression_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAsExpression_operand(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAsExpression_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAsExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNullCheck(
    EquivalenceVisitor visitor,
    NullCheck? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullCheck) return false;
    if (other is! NullCheck) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNullCheck_operand(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNullCheck_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStringLiteral(
    EquivalenceVisitor visitor,
    StringLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StringLiteral) return false;
    if (other is! StringLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStringLiteral_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStringLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIntLiteral(
    EquivalenceVisitor visitor,
    IntLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IntLiteral) return false;
    if (other is! IntLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIntLiteral_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIntLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDoubleLiteral(
    EquivalenceVisitor visitor,
    DoubleLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DoubleLiteral) return false;
    if (other is! DoubleLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDoubleLiteral_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDoubleLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkBoolLiteral(
    EquivalenceVisitor visitor,
    BoolLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! BoolLiteral) return false;
    if (other is! BoolLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkBoolLiteral_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBoolLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNullLiteral(
    EquivalenceVisitor visitor,
    NullLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullLiteral) return false;
    if (other is! NullLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNullLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSymbolLiteral(
    EquivalenceVisitor visitor,
    SymbolLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SymbolLiteral) return false;
    if (other is! SymbolLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSymbolLiteral_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSymbolLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypeLiteral(
    EquivalenceVisitor visitor,
    TypeLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypeLiteral) return false;
    if (other is! TypeLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypeLiteral_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkThisExpression(
    EquivalenceVisitor visitor,
    ThisExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ThisExpression) return false;
    if (other is! ThisExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkThisExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRethrow(EquivalenceVisitor visitor, Rethrow? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Rethrow) return false;
    if (other is! Rethrow) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRethrow_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkThrow(EquivalenceVisitor visitor, Throw? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Throw) return false;
    if (other is! Throw) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkThrow_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThrow_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThrow_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkListLiteral(
    EquivalenceVisitor visitor,
    ListLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ListLiteral) return false;
    if (other is! ListLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkListLiteral_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListLiteral_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListLiteral_expressions(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSetLiteral(
    EquivalenceVisitor visitor,
    SetLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SetLiteral) return false;
    if (other is! SetLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSetLiteral_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetLiteral_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetLiteral_expressions(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSetLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapLiteral(
    EquivalenceVisitor visitor,
    MapLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapLiteral) return false;
    if (other is! MapLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapLiteral_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteral_keyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteral_valueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteral_entries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordLiteral(
    EquivalenceVisitor visitor,
    RecordLiteral? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordLiteral) return false;
    if (other is! RecordLiteral) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordLiteral_isConst(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordLiteral_positional(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordLiteral_named(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordLiteral_recordType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordLiteral_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAwaitExpression(
    EquivalenceVisitor visitor,
    AwaitExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AwaitExpression) return false;
    if (other is! AwaitExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAwaitExpression_operand(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAwaitExpression_runtimeCheckType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAwaitExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFunctionExpression(
    EquivalenceVisitor visitor,
    FunctionExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionExpression) return false;
    if (other is! FunctionExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionExpression_function(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstantExpression(
    EquivalenceVisitor visitor,
    ConstantExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstantExpression) return false;
    if (other is! ConstantExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstantExpression_constant(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantExpression_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLet(EquivalenceVisitor visitor, Let? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Let) return false;
    if (other is! Let) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLet_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLet_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLet_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkBlockExpression(
    EquivalenceVisitor visitor,
    BlockExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! BlockExpression) return false;
    if (other is! BlockExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkBlockExpression_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlockExpression_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlockExpression_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlockExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLoadLibrary(
    EquivalenceVisitor visitor,
    LoadLibrary? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LoadLibrary) return false;
    if (other is! LoadLibrary) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLoadLibrary_import(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLoadLibrary_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkCheckLibraryIsLoaded(
    EquivalenceVisitor visitor,
    CheckLibraryIsLoaded? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! CheckLibraryIsLoaded) return false;
    if (other is! CheckLibraryIsLoaded) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkCheckLibraryIsLoaded_import(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCheckLibraryIsLoaded_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstructorTearOff(
    EquivalenceVisitor visitor,
    ConstructorTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstructorTearOff) return false;
    if (other is! ConstructorTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstructorTearOff_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstructorTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRedirectingFactoryTearOff(
    EquivalenceVisitor visitor,
    RedirectingFactoryTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RedirectingFactoryTearOff) return false;
    if (other is! RedirectingFactoryTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRedirectingFactoryTearOff_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactoryTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypedefTearOff(
    EquivalenceVisitor visitor,
    TypedefTearOff? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypedefTearOff) return false;
    if (other is! TypedefTearOff) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypedefTearOff_structuralParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefTearOff_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefTearOff_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefTearOff_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSwitchExpression(
    EquivalenceVisitor visitor,
    SwitchExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SwitchExpression) return false;
    if (other is! SwitchExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSwitchExpression_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpression_cases(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpression_expressionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpression_staticType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPatternAssignment(
    EquivalenceVisitor visitor,
    PatternAssignment? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PatternAssignment) return false;
    if (other is! PatternAssignment) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPatternAssignment_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternAssignment_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternAssignment_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternAssignment_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkArguments(
    EquivalenceVisitor visitor,
    Arguments? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Arguments) return false;
    if (other is! Arguments) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkArguments_types(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkArguments_positional(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkArguments_named(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkArguments_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNamedExpression(
    EquivalenceVisitor visitor,
    NamedExpression? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NamedExpression) return false;
    if (other is! NamedExpression) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNamedExpression_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedExpression_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedExpression_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapLiteralEntry(
    EquivalenceVisitor visitor,
    MapLiteralEntry? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapLiteralEntry) return false;
    if (other is! MapLiteralEntry) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapLiteralEntry_key(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteralEntry_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapLiteralEntry_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRedirectingFactoryTarget(
    EquivalenceVisitor visitor,
    RedirectingFactoryTarget? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RedirectingFactoryTarget) return false;
    if (other is! RedirectingFactoryTarget) return false;
    bool result = true;
    if (!checkRedirectingFactoryTarget_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactoryTarget_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactoryTarget_errorMessage(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    return result;
  }

  bool checkFunctionNode(
    EquivalenceVisitor visitor,
    FunctionNode? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionNode) return false;
    if (other is! FunctionNode) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionNode_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_asyncMarker(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_dartAsyncMarker(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_requiredParameterCount(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_positionalParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_namedParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_thisVariable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_returnType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_capturedContexts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_emittedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_redirectingFactoryTarget(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_lazyBuilder(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAuxiliaryInitializer(
    EquivalenceVisitor visitor,
    AuxiliaryInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryInitializer) return false;
    if (other is! AuxiliaryInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAuxiliaryInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInvalidInitializer(
    EquivalenceVisitor visitor,
    InvalidInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InvalidInitializer) return false;
    if (other is! InvalidInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInvalidInitializer_message(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidInitializer_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFieldInitializer(
    EquivalenceVisitor visitor,
    FieldInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FieldInitializer) return false;
    if (other is! FieldInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFieldInitializer_fieldReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFieldInitializer_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFieldInitializer_isSynthetic(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFieldInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSuperInitializer(
    EquivalenceVisitor visitor,
    SuperInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SuperInitializer) return false;
    if (other is! SuperInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSuperInitializer_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperInitializer_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperInitializer_isSynthetic(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSuperInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRedirectingInitializer(
    EquivalenceVisitor visitor,
    RedirectingInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RedirectingInitializer) return false;
    if (other is! RedirectingInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRedirectingInitializer_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingInitializer_arguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLocalInitializer(
    EquivalenceVisitor visitor,
    LocalInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LocalInitializer) return false;
    if (other is! LocalInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLocalInitializer_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAssertInitializer(
    EquivalenceVisitor visitor,
    AssertInitializer? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AssertInitializer) return false;
    if (other is! AssertInitializer) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAssertInitializer_statement(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLibraryDependency(
    EquivalenceVisitor visitor,
    LibraryDependency? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LibraryDependency) return false;
    if (other is! LibraryDependency) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLibraryDependency_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryDependency_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryDependency_importedLibraryReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryDependency_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryDependency_combinators(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryDependency_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLibraryPart(
    EquivalenceVisitor visitor,
    LibraryPart? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LibraryPart) return false;
    if (other is! LibraryPart) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLibraryPart_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryPart_partUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryPart_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLibraryPart_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkCombinator(
    EquivalenceVisitor visitor,
    Combinator? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Combinator) return false;
    if (other is! Combinator) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkCombinator_isShow(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCombinator_names(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCombinator_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstantPattern(
    EquivalenceVisitor visitor,
    ConstantPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstantPattern) return false;
    if (other is! ConstantPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstantPattern_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantPattern_expressionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantPattern_equalsTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantPattern_equalsType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantPattern_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstantPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAndPattern(
    EquivalenceVisitor visitor,
    AndPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AndPattern) return false;
    if (other is! AndPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAndPattern_left(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAndPattern_right(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAndPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkOrPattern(
    EquivalenceVisitor visitor,
    OrPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! OrPattern) return false;
    if (other is! OrPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkOrPattern_left(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkOrPattern_right(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkOrPattern_orPatternJointVariables(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkOrPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkCastPattern(
    EquivalenceVisitor visitor,
    CastPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! CastPattern) return false;
    if (other is! CastPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkCastPattern_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCastPattern_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCastPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNullAssertPattern(
    EquivalenceVisitor visitor,
    NullAssertPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullAssertPattern) return false;
    if (other is! NullAssertPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNullAssertPattern_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNullAssertPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNullCheckPattern(
    EquivalenceVisitor visitor,
    NullCheckPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullCheckPattern) return false;
    if (other is! NullCheckPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNullCheckPattern_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNullCheckPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkListPattern(
    EquivalenceVisitor visitor,
    ListPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ListPattern) return false;
    if (other is! ListPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkListPattern_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_patterns(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_requiredType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_lookupType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_lengthTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_lengthType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_lengthCheckTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_lengthCheckType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_sublistTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_sublistType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_minusTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_minusType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_indexGetTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_indexGetType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkListPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkObjectPattern(
    EquivalenceVisitor visitor,
    ObjectPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ObjectPattern) return false;
    if (other is! ObjectPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkObjectPattern_requiredType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkObjectPattern_fields(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkObjectPattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkObjectPattern_needsCheck(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkObjectPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRelationalPattern(
    EquivalenceVisitor visitor,
    RelationalPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RelationalPattern) return false;
    if (other is! RelationalPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRelationalPattern_kind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_expressionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_accessKind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_functionType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_expressionValue(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRelationalPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkWildcardPattern(
    EquivalenceVisitor visitor,
    WildcardPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! WildcardPattern) return false;
    if (other is! WildcardPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkWildcardPattern_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkWildcardPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAssignedVariablePattern(
    EquivalenceVisitor visitor,
    AssignedVariablePattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AssignedVariablePattern) return false;
    if (other is! AssignedVariablePattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAssignedVariablePattern_variableName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_variableType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_writeVariable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_needsCast(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_hasObservableEffect(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssignedVariablePattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapPattern(
    EquivalenceVisitor visitor,
    MapPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapPattern) return false;
    if (other is! MapPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapPattern_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_keyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_valueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_entries(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_requiredType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_lookupType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_containsKeyTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_containsKeyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_indexGetTargetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_indexGetType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNamedPattern(
    EquivalenceVisitor visitor,
    NamedPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NamedPattern) return false;
    if (other is! NamedPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNamedPattern_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_fieldName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_accessKind(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_resultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_checkReturn(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_recordType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_recordFieldIndex(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordPattern(
    EquivalenceVisitor visitor,
    RecordPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordPattern) return false;
    if (other is! RecordPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordPattern_patterns(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordPattern_requiredType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordPattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordPattern_needsCheck(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordPattern_lookupType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariablePattern(
    EquivalenceVisitor visitor,
    VariablePattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariablePattern) return false;
    if (other is! VariablePattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariablePattern_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariablePattern_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariablePattern_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariablePattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRestPattern(
    EquivalenceVisitor visitor,
    RestPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RestPattern) return false;
    if (other is! RestPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRestPattern_subPattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRestPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInvalidPattern(
    EquivalenceVisitor visitor,
    InvalidPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InvalidPattern) return false;
    if (other is! InvalidPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInvalidPattern_invalidExpression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidPattern_declaredVariables(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInvalidPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAuxiliaryPattern(
    EquivalenceVisitor visitor,
    AuxiliaryPattern? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryPattern) return false;
    if (other is! AuxiliaryPattern) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAuxiliaryPattern_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapPatternEntry(
    EquivalenceVisitor visitor,
    MapPatternEntry? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapPatternEntry) return false;
    if (other is! MapPatternEntry) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapPatternEntry_key(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPatternEntry_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPatternEntry_keyType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPatternEntry_keyValue(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkMapPatternEntry_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkMapPatternRestEntry(
    EquivalenceVisitor visitor,
    MapPatternRestEntry? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! MapPatternRestEntry) return false;
    if (other is! MapPatternRestEntry) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkMapPatternRestEntry_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPatternGuard(
    EquivalenceVisitor visitor,
    PatternGuard? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PatternGuard) return false;
    if (other is! PatternGuard) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPatternGuard_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternGuard_guard(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternGuard_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPatternSwitchCase(
    EquivalenceVisitor visitor,
    PatternSwitchCase? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PatternSwitchCase) return false;
    if (other is! PatternSwitchCase) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPatternSwitchCase_caseOffsets(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_patternGuards(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_labelUsers(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_isDefault(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_hasLabel(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_jointVariableDeclarations(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_jointVariableFirstUseOffsets(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_jointVariableScope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchCase_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSwitchCase(
    EquivalenceVisitor visitor,
    SwitchCase? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SwitchCase) return false;
    if (other is! SwitchCase) return false;
    if (!visitor.checkDeclarations(node, other, '')) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSwitchCase_expressions(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchCase_expressionOffsets(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchCase_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchCase_isDefault(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchCase_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPatternSwitchStatement(
    EquivalenceVisitor visitor,
    PatternSwitchStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PatternSwitchStatement) return false;
    if (other is! PatternSwitchStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPatternSwitchStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchStatement_cases(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchStatement_expressionTypeInternal(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchStatement_lastCaseTerminates(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchStatement_isExplicitlyExhaustive(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternSwitchStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSwitchStatement(
    EquivalenceVisitor visitor,
    SwitchStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SwitchStatement) return false;
    if (other is! SwitchStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSwitchStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchStatement_cases(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchStatement_isExplicitlyExhaustive(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchStatement_expressionTypeInternal(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPatternVariableDeclaration(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PatternVariableDeclaration) return false;
    if (other is! PatternVariableDeclaration) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPatternVariableDeclaration_pattern(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternVariableDeclaration_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternVariableDeclaration_isFinal(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternVariableDeclaration_matchedValueType(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPatternVariableDeclaration_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIfCaseStatement(
    EquivalenceVisitor visitor,
    IfCaseStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IfCaseStatement) return false;
    if (other is! IfCaseStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIfCaseStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_patternGuard(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_then(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_otherwise(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_matchedValueType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfCaseStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAuxiliaryStatement(
    EquivalenceVisitor visitor,
    AuxiliaryStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryStatement) return false;
    if (other is! AuxiliaryStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAuxiliaryStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkExpressionStatement(
    EquivalenceVisitor visitor,
    ExpressionStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ExpressionStatement) return false;
    if (other is! ExpressionStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkExpressionStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExpressionStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkBlock(EquivalenceVisitor visitor, Block? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Block) return false;
    if (other is! Block) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkBlock_statements(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlock_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlock_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBlock_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAssertBlock(
    EquivalenceVisitor visitor,
    AssertBlock? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AssertBlock) return false;
    if (other is! AssertBlock) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAssertBlock_statements(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertBlock_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkEmptyStatement(
    EquivalenceVisitor visitor,
    EmptyStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! EmptyStatement) return false;
    if (other is! EmptyStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkEmptyStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAssertStatement(
    EquivalenceVisitor visitor,
    AssertStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AssertStatement) return false;
    if (other is! AssertStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkAssertStatement_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertStatement_message(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertStatement_conditionStartOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertStatement_conditionEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLabeledStatement(
    EquivalenceVisitor visitor,
    LabeledStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LabeledStatement) return false;
    if (other is! LabeledStatement) return false;
    if (!visitor.checkDeclarations(node, other, '')) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLabeledStatement_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLabeledStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkBreakStatement(
    EquivalenceVisitor visitor,
    BreakStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! BreakStatement) return false;
    if (other is! BreakStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkBreakStatement_target(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkBreakStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkWhileStatement(
    EquivalenceVisitor visitor,
    WhileStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! WhileStatement) return false;
    if (other is! WhileStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkWhileStatement_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkWhileStatement_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkWhileStatement_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkWhileStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkDoStatement(
    EquivalenceVisitor visitor,
    DoStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DoStatement) return false;
    if (other is! DoStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkDoStatement_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDoStatement_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkDoStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkForStatement(
    EquivalenceVisitor visitor,
    ForStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ForStatement) return false;
    if (other is! ForStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkForStatement_variables(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForStatement_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForStatement_updates(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForStatement_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForStatement_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkForInStatement(
    EquivalenceVisitor visitor,
    ForInStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ForInStatement) return false;
    if (other is! ForInStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkForInStatement_bodyOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_iterable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_isAsync(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkForInStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkContinueSwitchStatement(
    EquivalenceVisitor visitor,
    ContinueSwitchStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ContinueSwitchStatement) return false;
    if (other is! ContinueSwitchStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkContinueSwitchStatement_target(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkContinueSwitchStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIfStatement(
    EquivalenceVisitor visitor,
    IfStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IfStatement) return false;
    if (other is! IfStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIfStatement_condition(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfStatement_then(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfStatement_otherwise(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIfStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkReturnStatement(
    EquivalenceVisitor visitor,
    ReturnStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ReturnStatement) return false;
    if (other is! ReturnStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkReturnStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkReturnStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTryCatch(
    EquivalenceVisitor visitor,
    TryCatch? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TryCatch) return false;
    if (other is! TryCatch) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTryCatch_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTryCatch_catches(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTryCatch_isSynthetic(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTryCatch_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTryFinally(
    EquivalenceVisitor visitor,
    TryFinally? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TryFinally) return false;
    if (other is! TryFinally) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTryFinally_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTryFinally_finalizer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTryFinally_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkYieldStatement(
    EquivalenceVisitor visitor,
    YieldStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! YieldStatement) return false;
    if (other is! YieldStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkYieldStatement_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkYieldStatement_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkYieldStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariableStatement(
    EquivalenceVisitor visitor,
    VariableStatement? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariableStatement) return false;
    if (other is! VariableStatement) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariableStatement_declaration(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableStatement_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFunctionDeclaration(
    EquivalenceVisitor visitor,
    FunctionDeclaration? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionDeclaration) return false;
    if (other is! FunctionDeclaration) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionDeclaration_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionDeclaration_function(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionDeclaration_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSwitchExpressionCase(
    EquivalenceVisitor visitor,
    SwitchExpressionCase? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SwitchExpressionCase) return false;
    if (other is! SwitchExpressionCase) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSwitchExpressionCase_patternGuard(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpressionCase_expression(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpressionCase_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSwitchExpressionCase_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkCatch(EquivalenceVisitor visitor, Catch? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Catch) return false;
    if (other is! Catch) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkCatch_guard(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatch_exception(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatch_stackTrace(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatch_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatch_scope(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatch_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNominalParameter(
    EquivalenceVisitor visitor,
    NominalParameter? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NominalParameter) return false;
    if (other is! NominalParameter) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNominalParameter_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_bound(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_defaultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_variance(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNominalParameter_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypeVariable(
    EquivalenceVisitor visitor,
    TypeVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypeVariable) return false;
    if (other is! TypeVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypeVariable_cosmeticName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeVariable_parameter(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLocalVariable(
    EquivalenceVisitor visitor,
    LocalVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LocalVariable) return false;
    if (other is! LocalVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLocalVariable_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLocalFunctionVariable(
    EquivalenceVisitor visitor,
    LocalFunctionVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LocalFunctionVariable) return false;
    if (other is! LocalFunctionVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLocalFunctionVariable_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLocalFunctionVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkLateVariable(
    EquivalenceVisitor visitor,
    LateVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! LateVariable) return false;
    if (other is! LateVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkLateVariable_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_initialValue(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkLateVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkConstVariable(
    EquivalenceVisitor visitor,
    ConstVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ConstVariable) return false;
    if (other is! ConstVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkConstVariable_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_value(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkConstVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSyntheticVariable(
    EquivalenceVisitor visitor,
    SyntheticVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! SyntheticVariable) return false;
    if (other is! SyntheticVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSyntheticVariable_cosmeticName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSyntheticVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkCatchVariable(
    EquivalenceVisitor visitor,
    CatchVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! CatchVariable) return false;
    if (other is! CatchVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkCatchVariable_catchVariableName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkCatchVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPositionalParameter(
    EquivalenceVisitor visitor,
    PositionalParameter? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! PositionalParameter) return false;
    if (other is! PositionalParameter) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkPositionalParameter_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_parameterName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_defaultValue(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkPositionalParameter_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNamedParameter(
    EquivalenceVisitor visitor,
    NamedParameter? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NamedParameter) return false;
    if (other is! NamedParameter) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNamedParameter_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_parameterName(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_defaultValue(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedParameter_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkThisVariable(
    EquivalenceVisitor visitor,
    ThisVariable? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ThisVariable) return false;
    if (other is! ThisVariable) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkThisVariable_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThisVariable_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThisVariable_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThisVariable_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThisVariable_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkThisVariable_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkVariableDeclaration(
    EquivalenceVisitor visitor,
    VariableDeclaration? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VariableDeclaration) return false;
    if (other is! VariableDeclaration) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariableDeclaration_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_capturedContexts(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkName(EquivalenceVisitor visitor, Name? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! Name) return false;
    if (other is! Name) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkName_text(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStructuralParameter(
    EquivalenceVisitor visitor,
    StructuralParameter? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StructuralParameter) return false;
    if (other is! StructuralParameter) return false;
    if (!visitor.checkDeclarations(node, other, '')) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStructuralParameter_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_uri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_bound(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_defaultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameter_variance(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkSupertype(
    EquivalenceVisitor visitor,
    Supertype? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! Supertype) return false;
    if (other is! Supertype) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkSupertype_className(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkSupertype_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInterfaceType(
    EquivalenceVisitor visitor,
    InterfaceType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InterfaceType) return false;
    if (other is! InterfaceType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkInterfaceType_classReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInterfaceType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkInterfaceType_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkExtensionType(
    EquivalenceVisitor visitor,
    ExtensionType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ExtensionType) return false;
    if (other is! ExtensionType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkExtensionType_extensionTypeDeclarationReference(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionType_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkAuxiliaryType(
    EquivalenceVisitor visitor,
    AuxiliaryType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! AuxiliaryType) return false;
    if (other is! AuxiliaryType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkFunctionTypeParameterType(
    EquivalenceVisitor visitor,
    FunctionTypeParameterType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionTypeParameterType) return false;
    if (other is! FunctionTypeParameterType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionTypeParameterType_variable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionTypeParameterType_declaredNullability(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkClassTypeParameterType(
    EquivalenceVisitor visitor,
    ClassTypeParameterType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! ClassTypeParameterType) return false;
    if (other is! ClassTypeParameterType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkClassTypeParameterType_thisVariable(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClassTypeParameterType_parameter(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkClassTypeParameterType_declaredNullability(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkInvalidType(
    EquivalenceVisitor visitor,
    InvalidType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! InvalidType) return false;
    if (other is! InvalidType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkDynamicType(
    EquivalenceVisitor visitor,
    DynamicType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! DynamicType) return false;
    if (other is! DynamicType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkVoidType(
    EquivalenceVisitor visitor,
    VoidType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! VoidType) return false;
    if (other is! VoidType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkNeverType(
    EquivalenceVisitor visitor,
    NeverType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NeverType) return false;
    if (other is! NeverType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNeverType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNullType(
    EquivalenceVisitor visitor,
    NullType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NullType) return false;
    if (other is! NullType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    visitor.popState();
    return result;
  }

  bool checkFunctionType(
    EquivalenceVisitor visitor,
    FunctionType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FunctionType) return false;
    if (other is! FunctionType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFunctionType_typeParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionType_requiredParameterCount(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionType_positionalParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionType_namedParameters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionType_returnType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypedefType(
    EquivalenceVisitor visitor,
    TypedefType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypedefType) return false;
    if (other is! TypedefType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypedefType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefType_typedefReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypedefType_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkFutureOrType(
    EquivalenceVisitor visitor,
    FutureOrType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! FutureOrType) return false;
    if (other is! FutureOrType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkFutureOrType_typeArgument(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFutureOrType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkIntersectionType(
    EquivalenceVisitor visitor,
    IntersectionType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! IntersectionType) return false;
    if (other is! IntersectionType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkIntersectionType_left(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkIntersectionType_right(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypeParameterType(
    EquivalenceVisitor visitor,
    TypeParameterType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! TypeParameterType) return false;
    if (other is! TypeParameterType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypeParameterType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameterType_parameter(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkStructuralParameterType(
    EquivalenceVisitor visitor,
    StructuralParameterType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! StructuralParameterType) return false;
    if (other is! StructuralParameterType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkStructuralParameterType_declaredNullability(
      visitor,
      node,
      other,
    )) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkStructuralParameterType_parameter(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkRecordType(
    EquivalenceVisitor visitor,
    RecordType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! RecordType) return false;
    if (other is! RecordType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRecordType_positional(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordType_named(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRecordType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkNamedType(
    EquivalenceVisitor visitor,
    NamedType? node,
    Object? other,
  ) {
    if (identical(node, other)) return true;
    if (node is! NamedType) return false;
    if (other is! NamedType) return false;
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkNamedType_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedType_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkNamedType_isRequired(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkPrimitiveConstant_value(
    EquivalenceVisitor visitor,
    PrimitiveConstant node,
    PrimitiveConstant other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkNullConstant_value(
    EquivalenceVisitor visitor,
    NullConstant node,
    NullConstant other,
  ) {
    return checkPrimitiveConstant_value(visitor, node, other);
  }

  bool checkBoolConstant_value(
    EquivalenceVisitor visitor,
    BoolConstant node,
    BoolConstant other,
  ) {
    return checkPrimitiveConstant_value(visitor, node, other);
  }

  bool checkIntConstant_value(
    EquivalenceVisitor visitor,
    IntConstant node,
    IntConstant other,
  ) {
    return checkPrimitiveConstant_value(visitor, node, other);
  }

  bool checkDoubleConstant_value(
    EquivalenceVisitor visitor,
    DoubleConstant node,
    DoubleConstant other,
  ) {
    return checkPrimitiveConstant_value(visitor, node, other);
  }

  bool checkStringConstant_value(
    EquivalenceVisitor visitor,
    StringConstant node,
    StringConstant other,
  ) {
    return checkPrimitiveConstant_value(visitor, node, other);
  }

  bool checkSymbolConstant_name(
    EquivalenceVisitor visitor,
    SymbolConstant node,
    SymbolConstant other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkSymbolConstant_libraryReference(
    EquivalenceVisitor visitor,
    SymbolConstant node,
    SymbolConstant other,
  ) {
    return visitor.checkReferences(
      node.libraryReference,
      other.libraryReference,
      'libraryReference',
    );
  }

  bool checkMapConstant_keyType(
    EquivalenceVisitor visitor,
    MapConstant node,
    MapConstant other,
  ) {
    return visitor.checkNodes(node.keyType, other.keyType, 'keyType');
  }

  bool checkMapConstant_valueType(
    EquivalenceVisitor visitor,
    MapConstant node,
    MapConstant other,
  ) {
    return visitor.checkNodes(node.valueType, other.valueType, 'valueType');
  }

  bool checkConstantMapEntry_key(
    EquivalenceVisitor visitor,
    ConstantMapEntry node,
    ConstantMapEntry other,
  ) {
    return visitor.checkNodes(node.key, other.key, 'key');
  }

  bool checkConstantMapEntry_value(
    EquivalenceVisitor visitor,
    ConstantMapEntry node,
    ConstantMapEntry other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkMapConstant_entries(
    EquivalenceVisitor visitor,
    MapConstant node,
    MapConstant other,
  ) {
    return visitor.checkLists(node.entries, other.entries, (a, b, _) {
      if (identical(a, b)) return true;
      return checkConstantMapEntry(visitor, a, b);
    }, 'entries');
  }

  bool checkListConstant_typeArgument(
    EquivalenceVisitor visitor,
    ListConstant node,
    ListConstant other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkListConstant_entries(
    EquivalenceVisitor visitor,
    ListConstant node,
    ListConstant other,
  ) {
    return visitor.checkLists(
      node.entries,
      other.entries,
      visitor.checkNodes,
      'entries',
    );
  }

  bool checkSetConstant_typeArgument(
    EquivalenceVisitor visitor,
    SetConstant node,
    SetConstant other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkSetConstant_entries(
    EquivalenceVisitor visitor,
    SetConstant node,
    SetConstant other,
  ) {
    return visitor.checkLists(
      node.entries,
      other.entries,
      visitor.checkNodes,
      'entries',
    );
  }

  bool checkRecordConstant_positional(
    EquivalenceVisitor visitor,
    RecordConstant node,
    RecordConstant other,
  ) {
    return visitor.checkLists(
      node.positional,
      other.positional,
      visitor.checkNodes,
      'positional',
    );
  }

  bool checkRecordConstant_named(
    EquivalenceVisitor visitor,
    RecordConstant node,
    RecordConstant other,
  ) {
    return visitor.checkMaps(
      node.named,
      other.named,
      visitor.matchValues,
      visitor.checkValues,
      visitor.checkNodes,
      'named',
    );
  }

  bool checkRecordConstant_recordType(
    EquivalenceVisitor visitor,
    RecordConstant node,
    RecordConstant other,
  ) {
    return visitor.checkNodes(node.recordType, other.recordType, 'recordType');
  }

  bool checkInstanceConstant_classReference(
    EquivalenceVisitor visitor,
    InstanceConstant node,
    InstanceConstant other,
  ) {
    return visitor.checkReferences(
      node.classReference,
      other.classReference,
      'classReference',
    );
  }

  bool checkInstanceConstant_typeArguments(
    EquivalenceVisitor visitor,
    InstanceConstant node,
    InstanceConstant other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkInstanceConstant_fieldValues(
    EquivalenceVisitor visitor,
    InstanceConstant node,
    InstanceConstant other,
  ) {
    return visitor.checkMaps(
      node.fieldValues,
      other.fieldValues,
      visitor.matchReferences,
      visitor.checkReferences,
      visitor.checkNodes,
      'fieldValues',
    );
  }

  bool checkInstantiationConstant_tearOffConstant(
    EquivalenceVisitor visitor,
    InstantiationConstant node,
    InstantiationConstant other,
  ) {
    return visitor.checkNodes(
      node.tearOffConstant,
      other.tearOffConstant,
      'tearOffConstant',
    );
  }

  bool checkInstantiationConstant_types(
    EquivalenceVisitor visitor,
    InstantiationConstant node,
    InstantiationConstant other,
  ) {
    return visitor.checkLists(
      node.types,
      other.types,
      visitor.checkNodes,
      'types',
    );
  }

  bool checkStaticTearOffConstant_targetReference(
    EquivalenceVisitor visitor,
    StaticTearOffConstant node,
    StaticTearOffConstant other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkConstructorTearOffConstant_targetReference(
    EquivalenceVisitor visitor,
    ConstructorTearOffConstant node,
    ConstructorTearOffConstant other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkRedirectingFactoryTearOffConstant_targetReference(
    EquivalenceVisitor visitor,
    RedirectingFactoryTearOffConstant node,
    RedirectingFactoryTearOffConstant other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkTypedefTearOffConstant_parameters(
    EquivalenceVisitor visitor,
    TypedefTearOffConstant node,
    TypedefTearOffConstant other,
  ) {
    return visitor.checkLists(
      node.parameters,
      other.parameters,
      visitor.checkNodes,
      'parameters',
    );
  }

  bool checkTypedefTearOffConstant_tearOffConstant(
    EquivalenceVisitor visitor,
    TypedefTearOffConstant node,
    TypedefTearOffConstant other,
  ) {
    return visitor.checkNodes(
      node.tearOffConstant,
      other.tearOffConstant,
      'tearOffConstant',
    );
  }

  bool checkTypedefTearOffConstant_types(
    EquivalenceVisitor visitor,
    TypedefTearOffConstant node,
    TypedefTearOffConstant other,
  ) {
    return visitor.checkLists(
      node.types,
      other.types,
      visitor.checkNodes,
      'types',
    );
  }

  bool checkTypeLiteralConstant_type(
    EquivalenceVisitor visitor,
    TypeLiteralConstant node,
    TypeLiteralConstant other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkUnevaluatedConstant_expression(
    EquivalenceVisitor visitor,
    UnevaluatedConstant node,
    UnevaluatedConstant other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkComponent_problemsAsJson(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return visitor.checkLists(
      node.problemsAsJson,
      other.problemsAsJson,
      visitor.checkValues,
      'problemsAsJson',
    );
  }

  bool checkComponent_libraries(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return visitor.checkLists(
      node.libraries,
      other.libraries,
      visitor.checkNodes,
      'libraries',
    );
  }

  bool checkSource_lineStarts(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkLists(
      node.lineStarts,
      other.lineStarts,
      visitor.checkValues,
      'lineStarts',
    );
  }

  bool checkSource_source(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkLists(
      node.source,
      other.source,
      visitor.checkValues,
      'source',
    );
  }

  bool checkSource_importUri(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkValues(node.importUri, other.importUri, 'importUri');
  }

  bool checkSource_fileUri(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkSource_constantCoverageConstructors(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkSets(
      node.constantCoverageConstructors,
      other.constantCoverageConstructors,
      visitor.matchReferences,
      visitor.checkReferences,
      'constantCoverageConstructors',
    );
  }

  bool checkSource_cachedText(
    EquivalenceVisitor visitor,
    Source node,
    Source other,
  ) {
    return visitor.checkValues(node.cachedText, other.cachedText, 'cachedText');
  }

  bool checkComponent_uriToSource(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return visitor.checkMaps(
      node.uriToSource,
      other.uriToSource,
      visitor.matchValues,
      visitor.checkValues,
      (a, b, _) {
        if (identical(a, b)) return true;
        return checkSource(visitor, a, b);
      },
      'uriToSource',
    );
  }

  bool checkComponent_metadata(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return visitor.checkMaps(
      node.metadata,
      other.metadata,
      visitor.matchValues,
      visitor.checkValues,
      (a, b, _) {
        if (identical(a, b)) return true;
        return checkMetadataRepository(visitor, a, b);
      },
      'metadata',
    );
  }

  bool checkComponent_mainMethodName(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return visitor.checkReferences(
      node.mainMethodName,
      other.mainMethodName,
      'mainMethodName',
    );
  }

  bool checkTreeNode_fileOffset(
    EquivalenceVisitor visitor,
    TreeNode node,
    TreeNode other,
  ) {
    return visitor.checkValues(node.fileOffset, other.fileOffset, 'fileOffset');
  }

  bool checkComponent_fileOffset(
    EquivalenceVisitor visitor,
    Component node,
    Component other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkClass_startFileOffset(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkValues(
      node.startFileOffset,
      other.startFileOffset,
      'startFileOffset',
    );
  }

  bool checkClass_fileEndOffset(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkValues(
      node.fileEndOffset,
      other.fileEndOffset,
      'fileEndOffset',
    );
  }

  bool checkClass_annotations(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkClass_name(EquivalenceVisitor visitor, Class node, Class other) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkClass_flags(EquivalenceVisitor visitor, Class node, Class other) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkClass_fileUri(EquivalenceVisitor visitor, Class node, Class other) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkClass_typeParameters(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkClass_supertype(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkNodes(node.supertype, other.supertype, 'supertype');
  }

  bool checkClass_mixedInType(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkNodes(
      node.mixedInType,
      other.mixedInType,
      'mixedInType',
    );
  }

  bool checkClass_implementedTypes(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkLists(
      node.implementedTypes,
      other.implementedTypes,
      visitor.checkNodes,
      'implementedTypes',
    );
  }

  bool checkClass_fields(EquivalenceVisitor visitor, Class node, Class other) {
    return visitor.checkLists(
      node.fields,
      other.fields,
      visitor.checkNodes,
      'fields',
    );
  }

  bool checkClass_constructors(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkLists(
      node.constructors,
      other.constructors,
      visitor.checkNodes,
      'constructors',
    );
  }

  bool checkClass_procedures(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return visitor.checkLists(
      node.procedures,
      other.procedures,
      visitor.checkNodes,
      'procedures',
    );
  }

  bool checkNamedNode_reference(
    EquivalenceVisitor visitor,
    NamedNode node,
    NamedNode other,
  ) {
    return visitor.checkReferences(
      node.reference,
      other.reference,
      'reference',
    );
  }

  bool checkClass_reference(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkNamedNode_fileOffset(
    EquivalenceVisitor visitor,
    NamedNode node,
    NamedNode other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkClass_fileOffset(
    EquivalenceVisitor visitor,
    Class node,
    Class other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkExtension_name(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkExtension_fileUri(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkExtension_typeParameters(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkExtension_onType(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkNodes(node.onType, other.onType, 'onType');
  }

  bool checkExtensionMemberDescriptor_name(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor node,
    ExtensionMemberDescriptor other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkExtensionMemberDescriptor_kind(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor node,
    ExtensionMemberDescriptor other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkExtensionMemberDescriptor_flags(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor node,
    ExtensionMemberDescriptor other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkExtensionMemberDescriptor_memberReference(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor node,
    ExtensionMemberDescriptor other,
  ) {
    return visitor.checkReferences(
      node.memberReference,
      other.memberReference,
      'memberReference',
    );
  }

  bool checkExtensionMemberDescriptor_tearOffReference(
    EquivalenceVisitor visitor,
    ExtensionMemberDescriptor node,
    ExtensionMemberDescriptor other,
  ) {
    return visitor.checkReferences(
      node.tearOffReference,
      other.tearOffReference,
      'tearOffReference',
    );
  }

  bool checkExtension_memberDescriptors(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkLists(node.memberDescriptors, other.memberDescriptors, (
      a,
      b,
      _,
    ) {
      if (identical(a, b)) return true;
      return checkExtensionMemberDescriptor(visitor, a, b);
    }, 'memberDescriptors');
  }

  bool checkExtension_annotations(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkExtension_flags(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkExtension_reference(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkExtension_fileOffset(
    EquivalenceVisitor visitor,
    Extension node,
    Extension other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkExtensionTypeDeclaration_name(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkExtensionTypeDeclaration_fileUri(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkExtensionTypeDeclaration_typeParameters(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkExtensionTypeDeclaration_declaredRepresentationType(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkNodes(
      node.declaredRepresentationType,
      other.declaredRepresentationType,
      'declaredRepresentationType',
    );
  }

  bool checkExtensionTypeDeclaration_representationName(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkValues(
      node.representationName,
      other.representationName,
      'representationName',
    );
  }

  bool checkExtensionTypeDeclaration_procedures(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkLists(
      node.procedures,
      other.procedures,
      visitor.checkNodes,
      'procedures',
    );
  }

  bool checkExtensionTypeMemberDescriptor_name(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor node,
    ExtensionTypeMemberDescriptor other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkExtensionTypeMemberDescriptor_kind(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor node,
    ExtensionTypeMemberDescriptor other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkExtensionTypeMemberDescriptor_flags(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor node,
    ExtensionTypeMemberDescriptor other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkExtensionTypeMemberDescriptor_memberReference(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor node,
    ExtensionTypeMemberDescriptor other,
  ) {
    return visitor.checkReferences(
      node.memberReference,
      other.memberReference,
      'memberReference',
    );
  }

  bool checkExtensionTypeMemberDescriptor_tearOffReference(
    EquivalenceVisitor visitor,
    ExtensionTypeMemberDescriptor node,
    ExtensionTypeMemberDescriptor other,
  ) {
    return visitor.checkReferences(
      node.tearOffReference,
      other.tearOffReference,
      'tearOffReference',
    );
  }

  bool checkExtensionTypeDeclaration_memberDescriptors(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkLists(node.memberDescriptors, other.memberDescriptors, (
      a,
      b,
      _,
    ) {
      if (identical(a, b)) return true;
      return checkExtensionTypeMemberDescriptor(visitor, a, b);
    }, 'memberDescriptors');
  }

  bool checkExtensionTypeDeclaration_annotations(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkExtensionTypeDeclaration_implements(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkLists(
      node.implements,
      other.implements,
      visitor.checkNodes,
      'implements',
    );
  }

  bool checkExtensionTypeDeclaration_flags(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkExtensionTypeDeclaration_reference(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkExtensionTypeDeclaration_fileOffset(
    EquivalenceVisitor visitor,
    ExtensionTypeDeclaration node,
    ExtensionTypeDeclaration other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkLibrary_importUri(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkValues(node.importUri, other.importUri, 'importUri');
  }

  bool checkLibrary_fileUri(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkLibrary_languageVersion(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkValues(
      node.languageVersion,
      other.languageVersion,
      'languageVersion',
    );
  }

  bool checkLibrary_flags(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkLibrary_name(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkLibrary_problemsAsJson(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.problemsAsJson,
      other.problemsAsJson,
      visitor.checkValues,
      'problemsAsJson',
    );
  }

  bool checkLibrary_annotations(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLibrary_dependencies(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.dependencies,
      other.dependencies,
      visitor.checkNodes,
      'dependencies',
    );
  }

  bool checkLibrary_additionalExports(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.additionalExports,
      other.additionalExports,
      visitor.checkReferences,
      'additionalExports',
    );
  }

  bool checkLibrary_parts(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.parts,
      other.parts,
      visitor.checkNodes,
      'parts',
    );
  }

  bool checkLibrary_typedefs(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.typedefs,
      other.typedefs,
      visitor.checkNodes,
      'typedefs',
    );
  }

  bool checkLibrary_classes(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.classes,
      other.classes,
      visitor.checkNodes,
      'classes',
    );
  }

  bool checkLibrary_extensions(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.extensions,
      other.extensions,
      visitor.checkNodes,
      'extensions',
    );
  }

  bool checkLibrary_extensionTypeDeclarations(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.extensionTypeDeclarations,
      other.extensionTypeDeclarations,
      visitor.checkNodes,
      'extensionTypeDeclarations',
    );
  }

  bool checkLibrary_procedures(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.procedures,
      other.procedures,
      visitor.checkNodes,
      'procedures',
    );
  }

  bool checkLibrary_fields(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return visitor.checkLists(
      node.fields,
      other.fields,
      visitor.checkNodes,
      'fields',
    );
  }

  bool checkLibrary_reference(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkLibrary_fileOffset(
    EquivalenceVisitor visitor,
    Library node,
    Library other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkField_type(EquivalenceVisitor visitor, Field node, Field other) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkField_flags(EquivalenceVisitor visitor, Field node, Field other) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkField_initializer(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return visitor.checkNodes(
      node.initializer,
      other.initializer,
      'initializer',
    );
  }

  bool checkField_getterReference(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return visitor.checkReferences(
      node.getterReference,
      other.getterReference,
      'getterReference',
    );
  }

  bool checkField_setterReference(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return visitor.checkReferences(
      node.setterReference,
      other.setterReference,
      'setterReference',
    );
  }

  bool checkVariableContext_captureKind(
    EquivalenceVisitor visitor,
    VariableContext node,
    VariableContext other,
  ) {
    return visitor.checkValues(
      node.captureKind,
      other.captureKind,
      'captureKind',
    );
  }

  bool checkVariableContext_variables(
    EquivalenceVisitor visitor,
    VariableContext node,
    VariableContext other,
  ) {
    return visitor.checkLists(
      node.variables,
      other.variables,
      visitor.checkNodes,
      'variables',
    );
  }

  bool checkScope_contexts(
    EquivalenceVisitor visitor,
    Scope node,
    Scope other,
  ) {
    return visitor.checkLists(node.contexts, other.contexts, (a, b, _) {
      if (identical(a, b)) return true;
      return checkVariableContext(visitor, a, b);
    }, 'contexts');
  }

  bool checkField_scope(EquivalenceVisitor visitor, Field node, Field other) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkField_thisVariable(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return visitor.checkNodes(
      node.thisVariable,
      other.thisVariable,
      'thisVariable',
    );
  }

  bool checkMember_fileEndOffset(
    EquivalenceVisitor visitor,
    Member node,
    Member other,
  ) {
    return visitor.checkValues(
      node.fileEndOffset,
      other.fileEndOffset,
      'fileEndOffset',
    );
  }

  bool checkField_fileEndOffset(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return checkMember_fileEndOffset(visitor, node, other);
  }

  bool checkMember_annotations(
    EquivalenceVisitor visitor,
    Member node,
    Member other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkField_annotations(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return checkMember_annotations(visitor, node, other);
  }

  bool checkMember_name(EquivalenceVisitor visitor, Member node, Member other) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkField_name(EquivalenceVisitor visitor, Field node, Field other) {
    return checkMember_name(visitor, node, other);
  }

  bool checkMember_fileUri(
    EquivalenceVisitor visitor,
    Member node,
    Member other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkField_fileUri(EquivalenceVisitor visitor, Field node, Field other) {
    return checkMember_fileUri(visitor, node, other);
  }

  bool checkField_fieldReference(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return visitor.checkReferences(
      node.fieldReference,
      other.fieldReference,
      'fieldReference',
    );
  }

  bool checkMember_fileOffset(
    EquivalenceVisitor visitor,
    Member node,
    Member other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkField_fileOffset(
    EquivalenceVisitor visitor,
    Field node,
    Field other,
  ) {
    return checkMember_fileOffset(visitor, node, other);
  }

  bool checkConstructor_startFileOffset(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return visitor.checkValues(
      node.startFileOffset,
      other.startFileOffset,
      'startFileOffset',
    );
  }

  bool checkConstructor_flags(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkConstructor_function(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return visitor.checkNodes(node.function, other.function, 'function');
  }

  bool checkConstructor_initializers(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return visitor.checkLists(
      node.initializers,
      other.initializers,
      visitor.checkNodes,
      'initializers',
    );
  }

  bool checkConstructor_fileEndOffset(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_fileEndOffset(visitor, node, other);
  }

  bool checkConstructor_annotations(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_annotations(visitor, node, other);
  }

  bool checkConstructor_name(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_name(visitor, node, other);
  }

  bool checkConstructor_fileUri(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_fileUri(visitor, node, other);
  }

  bool checkMember_reference(
    EquivalenceVisitor visitor,
    Member node,
    Member other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkConstructor_reference(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_reference(visitor, node, other);
  }

  bool checkConstructor_fileOffset(
    EquivalenceVisitor visitor,
    Constructor node,
    Constructor other,
  ) {
    return checkMember_fileOffset(visitor, node, other);
  }

  bool checkProcedure_fileStartOffset(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkValues(
      node.fileStartOffset,
      other.fileStartOffset,
      'fileStartOffset',
    );
  }

  bool checkProcedure_kind(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkProcedure_flags(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkProcedure_function(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkNodes(node.function, other.function, 'function');
  }

  bool checkProcedure_stubKind(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkValues(node.stubKind, other.stubKind, 'stubKind');
  }

  bool checkProcedure_stubTargetReference(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkReferences(
      node.stubTargetReference,
      other.stubTargetReference,
      'stubTargetReference',
    );
  }

  bool checkProcedure_signatureType(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return visitor.checkNodes(
      node.signatureType,
      other.signatureType,
      'signatureType',
    );
  }

  bool checkProcedure_fileEndOffset(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_fileEndOffset(visitor, node, other);
  }

  bool checkProcedure_annotations(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_annotations(visitor, node, other);
  }

  bool checkProcedure_name(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_name(visitor, node, other);
  }

  bool checkProcedure_fileUri(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_fileUri(visitor, node, other);
  }

  bool checkProcedure_reference(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_reference(visitor, node, other);
  }

  bool checkProcedure_fileOffset(
    EquivalenceVisitor visitor,
    Procedure node,
    Procedure other,
  ) {
    return checkMember_fileOffset(visitor, node, other);
  }

  bool checkTypedef_fileUri(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkTypedef_annotations(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkTypedef_name(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkTypedef_typeParameters(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkTypedef_type(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkTypedef_reference(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return checkNamedNode_reference(visitor, node, other);
  }

  bool checkTypedef_fileOffset(
    EquivalenceVisitor visitor,
    Typedef node,
    Typedef other,
  ) {
    return checkNamedNode_fileOffset(visitor, node, other);
  }

  bool checkExpression_fileOffset(
    EquivalenceVisitor visitor,
    Expression node,
    Expression other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkAuxiliaryExpression_fileOffset(
    EquivalenceVisitor visitor,
    AuxiliaryExpression node,
    AuxiliaryExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInvalidExpression_message(
    EquivalenceVisitor visitor,
    InvalidExpression node,
    InvalidExpression other,
  ) {
    return visitor.checkValues(node.message, other.message, 'message');
  }

  bool checkInvalidExpression_expression(
    EquivalenceVisitor visitor,
    InvalidExpression node,
    InvalidExpression other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkInvalidExpression_fileOffset(
    EquivalenceVisitor visitor,
    InvalidExpression node,
    InvalidExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkVariableGet_variable(
    EquivalenceVisitor visitor,
    VariableGet node,
    VariableGet other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkVariableGet_promotedType(
    EquivalenceVisitor visitor,
    VariableGet node,
    VariableGet other,
  ) {
    return visitor.checkNodes(
      node.promotedType,
      other.promotedType,
      'promotedType',
    );
  }

  bool checkVariableGet_fileOffset(
    EquivalenceVisitor visitor,
    VariableGet node,
    VariableGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkVariableSet_variable(
    EquivalenceVisitor visitor,
    VariableSet node,
    VariableSet other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkVariableSet_value(
    EquivalenceVisitor visitor,
    VariableSet node,
    VariableSet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkVariableSet_fileOffset(
    EquivalenceVisitor visitor,
    VariableSet node,
    VariableSet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRecordIndexGet_receiver(
    EquivalenceVisitor visitor,
    RecordIndexGet node,
    RecordIndexGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkRecordIndexGet_receiverType(
    EquivalenceVisitor visitor,
    RecordIndexGet node,
    RecordIndexGet other,
  ) {
    return visitor.checkNodes(
      node.receiverType,
      other.receiverType,
      'receiverType',
    );
  }

  bool checkRecordIndexGet_index(
    EquivalenceVisitor visitor,
    RecordIndexGet node,
    RecordIndexGet other,
  ) {
    return visitor.checkValues(node.index, other.index, 'index');
  }

  bool checkRecordIndexGet_fileOffset(
    EquivalenceVisitor visitor,
    RecordIndexGet node,
    RecordIndexGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRecordNameGet_receiver(
    EquivalenceVisitor visitor,
    RecordNameGet node,
    RecordNameGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkRecordNameGet_receiverType(
    EquivalenceVisitor visitor,
    RecordNameGet node,
    RecordNameGet other,
  ) {
    return visitor.checkNodes(
      node.receiverType,
      other.receiverType,
      'receiverType',
    );
  }

  bool checkRecordNameGet_name(
    EquivalenceVisitor visitor,
    RecordNameGet node,
    RecordNameGet other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkRecordNameGet_fileOffset(
    EquivalenceVisitor visitor,
    RecordNameGet node,
    RecordNameGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkDynamicGet_kind(
    EquivalenceVisitor visitor,
    DynamicGet node,
    DynamicGet other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkDynamicGet_receiver(
    EquivalenceVisitor visitor,
    DynamicGet node,
    DynamicGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkDynamicGet_name(
    EquivalenceVisitor visitor,
    DynamicGet node,
    DynamicGet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkDynamicGet_fileOffset(
    EquivalenceVisitor visitor,
    DynamicGet node,
    DynamicGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceGet_kind(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkInstanceGet_receiver(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkInstanceGet_name(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkInstanceGet_resultType(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return visitor.checkNodes(node.resultType, other.resultType, 'resultType');
  }

  bool checkInstanceGet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkInstanceGet_fileOffset(
    EquivalenceVisitor visitor,
    InstanceGet node,
    InstanceGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkFunctionTearOff_receiver(
    EquivalenceVisitor visitor,
    FunctionTearOff node,
    FunctionTearOff other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkFunctionTearOff_fileOffset(
    EquivalenceVisitor visitor,
    FunctionTearOff node,
    FunctionTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceTearOff_kind(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkInstanceTearOff_receiver(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkInstanceTearOff_name(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkInstanceTearOff_resultType(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return visitor.checkNodes(node.resultType, other.resultType, 'resultType');
  }

  bool checkInstanceTearOff_interfaceTargetReference(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkInstanceTearOff_fileOffset(
    EquivalenceVisitor visitor,
    InstanceTearOff node,
    InstanceTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkDynamicSet_kind(
    EquivalenceVisitor visitor,
    DynamicSet node,
    DynamicSet other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkDynamicSet_receiver(
    EquivalenceVisitor visitor,
    DynamicSet node,
    DynamicSet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkDynamicSet_name(
    EquivalenceVisitor visitor,
    DynamicSet node,
    DynamicSet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkDynamicSet_value(
    EquivalenceVisitor visitor,
    DynamicSet node,
    DynamicSet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkDynamicSet_fileOffset(
    EquivalenceVisitor visitor,
    DynamicSet node,
    DynamicSet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceSet_kind(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkInstanceSet_receiver(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkInstanceSet_name(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkInstanceSet_value(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkInstanceSet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkInstanceSet_fileOffset(
    EquivalenceVisitor visitor,
    InstanceSet node,
    InstanceSet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkAbstractSuperPropertyGet_receiver(
    EquivalenceVisitor visitor,
    AbstractSuperPropertyGet node,
    AbstractSuperPropertyGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkAbstractSuperPropertyGet_name(
    EquivalenceVisitor visitor,
    AbstractSuperPropertyGet node,
    AbstractSuperPropertyGet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkAbstractSuperPropertyGet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    AbstractSuperPropertyGet node,
    AbstractSuperPropertyGet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkAbstractSuperPropertyGet_fileOffset(
    EquivalenceVisitor visitor,
    AbstractSuperPropertyGet node,
    AbstractSuperPropertyGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkSuperPropertyGet_receiver(
    EquivalenceVisitor visitor,
    SuperPropertyGet node,
    SuperPropertyGet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkSuperPropertyGet_name(
    EquivalenceVisitor visitor,
    SuperPropertyGet node,
    SuperPropertyGet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkSuperPropertyGet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    SuperPropertyGet node,
    SuperPropertyGet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkSuperPropertyGet_fileOffset(
    EquivalenceVisitor visitor,
    SuperPropertyGet node,
    SuperPropertyGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkAbstractSuperPropertySet_receiver(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet node,
    AbstractSuperPropertySet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkAbstractSuperPropertySet_name(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet node,
    AbstractSuperPropertySet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkAbstractSuperPropertySet_value(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet node,
    AbstractSuperPropertySet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkAbstractSuperPropertySet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet node,
    AbstractSuperPropertySet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkAbstractSuperPropertySet_fileOffset(
    EquivalenceVisitor visitor,
    AbstractSuperPropertySet node,
    AbstractSuperPropertySet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkSuperPropertySet_receiver(
    EquivalenceVisitor visitor,
    SuperPropertySet node,
    SuperPropertySet other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkSuperPropertySet_name(
    EquivalenceVisitor visitor,
    SuperPropertySet node,
    SuperPropertySet other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkSuperPropertySet_value(
    EquivalenceVisitor visitor,
    SuperPropertySet node,
    SuperPropertySet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkSuperPropertySet_interfaceTargetReference(
    EquivalenceVisitor visitor,
    SuperPropertySet node,
    SuperPropertySet other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkSuperPropertySet_fileOffset(
    EquivalenceVisitor visitor,
    SuperPropertySet node,
    SuperPropertySet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStaticGet_targetReference(
    EquivalenceVisitor visitor,
    StaticGet node,
    StaticGet other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkStaticGet_fileOffset(
    EquivalenceVisitor visitor,
    StaticGet node,
    StaticGet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStaticTearOff_targetReference(
    EquivalenceVisitor visitor,
    StaticTearOff node,
    StaticTearOff other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkStaticTearOff_fileOffset(
    EquivalenceVisitor visitor,
    StaticTearOff node,
    StaticTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStaticSet_targetReference(
    EquivalenceVisitor visitor,
    StaticSet node,
    StaticSet other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkStaticSet_value(
    EquivalenceVisitor visitor,
    StaticSet node,
    StaticSet other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkStaticSet_fileOffset(
    EquivalenceVisitor visitor,
    StaticSet node,
    StaticSet other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkDynamicInvocation_kind(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkDynamicInvocation_receiver(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkDynamicInvocation_name(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkDynamicInvocation_arguments(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkDynamicInvocation_flags(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkInvocationExpression_fileOffset(
    EquivalenceVisitor visitor,
    InvocationExpression node,
    InvocationExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceInvocationExpression_fileOffset(
    EquivalenceVisitor visitor,
    InstanceInvocationExpression node,
    InstanceInvocationExpression other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkDynamicInvocation_fileOffset(
    EquivalenceVisitor visitor,
    DynamicInvocation node,
    DynamicInvocation other,
  ) {
    return checkInstanceInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceInvocation_kind(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkInstanceInvocation_receiver(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkInstanceInvocation_name(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkInstanceInvocation_arguments(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkInstanceInvocation_flags(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkInstanceInvocation_functionType(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkInstanceInvocation_resultType(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkNodes(node.resultType, other.resultType, 'resultType');
  }

  bool checkInstanceInvocation_interfaceTargetReference(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkInstanceInvocation_fileOffset(
    EquivalenceVisitor visitor,
    InstanceInvocation node,
    InstanceInvocation other,
  ) {
    return checkInstanceInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceGetterInvocation_kind(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkInstanceGetterInvocation_receiver(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkInstanceGetterInvocation_name(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkInstanceGetterInvocation_arguments(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkInstanceGetterInvocation_flags(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkInstanceGetterInvocation_functionType(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkInstanceGetterInvocation_interfaceTargetReference(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkInstanceGetterInvocation_fileOffset(
    EquivalenceVisitor visitor,
    InstanceGetterInvocation node,
    InstanceGetterInvocation other,
  ) {
    return checkInstanceInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkFunctionInvocation_kind(
    EquivalenceVisitor visitor,
    FunctionInvocation node,
    FunctionInvocation other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkFunctionInvocation_receiver(
    EquivalenceVisitor visitor,
    FunctionInvocation node,
    FunctionInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkFunctionInvocation_arguments(
    EquivalenceVisitor visitor,
    FunctionInvocation node,
    FunctionInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkFunctionInvocation_functionType(
    EquivalenceVisitor visitor,
    FunctionInvocation node,
    FunctionInvocation other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkFunctionInvocation_fileOffset(
    EquivalenceVisitor visitor,
    FunctionInvocation node,
    FunctionInvocation other,
  ) {
    return checkInstanceInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkLocalFunctionInvocation_variable(
    EquivalenceVisitor visitor,
    LocalFunctionInvocation node,
    LocalFunctionInvocation other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkLocalFunctionInvocation_arguments(
    EquivalenceVisitor visitor,
    LocalFunctionInvocation node,
    LocalFunctionInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkLocalFunctionInvocation_functionType(
    EquivalenceVisitor visitor,
    LocalFunctionInvocation node,
    LocalFunctionInvocation other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkLocalFunctionInvocation_fileOffset(
    EquivalenceVisitor visitor,
    LocalFunctionInvocation node,
    LocalFunctionInvocation other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkAbstractSuperMethodInvocation_receiver(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation node,
    AbstractSuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkAbstractSuperMethodInvocation_name(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation node,
    AbstractSuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkAbstractSuperMethodInvocation_arguments(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation node,
    AbstractSuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkAbstractSuperMethodInvocation_interfaceTargetReference(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation node,
    AbstractSuperMethodInvocation other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkAbstractSuperMethodInvocation_fileOffset(
    EquivalenceVisitor visitor,
    AbstractSuperMethodInvocation node,
    AbstractSuperMethodInvocation other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkSuperMethodInvocation_receiver(
    EquivalenceVisitor visitor,
    SuperMethodInvocation node,
    SuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.receiver, other.receiver, 'receiver');
  }

  bool checkSuperMethodInvocation_name(
    EquivalenceVisitor visitor,
    SuperMethodInvocation node,
    SuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkSuperMethodInvocation_arguments(
    EquivalenceVisitor visitor,
    SuperMethodInvocation node,
    SuperMethodInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkSuperMethodInvocation_interfaceTargetReference(
    EquivalenceVisitor visitor,
    SuperMethodInvocation node,
    SuperMethodInvocation other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkSuperMethodInvocation_fileOffset(
    EquivalenceVisitor visitor,
    SuperMethodInvocation node,
    SuperMethodInvocation other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkStaticInvocation_targetReference(
    EquivalenceVisitor visitor,
    StaticInvocation node,
    StaticInvocation other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkStaticInvocation_arguments(
    EquivalenceVisitor visitor,
    StaticInvocation node,
    StaticInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkStaticInvocation_isConst(
    EquivalenceVisitor visitor,
    StaticInvocation node,
    StaticInvocation other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkStaticInvocation_fileOffset(
    EquivalenceVisitor visitor,
    StaticInvocation node,
    StaticInvocation other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkConstructorInvocation_targetReference(
    EquivalenceVisitor visitor,
    ConstructorInvocation node,
    ConstructorInvocation other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkConstructorInvocation_arguments(
    EquivalenceVisitor visitor,
    ConstructorInvocation node,
    ConstructorInvocation other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkConstructorInvocation_isConst(
    EquivalenceVisitor visitor,
    ConstructorInvocation node,
    ConstructorInvocation other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkConstructorInvocation_fileOffset(
    EquivalenceVisitor visitor,
    ConstructorInvocation node,
    ConstructorInvocation other,
  ) {
    return checkInvocationExpression_fileOffset(visitor, node, other);
  }

  bool checkEqualsNull_expression(
    EquivalenceVisitor visitor,
    EqualsNull node,
    EqualsNull other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkEqualsNull_fileOffset(
    EquivalenceVisitor visitor,
    EqualsNull node,
    EqualsNull other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkEqualsCall_left(
    EquivalenceVisitor visitor,
    EqualsCall node,
    EqualsCall other,
  ) {
    return visitor.checkNodes(node.left, other.left, 'left');
  }

  bool checkEqualsCall_right(
    EquivalenceVisitor visitor,
    EqualsCall node,
    EqualsCall other,
  ) {
    return visitor.checkNodes(node.right, other.right, 'right');
  }

  bool checkEqualsCall_functionType(
    EquivalenceVisitor visitor,
    EqualsCall node,
    EqualsCall other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkEqualsCall_interfaceTargetReference(
    EquivalenceVisitor visitor,
    EqualsCall node,
    EqualsCall other,
  ) {
    return visitor.checkReferences(
      node.interfaceTargetReference,
      other.interfaceTargetReference,
      'interfaceTargetReference',
    );
  }

  bool checkEqualsCall_fileOffset(
    EquivalenceVisitor visitor,
    EqualsCall node,
    EqualsCall other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRedirectingFactoryInvocation_redirectingFactoryTargetReference(
    EquivalenceVisitor visitor,
    RedirectingFactoryInvocation node,
    RedirectingFactoryInvocation other,
  ) {
    return visitor.checkReferences(
      node.redirectingFactoryTargetReference,
      other.redirectingFactoryTargetReference,
      'redirectingFactoryTargetReference',
    );
  }

  bool checkRedirectingFactoryInvocation_expression(
    EquivalenceVisitor visitor,
    RedirectingFactoryInvocation node,
    RedirectingFactoryInvocation other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkRedirectingFactoryInvocation_fileOffset(
    EquivalenceVisitor visitor,
    RedirectingFactoryInvocation node,
    RedirectingFactoryInvocation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstantiation_expression(
    EquivalenceVisitor visitor,
    Instantiation node,
    Instantiation other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkInstantiation_typeArguments(
    EquivalenceVisitor visitor,
    Instantiation node,
    Instantiation other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkInstantiation_fileOffset(
    EquivalenceVisitor visitor,
    Instantiation node,
    Instantiation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkNot_operand(EquivalenceVisitor visitor, Not node, Not other) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  bool checkNot_fileOffset(EquivalenceVisitor visitor, Not node, Not other) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkLogicalExpression_left(
    EquivalenceVisitor visitor,
    LogicalExpression node,
    LogicalExpression other,
  ) {
    return visitor.checkNodes(node.left, other.left, 'left');
  }

  bool checkLogicalExpression_operatorEnum(
    EquivalenceVisitor visitor,
    LogicalExpression node,
    LogicalExpression other,
  ) {
    return visitor.checkValues(
      node.operatorEnum,
      other.operatorEnum,
      'operatorEnum',
    );
  }

  bool checkLogicalExpression_right(
    EquivalenceVisitor visitor,
    LogicalExpression node,
    LogicalExpression other,
  ) {
    return visitor.checkNodes(node.right, other.right, 'right');
  }

  bool checkLogicalExpression_fileOffset(
    EquivalenceVisitor visitor,
    LogicalExpression node,
    LogicalExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkConditionalExpression_condition(
    EquivalenceVisitor visitor,
    ConditionalExpression node,
    ConditionalExpression other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkConditionalExpression_then(
    EquivalenceVisitor visitor,
    ConditionalExpression node,
    ConditionalExpression other,
  ) {
    return visitor.checkNodes(node.then, other.then, 'then');
  }

  bool checkConditionalExpression_otherwise(
    EquivalenceVisitor visitor,
    ConditionalExpression node,
    ConditionalExpression other,
  ) {
    return visitor.checkNodes(node.otherwise, other.otherwise, 'otherwise');
  }

  bool checkConditionalExpression_staticType(
    EquivalenceVisitor visitor,
    ConditionalExpression node,
    ConditionalExpression other,
  ) {
    return visitor.checkNodes(node.staticType, other.staticType, 'staticType');
  }

  bool checkConditionalExpression_fileOffset(
    EquivalenceVisitor visitor,
    ConditionalExpression node,
    ConditionalExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStringConcatenation_expressions(
    EquivalenceVisitor visitor,
    StringConcatenation node,
    StringConcatenation other,
  ) {
    return visitor.checkLists(
      node.expressions,
      other.expressions,
      visitor.checkNodes,
      'expressions',
    );
  }

  bool checkStringConcatenation_fileOffset(
    EquivalenceVisitor visitor,
    StringConcatenation node,
    StringConcatenation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkListConcatenation_typeArgument(
    EquivalenceVisitor visitor,
    ListConcatenation node,
    ListConcatenation other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkListConcatenation_lists(
    EquivalenceVisitor visitor,
    ListConcatenation node,
    ListConcatenation other,
  ) {
    return visitor.checkLists(
      node.lists,
      other.lists,
      visitor.checkNodes,
      'lists',
    );
  }

  bool checkListConcatenation_fileOffset(
    EquivalenceVisitor visitor,
    ListConcatenation node,
    ListConcatenation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkSetConcatenation_typeArgument(
    EquivalenceVisitor visitor,
    SetConcatenation node,
    SetConcatenation other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkSetConcatenation_sets(
    EquivalenceVisitor visitor,
    SetConcatenation node,
    SetConcatenation other,
  ) {
    return visitor.checkLists(
      node.sets,
      other.sets,
      visitor.checkNodes,
      'sets',
    );
  }

  bool checkSetConcatenation_fileOffset(
    EquivalenceVisitor visitor,
    SetConcatenation node,
    SetConcatenation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkMapConcatenation_keyType(
    EquivalenceVisitor visitor,
    MapConcatenation node,
    MapConcatenation other,
  ) {
    return visitor.checkNodes(node.keyType, other.keyType, 'keyType');
  }

  bool checkMapConcatenation_valueType(
    EquivalenceVisitor visitor,
    MapConcatenation node,
    MapConcatenation other,
  ) {
    return visitor.checkNodes(node.valueType, other.valueType, 'valueType');
  }

  bool checkMapConcatenation_maps(
    EquivalenceVisitor visitor,
    MapConcatenation node,
    MapConcatenation other,
  ) {
    return visitor.checkLists(
      node.maps,
      other.maps,
      visitor.checkNodes,
      'maps',
    );
  }

  bool checkMapConcatenation_fileOffset(
    EquivalenceVisitor visitor,
    MapConcatenation node,
    MapConcatenation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkInstanceCreation_classReference(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return visitor.checkReferences(
      node.classReference,
      other.classReference,
      'classReference',
    );
  }

  bool checkInstanceCreation_typeArguments(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkInstanceCreation_fieldValues(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return visitor.checkMaps(
      node.fieldValues,
      other.fieldValues,
      visitor.matchReferences,
      visitor.checkReferences,
      visitor.checkNodes,
      'fieldValues',
    );
  }

  bool checkInstanceCreation_asserts(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return visitor.checkLists(
      node.asserts,
      other.asserts,
      visitor.checkNodes,
      'asserts',
    );
  }

  bool checkInstanceCreation_unusedArguments(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return visitor.checkLists(
      node.unusedArguments,
      other.unusedArguments,
      visitor.checkNodes,
      'unusedArguments',
    );
  }

  bool checkInstanceCreation_fileOffset(
    EquivalenceVisitor visitor,
    InstanceCreation node,
    InstanceCreation other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkFileUriExpression_fileUri(
    EquivalenceVisitor visitor,
    FileUriExpression node,
    FileUriExpression other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkFileUriExpression_expression(
    EquivalenceVisitor visitor,
    FileUriExpression node,
    FileUriExpression other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkFileUriExpression_fileOffset(
    EquivalenceVisitor visitor,
    FileUriExpression node,
    FileUriExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkIsExpression_operand(
    EquivalenceVisitor visitor,
    IsExpression node,
    IsExpression other,
  ) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  bool checkIsExpression_type(
    EquivalenceVisitor visitor,
    IsExpression node,
    IsExpression other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkIsExpression_fileOffset(
    EquivalenceVisitor visitor,
    IsExpression node,
    IsExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkAsExpression_flags(
    EquivalenceVisitor visitor,
    AsExpression node,
    AsExpression other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkAsExpression_operand(
    EquivalenceVisitor visitor,
    AsExpression node,
    AsExpression other,
  ) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  bool checkAsExpression_type(
    EquivalenceVisitor visitor,
    AsExpression node,
    AsExpression other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkAsExpression_fileOffset(
    EquivalenceVisitor visitor,
    AsExpression node,
    AsExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkNullCheck_operand(
    EquivalenceVisitor visitor,
    NullCheck node,
    NullCheck other,
  ) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  bool checkNullCheck_fileOffset(
    EquivalenceVisitor visitor,
    NullCheck node,
    NullCheck other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStringLiteral_value(
    EquivalenceVisitor visitor,
    StringLiteral node,
    StringLiteral other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkBasicLiteral_fileOffset(
    EquivalenceVisitor visitor,
    BasicLiteral node,
    BasicLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkStringLiteral_fileOffset(
    EquivalenceVisitor visitor,
    StringLiteral node,
    StringLiteral other,
  ) {
    return checkBasicLiteral_fileOffset(visitor, node, other);
  }

  bool checkIntLiteral_value(
    EquivalenceVisitor visitor,
    IntLiteral node,
    IntLiteral other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkIntLiteral_fileOffset(
    EquivalenceVisitor visitor,
    IntLiteral node,
    IntLiteral other,
  ) {
    return checkBasicLiteral_fileOffset(visitor, node, other);
  }

  bool checkDoubleLiteral_value(
    EquivalenceVisitor visitor,
    DoubleLiteral node,
    DoubleLiteral other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkDoubleLiteral_fileOffset(
    EquivalenceVisitor visitor,
    DoubleLiteral node,
    DoubleLiteral other,
  ) {
    return checkBasicLiteral_fileOffset(visitor, node, other);
  }

  bool checkBoolLiteral_value(
    EquivalenceVisitor visitor,
    BoolLiteral node,
    BoolLiteral other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkBoolLiteral_fileOffset(
    EquivalenceVisitor visitor,
    BoolLiteral node,
    BoolLiteral other,
  ) {
    return checkBasicLiteral_fileOffset(visitor, node, other);
  }

  bool checkNullLiteral_fileOffset(
    EquivalenceVisitor visitor,
    NullLiteral node,
    NullLiteral other,
  ) {
    return checkBasicLiteral_fileOffset(visitor, node, other);
  }

  bool checkSymbolLiteral_value(
    EquivalenceVisitor visitor,
    SymbolLiteral node,
    SymbolLiteral other,
  ) {
    return visitor.checkValues(node.value, other.value, 'value');
  }

  bool checkSymbolLiteral_fileOffset(
    EquivalenceVisitor visitor,
    SymbolLiteral node,
    SymbolLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkTypeLiteral_type(
    EquivalenceVisitor visitor,
    TypeLiteral node,
    TypeLiteral other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkTypeLiteral_fileOffset(
    EquivalenceVisitor visitor,
    TypeLiteral node,
    TypeLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkThisExpression_fileOffset(
    EquivalenceVisitor visitor,
    ThisExpression node,
    ThisExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRethrow_fileOffset(
    EquivalenceVisitor visitor,
    Rethrow node,
    Rethrow other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkThrow_expression(
    EquivalenceVisitor visitor,
    Throw node,
    Throw other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkThrow_flags(EquivalenceVisitor visitor, Throw node, Throw other) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkThrow_fileOffset(
    EquivalenceVisitor visitor,
    Throw node,
    Throw other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkListLiteral_isConst(
    EquivalenceVisitor visitor,
    ListLiteral node,
    ListLiteral other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkListLiteral_typeArgument(
    EquivalenceVisitor visitor,
    ListLiteral node,
    ListLiteral other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkListLiteral_expressions(
    EquivalenceVisitor visitor,
    ListLiteral node,
    ListLiteral other,
  ) {
    return visitor.checkLists(
      node.expressions,
      other.expressions,
      visitor.checkNodes,
      'expressions',
    );
  }

  bool checkListLiteral_fileOffset(
    EquivalenceVisitor visitor,
    ListLiteral node,
    ListLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkSetLiteral_isConst(
    EquivalenceVisitor visitor,
    SetLiteral node,
    SetLiteral other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkSetLiteral_typeArgument(
    EquivalenceVisitor visitor,
    SetLiteral node,
    SetLiteral other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkSetLiteral_expressions(
    EquivalenceVisitor visitor,
    SetLiteral node,
    SetLiteral other,
  ) {
    return visitor.checkLists(
      node.expressions,
      other.expressions,
      visitor.checkNodes,
      'expressions',
    );
  }

  bool checkSetLiteral_fileOffset(
    EquivalenceVisitor visitor,
    SetLiteral node,
    SetLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkMapLiteral_isConst(
    EquivalenceVisitor visitor,
    MapLiteral node,
    MapLiteral other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkMapLiteral_keyType(
    EquivalenceVisitor visitor,
    MapLiteral node,
    MapLiteral other,
  ) {
    return visitor.checkNodes(node.keyType, other.keyType, 'keyType');
  }

  bool checkMapLiteral_valueType(
    EquivalenceVisitor visitor,
    MapLiteral node,
    MapLiteral other,
  ) {
    return visitor.checkNodes(node.valueType, other.valueType, 'valueType');
  }

  bool checkMapLiteral_entries(
    EquivalenceVisitor visitor,
    MapLiteral node,
    MapLiteral other,
  ) {
    return visitor.checkLists(
      node.entries,
      other.entries,
      visitor.checkNodes,
      'entries',
    );
  }

  bool checkMapLiteral_fileOffset(
    EquivalenceVisitor visitor,
    MapLiteral node,
    MapLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRecordLiteral_isConst(
    EquivalenceVisitor visitor,
    RecordLiteral node,
    RecordLiteral other,
  ) {
    return visitor.checkValues(node.isConst, other.isConst, 'isConst');
  }

  bool checkRecordLiteral_positional(
    EquivalenceVisitor visitor,
    RecordLiteral node,
    RecordLiteral other,
  ) {
    return visitor.checkLists(
      node.positional,
      other.positional,
      visitor.checkNodes,
      'positional',
    );
  }

  bool checkRecordLiteral_named(
    EquivalenceVisitor visitor,
    RecordLiteral node,
    RecordLiteral other,
  ) {
    return visitor.checkLists(
      node.named,
      other.named,
      visitor.checkNodes,
      'named',
    );
  }

  bool checkRecordLiteral_recordType(
    EquivalenceVisitor visitor,
    RecordLiteral node,
    RecordLiteral other,
  ) {
    return visitor.checkNodes(node.recordType, other.recordType, 'recordType');
  }

  bool checkRecordLiteral_fileOffset(
    EquivalenceVisitor visitor,
    RecordLiteral node,
    RecordLiteral other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkAwaitExpression_operand(
    EquivalenceVisitor visitor,
    AwaitExpression node,
    AwaitExpression other,
  ) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  bool checkAwaitExpression_runtimeCheckType(
    EquivalenceVisitor visitor,
    AwaitExpression node,
    AwaitExpression other,
  ) {
    return visitor.checkNodes(
      node.runtimeCheckType,
      other.runtimeCheckType,
      'runtimeCheckType',
    );
  }

  bool checkAwaitExpression_fileOffset(
    EquivalenceVisitor visitor,
    AwaitExpression node,
    AwaitExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkFunctionExpression_function(
    EquivalenceVisitor visitor,
    FunctionExpression node,
    FunctionExpression other,
  ) {
    return visitor.checkNodes(node.function, other.function, 'function');
  }

  bool checkFunctionExpression_fileOffset(
    EquivalenceVisitor visitor,
    FunctionExpression node,
    FunctionExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkConstantExpression_constant(
    EquivalenceVisitor visitor,
    ConstantExpression node,
    ConstantExpression other,
  ) {
    return visitor.checkNodes(node.constant, other.constant, 'constant');
  }

  bool checkConstantExpression_type(
    EquivalenceVisitor visitor,
    ConstantExpression node,
    ConstantExpression other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkConstantExpression_fileOffset(
    EquivalenceVisitor visitor,
    ConstantExpression node,
    ConstantExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkLet_variable(EquivalenceVisitor visitor, Let node, Let other) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkLet_body(EquivalenceVisitor visitor, Let node, Let other) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkLet_fileOffset(EquivalenceVisitor visitor, Let node, Let other) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkBlockExpression_body(
    EquivalenceVisitor visitor,
    BlockExpression node,
    BlockExpression other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkBlockExpression_value(
    EquivalenceVisitor visitor,
    BlockExpression node,
    BlockExpression other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkBlockExpression_scope(
    EquivalenceVisitor visitor,
    BlockExpression node,
    BlockExpression other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkBlockExpression_fileOffset(
    EquivalenceVisitor visitor,
    BlockExpression node,
    BlockExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkLoadLibrary_import(
    EquivalenceVisitor visitor,
    LoadLibrary node,
    LoadLibrary other,
  ) {
    return visitor.checkNodes(node.import, other.import, 'import');
  }

  bool checkLoadLibrary_fileOffset(
    EquivalenceVisitor visitor,
    LoadLibrary node,
    LoadLibrary other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkCheckLibraryIsLoaded_import(
    EquivalenceVisitor visitor,
    CheckLibraryIsLoaded node,
    CheckLibraryIsLoaded other,
  ) {
    return visitor.checkNodes(node.import, other.import, 'import');
  }

  bool checkCheckLibraryIsLoaded_fileOffset(
    EquivalenceVisitor visitor,
    CheckLibraryIsLoaded node,
    CheckLibraryIsLoaded other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkConstructorTearOff_targetReference(
    EquivalenceVisitor visitor,
    ConstructorTearOff node,
    ConstructorTearOff other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkConstructorTearOff_fileOffset(
    EquivalenceVisitor visitor,
    ConstructorTearOff node,
    ConstructorTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkRedirectingFactoryTearOff_targetReference(
    EquivalenceVisitor visitor,
    RedirectingFactoryTearOff node,
    RedirectingFactoryTearOff other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkRedirectingFactoryTearOff_fileOffset(
    EquivalenceVisitor visitor,
    RedirectingFactoryTearOff node,
    RedirectingFactoryTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkTypedefTearOff_structuralParameters(
    EquivalenceVisitor visitor,
    TypedefTearOff node,
    TypedefTearOff other,
  ) {
    return visitor.checkLists(
      node.structuralParameters,
      other.structuralParameters,
      visitor.checkNodes,
      'structuralParameters',
    );
  }

  bool checkTypedefTearOff_expression(
    EquivalenceVisitor visitor,
    TypedefTearOff node,
    TypedefTearOff other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkTypedefTearOff_typeArguments(
    EquivalenceVisitor visitor,
    TypedefTearOff node,
    TypedefTearOff other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkTypedefTearOff_fileOffset(
    EquivalenceVisitor visitor,
    TypedefTearOff node,
    TypedefTearOff other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkSwitchExpression_expression(
    EquivalenceVisitor visitor,
    SwitchExpression node,
    SwitchExpression other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkSwitchExpression_cases(
    EquivalenceVisitor visitor,
    SwitchExpression node,
    SwitchExpression other,
  ) {
    return visitor.checkLists(
      node.cases,
      other.cases,
      visitor.checkNodes,
      'cases',
    );
  }

  bool checkSwitchExpression_expressionType(
    EquivalenceVisitor visitor,
    SwitchExpression node,
    SwitchExpression other,
  ) {
    return visitor.checkNodes(
      node.expressionType,
      other.expressionType,
      'expressionType',
    );
  }

  bool checkSwitchExpression_staticType(
    EquivalenceVisitor visitor,
    SwitchExpression node,
    SwitchExpression other,
  ) {
    return visitor.checkNodes(node.staticType, other.staticType, 'staticType');
  }

  bool checkSwitchExpression_fileOffset(
    EquivalenceVisitor visitor,
    SwitchExpression node,
    SwitchExpression other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkPatternAssignment_pattern(
    EquivalenceVisitor visitor,
    PatternAssignment node,
    PatternAssignment other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkPatternAssignment_expression(
    EquivalenceVisitor visitor,
    PatternAssignment node,
    PatternAssignment other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkPatternAssignment_matchedValueType(
    EquivalenceVisitor visitor,
    PatternAssignment node,
    PatternAssignment other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkPatternAssignment_fileOffset(
    EquivalenceVisitor visitor,
    PatternAssignment node,
    PatternAssignment other,
  ) {
    return checkExpression_fileOffset(visitor, node, other);
  }

  bool checkArguments_types(
    EquivalenceVisitor visitor,
    Arguments node,
    Arguments other,
  ) {
    return visitor.checkLists(
      node.types,
      other.types,
      visitor.checkNodes,
      'types',
    );
  }

  bool checkArguments_positional(
    EquivalenceVisitor visitor,
    Arguments node,
    Arguments other,
  ) {
    return visitor.checkLists(
      node.positional,
      other.positional,
      visitor.checkNodes,
      'positional',
    );
  }

  bool checkArguments_named(
    EquivalenceVisitor visitor,
    Arguments node,
    Arguments other,
  ) {
    return visitor.checkLists(
      node.named,
      other.named,
      visitor.checkNodes,
      'named',
    );
  }

  bool checkArguments_fileOffset(
    EquivalenceVisitor visitor,
    Arguments node,
    Arguments other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkNamedExpression_name(
    EquivalenceVisitor visitor,
    NamedExpression node,
    NamedExpression other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkNamedExpression_value(
    EquivalenceVisitor visitor,
    NamedExpression node,
    NamedExpression other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkNamedExpression_fileOffset(
    EquivalenceVisitor visitor,
    NamedExpression node,
    NamedExpression other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkMapLiteralEntry_key(
    EquivalenceVisitor visitor,
    MapLiteralEntry node,
    MapLiteralEntry other,
  ) {
    return visitor.checkNodes(node.key, other.key, 'key');
  }

  bool checkMapLiteralEntry_value(
    EquivalenceVisitor visitor,
    MapLiteralEntry node,
    MapLiteralEntry other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkMapLiteralEntry_fileOffset(
    EquivalenceVisitor visitor,
    MapLiteralEntry node,
    MapLiteralEntry other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkFunctionNode_fileEndOffset(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkValues(
      node.fileEndOffset,
      other.fileEndOffset,
      'fileEndOffset',
    );
  }

  bool checkFunctionNode_asyncMarker(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkValues(
      node.asyncMarker,
      other.asyncMarker,
      'asyncMarker',
    );
  }

  bool checkFunctionNode_dartAsyncMarker(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkValues(
      node.dartAsyncMarker,
      other.dartAsyncMarker,
      'dartAsyncMarker',
    );
  }

  bool checkFunctionNode_typeParameters(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkFunctionNode_requiredParameterCount(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkValues(
      node.requiredParameterCount,
      other.requiredParameterCount,
      'requiredParameterCount',
    );
  }

  bool checkFunctionNode_positionalParameters(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkLists(
      node.positionalParameters,
      other.positionalParameters,
      visitor.checkNodes,
      'positionalParameters',
    );
  }

  bool checkFunctionNode_namedParameters(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkLists(
      node.namedParameters,
      other.namedParameters,
      visitor.checkNodes,
      'namedParameters',
    );
  }

  bool checkFunctionNode_thisVariable(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkNodes(
      node.thisVariable,
      other.thisVariable,
      'thisVariable',
    );
  }

  bool checkFunctionNode_returnType(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkNodes(node.returnType, other.returnType, 'returnType');
  }

  bool checkFunctionNode_body(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkFunctionNode_scope(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkFunctionNode_capturedContexts(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkLists(node.capturedContexts, other.capturedContexts, (
      a,
      b,
      _,
    ) {
      if (identical(a, b)) return true;
      return checkVariableContext(visitor, a, b);
    }, 'capturedContexts');
  }

  bool checkFunctionNode_emittedValueType(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkNodes(
      node.emittedValueType,
      other.emittedValueType,
      'emittedValueType',
    );
  }

  bool checkRedirectingFactoryTarget_targetReference(
    EquivalenceVisitor visitor,
    RedirectingFactoryTarget node,
    RedirectingFactoryTarget other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkRedirectingFactoryTarget_typeArguments(
    EquivalenceVisitor visitor,
    RedirectingFactoryTarget node,
    RedirectingFactoryTarget other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkRedirectingFactoryTarget_errorMessage(
    EquivalenceVisitor visitor,
    RedirectingFactoryTarget node,
    RedirectingFactoryTarget other,
  ) {
    return visitor.checkValues(
      node.errorMessage,
      other.errorMessage,
      'errorMessage',
    );
  }

  bool checkFunctionNode_redirectingFactoryTarget(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    'redirectingFactoryTarget';
    return checkRedirectingFactoryTarget(
      visitor,
      node.redirectingFactoryTarget,
      other.redirectingFactoryTarget,
    );
  }

  bool checkFunctionNode_lazyBuilder(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return visitor.checkValues(
      node.lazyBuilder,
      other.lazyBuilder,
      'lazyBuilder',
    );
  }

  bool checkFunctionNode_fileOffset(
    EquivalenceVisitor visitor,
    FunctionNode node,
    FunctionNode other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkInitializer_fileOffset(
    EquivalenceVisitor visitor,
    Initializer node,
    Initializer other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkAuxiliaryInitializer_fileOffset(
    EquivalenceVisitor visitor,
    AuxiliaryInitializer node,
    AuxiliaryInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkInvalidInitializer_message(
    EquivalenceVisitor visitor,
    InvalidInitializer node,
    InvalidInitializer other,
  ) {
    return visitor.checkValues(node.message, other.message, 'message');
  }

  bool checkInvalidInitializer_flags(
    EquivalenceVisitor visitor,
    InvalidInitializer node,
    InvalidInitializer other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkInvalidInitializer_fileOffset(
    EquivalenceVisitor visitor,
    InvalidInitializer node,
    InvalidInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkFieldInitializer_fieldReference(
    EquivalenceVisitor visitor,
    FieldInitializer node,
    FieldInitializer other,
  ) {
    return visitor.checkReferences(
      node.fieldReference,
      other.fieldReference,
      'fieldReference',
    );
  }

  bool checkFieldInitializer_value(
    EquivalenceVisitor visitor,
    FieldInitializer node,
    FieldInitializer other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkFieldInitializer_isSynthetic(
    EquivalenceVisitor visitor,
    FieldInitializer node,
    FieldInitializer other,
  ) {
    return visitor.checkValues(
      node.isSynthetic,
      other.isSynthetic,
      'isSynthetic',
    );
  }

  bool checkFieldInitializer_fileOffset(
    EquivalenceVisitor visitor,
    FieldInitializer node,
    FieldInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkSuperInitializer_targetReference(
    EquivalenceVisitor visitor,
    SuperInitializer node,
    SuperInitializer other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkSuperInitializer_arguments(
    EquivalenceVisitor visitor,
    SuperInitializer node,
    SuperInitializer other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkSuperInitializer_isSynthetic(
    EquivalenceVisitor visitor,
    SuperInitializer node,
    SuperInitializer other,
  ) {
    return visitor.checkValues(
      node.isSynthetic,
      other.isSynthetic,
      'isSynthetic',
    );
  }

  bool checkSuperInitializer_fileOffset(
    EquivalenceVisitor visitor,
    SuperInitializer node,
    SuperInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkRedirectingInitializer_targetReference(
    EquivalenceVisitor visitor,
    RedirectingInitializer node,
    RedirectingInitializer other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkRedirectingInitializer_arguments(
    EquivalenceVisitor visitor,
    RedirectingInitializer node,
    RedirectingInitializer other,
  ) {
    return visitor.checkNodes(node.arguments, other.arguments, 'arguments');
  }

  bool checkRedirectingInitializer_fileOffset(
    EquivalenceVisitor visitor,
    RedirectingInitializer node,
    RedirectingInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkLocalInitializer_variable(
    EquivalenceVisitor visitor,
    LocalInitializer node,
    LocalInitializer other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkLocalInitializer_fileOffset(
    EquivalenceVisitor visitor,
    LocalInitializer node,
    LocalInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkAssertInitializer_statement(
    EquivalenceVisitor visitor,
    AssertInitializer node,
    AssertInitializer other,
  ) {
    return visitor.checkNodes(node.statement, other.statement, 'statement');
  }

  bool checkAssertInitializer_fileOffset(
    EquivalenceVisitor visitor,
    AssertInitializer node,
    AssertInitializer other,
  ) {
    return checkInitializer_fileOffset(visitor, node, other);
  }

  bool checkLibraryDependency_flags(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkLibraryDependency_annotations(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLibraryDependency_importedLibraryReference(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return visitor.checkReferences(
      node.importedLibraryReference,
      other.importedLibraryReference,
      'importedLibraryReference',
    );
  }

  bool checkLibraryDependency_name(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkLibraryDependency_combinators(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return visitor.checkLists(
      node.combinators,
      other.combinators,
      visitor.checkNodes,
      'combinators',
    );
  }

  bool checkLibraryDependency_fileOffset(
    EquivalenceVisitor visitor,
    LibraryDependency node,
    LibraryDependency other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkLibraryPart_annotations(
    EquivalenceVisitor visitor,
    LibraryPart node,
    LibraryPart other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLibraryPart_partUri(
    EquivalenceVisitor visitor,
    LibraryPart node,
    LibraryPart other,
  ) {
    return visitor.checkValues(node.partUri, other.partUri, 'partUri');
  }

  bool checkLibraryPart_fileUri(
    EquivalenceVisitor visitor,
    LibraryPart node,
    LibraryPart other,
  ) {
    return visitor.checkValues(node.fileUri, other.fileUri, 'fileUri');
  }

  bool checkLibraryPart_fileOffset(
    EquivalenceVisitor visitor,
    LibraryPart node,
    LibraryPart other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkCombinator_isShow(
    EquivalenceVisitor visitor,
    Combinator node,
    Combinator other,
  ) {
    return visitor.checkValues(node.isShow, other.isShow, 'isShow');
  }

  bool checkCombinator_names(
    EquivalenceVisitor visitor,
    Combinator node,
    Combinator other,
  ) {
    return visitor.checkLists(
      node.names,
      other.names,
      visitor.checkValues,
      'names',
    );
  }

  bool checkCombinator_fileOffset(
    EquivalenceVisitor visitor,
    Combinator node,
    Combinator other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkConstantPattern_expression(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkConstantPattern_expressionType(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return visitor.checkNodes(
      node.expressionType,
      other.expressionType,
      'expressionType',
    );
  }

  bool checkConstantPattern_equalsTargetReference(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return visitor.checkReferences(
      node.equalsTargetReference,
      other.equalsTargetReference,
      'equalsTargetReference',
    );
  }

  bool checkConstantPattern_equalsType(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return visitor.checkNodes(node.equalsType, other.equalsType, 'equalsType');
  }

  bool checkConstantPattern_value(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkPattern_fileOffset(
    EquivalenceVisitor visitor,
    Pattern node,
    Pattern other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkConstantPattern_fileOffset(
    EquivalenceVisitor visitor,
    ConstantPattern node,
    ConstantPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkAndPattern_left(
    EquivalenceVisitor visitor,
    AndPattern node,
    AndPattern other,
  ) {
    return visitor.checkNodes(node.left, other.left, 'left');
  }

  bool checkAndPattern_right(
    EquivalenceVisitor visitor,
    AndPattern node,
    AndPattern other,
  ) {
    return visitor.checkNodes(node.right, other.right, 'right');
  }

  bool checkAndPattern_fileOffset(
    EquivalenceVisitor visitor,
    AndPattern node,
    AndPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkOrPattern_left(
    EquivalenceVisitor visitor,
    OrPattern node,
    OrPattern other,
  ) {
    return visitor.checkNodes(node.left, other.left, 'left');
  }

  bool checkOrPattern_right(
    EquivalenceVisitor visitor,
    OrPattern node,
    OrPattern other,
  ) {
    return visitor.checkNodes(node.right, other.right, 'right');
  }

  bool checkOrPattern_orPatternJointVariables(
    EquivalenceVisitor visitor,
    OrPattern node,
    OrPattern other,
  ) {
    return visitor.checkLists(
      node.orPatternJointVariables,
      other.orPatternJointVariables,
      visitor.checkNodes,
      'orPatternJointVariables',
    );
  }

  bool checkOrPattern_fileOffset(
    EquivalenceVisitor visitor,
    OrPattern node,
    OrPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkCastPattern_pattern(
    EquivalenceVisitor visitor,
    CastPattern node,
    CastPattern other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkCastPattern_type(
    EquivalenceVisitor visitor,
    CastPattern node,
    CastPattern other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkCastPattern_fileOffset(
    EquivalenceVisitor visitor,
    CastPattern node,
    CastPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkNullAssertPattern_pattern(
    EquivalenceVisitor visitor,
    NullAssertPattern node,
    NullAssertPattern other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkNullAssertPattern_fileOffset(
    EquivalenceVisitor visitor,
    NullAssertPattern node,
    NullAssertPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkNullCheckPattern_pattern(
    EquivalenceVisitor visitor,
    NullCheckPattern node,
    NullCheckPattern other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkNullCheckPattern_fileOffset(
    EquivalenceVisitor visitor,
    NullCheckPattern node,
    NullCheckPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkListPattern_flags(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkListPattern_typeArgument(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkListPattern_patterns(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkLists(
      node.patterns,
      other.patterns,
      visitor.checkNodes,
      'patterns',
    );
  }

  bool checkListPattern_requiredType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.requiredType,
      other.requiredType,
      'requiredType',
    );
  }

  bool checkListPattern_matchedValueType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkListPattern_lookupType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(node.lookupType, other.lookupType, 'lookupType');
  }

  bool checkListPattern_lengthTargetReference(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkReferences(
      node.lengthTargetReference,
      other.lengthTargetReference,
      'lengthTargetReference',
    );
  }

  bool checkListPattern_lengthType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(node.lengthType, other.lengthType, 'lengthType');
  }

  bool checkListPattern_lengthCheckTargetReference(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkReferences(
      node.lengthCheckTargetReference,
      other.lengthCheckTargetReference,
      'lengthCheckTargetReference',
    );
  }

  bool checkListPattern_lengthCheckType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.lengthCheckType,
      other.lengthCheckType,
      'lengthCheckType',
    );
  }

  bool checkListPattern_sublistTargetReference(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkReferences(
      node.sublistTargetReference,
      other.sublistTargetReference,
      'sublistTargetReference',
    );
  }

  bool checkListPattern_sublistType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.sublistType,
      other.sublistType,
      'sublistType',
    );
  }

  bool checkListPattern_minusTargetReference(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkReferences(
      node.minusTargetReference,
      other.minusTargetReference,
      'minusTargetReference',
    );
  }

  bool checkListPattern_minusType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(node.minusType, other.minusType, 'minusType');
  }

  bool checkListPattern_indexGetTargetReference(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkReferences(
      node.indexGetTargetReference,
      other.indexGetTargetReference,
      'indexGetTargetReference',
    );
  }

  bool checkListPattern_indexGetType(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return visitor.checkNodes(
      node.indexGetType,
      other.indexGetType,
      'indexGetType',
    );
  }

  bool checkListPattern_fileOffset(
    EquivalenceVisitor visitor,
    ListPattern node,
    ListPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkObjectPattern_requiredType(
    EquivalenceVisitor visitor,
    ObjectPattern node,
    ObjectPattern other,
  ) {
    return visitor.checkNodes(
      node.requiredType,
      other.requiredType,
      'requiredType',
    );
  }

  bool checkObjectPattern_fields(
    EquivalenceVisitor visitor,
    ObjectPattern node,
    ObjectPattern other,
  ) {
    return visitor.checkLists(
      node.fields,
      other.fields,
      visitor.checkNodes,
      'fields',
    );
  }

  bool checkObjectPattern_matchedValueType(
    EquivalenceVisitor visitor,
    ObjectPattern node,
    ObjectPattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkObjectPattern_needsCheck(
    EquivalenceVisitor visitor,
    ObjectPattern node,
    ObjectPattern other,
  ) {
    return visitor.checkValues(node.needsCheck, other.needsCheck, 'needsCheck');
  }

  bool checkObjectPattern_fileOffset(
    EquivalenceVisitor visitor,
    ObjectPattern node,
    ObjectPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkRelationalPattern_kind(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkValues(node.kind, other.kind, 'kind');
  }

  bool checkRelationalPattern_expression(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkRelationalPattern_expressionType(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(
      node.expressionType,
      other.expressionType,
      'expressionType',
    );
  }

  bool checkRelationalPattern_matchedValueType(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkRelationalPattern_accessKind(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkValues(node.accessKind, other.accessKind, 'accessKind');
  }

  bool checkRelationalPattern_name(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(node.name, other.name, 'name');
  }

  bool checkRelationalPattern_targetReference(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkRelationalPattern_typeArguments(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkRelationalPattern_functionType(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(
      node.functionType,
      other.functionType,
      'functionType',
    );
  }

  bool checkRelationalPattern_expressionValue(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return visitor.checkNodes(
      node.expressionValue,
      other.expressionValue,
      'expressionValue',
    );
  }

  bool checkRelationalPattern_fileOffset(
    EquivalenceVisitor visitor,
    RelationalPattern node,
    RelationalPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkWildcardPattern_type(
    EquivalenceVisitor visitor,
    WildcardPattern node,
    WildcardPattern other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkWildcardPattern_fileOffset(
    EquivalenceVisitor visitor,
    WildcardPattern node,
    WildcardPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkAssignedVariablePattern_variableName(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkValues(
      node.variableName,
      other.variableName,
      'variableName',
    );
  }

  bool checkAssignedVariablePattern_variableType(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkNodes(
      node.variableType,
      other.variableType,
      'variableType',
    );
  }

  bool checkAssignedVariablePattern_writeVariable(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkNodes(
      node.writeVariable,
      other.writeVariable,
      'writeVariable',
    );
  }

  bool checkAssignedVariablePattern_matchedValueType(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkAssignedVariablePattern_needsCast(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkValues(node.needsCast, other.needsCast, 'needsCast');
  }

  bool checkAssignedVariablePattern_hasObservableEffect(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return visitor.checkValues(
      node.hasObservableEffect,
      other.hasObservableEffect,
      'hasObservableEffect',
    );
  }

  bool checkAssignedVariablePattern_fileOffset(
    EquivalenceVisitor visitor,
    AssignedVariablePattern node,
    AssignedVariablePattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkMapPattern_flags(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkMapPattern_keyType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(node.keyType, other.keyType, 'keyType');
  }

  bool checkMapPattern_valueType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(node.valueType, other.valueType, 'valueType');
  }

  bool checkMapPattern_entries(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkLists(
      node.entries,
      other.entries,
      visitor.checkNodes,
      'entries',
    );
  }

  bool checkMapPattern_requiredType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(
      node.requiredType,
      other.requiredType,
      'requiredType',
    );
  }

  bool checkMapPattern_matchedValueType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkMapPattern_lookupType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(node.lookupType, other.lookupType, 'lookupType');
  }

  bool checkMapPattern_containsKeyTargetReference(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkReferences(
      node.containsKeyTargetReference,
      other.containsKeyTargetReference,
      'containsKeyTargetReference',
    );
  }

  bool checkMapPattern_containsKeyType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(
      node.containsKeyType,
      other.containsKeyType,
      'containsKeyType',
    );
  }

  bool checkMapPattern_indexGetTargetReference(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkReferences(
      node.indexGetTargetReference,
      other.indexGetTargetReference,
      'indexGetTargetReference',
    );
  }

  bool checkMapPattern_indexGetType(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return visitor.checkNodes(
      node.indexGetType,
      other.indexGetType,
      'indexGetType',
    );
  }

  bool checkMapPattern_fileOffset(
    EquivalenceVisitor visitor,
    MapPattern node,
    MapPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkNamedPattern_name(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkNamedPattern_pattern(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkNamedPattern_fieldName(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkNodes(node.fieldName, other.fieldName, 'fieldName');
  }

  bool checkNamedPattern_accessKind(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkValues(node.accessKind, other.accessKind, 'accessKind');
  }

  bool checkNamedPattern_targetReference(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkReferences(
      node.targetReference,
      other.targetReference,
      'targetReference',
    );
  }

  bool checkNamedPattern_resultType(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkNodes(node.resultType, other.resultType, 'resultType');
  }

  bool checkNamedPattern_checkReturn(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkValues(
      node.checkReturn,
      other.checkReturn,
      'checkReturn',
    );
  }

  bool checkNamedPattern_recordType(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkNodes(node.recordType, other.recordType, 'recordType');
  }

  bool checkNamedPattern_recordFieldIndex(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkValues(
      node.recordFieldIndex,
      other.recordFieldIndex,
      'recordFieldIndex',
    );
  }

  bool checkNamedPattern_typeArguments(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkNamedPattern_fileOffset(
    EquivalenceVisitor visitor,
    NamedPattern node,
    NamedPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkRecordPattern_patterns(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return visitor.checkLists(
      node.patterns,
      other.patterns,
      visitor.checkNodes,
      'patterns',
    );
  }

  bool checkRecordPattern_requiredType(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return visitor.checkNodes(
      node.requiredType,
      other.requiredType,
      'requiredType',
    );
  }

  bool checkRecordPattern_matchedValueType(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkRecordPattern_needsCheck(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return visitor.checkValues(node.needsCheck, other.needsCheck, 'needsCheck');
  }

  bool checkRecordPattern_lookupType(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return visitor.checkNodes(node.lookupType, other.lookupType, 'lookupType');
  }

  bool checkRecordPattern_fileOffset(
    EquivalenceVisitor visitor,
    RecordPattern node,
    RecordPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkVariablePattern_type(
    EquivalenceVisitor visitor,
    VariablePattern node,
    VariablePattern other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkVariablePattern_variable(
    EquivalenceVisitor visitor,
    VariablePattern node,
    VariablePattern other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkVariablePattern_matchedValueType(
    EquivalenceVisitor visitor,
    VariablePattern node,
    VariablePattern other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkVariablePattern_fileOffset(
    EquivalenceVisitor visitor,
    VariablePattern node,
    VariablePattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkRestPattern_subPattern(
    EquivalenceVisitor visitor,
    RestPattern node,
    RestPattern other,
  ) {
    return visitor.checkNodes(node.subPattern, other.subPattern, 'subPattern');
  }

  bool checkRestPattern_fileOffset(
    EquivalenceVisitor visitor,
    RestPattern node,
    RestPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkInvalidPattern_invalidExpression(
    EquivalenceVisitor visitor,
    InvalidPattern node,
    InvalidPattern other,
  ) {
    return visitor.checkNodes(
      node.invalidExpression,
      other.invalidExpression,
      'invalidExpression',
    );
  }

  bool checkInvalidPattern_declaredVariables(
    EquivalenceVisitor visitor,
    InvalidPattern node,
    InvalidPattern other,
  ) {
    return visitor.checkLists(
      node.declaredVariables,
      other.declaredVariables,
      visitor.checkNodes,
      'declaredVariables',
    );
  }

  bool checkInvalidPattern_fileOffset(
    EquivalenceVisitor visitor,
    InvalidPattern node,
    InvalidPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkAuxiliaryPattern_fileOffset(
    EquivalenceVisitor visitor,
    AuxiliaryPattern node,
    AuxiliaryPattern other,
  ) {
    return checkPattern_fileOffset(visitor, node, other);
  }

  bool checkMapPatternEntry_key(
    EquivalenceVisitor visitor,
    MapPatternEntry node,
    MapPatternEntry other,
  ) {
    return visitor.checkNodes(node.key, other.key, 'key');
  }

  bool checkMapPatternEntry_value(
    EquivalenceVisitor visitor,
    MapPatternEntry node,
    MapPatternEntry other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkMapPatternEntry_keyType(
    EquivalenceVisitor visitor,
    MapPatternEntry node,
    MapPatternEntry other,
  ) {
    return visitor.checkNodes(node.keyType, other.keyType, 'keyType');
  }

  bool checkMapPatternEntry_keyValue(
    EquivalenceVisitor visitor,
    MapPatternEntry node,
    MapPatternEntry other,
  ) {
    return visitor.checkNodes(node.keyValue, other.keyValue, 'keyValue');
  }

  bool checkMapPatternEntry_fileOffset(
    EquivalenceVisitor visitor,
    MapPatternEntry node,
    MapPatternEntry other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkMapPatternRestEntry_fileOffset(
    EquivalenceVisitor visitor,
    MapPatternRestEntry node,
    MapPatternRestEntry other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkPatternGuard_pattern(
    EquivalenceVisitor visitor,
    PatternGuard node,
    PatternGuard other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkPatternGuard_guard(
    EquivalenceVisitor visitor,
    PatternGuard node,
    PatternGuard other,
  ) {
    return visitor.checkNodes(node.guard, other.guard, 'guard');
  }

  bool checkPatternGuard_fileOffset(
    EquivalenceVisitor visitor,
    PatternGuard node,
    PatternGuard other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkPatternSwitchCase_caseOffsets(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkLists(
      node.caseOffsets,
      other.caseOffsets,
      visitor.checkValues,
      'caseOffsets',
    );
  }

  bool checkPatternSwitchCase_patternGuards(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkLists(
      node.patternGuards,
      other.patternGuards,
      visitor.checkNodes,
      'patternGuards',
    );
  }

  bool checkPatternSwitchCase_labelUsers(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkLists(
      node.labelUsers,
      other.labelUsers,
      visitor.checkNodes,
      'labelUsers',
    );
  }

  bool checkPatternSwitchCase_body(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkPatternSwitchCase_isDefault(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkValues(node.isDefault, other.isDefault, 'isDefault');
  }

  bool checkPatternSwitchCase_hasLabel(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkValues(node.hasLabel, other.hasLabel, 'hasLabel');
  }

  bool checkPatternSwitchCase_jointVariableDeclarations(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkLists(
      node.jointVariableDeclarations,
      other.jointVariableDeclarations,
      visitor.checkNodes,
      'jointVariableDeclarations',
    );
  }

  bool checkPatternSwitchCase_jointVariableFirstUseOffsets(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return visitor.checkLists(
      node.jointVariableFirstUseOffsets,
      other.jointVariableFirstUseOffsets,
      visitor.checkValues,
      'jointVariableFirstUseOffsets',
    );
  }

  bool checkPatternSwitchCase_jointVariableScope(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    'jointVariableScope';
    return checkScope(
      visitor,
      node.jointVariableScope,
      other.jointVariableScope,
    );
  }

  bool checkPatternSwitchCase_scope(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkPatternSwitchCase_fileOffset(
    EquivalenceVisitor visitor,
    PatternSwitchCase node,
    PatternSwitchCase other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkSwitchCase_expressions(
    EquivalenceVisitor visitor,
    SwitchCase node,
    SwitchCase other,
  ) {
    return visitor.checkLists(
      node.expressions,
      other.expressions,
      visitor.checkNodes,
      'expressions',
    );
  }

  bool checkSwitchCase_expressionOffsets(
    EquivalenceVisitor visitor,
    SwitchCase node,
    SwitchCase other,
  ) {
    return visitor.checkLists(
      node.expressionOffsets,
      other.expressionOffsets,
      visitor.checkValues,
      'expressionOffsets',
    );
  }

  bool checkSwitchCase_body(
    EquivalenceVisitor visitor,
    SwitchCase node,
    SwitchCase other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkSwitchCase_isDefault(
    EquivalenceVisitor visitor,
    SwitchCase node,
    SwitchCase other,
  ) {
    return visitor.checkValues(node.isDefault, other.isDefault, 'isDefault');
  }

  bool checkSwitchCase_fileOffset(
    EquivalenceVisitor visitor,
    SwitchCase node,
    SwitchCase other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkPatternSwitchStatement_expression(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkPatternSwitchStatement_cases(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return visitor.checkLists(
      node.cases,
      other.cases,
      visitor.checkNodes,
      'cases',
    );
  }

  bool checkPatternSwitchStatement_expressionTypeInternal(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return visitor.checkNodes(
      node.expressionTypeInternal,
      other.expressionTypeInternal,
      'expressionTypeInternal',
    );
  }

  bool checkPatternSwitchStatement_lastCaseTerminates(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return visitor.checkValues(
      node.lastCaseTerminates,
      other.lastCaseTerminates,
      'lastCaseTerminates',
    );
  }

  bool checkPatternSwitchStatement_isExplicitlyExhaustive(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return visitor.checkValues(
      node.isExplicitlyExhaustive,
      other.isExplicitlyExhaustive,
      'isExplicitlyExhaustive',
    );
  }

  bool checkStatement_fileOffset(
    EquivalenceVisitor visitor,
    Statement node,
    Statement other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkPatternSwitchStatement_fileOffset(
    EquivalenceVisitor visitor,
    PatternSwitchStatement node,
    PatternSwitchStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkSwitchStatement_expression(
    EquivalenceVisitor visitor,
    SwitchStatement node,
    SwitchStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkSwitchStatement_cases(
    EquivalenceVisitor visitor,
    SwitchStatement node,
    SwitchStatement other,
  ) {
    return visitor.checkLists(
      node.cases,
      other.cases,
      visitor.checkNodes,
      'cases',
    );
  }

  bool checkSwitchStatement_isExplicitlyExhaustive(
    EquivalenceVisitor visitor,
    SwitchStatement node,
    SwitchStatement other,
  ) {
    return visitor.checkValues(
      node.isExplicitlyExhaustive,
      other.isExplicitlyExhaustive,
      'isExplicitlyExhaustive',
    );
  }

  bool checkSwitchStatement_expressionTypeInternal(
    EquivalenceVisitor visitor,
    SwitchStatement node,
    SwitchStatement other,
  ) {
    return visitor.checkNodes(
      node.expressionTypeInternal,
      other.expressionTypeInternal,
      'expressionTypeInternal',
    );
  }

  bool checkSwitchStatement_fileOffset(
    EquivalenceVisitor visitor,
    SwitchStatement node,
    SwitchStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkPatternVariableDeclaration_pattern(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration node,
    PatternVariableDeclaration other,
  ) {
    return visitor.checkNodes(node.pattern, other.pattern, 'pattern');
  }

  bool checkPatternVariableDeclaration_initializer(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration node,
    PatternVariableDeclaration other,
  ) {
    return visitor.checkNodes(
      node.initializer,
      other.initializer,
      'initializer',
    );
  }

  bool checkPatternVariableDeclaration_isFinal(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration node,
    PatternVariableDeclaration other,
  ) {
    return visitor.checkValues(node.isFinal, other.isFinal, 'isFinal');
  }

  bool checkPatternVariableDeclaration_matchedValueType(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration node,
    PatternVariableDeclaration other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkPatternVariableDeclaration_fileOffset(
    EquivalenceVisitor visitor,
    PatternVariableDeclaration node,
    PatternVariableDeclaration other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkIfCaseStatement_expression(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkIfCaseStatement_patternGuard(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return visitor.checkNodes(
      node.patternGuard,
      other.patternGuard,
      'patternGuard',
    );
  }

  bool checkIfCaseStatement_then(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return visitor.checkNodes(node.then, other.then, 'then');
  }

  bool checkIfCaseStatement_otherwise(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return visitor.checkNodes(node.otherwise, other.otherwise, 'otherwise');
  }

  bool checkIfCaseStatement_matchedValueType(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return visitor.checkNodes(
      node.matchedValueType,
      other.matchedValueType,
      'matchedValueType',
    );
  }

  bool checkIfCaseStatement_scope(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkIfCaseStatement_fileOffset(
    EquivalenceVisitor visitor,
    IfCaseStatement node,
    IfCaseStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkAuxiliaryStatement_fileOffset(
    EquivalenceVisitor visitor,
    AuxiliaryStatement node,
    AuxiliaryStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkExpressionStatement_expression(
    EquivalenceVisitor visitor,
    ExpressionStatement node,
    ExpressionStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkExpressionStatement_fileOffset(
    EquivalenceVisitor visitor,
    ExpressionStatement node,
    ExpressionStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkBlock_statements(
    EquivalenceVisitor visitor,
    Block node,
    Block other,
  ) {
    return visitor.checkLists(
      node.statements,
      other.statements,
      visitor.checkNodes,
      'statements',
    );
  }

  bool checkBlock_fileEndOffset(
    EquivalenceVisitor visitor,
    Block node,
    Block other,
  ) {
    return visitor.checkValues(
      node.fileEndOffset,
      other.fileEndOffset,
      'fileEndOffset',
    );
  }

  bool checkBlock_scope(EquivalenceVisitor visitor, Block node, Block other) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkBlock_fileOffset(
    EquivalenceVisitor visitor,
    Block node,
    Block other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkAssertBlock_statements(
    EquivalenceVisitor visitor,
    AssertBlock node,
    AssertBlock other,
  ) {
    return visitor.checkLists(
      node.statements,
      other.statements,
      visitor.checkNodes,
      'statements',
    );
  }

  bool checkAssertBlock_fileOffset(
    EquivalenceVisitor visitor,
    AssertBlock node,
    AssertBlock other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkEmptyStatement_fileOffset(
    EquivalenceVisitor visitor,
    EmptyStatement node,
    EmptyStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkAssertStatement_condition(
    EquivalenceVisitor visitor,
    AssertStatement node,
    AssertStatement other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkAssertStatement_message(
    EquivalenceVisitor visitor,
    AssertStatement node,
    AssertStatement other,
  ) {
    return visitor.checkNodes(node.message, other.message, 'message');
  }

  bool checkAssertStatement_conditionStartOffset(
    EquivalenceVisitor visitor,
    AssertStatement node,
    AssertStatement other,
  ) {
    return visitor.checkValues(
      node.conditionStartOffset,
      other.conditionStartOffset,
      'conditionStartOffset',
    );
  }

  bool checkAssertStatement_conditionEndOffset(
    EquivalenceVisitor visitor,
    AssertStatement node,
    AssertStatement other,
  ) {
    return visitor.checkValues(
      node.conditionEndOffset,
      other.conditionEndOffset,
      'conditionEndOffset',
    );
  }

  bool checkAssertStatement_fileOffset(
    EquivalenceVisitor visitor,
    AssertStatement node,
    AssertStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkLabeledStatement_body(
    EquivalenceVisitor visitor,
    LabeledStatement node,
    LabeledStatement other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkLabeledStatement_fileOffset(
    EquivalenceVisitor visitor,
    LabeledStatement node,
    LabeledStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkBreakStatement_target(
    EquivalenceVisitor visitor,
    BreakStatement node,
    BreakStatement other,
  ) {
    return visitor.checkDeclarations(node.target, other.target, 'target');
  }

  bool checkBreakStatement_fileOffset(
    EquivalenceVisitor visitor,
    BreakStatement node,
    BreakStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkWhileStatement_condition(
    EquivalenceVisitor visitor,
    WhileStatement node,
    WhileStatement other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkWhileStatement_body(
    EquivalenceVisitor visitor,
    WhileStatement node,
    WhileStatement other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkWhileStatement_scope(
    EquivalenceVisitor visitor,
    WhileStatement node,
    WhileStatement other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkWhileStatement_fileOffset(
    EquivalenceVisitor visitor,
    WhileStatement node,
    WhileStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkDoStatement_body(
    EquivalenceVisitor visitor,
    DoStatement node,
    DoStatement other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkDoStatement_condition(
    EquivalenceVisitor visitor,
    DoStatement node,
    DoStatement other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkDoStatement_fileOffset(
    EquivalenceVisitor visitor,
    DoStatement node,
    DoStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkForStatement_variables(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    return visitor.checkLists(
      node.variables,
      other.variables,
      visitor.checkNodes,
      'variables',
    );
  }

  bool checkForStatement_condition(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkForStatement_updates(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    return visitor.checkLists(
      node.updates,
      other.updates,
      visitor.checkNodes,
      'updates',
    );
  }

  bool checkForStatement_body(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkForStatement_scope(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkForStatement_fileOffset(
    EquivalenceVisitor visitor,
    ForStatement node,
    ForStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkForInStatement_bodyOffset(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return visitor.checkValues(node.bodyOffset, other.bodyOffset, 'bodyOffset');
  }

  bool checkForInStatement_variable(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkForInStatement_iterable(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return visitor.checkNodes(node.iterable, other.iterable, 'iterable');
  }

  bool checkForInStatement_body(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkForInStatement_isAsync(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return visitor.checkValues(node.isAsync, other.isAsync, 'isAsync');
  }

  bool checkForInStatement_scope(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkForInStatement_fileOffset(
    EquivalenceVisitor visitor,
    ForInStatement node,
    ForInStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkContinueSwitchStatement_target(
    EquivalenceVisitor visitor,
    ContinueSwitchStatement node,
    ContinueSwitchStatement other,
  ) {
    return visitor.checkDeclarations(node.target, other.target, 'target');
  }

  bool checkContinueSwitchStatement_fileOffset(
    EquivalenceVisitor visitor,
    ContinueSwitchStatement node,
    ContinueSwitchStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkIfStatement_condition(
    EquivalenceVisitor visitor,
    IfStatement node,
    IfStatement other,
  ) {
    return visitor.checkNodes(node.condition, other.condition, 'condition');
  }

  bool checkIfStatement_then(
    EquivalenceVisitor visitor,
    IfStatement node,
    IfStatement other,
  ) {
    return visitor.checkNodes(node.then, other.then, 'then');
  }

  bool checkIfStatement_otherwise(
    EquivalenceVisitor visitor,
    IfStatement node,
    IfStatement other,
  ) {
    return visitor.checkNodes(node.otherwise, other.otherwise, 'otherwise');
  }

  bool checkIfStatement_fileOffset(
    EquivalenceVisitor visitor,
    IfStatement node,
    IfStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkReturnStatement_expression(
    EquivalenceVisitor visitor,
    ReturnStatement node,
    ReturnStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkReturnStatement_fileOffset(
    EquivalenceVisitor visitor,
    ReturnStatement node,
    ReturnStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkTryCatch_body(
    EquivalenceVisitor visitor,
    TryCatch node,
    TryCatch other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkTryCatch_catches(
    EquivalenceVisitor visitor,
    TryCatch node,
    TryCatch other,
  ) {
    return visitor.checkLists(
      node.catches,
      other.catches,
      visitor.checkNodes,
      'catches',
    );
  }

  bool checkTryCatch_isSynthetic(
    EquivalenceVisitor visitor,
    TryCatch node,
    TryCatch other,
  ) {
    return visitor.checkValues(
      node.isSynthetic,
      other.isSynthetic,
      'isSynthetic',
    );
  }

  bool checkTryCatch_fileOffset(
    EquivalenceVisitor visitor,
    TryCatch node,
    TryCatch other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkTryFinally_body(
    EquivalenceVisitor visitor,
    TryFinally node,
    TryFinally other,
  ) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkTryFinally_finalizer(
    EquivalenceVisitor visitor,
    TryFinally node,
    TryFinally other,
  ) {
    return visitor.checkNodes(node.finalizer, other.finalizer, 'finalizer');
  }

  bool checkTryFinally_fileOffset(
    EquivalenceVisitor visitor,
    TryFinally node,
    TryFinally other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkYieldStatement_expression(
    EquivalenceVisitor visitor,
    YieldStatement node,
    YieldStatement other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkYieldStatement_flags(
    EquivalenceVisitor visitor,
    YieldStatement node,
    YieldStatement other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkYieldStatement_fileOffset(
    EquivalenceVisitor visitor,
    YieldStatement node,
    YieldStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkVariableStatement_declaration(
    EquivalenceVisitor visitor,
    VariableStatement node,
    VariableStatement other,
  ) {
    return visitor.checkNodes(
      node.declaration,
      other.declaration,
      'declaration',
    );
  }

  bool checkVariableStatement_fileOffset(
    EquivalenceVisitor visitor,
    VariableStatement node,
    VariableStatement other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkFunctionDeclaration_variable(
    EquivalenceVisitor visitor,
    FunctionDeclaration node,
    FunctionDeclaration other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkFunctionDeclaration_function(
    EquivalenceVisitor visitor,
    FunctionDeclaration node,
    FunctionDeclaration other,
  ) {
    return visitor.checkNodes(node.function, other.function, 'function');
  }

  bool checkFunctionDeclaration_fileOffset(
    EquivalenceVisitor visitor,
    FunctionDeclaration node,
    FunctionDeclaration other,
  ) {
    return checkStatement_fileOffset(visitor, node, other);
  }

  bool checkSwitchExpressionCase_patternGuard(
    EquivalenceVisitor visitor,
    SwitchExpressionCase node,
    SwitchExpressionCase other,
  ) {
    return visitor.checkNodes(
      node.patternGuard,
      other.patternGuard,
      'patternGuard',
    );
  }

  bool checkSwitchExpressionCase_expression(
    EquivalenceVisitor visitor,
    SwitchExpressionCase node,
    SwitchExpressionCase other,
  ) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkSwitchExpressionCase_scope(
    EquivalenceVisitor visitor,
    SwitchExpressionCase node,
    SwitchExpressionCase other,
  ) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkSwitchExpressionCase_fileOffset(
    EquivalenceVisitor visitor,
    SwitchExpressionCase node,
    SwitchExpressionCase other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkCatch_guard(EquivalenceVisitor visitor, Catch node, Catch other) {
    return visitor.checkNodes(node.guard, other.guard, 'guard');
  }

  bool checkCatch_exception(
    EquivalenceVisitor visitor,
    Catch node,
    Catch other,
  ) {
    return visitor.checkNodes(node.exception, other.exception, 'exception');
  }

  bool checkCatch_stackTrace(
    EquivalenceVisitor visitor,
    Catch node,
    Catch other,
  ) {
    return visitor.checkNodes(node.stackTrace, other.stackTrace, 'stackTrace');
  }

  bool checkCatch_body(EquivalenceVisitor visitor, Catch node, Catch other) {
    return visitor.checkNodes(node.body, other.body, 'body');
  }

  bool checkCatch_scope(EquivalenceVisitor visitor, Catch node, Catch other) {
    'scope';
    return checkScope(visitor, node.scope, other.scope);
  }

  bool checkCatch_fileOffset(
    EquivalenceVisitor visitor,
    Catch node,
    Catch other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkNominalParameter_flags(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkNominalParameter_annotations(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkNominalParameter_name(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkNominalParameter_bound(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkNodes(node.bound, other.bound, 'bound');
  }

  bool checkNominalParameter_defaultType(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkNodes(
      node.defaultType,
      other.defaultType,
      'defaultType',
    );
  }

  bool checkNominalParameter_variance(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return visitor.checkValues(node.variance, other.variance, 'variance');
  }

  bool checkNominalParameter_fileOffset(
    EquivalenceVisitor visitor,
    NominalParameter node,
    NominalParameter other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkTypeVariable_cosmeticName(
    EquivalenceVisitor visitor,
    TypeVariable node,
    TypeVariable other,
  ) {
    return visitor.checkValues(
      node.cosmeticName,
      other.cosmeticName,
      'cosmeticName',
    );
  }

  bool checkTypeVariable_parameter(
    EquivalenceVisitor visitor,
    TypeVariable node,
    TypeVariable other,
  ) {
    return visitor.checkDeclarations(
      node.parameter,
      other.parameter,
      'parameter',
    );
  }

  bool checkTypeVariable_annotations(
    EquivalenceVisitor visitor,
    TypeVariable node,
    TypeVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkVariableBase_flags(
    EquivalenceVisitor visitor,
    VariableBase node,
    VariableBase other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkTypeVariable_flags(
    EquivalenceVisitor visitor,
    TypeVariable node,
    TypeVariable other,
  ) {
    return checkVariableBase_flags(visitor, node, other);
  }

  bool checkVariableBase_fileOffset(
    EquivalenceVisitor visitor,
    VariableBase node,
    VariableBase other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkTypeVariable_fileOffset(
    EquivalenceVisitor visitor,
    TypeVariable node,
    TypeVariable other,
  ) {
    return checkVariableBase_fileOffset(visitor, node, other);
  }

  bool checkLocalVariable_name(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkLocalVariable_type(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkLocalVariable_annotations(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLocalVariable_initializer(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkNodes(
      node.initializer,
      other.initializer,
      'initializer',
    );
  }

  bool checkLocalVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkLocalVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkVariable_flags(
    EquivalenceVisitor visitor,
    Variable node,
    Variable other,
  ) {
    return checkVariableBase_flags(visitor, node, other);
  }

  bool checkDeclaredVariable_flags(
    EquivalenceVisitor visitor,
    DeclaredVariable node,
    DeclaredVariable other,
  ) {
    return checkVariable_flags(visitor, node, other);
  }

  bool checkLocalVariable_flags(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return checkDeclaredVariable_flags(visitor, node, other);
  }

  bool checkVariable_fileOffset(
    EquivalenceVisitor visitor,
    Variable node,
    Variable other,
  ) {
    return checkVariableBase_fileOffset(visitor, node, other);
  }

  bool checkDeclaredVariable_fileOffset(
    EquivalenceVisitor visitor,
    DeclaredVariable node,
    DeclaredVariable other,
  ) {
    return checkVariable_fileOffset(visitor, node, other);
  }

  bool checkLocalVariable_fileOffset(
    EquivalenceVisitor visitor,
    LocalVariable node,
    LocalVariable other,
  ) {
    return checkDeclaredVariable_fileOffset(visitor, node, other);
  }

  bool checkLocalFunctionVariable_name(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkLocalFunctionVariable_type(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkLocalFunctionVariable_annotations(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLocalFunctionVariable_initializer(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkNodes(
      node.initializer,
      other.initializer,
      'initializer',
    );
  }

  bool checkLocalFunctionVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkLocalFunctionVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkLocalFunctionVariable_flags(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return checkDeclaredVariable_flags(visitor, node, other);
  }

  bool checkLocalFunctionVariable_fileOffset(
    EquivalenceVisitor visitor,
    LocalFunctionVariable node,
    LocalFunctionVariable other,
  ) {
    return checkDeclaredVariable_fileOffset(visitor, node, other);
  }

  bool checkLateVariable_name(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkLateVariable_type(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkLateVariable_annotations(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkLateVariable_initialValue(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkNodes(
      node.initialValue,
      other.initialValue,
      'initialValue',
    );
  }

  bool checkLateVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkLateVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkLateVariable_flags(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return checkDeclaredVariable_flags(visitor, node, other);
  }

  bool checkLateVariable_fileOffset(
    EquivalenceVisitor visitor,
    LateVariable node,
    LateVariable other,
  ) {
    return checkDeclaredVariable_fileOffset(visitor, node, other);
  }

  bool checkConstVariable_name(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkConstVariable_type(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkConstVariable_annotations(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkConstVariable_value(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkNodes(node.value, other.value, 'value');
  }

  bool checkConstVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkConstVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkConstVariable_flags(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return checkDeclaredVariable_flags(visitor, node, other);
  }

  bool checkConstVariable_fileOffset(
    EquivalenceVisitor visitor,
    ConstVariable node,
    ConstVariable other,
  ) {
    return checkDeclaredVariable_fileOffset(visitor, node, other);
  }

  bool checkSyntheticVariable_cosmeticName(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkValues(
      node.cosmeticName,
      other.cosmeticName,
      'cosmeticName',
    );
  }

  bool checkSyntheticVariable_type(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkSyntheticVariable_annotations(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkSyntheticVariable_initializer(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkNodes(
      node.initializer,
      other.initializer,
      'initializer',
    );
  }

  bool checkSyntheticVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkSyntheticVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkSyntheticVariable_flags(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return checkDeclaredVariable_flags(visitor, node, other);
  }

  bool checkSyntheticVariable_fileOffset(
    EquivalenceVisitor visitor,
    SyntheticVariable node,
    SyntheticVariable other,
  ) {
    return checkDeclaredVariable_fileOffset(visitor, node, other);
  }

  bool checkCatchVariable_catchVariableName(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return visitor.checkValues(
      node.catchVariableName,
      other.catchVariableName,
      'catchVariableName',
    );
  }

  bool checkCatchVariable_type(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkCatchVariable_annotations(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkCatchVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkCatchVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkCatchVariable_flags(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return checkVariable_flags(visitor, node, other);
  }

  bool checkCatchVariable_fileOffset(
    EquivalenceVisitor visitor,
    CatchVariable node,
    CatchVariable other,
  ) {
    return checkVariable_fileOffset(visitor, node, other);
  }

  bool checkPositionalParameter_type(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkPositionalParameter_annotations(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkPositionalParameter_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkPositionalParameter_fileEqualsOffset(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkFunctionParameter_parameterName(
    EquivalenceVisitor visitor,
    FunctionParameter node,
    FunctionParameter other,
  ) {
    return visitor.checkValues(
      node.parameterName,
      other.parameterName,
      'parameterName',
    );
  }

  bool checkPositionalParameter_parameterName(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return checkFunctionParameter_parameterName(visitor, node, other);
  }

  bool checkFunctionParameter_defaultValue(
    EquivalenceVisitor visitor,
    FunctionParameter node,
    FunctionParameter other,
  ) {
    return visitor.checkNodes(
      node.defaultValue,
      other.defaultValue,
      'defaultValue',
    );
  }

  bool checkPositionalParameter_defaultValue(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return checkFunctionParameter_defaultValue(visitor, node, other);
  }

  bool checkFunctionParameter_flags(
    EquivalenceVisitor visitor,
    FunctionParameter node,
    FunctionParameter other,
  ) {
    return checkVariable_flags(visitor, node, other);
  }

  bool checkPositionalParameter_flags(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return checkFunctionParameter_flags(visitor, node, other);
  }

  bool checkFunctionParameter_fileOffset(
    EquivalenceVisitor visitor,
    FunctionParameter node,
    FunctionParameter other,
  ) {
    return checkVariable_fileOffset(visitor, node, other);
  }

  bool checkPositionalParameter_fileOffset(
    EquivalenceVisitor visitor,
    PositionalParameter node,
    PositionalParameter other,
  ) {
    return checkFunctionParameter_fileOffset(visitor, node, other);
  }

  bool checkNamedParameter_type(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkNamedParameter_annotations(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkNamedParameter_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkNamedParameter_fileEqualsOffset(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkNamedParameter_parameterName(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return checkFunctionParameter_parameterName(visitor, node, other);
  }

  bool checkNamedParameter_defaultValue(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return checkFunctionParameter_defaultValue(visitor, node, other);
  }

  bool checkNamedParameter_flags(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return checkFunctionParameter_flags(visitor, node, other);
  }

  bool checkNamedParameter_fileOffset(
    EquivalenceVisitor visitor,
    NamedParameter node,
    NamedParameter other,
  ) {
    return checkFunctionParameter_fileOffset(visitor, node, other);
  }

  bool checkThisVariable_type(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkThisVariable_annotations(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return visitor.checkLists(
      node.annotations,
      other.annotations,
      visitor.checkNodes,
      'annotations',
    );
  }

  bool checkThisVariable_binaryOffsetNoTag(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return visitor.checkValues(
      node.binaryOffsetNoTag,
      other.binaryOffsetNoTag,
      'binaryOffsetNoTag',
    );
  }

  bool checkThisVariable_fileEqualsOffset(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return visitor.checkValues(
      node.fileEqualsOffset,
      other.fileEqualsOffset,
      'fileEqualsOffset',
    );
  }

  bool checkThisVariable_flags(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return checkVariable_flags(visitor, node, other);
  }

  bool checkThisVariable_fileOffset(
    EquivalenceVisitor visitor,
    ThisVariable node,
    ThisVariable other,
  ) {
    return checkVariable_fileOffset(visitor, node, other);
  }

  bool checkVariableDeclaration_variable(
    EquivalenceVisitor visitor,
    VariableDeclaration node,
    VariableDeclaration other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkVariableDeclaration_capturedContexts(
    EquivalenceVisitor visitor,
    VariableDeclaration node,
    VariableDeclaration other,
  ) {
    return visitor.checkLists(node.capturedContexts, other.capturedContexts, (
      a,
      b,
      _,
    ) {
      if (identical(a, b)) return true;
      return checkVariableContext(visitor, a, b);
    }, 'capturedContexts');
  }

  bool checkVariableDeclaration_fileOffset(
    EquivalenceVisitor visitor,
    VariableDeclaration node,
    VariableDeclaration other,
  ) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  bool checkName_text(EquivalenceVisitor visitor, Name node, Name other) {
    return visitor.checkValues(node.text, other.text, 'text');
  }

  bool checkStructuralParameter_flags(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  bool checkStructuralParameter_name(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkStructuralParameter_fileOffset(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkValues(node.fileOffset, other.fileOffset, 'fileOffset');
  }

  bool checkStructuralParameter_uri(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkValues(node.uri, other.uri, 'uri');
  }

  bool checkStructuralParameter_bound(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkNodes(node.bound, other.bound, 'bound');
  }

  bool checkStructuralParameter_defaultType(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkNodes(
      node.defaultType,
      other.defaultType,
      'defaultType',
    );
  }

  bool checkStructuralParameter_variance(
    EquivalenceVisitor visitor,
    StructuralParameter node,
    StructuralParameter other,
  ) {
    return visitor.checkValues(node.variance, other.variance, 'variance');
  }

  bool checkSupertype_className(
    EquivalenceVisitor visitor,
    Supertype node,
    Supertype other,
  ) {
    return visitor.checkReferences(
      node.className,
      other.className,
      'className',
    );
  }

  bool checkSupertype_typeArguments(
    EquivalenceVisitor visitor,
    Supertype node,
    Supertype other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkInterfaceType_classReference(
    EquivalenceVisitor visitor,
    InterfaceType node,
    InterfaceType other,
  ) {
    return visitor.checkReferences(
      node.classReference,
      other.classReference,
      'classReference',
    );
  }

  bool checkInterfaceType_declaredNullability(
    EquivalenceVisitor visitor,
    InterfaceType node,
    InterfaceType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkInterfaceType_typeArguments(
    EquivalenceVisitor visitor,
    InterfaceType node,
    InterfaceType other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkExtensionType_extensionTypeDeclarationReference(
    EquivalenceVisitor visitor,
    ExtensionType node,
    ExtensionType other,
  ) {
    return visitor.checkReferences(
      node.extensionTypeDeclarationReference,
      other.extensionTypeDeclarationReference,
      'extensionTypeDeclarationReference',
    );
  }

  bool checkExtensionType_declaredNullability(
    EquivalenceVisitor visitor,
    ExtensionType node,
    ExtensionType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkExtensionType_typeArguments(
    EquivalenceVisitor visitor,
    ExtensionType node,
    ExtensionType other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkFunctionTypeParameterType_variable(
    EquivalenceVisitor visitor,
    FunctionTypeParameterType node,
    FunctionTypeParameterType other,
  ) {
    return visitor.checkNodes(node.variable, other.variable, 'variable');
  }

  bool checkFunctionTypeParameterType_declaredNullability(
    EquivalenceVisitor visitor,
    FunctionTypeParameterType node,
    FunctionTypeParameterType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkClassTypeParameterType_thisVariable(
    EquivalenceVisitor visitor,
    ClassTypeParameterType node,
    ClassTypeParameterType other,
  ) {
    return visitor.checkNodes(
      node.thisVariable,
      other.thisVariable,
      'thisVariable',
    );
  }

  bool checkClassTypeParameterType_parameter(
    EquivalenceVisitor visitor,
    ClassTypeParameterType node,
    ClassTypeParameterType other,
  ) {
    return visitor.checkDeclarations(
      node.parameter,
      other.parameter,
      'parameter',
    );
  }

  bool checkClassTypeParameterType_declaredNullability(
    EquivalenceVisitor visitor,
    ClassTypeParameterType node,
    ClassTypeParameterType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkNeverType_declaredNullability(
    EquivalenceVisitor visitor,
    NeverType node,
    NeverType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkFunctionType_typeParameters(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkLists(
      node.typeParameters,
      other.typeParameters,
      visitor.checkNodes,
      'typeParameters',
    );
  }

  bool checkFunctionType_requiredParameterCount(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkValues(
      node.requiredParameterCount,
      other.requiredParameterCount,
      'requiredParameterCount',
    );
  }

  bool checkFunctionType_positionalParameters(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkLists(
      node.positionalParameters,
      other.positionalParameters,
      visitor.checkNodes,
      'positionalParameters',
    );
  }

  bool checkFunctionType_namedParameters(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkLists(
      node.namedParameters,
      other.namedParameters,
      visitor.checkNodes,
      'namedParameters',
    );
  }

  bool checkFunctionType_declaredNullability(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkFunctionType_returnType(
    EquivalenceVisitor visitor,
    FunctionType node,
    FunctionType other,
  ) {
    return visitor.checkNodes(node.returnType, other.returnType, 'returnType');
  }

  bool checkTypedefType_declaredNullability(
    EquivalenceVisitor visitor,
    TypedefType node,
    TypedefType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkTypedefType_typedefReference(
    EquivalenceVisitor visitor,
    TypedefType node,
    TypedefType other,
  ) {
    return visitor.checkReferences(
      node.typedefReference,
      other.typedefReference,
      'typedefReference',
    );
  }

  bool checkTypedefType_typeArguments(
    EquivalenceVisitor visitor,
    TypedefType node,
    TypedefType other,
  ) {
    return visitor.checkLists(
      node.typeArguments,
      other.typeArguments,
      visitor.checkNodes,
      'typeArguments',
    );
  }

  bool checkFutureOrType_typeArgument(
    EquivalenceVisitor visitor,
    FutureOrType node,
    FutureOrType other,
  ) {
    return visitor.checkNodes(
      node.typeArgument,
      other.typeArgument,
      'typeArgument',
    );
  }

  bool checkFutureOrType_declaredNullability(
    EquivalenceVisitor visitor,
    FutureOrType node,
    FutureOrType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkIntersectionType_left(
    EquivalenceVisitor visitor,
    IntersectionType node,
    IntersectionType other,
  ) {
    return visitor.checkNodes(node.left, other.left, 'left');
  }

  bool checkIntersectionType_right(
    EquivalenceVisitor visitor,
    IntersectionType node,
    IntersectionType other,
  ) {
    return visitor.checkNodes(node.right, other.right, 'right');
  }

  bool checkTypeParameterType_declaredNullability(
    EquivalenceVisitor visitor,
    TypeParameterType node,
    TypeParameterType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkTypeParameterType_parameter(
    EquivalenceVisitor visitor,
    TypeParameterType node,
    TypeParameterType other,
  ) {
    return visitor.checkDeclarations(
      node.parameter,
      other.parameter,
      'parameter',
    );
  }

  bool checkStructuralParameterType_declaredNullability(
    EquivalenceVisitor visitor,
    StructuralParameterType node,
    StructuralParameterType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkStructuralParameterType_parameter(
    EquivalenceVisitor visitor,
    StructuralParameterType node,
    StructuralParameterType other,
  ) {
    return visitor.checkDeclarations(
      node.parameter,
      other.parameter,
      'parameter',
    );
  }

  bool checkRecordType_positional(
    EquivalenceVisitor visitor,
    RecordType node,
    RecordType other,
  ) {
    return visitor.checkLists(
      node.positional,
      other.positional,
      visitor.checkNodes,
      'positional',
    );
  }

  bool checkRecordType_named(
    EquivalenceVisitor visitor,
    RecordType node,
    RecordType other,
  ) {
    return visitor.checkLists(
      node.named,
      other.named,
      visitor.checkNodes,
      'named',
    );
  }

  bool checkRecordType_declaredNullability(
    EquivalenceVisitor visitor,
    RecordType node,
    RecordType other,
  ) {
    return visitor.checkValues(
      node.declaredNullability,
      other.declaredNullability,
      'declaredNullability',
    );
  }

  bool checkNamedType_name(
    EquivalenceVisitor visitor,
    NamedType node,
    NamedType other,
  ) {
    return visitor.checkValues(node.name, other.name, 'name');
  }

  bool checkNamedType_type(
    EquivalenceVisitor visitor,
    NamedType node,
    NamedType other,
  ) {
    return visitor.checkNodes(node.type, other.type, 'type');
  }

  bool checkNamedType_isRequired(
    EquivalenceVisitor visitor,
    NamedType node,
    NamedType other,
  ) {
    return visitor.checkValues(node.isRequired, other.isRequired, 'isRequired');
  }
}