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