// 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.

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;

  EquivalenceVisitor({this.strategy: const EquivalenceStrategy()});

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

  @override
  bool defaultTreeNode(TreeNode node, Node other) {
    return false;
  }

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

  @override
  bool visitTypedef(Typedef node, Node other) {
    return strategy.checkTypedef(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 defaultMember(Member node, Node other) {
    return false;
  }

  @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 visitRedirectingFactory(RedirectingFactory node, Node other) {
    return strategy.checkRedirectingFactory(this, node, other);
  }

  @override
  bool visitProcedure(Procedure node, Node other) {
    return strategy.checkProcedure(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 defaultInitializer(Initializer node, Node other) {
    return false;
  }

  @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 visitFunctionNode(FunctionNode node, Node other) {
    return strategy.checkFunctionNode(this, node, other);
  }

  @override
  bool defaultExpression(Expression node, Node other) {
    return false;
  }

  @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 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 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 defaultBasicLiteral(BasicLiteral node, Node other) {
    return false;
  }

  @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 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 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 defaultStatement(Statement node, Node other) {
    return false;
  }

  @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 visitSwitchStatement(SwitchStatement node, Node other) {
    return strategy.checkSwitchStatement(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 visitVariableDeclaration(VariableDeclaration node, Node other) {
    return strategy.checkVariableDeclaration(this, node, other);
  }

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

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

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

  @override
  bool visitTypeParameter(TypeParameter node, Node other) {
    return strategy.checkTypeParameter(this, node, other);
  }

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

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

  @override
  bool defaultDartType(DartType node, Node other) {
    return false;
  }

  @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 visitInterfaceType(InterfaceType node, Node other) {
    return strategy.checkInterfaceType(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 visitExtensionType(ExtensionType node, Node other) {
    return strategy.checkExtensionType(this, node, other);
  }

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

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

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

  @override
  bool defaultConstant(Constant node, Node other) {
    return false;
  }

  @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 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 visitTypedefReference(Typedef node, Node other) {
    return false;
  }

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

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

  @override
  bool defaultMemberReference(Member 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 visitRedirectingFactoryReference(RedirectingFactory node, Node other) {
    return false;
  }

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

  @override
  bool defaultConstantReference(Constant 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 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 identical or equal. Inequivalence is
  /// _not_ registered.
  bool shallowMatchNodes<T extends Node>(T? a, T? b) {
    return _checkValues(a, b);
  }

  /// Returns `true` if [a] and [b] are equivalent, as defined by the current
  /// strategy. Inequivalence is _not_ registered.
  bool deepMatchNodes<T extends Node>(T? a, T? b) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result = checkNodes(a, b);
    _checkingState = oldState;
    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. Inequivalence is _not_
  /// registered.
  bool deeplyMatchReferences(Reference? a, Reference? b) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result = checkReferences(a, b);
    _checkingState = oldState;
    return result;
  }

  /// 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 LabeledStatement) {
      return b is LabeledStatement;
    }
    if (a is VariableDeclaration) {
      return b is VariableDeclaration && a.name == b.name;
    }
    if (a is SwitchCase) {
      return b is SwitchCase;
    }
    if (a is TypeParameter) {
      return b is TypeParameter && 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 deepMatchDeclarations(dynamic a, dynamic b) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result = checkDeclarations(a, b);
    _checkingState = oldState;
    return result;
  }

  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 lists [a] and [b] are equivalent, using
  /// [equivalentValues] to determine element-wise equivalence.
  ///
  /// Inequivalence is _not_ registered.
  bool matchLists<E>(
      List<E>? a, List<E>? b, bool Function(E?, E?, String) equivalentValues) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result = checkLists(a, b, equivalentValues);
    _checkingState = oldState;
    return result;
  }

  /// 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 sets [a] and [b] are equivalent, using
  /// [matchingValues] to determine which elements that should be checked for
  /// element-wise equivalence using [equivalentValues].
  ///
  /// Inequivalence is _not_registered.
  bool matchSets<E>(Set<E>? a, Set<E>? b, bool Function(E?, E?) matchingValues,
      bool Function(E?, E?, String) equivalentValues) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result = checkSets(a, b, matchingValues, equivalentValues);
    _checkingState = oldState;
    return result;
  }

  /// 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;
  }

  /// 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.
  ///
  /// Inequivalence is _not_ registered.
  bool matchMaps<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) {
    CheckingState oldState = _checkingState;
    _checkingState = _checkingState.toMatchingState();
    bool result =
        checkMaps(a, b, matchingKeys, equivalentKeys, equivalentValues);
    _checkingState = oldState;
    return result;
  }

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

  /// Runs [f] in a new state that holds all current assumptions. If
  /// [isAsserting] is `true`, inequivalences are registered. Returns the
  /// collected inequivalences.
  ///
  /// If [f] returns `false`, the returned result is marked as having
  /// inequivalences even when non have being registered.
  EquivalenceResult inSubState(bool Function() f, {bool isAsserting: false}) {
    CheckingState _oldState = _checkingState;
    _checkingState = _checkingState.createSubState(isAsserting: isAsserting);
    bool hasInequivalences = f();
    EquivalenceResult result =
        _checkingState.toResult(hasInequivalences: hasInequivalences);
    _checkingState = _oldState;
    return result;
  }

  /// Registers that the visitor enters the property named [propertyName] and
  /// the currently visited node.
  void pushPropertyState(String propertyName) {
    _checkingState.pushPropertyState(propertyName);
  }

  /// 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 EquivalenceStrategy();

  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_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 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 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_redirectingFactories(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 checkExtensionTypeShowHideClause(EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! ExtensionTypeShowHideClause) return false;
    if (other is! ExtensionTypeShowHideClause) return false;
    bool result = true;
    if (!checkExtensionTypeShowHideClause_shownSupertypes(
        visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_shownMethods(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_shownGetters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_shownSetters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_shownOperators(
        visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_hiddenSupertypes(
        visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_hiddenMethods(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_hiddenGetters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_hiddenSetters(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionTypeShowHideClause_hiddenOperators(
        visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    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_member(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_showHideClause(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtension_members(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 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_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_transformerFlags(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_transformerFlags(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 checkRedirectingFactory(
      EquivalenceVisitor visitor, RedirectingFactory? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! RedirectingFactory) return false;
    if (other is! RedirectingFactory) return false;
    if (!visitor.matchNamedNodes(node, other)) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkRedirectingFactory_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_targetReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_function(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_fileEndOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_fileUri(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_transformerFlags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_reference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkRedirectingFactory_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_transformerFlags(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 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_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 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_isSynthetic(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_isSynthetic(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_isSynthetic(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_isSynthetic(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkAssertInitializer_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    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_returnType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_body(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkFunctionNode_futureValueType(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 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 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_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_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_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_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_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_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_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_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 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_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    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_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 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_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_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_typeParameters(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 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 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_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_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_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_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_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 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;
    if (!visitor.checkDeclarations(node, other, '')) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkVariableDeclaration_fileEqualsOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_type(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_binaryOffsetNoTag(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_initializer(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkVariableDeclaration_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 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 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_fileOffset(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    visitor.popState();
    return result;
  }

  bool checkTypeParameter(
      EquivalenceVisitor visitor, TypeParameter? node, Object? other) {
    if (identical(node, other)) return true;
    if (node is! TypeParameter) return false;
    if (other is! TypeParameter) return false;
    if (!visitor.checkDeclarations(node, other, '')) {
      return false;
    }
    visitor.pushNodeState(node, other);
    bool result = true;
    if (!checkTypeParameter_flags(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_annotations(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_name(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_bound(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_defaultType(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_variance(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkTypeParameter_fileOffset(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_mode(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkComponent_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 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 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_className(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 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 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_extensionReference(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionType_declaredNullability(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionType_typeArguments(visitor, node, other)) {
      result = visitor.resultOnInequivalence;
    }
    if (!checkExtensionType_onType(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;
    }
    if (!checkTypeParameterType_promotedBound(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 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 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 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 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_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 checkNamedNode_reference(
      EquivalenceVisitor visitor, NamedNode node, NamedNode other) {
    return visitor.checkReferences(
        node.reference, other.reference, 'reference');
  }

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

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

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

  bool checkLibrary_fileOffset(
      EquivalenceVisitor visitor, Library node, Library other) {
    return checkNamedNode_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 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 checkClass_redirectingFactories(
      EquivalenceVisitor visitor, Class node, Class other) {
    return visitor.checkLists(node.redirectingFactories,
        other.redirectingFactories, visitor.checkNodes, 'redirectingFactories');
  }

  bool checkClass_reference(
      EquivalenceVisitor visitor, Class node, Class other) {
    return checkNamedNode_reference(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 checkExtensionTypeShowHideClause_shownSupertypes(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.shownSupertypes, other.shownSupertypes,
        visitor.checkNodes, 'shownSupertypes');
  }

  bool checkExtensionTypeShowHideClause_shownMethods(EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node, ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.shownMethods, other.shownMethods,
        visitor.checkReferences, 'shownMethods');
  }

  bool checkExtensionTypeShowHideClause_shownGetters(EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node, ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.shownGetters, other.shownGetters,
        visitor.checkReferences, 'shownGetters');
  }

  bool checkExtensionTypeShowHideClause_shownSetters(EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node, ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.shownSetters, other.shownSetters,
        visitor.checkReferences, 'shownSetters');
  }

  bool checkExtensionTypeShowHideClause_shownOperators(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.shownOperators, other.shownOperators,
        visitor.checkReferences, 'shownOperators');
  }

  bool checkExtensionTypeShowHideClause_hiddenSupertypes(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.hiddenSupertypes, other.hiddenSupertypes,
        visitor.checkNodes, 'hiddenSupertypes');
  }

  bool checkExtensionTypeShowHideClause_hiddenMethods(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.hiddenMethods, other.hiddenMethods,
        visitor.checkReferences, 'hiddenMethods');
  }

  bool checkExtensionTypeShowHideClause_hiddenGetters(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.hiddenGetters, other.hiddenGetters,
        visitor.checkReferences, 'hiddenGetters');
  }

  bool checkExtensionTypeShowHideClause_hiddenSetters(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.hiddenSetters, other.hiddenSetters,
        visitor.checkReferences, 'hiddenSetters');
  }

  bool checkExtensionTypeShowHideClause_hiddenOperators(
      EquivalenceVisitor visitor,
      ExtensionTypeShowHideClause node,
      ExtensionTypeShowHideClause other) {
    return visitor.checkLists(node.hiddenOperators, other.hiddenOperators,
        visitor.checkReferences, 'hiddenOperators');
  }

  bool checkExtension_showHideClause(
      EquivalenceVisitor visitor, Extension node, Extension other) {
    'showHideClause';
    return checkExtensionTypeShowHideClause(
        visitor, node.showHideClause, other.showHideClause);
  }

  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_member(EquivalenceVisitor visitor,
      ExtensionMemberDescriptor node, ExtensionMemberDescriptor other) {
    return visitor.checkReferences(node.member, other.member, 'member');
  }

  bool checkExtension_members(
      EquivalenceVisitor visitor, Extension node, Extension other) {
    return visitor.checkLists(node.members, other.members, (a, b, _) {
      if (identical(a, b)) return true;
      if (a is! ExtensionMemberDescriptor) return false;
      if (b is! ExtensionMemberDescriptor) return false;
      return checkExtensionMemberDescriptor(visitor, a, b);
    }, 'members');
  }

  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 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 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 checkMember_transformerFlags(
      EquivalenceVisitor visitor, Member node, Member other) {
    return visitor.checkValues(
        node.transformerFlags, other.transformerFlags, 'transformerFlags');
  }

  bool checkField_transformerFlags(
      EquivalenceVisitor visitor, Field node, Field other) {
    return checkMember_transformerFlags(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 checkConstructor_transformerFlags(
      EquivalenceVisitor visitor, Constructor node, Constructor other) {
    return checkMember_transformerFlags(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 checkRedirectingFactory_flags(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

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

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

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

  bool checkRedirectingFactory_fileEndOffset(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_fileEndOffset(visitor, node, other);
  }

  bool checkRedirectingFactory_annotations(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_annotations(visitor, node, other);
  }

  bool checkRedirectingFactory_name(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_name(visitor, node, other);
  }

  bool checkRedirectingFactory_fileUri(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_fileUri(visitor, node, other);
  }

  bool checkRedirectingFactory_transformerFlags(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_transformerFlags(visitor, node, other);
  }

  bool checkRedirectingFactory_reference(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory other) {
    return checkMember_reference(visitor, node, other);
  }

  bool checkRedirectingFactory_fileOffset(EquivalenceVisitor visitor,
      RedirectingFactory node, RedirectingFactory 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_transformerFlags(
      EquivalenceVisitor visitor, Procedure node, Procedure other) {
    return checkMember_transformerFlags(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 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_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 checkInitializer_isSynthetic(
      EquivalenceVisitor visitor, Initializer node, Initializer other) {
    return visitor.checkValues(
        node.isSynthetic, other.isSynthetic, 'isSynthetic');
  }

  bool checkInvalidInitializer_isSynthetic(EquivalenceVisitor visitor,
      InvalidInitializer node, InvalidInitializer other) {
    return checkInitializer_isSynthetic(visitor, node, other);
  }

  bool checkInitializer_fileOffset(
      EquivalenceVisitor visitor, Initializer node, Initializer other) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  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 checkInitializer_isSynthetic(visitor, node, other);
  }

  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 checkInitializer_isSynthetic(visitor, node, other);
  }

  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_isSynthetic(EquivalenceVisitor visitor,
      RedirectingInitializer node, RedirectingInitializer other) {
    return checkInitializer_isSynthetic(visitor, node, other);
  }

  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_isSynthetic(EquivalenceVisitor visitor,
      LocalInitializer node, LocalInitializer other) {
    return checkInitializer_isSynthetic(visitor, node, other);
  }

  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_isSynthetic(EquivalenceVisitor visitor,
      AssertInitializer node, AssertInitializer other) {
    return checkInitializer_isSynthetic(visitor, node, other);
  }

  bool checkAssertInitializer_fileOffset(EquivalenceVisitor visitor,
      AssertInitializer node, AssertInitializer other) {
    return checkInitializer_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_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_futureValueType(
      EquivalenceVisitor visitor, FunctionNode node, FunctionNode other) {
    return visitor.checkNodes(
        node.futureValueType, other.futureValueType, 'futureValueType');
  }

  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 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 checkExpression_fileOffset(
      EquivalenceVisitor visitor, Expression node, Expression other) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  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.checkDeclarations(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.checkDeclarations(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 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_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_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_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_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 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_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.checkDeclarations(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_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_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 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_flags(
      EquivalenceVisitor visitor, IsExpression node, IsExpression other) {
    return visitor.checkValues(node.flags, other.flags, 'flags');
  }

  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_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 checkAwaitExpression_operand(
      EquivalenceVisitor visitor, AwaitExpression node, AwaitExpression other) {
    return visitor.checkNodes(node.operand, other.operand, 'operand');
  }

  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_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_typeParameters(
      EquivalenceVisitor visitor, TypedefTearOff node, TypedefTearOff other) {
    return visitor.checkLists(node.typeParameters, other.typeParameters,
        visitor.checkNodes, 'typeParameters');
  }

  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 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 checkExpressionStatement_expression(EquivalenceVisitor visitor,
      ExpressionStatement node, ExpressionStatement other) {
    return visitor.checkNodes(node.expression, other.expression, 'expression');
  }

  bool checkStatement_fileOffset(
      EquivalenceVisitor visitor, Statement node, Statement other) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  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_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_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_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_fileOffset(
      EquivalenceVisitor visitor, ForInStatement node, ForInStatement 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_fileOffset(
      EquivalenceVisitor visitor, SwitchStatement node, SwitchStatement 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 checkVariableDeclaration_fileEqualsOffset(EquivalenceVisitor visitor,
      VariableDeclaration node, VariableDeclaration other) {
    return visitor.checkValues(
        node.fileEqualsOffset, other.fileEqualsOffset, 'fileEqualsOffset');
  }

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

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

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

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

  bool checkVariableDeclaration_binaryOffsetNoTag(EquivalenceVisitor visitor,
      VariableDeclaration node, VariableDeclaration other) {
    return visitor.checkValues(
        node.binaryOffsetNoTag, other.binaryOffsetNoTag, 'binaryOffsetNoTag');
  }

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

  bool checkVariableDeclaration_fileOffset(EquivalenceVisitor visitor,
      VariableDeclaration node, VariableDeclaration 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 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 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_fileOffset(
      EquivalenceVisitor visitor, Catch node, Catch other) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

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

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

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

  bool checkTypeParameter_bound(
      EquivalenceVisitor visitor, TypeParameter node, TypeParameter other) {
    return visitor.checkNodes(node.bound, other.bound, 'bound');
  }

  bool checkTypeParameter_defaultType(
      EquivalenceVisitor visitor, TypeParameter node, TypeParameter other) {
    return visitor.checkNodes(
        node.defaultType, other.defaultType, 'defaultType');
  }

  bool checkTypeParameter_variance(
      EquivalenceVisitor visitor, TypeParameter node, TypeParameter other) {
    return visitor.checkValues(node.variance, other.variance, 'variance');
  }

  bool checkTypeParameter_fileOffset(
      EquivalenceVisitor visitor, TypeParameter node, TypeParameter other) {
    return checkTreeNode_fileOffset(visitor, node, other);
  }

  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;
      if (a is! Source) return false;
      if (b is! Source) return false;
      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;
      if (a is! MetadataRepository) return false;
      if (b is! MetadataRepository) return false;
      return checkMetadataRepository(visitor, a, b);
    }, 'metadata');
  }

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

  bool checkComponent_mode(
      EquivalenceVisitor visitor, Component node, Component other) {
    return visitor.checkValues(node.mode, other.mode, 'mode');
  }

  bool checkComponent_fileOffset(
      EquivalenceVisitor visitor, Component node, Component 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 checkNeverType_declaredNullability(
      EquivalenceVisitor visitor, NeverType node, NeverType other) {
    return visitor.checkValues(node.declaredNullability,
        other.declaredNullability, 'declaredNullability');
  }

  bool checkInterfaceType_className(
      EquivalenceVisitor visitor, InterfaceType node, InterfaceType other) {
    return visitor.checkReferences(
        node.className, other.className, 'className');
  }

  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 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 checkExtensionType_extensionReference(
      EquivalenceVisitor visitor, ExtensionType node, ExtensionType other) {
    return visitor.checkReferences(node.extensionReference,
        other.extensionReference, 'extensionReference');
  }

  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 checkExtensionType_onType(
      EquivalenceVisitor visitor, ExtensionType node, ExtensionType other) {
    return visitor.checkNodes(node.onType, other.onType, 'onType');
  }

  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 checkTypeParameterType_promotedBound(EquivalenceVisitor visitor,
      TypeParameterType node, TypeParameterType other) {
    return visitor.checkNodes(
        node.promotedBound, other.promotedBound, 'promotedBound');
  }

  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');
  }

  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 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;
      if (a is! ConstantMapEntry) return false;
      if (b is! ConstantMapEntry) return false;
      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 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');
  }
}